🎽 🛤️ 🎇 एक उदाहरण के रूप में टॉकिंग हैट का उपयोग करके अनुसंधान से लेकर कार्यान्वयन तक डेटा विज्ञान परियोजना 🌴 🏜️ 🤱🏽

एक महीने पहले, लेंटा ने एक प्रतियोगिता शुरू की, जिसमें हैरी पॉटर के वही टॉकिंग हैट उन प्रतिभागियों की पहचान करते हैं जिनकी सोशल नेटवर्क पर चार संकायों में से एक तक पहुंच है। प्रतियोगिता खराब नहीं है, अलग-अलग ध्वनि वाले नाम अलग-अलग संकायों द्वारा निर्धारित किए जाते हैं, और समान अंग्रेजी और रूसी नाम और उपनाम एक समान तरीके से वितरित किए जाते हैं। मुझे नहीं पता कि क्या वितरण केवल नामों और उपनामों पर निर्भर करता है, और क्या दोस्तों या अन्य कारकों की संख्या को किसी भी तरह से ध्यान में रखा जाता है, लेकिन इस प्रतियोगिता ने इस लेख के विचार का सुझाव दिया: खरोंच से एक क्लासिफायर ट्रेन करने का प्रयास करें, जो उपयोगकर्ताओं को विभिन्न संकायों में वितरित करने की अनुमति देगा।

इस लेख में, हम एक साधारण एमएल-मॉडल बनाएंगे, जो हैरी पॉटर के विभागों को उनके नाम और उपनाम के आधार पर लोगों को वितरित करता है, जो सीआरआईएसपी पद्धति के बाद एक छोटी शोध प्रक्रिया से गुजरा है । अर्थात् हम:

हम समस्या तैयार करते हैं;
हम इसके समाधान के लिए संभावित दृष्टिकोणों की जांच करते हैं और डेटा आवश्यकताओं (समाधान विधियों और डेटा) को तैयार करते हैं;
हम आवश्यक डेटा (समाधान विधियों और डेटा) एकत्र करेंगे;
हम एकत्र किए गए डेटासेट (खोजपूर्ण अनुसंधान) का अध्ययन करेंगे;
कच्चे डेटा (फीचर इंजीनियरिंग) से विशेषताएं निकालें;
आइए मशीन सीखने का एक मॉडल (मॉडल मूल्यांकन) सिखाएं;
प्राप्त परिणामों की तुलना करें, समाधानों की गुणवत्ता का मूल्यांकन करें और यदि आवश्यक हो, तो पैराग्राफ 2-6 दोहराएं;
हम समाधान को एक सेवा में पैक करते हैं जिसका उपयोग किया जा सकता है (उत्पादन)।

यह कार्य तुच्छ लग सकता है, इसलिए हम पूरी प्रक्रिया पर एक अतिरिक्त प्रतिबंध लगाएंगे (ताकि इसमें 2 घंटे से कम समय लगे) और इस लेख पर (ताकि इसका पढ़ने का समय 15 मिनट से कम हो)।

यदि आप पहले से ही डेटा साइंस की सुंदर और अद्भुत दुनिया में डूबे हुए हैं और आप कैग्लगाइट को लगातार नहीं देखते हैं, या (भगवान न करे) अपने सहकर्मियों के साथ बैठकों के दौरान अपने हडप की लंबाई को मापना पसंद करते हैं, तो सबसे अधिक संभावना है कि लेख आपको सरल और अटूट लगेगा। इसके अलावा: अंतिम मॉडल की गुणवत्ता इस लेख का मुख्य मूल्य नहीं है। हमने आपको चेतावनी दी है। चलो चलते हैं।

लेख में उपयोग किए गए कोड के साथ एक जीथब रिपॉजिटरी भी उत्सुक पाठकों के लिए उपलब्ध है। त्रुटियों के मामले में, कृपया PR खोलें।

हम समस्या तैयार करते हैं

ऐसी समस्या को हल करना संभव है जिसमें एक लंबे समय के लिए स्पष्ट निर्णय मानदंड नहीं हैं, इसलिए हम तुरंत फैसला करेंगे कि हम एक समाधान प्राप्त करना चाहते हैं जो हमें प्रवेश लाइन के जवाब में "ग्रिफ़िंडोर", "रेवेनक्लाव", "हफलपफ" या "स्लीथेरिन" का जवाब देने की अनुमति देगा।

वास्तव में, हम एक ब्लैक बॉक्स प्राप्त करना चाहते हैं:

" " => [?] => Griffindor

मूल काली टोपी ने उनकी प्रकृति और व्यक्तिगत गुणों के आधार पर विभागों को युवा जादूगरों को वितरित किया। चूँकि समस्या की स्थितियों के अनुसार चरित्र और व्यक्तित्व के आंकड़े हमारे पास उपलब्ध नहीं हैं, हम प्रतिभागी के नाम और उपनाम का उपयोग करेंगे, यह याद करते हुए कि इस मामले में हमें पुस्तक के पात्रों को उन विभागों को वितरित करना चाहिए जो पुस्तक से उनके मूल विभागों के अनुरूप हैं। और अगर हमारे फैसले ने हैरी को हफलपफ या रेवेनक्लाव को वितरित किया (लेकिन यह हैरी को ग्रिफिंडोर और स्लीथेरिन को पुस्तक की भावना व्यक्त करने की समान संभावना के साथ भेजना चाहिए) तो निश्चित रूप से परेशान होंगे।

चूंकि हम संभावनाओं के बारे में बात कर रहे हैं, इसलिए हम इस समस्या को अधिक कठोर गणितीय शब्दों में औपचारिक रूप देते हैं। डेटा विज्ञान के दृष्टिकोण से, हम वर्गीकरण समस्या को हल करते हैं, अर्थात् एक वस्तु (स्ट्रिंग, एक नाम और उपनाम के रूप में) को निर्दिष्ट करते हुए एक निश्चित वर्ग (वास्तव में यह सिर्फ एक लेबल, या लेबल है, जो एक संख्या या 4 चर हो सकता है, जिनका हां / नहीं मान है )। हम समझते हैं कि कम से कम हैरी के मामले में 2 उत्तर देना सही होगा: ग्रिफ़िंडोर और स्लीथेरिन, इसलिए यह बेहतर होगा कि विशिष्ट संकाय की भविष्यवाणी न करें कि टोपी परिभाषित करता है, लेकिन संभावना है कि एक व्यक्ति को इस संकाय को आवंटित किया जाएगा, इसलिए हमारा निर्णय इसमें किया जाएगा। कुछ समारोह की तरह

न ा म उ प न ा म

$f (<नाम> <उपनाम>) = (P_ {griffindor}; P_ {ravllaw}; P_ {hufflpuff}; p_ {slitherin})$

मेट्रिक्स और क्वालिटी असेसमेंट

कार्य और लक्ष्य तैयार किया जाता है, ~~अब हम सोचते हैं कि इसे कैसे हल किया जाए~~ लेकिन यह सब नहीं है। अध्ययन शुरू करने के लिए, आपको गुणवत्ता मीट्रिक दर्ज करने की आवश्यकता है। दूसरे शब्दों में, यह निर्धारित करने के लिए कि हम एक दूसरे से 2 विभिन्न समाधानों की तुलना कैसे करेंगे।

जीवन में सब कुछ अच्छा और सरल है - हम सहज रूप से समझते हैं कि एक स्पैम डिटेक्टर को आने वाले संदेशों के लिए न्यूनतम स्पैम को पारित करना होगा, साथ ही अधिकतम आवश्यक पत्र पास करना होगा और यह निश्चित रूप से स्पैम को आवश्यक पत्र नहीं भेजना चाहिए।

वास्तव में, सब कुछ अधिक जटिल है और इसकी पुष्टि बड़ी संख्या में लेख हैं जो बताते हैं कि कैसे और क्या मैट्रिक्स का उपयोग किया जाता है। अभ्यास इस सर्वोत्तम को समझने में मदद करता है, लेकिन यह एक ऐसा बड़ा विषय है जिसे हम इसके बारे में एक अलग पोस्ट लिखने और एक खुली तालिका बनाने का वादा करते हैं ताकि हर कोई आसपास खेल सके और अभ्यास में समझ सके कि यह कैसे अलग है।

घर "लेकिन चलो सबसे अच्छा चुनते हैं" हमारे लिए आरओसी एयूसी होगा । इस मामले में हम मीट्रिक से बिल्कुल यही चाहते हैं: कम झूठी सकारात्मक और अधिक सटीक वास्तविक भविष्यवाणी, जितना बड़ा आरओसी एयूसी।

एक आदर्श आरओसी मॉडल के लिए, एयूसी 1 है, एक आदर्श यादृच्छिक मॉडल के लिए जो कक्षाओं को बिल्कुल यादृच्छिक रूप से परिभाषित करता है - 0.5।

$ROC \ AUC [0.5; 1] $ मे$

एल्गोरिदम

हमारे ब्लैक बॉक्स को पुस्तकों के नायकों के वितरण को ध्यान में रखना चाहिए, इनपुट के रूप में एक अलग नाम और उपनाम लेना चाहिए, और परिणाम देना चाहिए। वर्गीकरण समस्या को हल करने के लिए, आप विभिन्न मशीन लर्निंग एल्गोरिदम का उपयोग कर सकते हैं:

तंत्रिका नेटवर्क, कारककरण मशीनें, रैखिक प्रतिगमन, या, उदाहरण के लिए, एसवीएम।

आम धारणा के विपरीत, डेटा साइंस केवल तंत्रिका नेटवर्क तक सीमित नहीं है, और इस विचार को लोकप्रिय बनाने के लिए, इस लेख में तंत्रिका नेटवर्क को एक जिज्ञासु पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है । जिन लोगों ने डेटा विश्लेषण में एक भी कोर्स नहीं लिया (विशेष रूप से ओडीएस से विषयगत रूप से बेहतर है ), या मशीन सीखने या एआई के बारे में केवल एन समाचार पढ़ा, जो अब शौकिया मछुआरों की पत्रिकाओं में भी प्रकाशित होते हैं, एल्गोरिदम के सामान्य समूहों के नामों से मिले होंगे। : बैगिंग, बूस्टिंग, सपोर्ट वेक्टर विधि (एसवीएम), रैखिक प्रतिगमन। यह वह है जो हम अपनी समस्या को हल करने के लिए उपयोग करेंगे।

और अधिक सटीक होने के लिए, हम तुलना करते हैं:

रैखिक प्रतिगमन
बूस्टिंग (XGboost, लाइट जीबीएम)
पेड़ों का निर्णय लेना (सख्ती से बोलना, यह वही बढ़ावा है, लेकिन हम इसे अलग से निकालेंगे: अतिरिक्त पेड़)
बैगिंग (यादृच्छिक वन)
SVM

हम संकाय में से प्रत्येक को परिभाषित करके संकायों में से प्रत्येक को एक हॉगवर्ट्स छात्र को वितरित करने की समस्या को हल कर सकते हैं, लेकिन इस कार्य को कड़ाई से बोलने से यह निर्धारित करने की समस्या हल हो जाती है कि क्या प्रत्येक वर्ग व्यक्तिगत रूप से है। इसलिए, इस लेख के ढांचे में हमने खुद को 4 मॉडल प्राप्त करने का लक्ष्य निर्धारित किया है, प्रत्येक संकाय के लिए।

डेटा

प्रशिक्षण के लिए सही डेटासेट ढूंढना, और अधिक महत्वपूर्ण बात, सही उद्देश्य के लिए इसका उपयोग करने के लिए कानूनी, डेटा साइंस में सबसे जटिल और समय लेने वाले कार्यों में से एक है। अपने कार्य के लिए, हम हैरी पॉटर की दुनिया भर के विकिया से डेटा लेंगे। उदाहरण के लिए, इस लिंक पर आप उन सभी पात्रों को पा सकते हैं, जिन्होंने Gryffindor के संकाय में अध्ययन किया था। यह महत्वपूर्ण है कि इस मामले में हम गैर-वाणिज्यिक उद्देश्यों के लिए डेटा का उपयोग करते हैं, इसलिए हम इस साइट के लाइसेंस का उल्लंघन नहीं करते हैं।

जो लोग सोचते हैं कि डेटा वैज्ञानिक ऐसे शांत व्यक्ति हैं, मैं डेटा वैज्ञानिकों के पास जाऊंगा और मुझे सिखाने दूंगा, हम आपको याद दिलाते हैं कि डेटा को साफ करने और तैयार करने के लिए एक कदम है। डाउनलोड किए गए डेटा को हटाने के लिए मैन्युअल रूप से संचालित किया जाना चाहिए, उदाहरण के लिए, "Gryffindor के सातवें प्रान्त" और "अनजान लड़की को Gryffindor" से स्वचालित रूप से हटा दें। वास्तविक कार्य में, कार्य का एक आनुपातिक रूप से बड़ा हिस्सा हमेशा डेटासेट में अनुपलब्ध मानों की तैयारी, सफाई और बहाली से जुड़ा होता है।

थोड़ा ctrl + c & ctrl + v और आउटपुट में हमें 4 टेक्स्ट फाइलें मिलती हैं, जिसमें 2 भाषाओं में अक्षरों के नाम होते हैं: अंग्रेजी और रूसी।

हम एकत्र डेटा (EDA, खोजपूर्ण डेटा विश्लेषण) का अध्ययन करते हैं

इस चरण के लिए, हमारे पास 4 फाइलें हैं, जिनमें संकायों के छात्रों के नाम हैं, हम और अधिक विस्तार से देखेंगे:

 $ ls ../input griffindor.txt hufflpuff.txt ravenclaw.txt slitherin.txt

प्रत्येक फ़ाइल में प्रति पंक्ति छात्र का 1 नाम और उपनाम (यदि कोई हो):

 $ wc -l ../input/*.txt 250 ../input/griffindor.txt 167 ../input/hufflpuff.txt 180 ../input/ravenclaw.txt 254 ../input/slitherin.txt 851 total

एकत्रित डेटा फॉर्म का है:

 $ cat ../input/griffindor.txt | head -3 && cat ../input/griffindor.txt | tail -3      Charlie Stainforth Melanie Stanmore Stewart

हमारा पूरा विचार इस धारणा पर आधारित है कि नामों और उपनामों में कुछ समान है जो हमारे ब्लैक बॉक्स (या ब्लैक हैट) को भेद करना सीख सकते हैं।

एल्गोरिथम लाइनों को फीड कर सकता है, लेकिन परिणाम अच्छा नहीं होगा, क्योंकि बुनियादी मॉडल स्वतंत्र रूप से यह समझने में सक्षम नहीं होंगे कि "ड्रेको" "हैरी" से कैसे भिन्न है, इसलिए हमें अपने नामों और उपनामों से संकेत निकालने की आवश्यकता होगी।

डेटा तैयारी (फ़ीचर इंजीनियरिंग)

संकेत (या सुविधाएँ, अंग्रेज़ी सुविधा - संपत्ति से) किसी वस्तु के विशिष्ट गुण हैं। किसी व्यक्ति ने पिछले वर्ष में जितनी बार नौकरी बदली, उसके बाएं हाथ की उँगलियों की संख्या, इंजन की इंजन क्षमता, चाहे कार का माइलेज 100,000 किमी से अधिक हो या न हो। सभी प्रकार के संकेतों का वर्गीकरण बहुत बड़ी संख्या में किया गया था, इस संबंध में एक भी प्रणाली नहीं है और न ही हो सकती है, इसलिए हम उदाहरण देंगे कि संकेत क्या हो सकते हैं:

परिमेय संख्या
श्रेणी (12, 12-18 या 18+ तक)
बाइनरी वैल्यू (पहला ऋण लौटाया या नहीं)
दिनांक, रंग, शेयर आदि।

सुविधाओं की खोज (या गठन) ( अंग्रेजी फ़ीचर इंजीनियरिंग में ) अक्सर अनुसंधान के एक अलग चरण या डेटा विश्लेषण विशेषज्ञ के काम के रूप में सामने आती है। वास्तव में, सामान्य ज्ञान, अनुभव और परिकल्पना परीक्षण प्रक्रिया में ही मदद करते हैं। सही संकेतों का तुरंत अनुमान लगाना एक पूर्ण हाथ, मौलिक ज्ञान और भाग्य के संयोजन का सवाल है। कभी-कभी इसमें शर्मिंदगी होती है, लेकिन सामान्य दृष्टिकोण बहुत सरल है: आपको वह करने की ज़रूरत है जो मन में आता है, और फिर जांचें कि क्या एक नई विशेषता जोड़कर समाधान में सुधार करना संभव है। उदाहरण के लिए, हमारे कार्य के लिए एक संकेत के रूप में, हम नाम में सिज़लिंग की संख्या ले सकते हैं।

हमारे मॉडल के पहले संस्करण में (क्योंकि वास्तविक डेटा विज्ञान का अध्ययन - एक उत्कृष्ट कृति के रूप में, कभी पूरा नहीं किया जा सकता), हम पहले और अंतिम नाम के लिए निम्नलिखित विशेषताओं का उपयोग करेंगे:

1 और शब्द का अंतिम अक्षर - स्वर या व्यंजन
डबल स्वर और व्यंजन
स्वरों की संख्या, व्यंजन, बहरा, आवाज उठाई
नाम लंबाई, अंतिम नाम लंबाई
...

ऐसा करने के लिए, हम इस भंडार को एक आधार के रूप में लेंगे और एक वर्ग जोड़ेंगे ताकि इसका उपयोग लैटिन अक्षरों के लिए किया जा सके। यह हमें यह निर्धारित करने का अवसर देगा कि प्रत्येक अक्षर कैसा लगता है।

 >> from Phonetic import RussianLetter, EnglishLetter >> RussianLetter('').classify() {'consonant': True, 'deaf': False, 'hard': False, 'mark': False, 'paired': False, 'shock': False, 'soft': False, 'sonorus': True, 'vowel': False} >> EnglishLetter('d').classify() {'consonant': True, 'deaf': False, 'hard': True, 'mark': False, 'paired': False, 'shock': False, 'soft': False, 'sonorus': True, 'vowel': False}

अब हम आँकड़ों की गणना के लिए सरल कार्यों को परिभाषित कर सकते हैं, उदाहरण के लिए:

 def starts_with_letter(word, letter_type='vowel'): """   ,    . :param word:  :param letter_type: 'vowel'  'consonant'.   . :return: Boolean """ if len(word) == 0: return False return Letter(word[0]).classify()[letter_type] def count_letter_type(word): """       . :param word:  :param debug:    :return: :obj:`dict` of :obj:`str` => :int:count """ count = { 'consonant': 0, 'deaf': 0, 'hard': 0, 'mark': 0, 'paired': 0, 'shock': 0, 'soft': 0, 'sonorus': 0, 'vowel': 0 } for letter in word: classes = Letter(letter).classify() for key in count.keys(): if classes[key]: count[key] += 1 return count

इन कार्यों का उपयोग करते हुए, हम पहले से ही पहले संकेत प्राप्त कर सकते हैं:

 from feature_engineering import * >> print("  («»): ", len(""))   («»): 5 >> print(" («»)   : ", starts_with_letter('', 'vowel'))  («»)   : False >> print(" («»)   : ", starts_with_letter('', 'consonant'))  («»)   : True >> count_Harry = count_letter_type("") >> print ("     («»): ", count_Harry['paired'])      («»): 1

कड़ाई से बोलते हुए, इन कार्यों की मदद से हम स्ट्रिंग के कुछ वेक्टर प्रतिनिधित्व प्राप्त कर सकते हैं, अर्थात्, हम मानचित्रण प्राप्त करते हैं:

$f (<नाम> <उपनाम>) => (लंबाई_ {नाम}, लंबाई_ {उपनाम}, ..., \ _vowels_ {उपनाम] की संख्या)$

अब हम अपने डेटा को एक डेटासेट के रूप में प्रस्तुत कर सकते हैं जो मशीन लर्निंग एल्गोरिदम के लिए इनपुट हो सकता है:

 >> from data_loaders import load_processed_data >> hogwarts_df = load_processed_data() >> hogwarts_df.head()

इसके अलावा, परिणामस्वरूप, हमें प्रत्येक छात्र के लिए निम्नलिखित लक्षण मिलते हैं:

 >> hogwarts_df[hogwarts_df.columns].dtypes

संकेत प्राप्त हुए

 name object surname object is_english bool name_starts_with_vowel bool name_starts_with_consonant bool name_ends_with_vowel bool name_ends_with_consonant bool name_length int64 name_vowels_count int64 name_double_vowels_count int64 name_consonant_count int64 name_double_consonant_count int64 name_paired_count int64 name_deaf_count int64 name_sonorus_count int64 surname_starts_with_vowel bool surname_starts_with_consonant bool surname_ends_with_vowel bool surname_ends_with_consonant bool surname_length int64 surname_vowels_count int64 surname_double_vowels_count int64 surname_consonant_count int64 surname_double_consonant_count int64 surname_paired_count int64 surname_deaf_count int64 surname_sonorus_count int64 is_griffindor int64 is_hufflpuff int64 is_ravenclaw int64 is_slitherin int64 dtype: object

अंतिम 4 कॉलम लक्षित होते हैं - उनमें वह जानकारी होती है जिस पर एक छात्र द्वारा दाखिला लिया जाता है।

एल्गोरिथम प्रशिक्षण

संक्षेप में, एल्गोरिदम को लोगों की तरह प्रशिक्षित किया जाता है: वे गलतियाँ करते हैं और उनसे सीखते हैं। यह समझने के लिए कि उन्होंने कितनी गलती की, एल्गोरिदम त्रुटि कार्यों (हानि कार्यों, अंग्रेजी हानि-कार्य ) का उपयोग करता है।

एक नियम के रूप में, सीखने की प्रक्रिया बहुत सरल है और इसमें कई चरण होते हैं:

एक भविष्यवाणी करें।
त्रुटि दर।
मॉडल के मापदंडों को ठीक करें।
1-3 तक दोहराएं जब तक कि लक्ष्य पूरा न हो जाए, प्रक्रिया रुक जाती है या डेटा समाप्त हो जाता है।
परिणामी मॉडल की गुणवत्ता को रेट करें।

व्यवहार में, ज़ाहिर है, सब कुछ थोड़ा अधिक जटिल है। उदाहरण के लिए, ओवरफिटिंग की घटना है - एल्गोरिथ्म वास्तव में याद रख सकता है कि विशेषताएँ क्या जवाब के अनुरूप हैं और इस प्रकार उन वस्तुओं के लिए परिणाम को खराब करती हैं जो उन लोगों के समान नहीं हैं जिन पर यह प्रशिक्षित किया गया था। इससे बचने के लिए, विभिन्न तकनीकों और हैक हैं।

जैसा कि ऊपर उल्लेख किया गया है, हम 4 समस्याओं को हल करेंगे: प्रत्येक संकाय के लिए एक। इसलिए, हम Slytherin के लिए डेटा तैयार करेंगे:

 #  ,     - : >> data_full = hogwarts_df.drop( [ 'name', 'surname', 'is_griffindor', 'is_hufflpuff', 'is_ravenclaw' ], axis=1).copy() #    ,   : >> X_data = data_full.drop('is_slitherin', axis=1) #     ,   1    >> y = data_full.is_slitherin

सीखते समय, एल्गोरिदम लगातार वास्तविक डेटा के साथ अपने परिणामों की तुलना करता है, इसके लिए डेटासेट के इस हिस्से को सत्यापन के लिए आवंटित किया जाता है। अच्छी टोन के नियम को व्यक्तिगत डेटा पर एल्गोरिदम के परिणाम का मूल्यांकन करने के लिए भी माना जाता है जो कि एल्गोरिदम ने बिल्कुल नहीं देखा था। इसलिए, अब हम नमूने को 70/30 के अनुपात में विभाजित करते हैं और पहले एल्गोरिथ्म को प्रशिक्षित करते हैं:

 from sklearn.cross_validation import train_test_split from sklearn.ensemble import RandomForestClassifier #      >> seed = 7 #    >> test_size = 0.3 >> X_train, X_test, y_train, y_test = train_test_split(X_data, y, test_size=test_size, random_state=seed) >> rfc = RandomForestClassifier() >> rfc_model = rfc.fit(X_train, y_train)

हो गया। अब, यदि आप इस मॉडल के इनपुट में डेटा जमा करते हैं, तो यह एक परिणाम देगा। यह मजेदार है, इसलिए सबसे पहले हम यह देखने के लिए जांच करेंगे कि क्या हैरी का मॉडल स्लीथेरिन को पहचानता है। ऐसा करने के लिए, पहले एल्गोरिथ्म की भविष्यवाणी प्राप्त करने के लिए कार्यों को तैयार करें:

कोड देखें

 from data_loaders import parse_line_to_hogwarts_df import pandas as pd def get_single_student_features (name): """      :param name: string     :return: pd.DataFrame     """ featurized_person_df = parse_line_to_hogwarts_df(name) person_df = pd.DataFrame(featurized_person_df, columns=[ 'name', 'surname', 'is_english', 'name_starts_with_vowel', 'name_starts_with_consonant', 'name_ends_with_vowel', 'name_ends_with_consonant', 'name_length', 'name_vowels_count', 'name_double_vowels_count', 'name_consonant_count', 'name_double_consonant_count', 'name_paired_count', 'name_deaf_count', 'name_sonorus_count', 'surname_starts_with_vowel', 'surname_starts_with_consonant', 'surname_ends_with_vowel', 'surname_ends_with_consonant', 'surname_length', 'surname_vowels_count', 'surname_double_vowels_count', 'surname_consonant_count', 'surname_double_consonant_count', 'surname_paired_count', 'surname_deaf_count', 'surname_sonorus_count', ], index=[0] ) featurized_person = person_df.drop( ['name', 'surname'], axis = 1 ) return featurized_person def get_predictions_vector (model, person): """    :param model:   :param person: string   :return: list    """ encoded_person = get_single_student_features(person) return model.predict_proba(encoded_person)[0]

अब एल्गोरिदम के परिणामों पर विचार करने के लिए एक छोटा परीक्षण डेटा सेट दें।

 def score_testing_dataset (model): """      . :param model:   """ testing_dataset = [ " ", "Kirill Malev", " ", "Harry Potter", " ", " ","Severus Snape", " ", "Tom Riddle", " ", "Salazar Slytherin"] for name in testing_dataset: print ("{} — {}".format(name, get_predictions_vector(model, name)[1])) score_testing_dataset(rfc_model)

   — 0.5 Kirill Malev — 0.5   — 0.0 Harry Potter — 0.0   — 0.75   — 0.9 Severus Snape — 0.5   — 0.2 Tom Riddle — 0.5   — 0.2 Salazar Slytherin — 0.3

परिणाम संदिग्ध थे। यहां तक कि संकाय के संस्थापक भी इस मॉडल के अनुसार, अपने संकाय में नहीं होंगे। इसलिए, आपको सख्त गुणवत्ता का मूल्यांकन करने की आवश्यकता है: उन मैट्रिक्स को देखें जो हमने शुरुआत में पूछे थे:

 from sklearn.metrics import accuracy_score, roc_auc_score, classification_report predictions = rfc_model.predict(X_test) print("Classification report: ") print(classification_report(y_test, predictions)) print("Accuracy for Random Forest Model: %.2f" % (accuracy_score(y_test, predictions) * 100)) print("ROC AUC from first Random Forest Model: %.2f" % (roc_auc_score(y_test, predictions)))

 Classification report: precision recall f1-score support 0 0.66 0.88 0.75 168 1 0.38 0.15 0.21 89 avg / total 0.56 0.62 0.56 257 Accuracy for Random Forest Model: 62.26 ROC AUC from first Random Forest Model: 0.51

यह आश्चर्यजनक नहीं है कि परिणाम इतने संदिग्ध थे - लगभग 0.51 का आरओसी एयूसी बताता है कि मॉडल एक सिक्का टॉस की तुलना में थोड़ा बेहतर भविष्यवाणी करता है।

परिणामों का परीक्षण। गुणवत्ता मैट्रिक्स

ऊपर एक उदाहरण का उपयोग करते हुए, हमने देखा कि कैसे 1 एल्गोरिथ्म को प्रशिक्षित किया जाता है जो स्केलेर इंटरफेस का समर्थन करता है। बाकी बिल्कुल उसी तरह से प्रशिक्षित हैं, इसलिए हम केवल सभी एल्गोरिदम को प्रशिक्षित कर सकते हैं और प्रत्येक मामले में सर्वश्रेष्ठ चुन सकते हैं।

यह जटिल नहीं है, प्रत्येक एल्गोरिथ्म के लिए हम 1 को मानक सेटिंग्स के साथ प्रशिक्षित करते हैं, और एक पूरे सेट को भी प्रशिक्षित करते हैं, जो विभिन्न विकल्पों के माध्यम से सॉर्ट करता है जो एल्गोरिदम की गुणवत्ता को प्रभावित करता है। इस चरण को मॉडल ट्यूनिंग या हाइपरपरेट ऑप्टिमाइज़ेशन कहा जाता है और इसका सार बहुत सरल है: सबसे अच्छा परिणाम देने वाली सेटिंग्स का सेट चुना गया है।

 from model_training import train_classifiers from data_loaders import load_processed_data import warnings warnings.filterwarnings('ignore') #   hogwarts_df = load_processed_data() #     data_full = hogwarts_df.drop( [ 'name', 'surname', 'is_griffindor', 'is_hufflpuff', 'is_ravenclaw' ], axis=1).copy() X_data = data_full.drop('is_slitherin', axis=1) y = data_full.is_slitherin #    slitherin_models = train_classifiers(data_full, X_data, y) score_testing_dataset(slitherin_models[5])

   — 0.09437856871661066 Kirill Malev — 0.20820536334902712   — 0.07550095601699099 Harry Potter — 0.07683794773639624   — 0.9414529336862744   — 0.9293671807790949 Severus Snape — 0.6576783576162999   — 0.18577792617672767 Tom Riddle — 0.8351835484058869   — 0.25930925139546795 Salazar Slytherin — 0.24008788903854789

इस संस्करण में संख्याएं अतीत की तुलना में विषयगत रूप से बेहतर दिखती हैं, लेकिन आंतरिक पूर्णतावादी के लिए अभी भी पर्याप्त नहीं हैं। इसलिए, हम एक स्तर तक नीचे जाएंगे और अपने कार्य के उत्पाद अर्थों में लौटेंगे: हमें सबसे अधिक संभावना संकाय की भविष्यवाणी करने की आवश्यकता है, जिसमें नायक को वितरण टोपी द्वारा निर्धारित किया जाएगा। इसका मतलब है कि आपको प्रत्येक संकाय के लिए मॉडल को प्रशिक्षित करने की आवश्यकता है।

 >> from model_training import train_all_models #      >> slitherin_models, griffindor_models, ravenclaw_models, hufflpuff_models = \ train_all_models()

बहुपद प्रतिगमन के परिणामों और परिणामों का लंबा निष्कर्ष

 SVM Default Report Accuracy for SVM Default: 73.93 ROC AUC for SVM Default: 0.53 Tuned SVM Report Accuracy for Tuned SVM: 72.37 ROC AUC for Tuned SVM: 0.50 KNN Default Report Accuracy for KNN Default: 70.04 ROC AUC for KNN Default: 0.58 Tuned KNN Report Accuracy for Tuned KNN: 69.65 ROC AUC for Tuned KNN: 0.58 XGBoost Default Report Accuracy for XGBoost Default: 70.43 ROC AUC for XGBoost Default: 0.54 Tuned XGBoost Report Accuracy for Tuned XGBoost: 68.09 ROC AUC for Tuned XGBoost: 0.56 Random Forest Default Report Accuracy for Random Forest Default: 73.93 ROC AUC for Random Forest Default: 0.62 Tuned Random Forest Report Accuracy for Tuned Random Forest: 74.32 ROC AUC for Tuned Random Forest: 0.54 Extra Trees Default Report Accuracy for Extra Trees Default: 69.26 ROC AUC for Extra Trees Default: 0.57 Tuned Extra Trees Report Accuracy for Tuned Extra Trees: 73.54 ROC AUC for Tuned Extra Trees: 0.55 LGBM Default Report Accuracy for LGBM Default: 70.82 ROC AUC for LGBM Default: 0.62 Tuned LGBM Report Accuracy for Tuned LGBM: 74.71 ROC AUC for Tuned LGBM: 0.53 RGF Default Report Accuracy for RGF Default: 70.43 ROC AUC for RGF Default: 0.58 Tuned RGF Report Accuracy for Tuned RGF: 71.60 ROC AUC for Tuned RGF: 0.60 FRGF Default Report Accuracy for FRGF Default: 68.87 ROC AUC for FRGF Default: 0.59 Tuned FRGF Report Accuracy for Tuned FRGF: 69.26 ROC AUC for Tuned FRGF: 0.59 SVM Default Report Accuracy for SVM Default: 70.43 ROC AUC for SVM Default: 0.50 Tuned SVM Report Accuracy for Tuned SVM: 71.60 ROC AUC for Tuned SVM: 0.50 KNN Default Report Accuracy for KNN Default: 63.04 ROC AUC for KNN Default: 0.49 Tuned KNN Report Accuracy for Tuned KNN: 65.76 ROC AUC for Tuned KNN: 0.50 XGBoost Default Report Accuracy for XGBoost Default: 69.65 ROC AUC for XGBoost Default: 0.54 Tuned XGBoost Report Accuracy for Tuned XGBoost: 68.09 ROC AUC for Tuned XGBoost: 0.50 Random Forest Default Report Accuracy for Random Forest Default: 66.15 ROC AUC for Random Forest Default: 0.51 Tuned Random Forest Report Accuracy for Tuned Random Forest: 70.43 ROC AUC for Tuned Random Forest: 0.50 Extra Trees Default Report Accuracy for Extra Trees Default: 64.20 ROC AUC for Extra Trees Default: 0.49 Tuned Extra Trees Report Accuracy for Tuned Extra Trees: 70.82 ROC AUC for Tuned Extra Trees: 0.51 LGBM Default Report Accuracy for LGBM Default: 67.70 ROC AUC for LGBM Default: 0.56 Tuned LGBM Report Accuracy for Tuned LGBM: 70.82 ROC AUC for Tuned LGBM: 0.50 RGF Default Report Accuracy for RGF Default: 66.54 ROC AUC for RGF Default: 0.52 Tuned RGF Report Accuracy for Tuned RGF: 65.76 ROC AUC for Tuned RGF: 0.53 FRGF Default Report Accuracy for FRGF Default: 65.76 ROC AUC for FRGF Default: 0.53 Tuned FRGF Report Accuracy for Tuned FRGF: 69.65 ROC AUC for Tuned FRGF: 0.52 SVM Default Report Accuracy for SVM Default: 74.32 ROC AUC for SVM Default: 0.50 Tuned SVM Report Accuracy for Tuned SVM: 74.71 ROC AUC for Tuned SVM: 0.51 KNN Default Report Accuracy for KNN Default: 69.26 ROC AUC for KNN Default: 0.48 Tuned KNN Report Accuracy for Tuned KNN: 73.15 ROC AUC for Tuned KNN: 0.49 XGBoost Default Report Accuracy for XGBoost Default: 72.76 ROC AUC for XGBoost Default: 0.49 Tuned XGBoost Report Accuracy for Tuned XGBoost: 74.32 ROC AUC for Tuned XGBoost: 0.50 Random Forest Default Report Accuracy for Random Forest Default: 73.93 ROC AUC for Random Forest Default: 0.52 Tuned Random Forest Report Accuracy for Tuned Random Forest: 74.32 ROC AUC for Tuned Random Forest: 0.50 Extra Trees Default Report Accuracy for Extra Trees Default: 73.93 ROC AUC for Extra Trees Default: 0.52 Tuned Extra Trees Report Accuracy for Tuned Extra Trees: 73.93 ROC AUC for Tuned Extra Trees: 0.50 LGBM Default Report Accuracy for LGBM Default: 73.54 ROC AUC for LGBM Default: 0.52 Tuned LGBM Report Accuracy for Tuned LGBM: 74.32 ROC AUC for Tuned LGBM: 0.50 RGF Default Report Accuracy for RGF Default: 73.54 ROC AUC for RGF Default: 0.51 Tuned RGF Report Accuracy for Tuned RGF: 73.93 ROC AUC for Tuned RGF: 0.50 FRGF Default Report Accuracy for FRGF Default: 73.93 ROC AUC for FRGF Default: 0.53 Tuned FRGF Report Accuracy for Tuned FRGF: 73.93 ROC AUC for Tuned FRGF: 0.50 SVM Default Report Accuracy for SVM Default: 80.54 ROC AUC for SVM Default: 0.50 Tuned SVM Report Accuracy for Tuned SVM: 80.93 ROC AUC for Tuned SVM: 0.52 KNN Default Report Accuracy for KNN Default: 78.60 ROC AUC for KNN Default: 0.50 Tuned KNN Report Accuracy for Tuned KNN: 80.16 ROC AUC for Tuned KNN: 0.51 XGBoost Default Report Accuracy for XGBoost Default: 80.54 ROC AUC for XGBoost Default: 0.50 Tuned XGBoost Report Accuracy for Tuned XGBoost: 77.04 ROC AUC for Tuned XGBoost: 0.52 Random Forest Default Report Accuracy for Random Forest Default: 77.43 ROC AUC for Random Forest Default: 0.49 Tuned Random Forest Report Accuracy for Tuned Random Forest: 80.54 ROC AUC for Tuned Random Forest: 0.50 Extra Trees Default Report Accuracy for Extra Trees Default: 76.26 ROC AUC for Extra Trees Default: 0.48 Tuned Extra Trees Report Accuracy for Tuned Extra Trees: 78.60 ROC AUC for Tuned Extra Trees: 0.50 LGBM Default Report Accuracy for LGBM Default: 75.49 ROC AUC for LGBM Default: 0.51 Tuned LGBM Report Accuracy for Tuned LGBM: 80.54 ROC AUC for Tuned LGBM: 0.50 RGF Default Report Accuracy for RGF Default: 78.99 ROC AUC for RGF Default: 0.52 Tuned RGF Report Accuracy for Tuned RGF: 75.88 ROC AUC for Tuned RGF: 0.55 FRGF Default Report Accuracy for FRGF Default: 76.65 ROC AUC for FRGF Default: 0.50 #   ,

 from sklearn.linear_model import LogisticRegression clf = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial') hogwarts_df = load_processed_data_multi() #     data_full = hogwarts_df.drop( [ 'name', 'surname', ], axis=1).copy() X_data = data_full.drop('faculty', axis=1) y = data_full.faculty clf.fit(X_data, y) score_testing_dataset(clf)

   — [0.3602361 0.16166944 0.16771712 0.31037733] Kirill Malev — [0.47473072 0.16051924 0.13511385 0.22963619]   — [0.38697926 0.19330242 0.17451052 0.2452078 ] Harry Potter — [0.40245098 0.16410043 0.16023278 0.27321581]   — [0.13197025 0.16438855 0.17739254 0.52624866]   — [0.17170203 0.1205678 0.14341742 0.56431275] Severus Snape — [0.15558044 0.21589378 0.17370406 0.45482172]   — [0.39301231 0.07397324 0.1212741 0.41174035] Tom Riddle — [0.26623969 0.14194379 0.1728505 0.41896601]   — [0.24843037 0.21632736 0.21532696 0.3199153 ] Salazar Slytherin — [0.09359144 0.26735897 0.2742305 0.36481909]

confusion_matrix:

 confusion_matrix(clf.predict(X_data), y)

 array([[144, 68, 64, 78], [ 8, 9, 8, 6], [ 22, 18, 31, 20], [ 77, 73, 78, 151]])

 def get_predctions_vector (models, person): predictions = [get_predictions_vector (model, person)[1] for model in models] return { 'slitherin': predictions[0], 'griffindor': predictions[1], 'ravenclaw': predictions[2], 'hufflpuff': predictions[3] } def score_testing_dataset (models): testing_dataset = [ " ", "Kirill Malev", " ", "Harry Potter", " ", " ","Severus Snape", " ", "Tom Riddle", " ", "Salazar Slytherin"] data = [] for name in testing_dataset: predictions = get_predctions_vector(models, name) predictions['name'] = name data.append(predictions) scoring_df = pd.DataFrame(data, columns=['name', 'slitherin', 'griffindor', 'hufflpuff', 'ravenclaw']) return scoring_df # Data Science —    ,       top_models = [ slitherin_models[3], griffindor_models[3], ravenclaw_models[3], hufflpuff_models[3] ] score_testing_dataset(top_models)

  name slitherin griffindor hufflpuff ravenclaw 0   0.349084 0.266909 0.110311 0.091045 1 Kirill Malev 0.289914 0.376122 0.384986 0.103056 2   0.338258 0.400841 0.016668 0.124825 3 Harry Potter 0.245377 0.357934 0.026287 0.154592 4   0.917423 0.126997 0.176640 0.096570 5   0.969693 0.106384 0.150146 0.082195 6 Severus Snape 0.663732 0.259189 0.290252 0.074148 7   0.268466 0.579401 0.007900 0.083195 8 Tom Riddle 0.639731 0.541184 0.084395 0.156245 9   0.653595 0.147506 0.172940 0.137134 10 Salazar Slytherin 0.647399 0.169964 0.095450 0.26126

, . ROC AUC , 0.5. , :

;
;
, ;
, ;
, , .

, , , , XGBoost CV , .

! , 70% . , 4 .

 from model_training import train_production_models from xgboost import XGBClassifier best_models = [] for i in range (0,4): best_models.append(XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1, colsample_bytree=0.7, gamma=0, learning_rate=0.05, max_delta_step=0, max_depth=6, min_child_weight=11, missing=-999, n_estimators=1000, n_jobs=1, nthread=4, objective='binary:logistic', random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=1337, silent=1, subsample=0.8)) slitherin_model, griffindor_model, ravenclaw_model, hufflpuff_model = \ train_production_models(best_models) top_models = slitherin_model, griffindor_model, ravenclaw_model, hufflpuff_model score_testing_dataset(top_models)

 name slitherin griffindor hufflpuff ravenclaw 0   0.273713 0.372337 0.065923 0.279577 1 Kirill Malev 0.401603 0.761467 0.111068 0.023902 2   0.031540 0.616535 0.196342 0.217829 3 Harry Potter 0.183760 0.422733 0.119393 0.173184 4   0.945895 0.021788 0.209820 0.019449 5   0.950932 0.088979 0.084131 0.012575 6 Severus Snape 0.634035 0.088230 0.249871 0.036682 7   0.426440 0.431351 0.028444 0.083636 8 Tom Riddle 0.816804 0.136530 0.069564 0.035500 9   0.409634 0.213925 0.028631 0.252723 10 Salazar Slytherin 0.824590 0.067910 0.111147 0.085710

, , .

, , . .

 import pickle pickle.dump(slitherin_model, open("../output/slitherin.xgbm", "wb")) pickle.dump(griffindor_model, open("../output/griffindor.xgbm", "wb")) pickle.dump(ravenclaw_model, open("../output/ravenclaw.xgbm", "wb")) pickle.dump(hufflpuff_model, open("../output/hufflpuff.xgbm", "wb"))

, . , , , .

, , . , . , Data Scientist — -.

;
json- json;
.

, docker-, python-. , flask.

 from __future__ import print_function # In python 2.7 import os import subprocess import json import re from flask import Flask, request, jsonify from inspect import getmembers, ismethod import numpy as npb import pandas as pd import math import os import pickle import xgboost as xgb import sys from letter import Letter from talking_hat import * from sklearn.ensemble import RandomForestClassifier import warnings def prod_predict_classes_for_name (full_name): featurized_person = parse_line_to_hogwarts_df(full_name) person_df = pd.DataFrame(featurized_person, columns=[ 'name', 'surname', 'is_english', 'name_starts_with_vowel', 'name_starts_with_consonant', 'name_ends_with_vowel', 'name_ends_with_consonant', 'name_length', 'name_vowels_count', 'name_double_vowels_count', 'name_consonant_count', 'name_double_consonant_count', 'name_paired_count', 'name_deaf_count', 'name_sonorus_count', 'surname_starts_with_vowel', 'surname_starts_with_consonant', 'surname_ends_with_vowel', 'surname_ends_with_consonant', 'surname_length', 'surname_vowels_count', 'surname_double_vowels_count', 'surname_consonant_count', 'surname_double_consonant_count', 'surname_paired_count', 'surname_deaf_count', 'surname_sonorus_count', ], index=[0] ) slitherin_model = pickle.load(open("models/slitherin.xgbm", "rb")) griffindor_model = pickle.load(open("models/griffindor.xgbm", "rb")) ravenclaw_model = pickle.load(open("models/ravenclaw.xgbm", "rb")) hufflpuff_model = pickle.load(open("models/hufflpuff.xgbm", "rb")) predictions = get_predctions_vector([ slitherin_model, griffindor_model, ravenclaw_model, hufflpuff_model ], person_df.drop(['name', 'surname'], axis=1)) return { 'slitherin': float(predictions[0][1]), 'griffindor': float(predictions[1][1]), 'ravenclaw': float(predictions[2][1]), 'hufflpuff': float(predictions[3][1]) } def predict(params): fullname = params['fullname'] print(params) return prod_predict_classes_for_name(fullname) def create_app(): app = Flask(__name__) functions_list = [predict] @app.route('/<func_name>', methods=['POST']) def api_root(func_name): for function in functions_list: if function.__name__ == func_name: try: json_req_data = request.get_json() if json_req_data: res = function(json_req_data) else: return jsonify({"error": "error in receiving the json input"}) except Exception as e: data = { "error": "error while running the function" } if hasattr(e, 'message'): data['message'] = e.message elif len(e.args) >= 1: data['message'] = e.args[0] return jsonify(data) return jsonify({"success": True, "result": res}) output_string = 'function: %s not found' % func_name return jsonify({"error": output_string}) return app if __name__ == '__main__': app = create_app() app.run(host='0.0.0.0')

Dockerfile:

 FROM datmo/python-base:cpu-py35 #  python3-wheel,        RUN apt-get update; apt-get install -y python3-pip python3-numpy python3-scipy python3-wheel ADD requirements.txt / RUN pip3 install -r /requirements.txt RUN mkdir /code;mkdir /code/models COPY ./python_api.py ./talking_hat.py ./letter.py ./request.py /code/ COPY ./models/* /code/models/ WORKDIR /code CMD python3 /code/python_api.py

 docker build -t talking_hat . && docker rm talking_hat && docker run --name talking_hat -p 5000:5000 talking_hat

— . , Apache Benchmark . , . — .

 $ ab -p data.json -T application/json -c 50 -n 10000 http://0.0.0.0:5000/predict

 This is ApacheBench, Version 2.3 <$Revision: 1807734 $> Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Licensed to The Apache Software Foundation, http://www.apache.org/ Benchmarking 0.0.0.0 (be patient) Completed 1000 requests Completed 2000 requests Completed 3000 requests Completed 4000 requests Completed 5000 requests Completed 6000 requests Completed 7000 requests Completed 8000 requests Completed 9000 requests Completed 10000 requests Finished 10000 requests Server Software: Werkzeug/0.14.1 Server Hostname: 0.0.0.0 Server Port: 5000 Document Path: /predict Document Length: 141 bytes Concurrency Level: 50 Time taken for tests: 238.552 seconds Complete requests: 10000 Failed requests: 0 Total transferred: 2880000 bytes Total body sent: 1800000 HTML transferred: 1410000 bytes Requests per second: 41.92 [#/sec] (mean) Time per request: 1192.758 [ms] (mean) Time per request: 23.855 [ms] (mean, across all concurrent requests) Transfer rate: 11.79 [Kbytes/sec] received 7.37 kb/s sent 19.16 kb/s total Connection Times (ms) min mean[+/-sd] median max Connect: 0 0 0.1 0 3 Processing: 199 1191 352.5 1128 3352 Waiting: 198 1190 352.5 1127 3351 Total: 202 1191 352.5 1128 3352 Percentage of the requests served within a certain time (ms) 50% 1128 66% 1277 75% 1378 80% 1451 90% 1668 95% 1860 98% 2096 99% 2260 100% 3352 (longest request)

, :

 def prod_predict_classes_for_name (full_name): <...> predictions = get_predctions_vector([ app.slitherin_model, app.griffindor_model, app.ravenclaw_model, app.hufflpuff_model ], person_df.drop(['name', 'surname'], axis=1)) return { 'slitherin': float(predictions[0][1]), 'griffindor': float(predictions[1][1]), 'ravenclaw': float(predictions[2][1]), 'hufflpuff': float(predictions[3][1]) } def create_app(): <...> with app.app_context(): app.slitherin_model = pickle.load(open("models/slitherin.xgbm", "rb")) app.griffindor_model = pickle.load(open("models/griffindor.xgbm", "rb")) app.ravenclaw_model = pickle.load(open("models/ravenclaw.xgbm", "rb")) app.hufflpuff_model = pickle.load(open("models/hufflpuff.xgbm", "rb")) return app

 $ docker build -t talking_hat . && docker rm talking_hat && docker run --name talking_hat -p 5000:5000 talking_hat $ ab -p data.json -T application/json -c 50 -n 10000 http://0.0.0.0:5000/predict

 This is ApacheBench, Version 2.3 <$Revision: 1807734 $> Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Licensed to The Apache Software Foundation, http://www.apache.org/ Benchmarking 0.0.0.0 (be patient) Completed 1000 requests Completed 2000 requests Completed 3000 requests Completed 4000 requests Completed 5000 requests Completed 6000 requests Completed 7000 requests Completed 8000 requests Completed 9000 requests Completed 10000 requests Finished 10000 requests Server Software: Werkzeug/0.14.1 Server Hostname: 0.0.0.0 Server Port: 5000 Document Path: /predict Document Length: 141 bytes Concurrency Level: 50 Time taken for tests: 219.812 seconds Complete requests: 10000 Failed requests: 3 (Connect: 0, Receive: 0, Length: 3, Exceptions: 0) Total transferred: 2879997 bytes Total body sent: 1800000 HTML transferred: 1409997 bytes Requests per second: 45.49 [#/sec] (mean) Time per request: 1099.062 [ms] (mean) Time per request: 21.981 [ms] (mean, across all concurrent requests) Transfer rate: 12.79 [Kbytes/sec] received 8.00 kb/s sent 20.79 kb/s total Connection Times (ms) min mean[+/-sd] median max Connect: 0 0 0.1 0 2 Processing: 235 1098 335.2 1035 3464 Waiting: 235 1097 335.2 1034 3462 Total: 238 1098 335.2 1035 3464 Percentage of the requests served within a certain time (ms) 50% 1035 66% 1176 75% 1278 80% 1349 90% 1541 95% 1736 98% 1967 99% 2141 100% 3464 (longest request)

. . , .

निष्कर्ष

, . - .

, :

feature engineering- ( ), , Soundex .
PyTorch . , , .
flask Quart , , .
- -, .

, , . , !

यह लेख ओपन डेटा साइंस समुदाय के बिना प्रकाशित नहीं किया गया होगा, जो डेटा विश्लेषण के क्षेत्र में बड़ी संख्या में रूसी भाषी विशेषज्ञों को एक साथ लाता है।

एक उदाहरण के रूप में टॉकिंग हैट का उपयोग करके अनुसंधान से लेकर कार्यान्वयन तक डेटा विज्ञान परियोजना