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

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

इसके अलावा, विशेष रूप से डेटा शोधकर्ताओं पर जोर देते हुए, अपने अनुभव को साझा करते हुए, जोर देते हैं: "एक मूल्यांकन पद्धति का विकल्प आंशिक रूप से आपके डेटा पर निर्भर होना चाहिए और आपकी राय में, मॉडल अच्छा होना चाहिए" ("डेटा साइंस: शुरुआती लोगों के लिए अंदरूनी जानकारी"। जिसमें कैथी ओ'नील, रशेल शट्ट द्वारा आर भाषा शामिल है) ।

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

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

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

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

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

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

इसे कैसे बनाया जाता है?

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

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

चूंकि इस लेख में समय श्रृंखला का उपयोग उदाहरणों में नहीं किया जाएगा, पूर्वानुमान शब्द का अर्थ भविष्य कहनेवाला विश्लेषण है ।

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

सभी कोड उदाहरण पायथन 3.7.3 पर आईडीई स्पाइडर 3.3.3 कंसोल में निष्पादित किए जाते हैं।

वर्गीकरण की समस्या

सबसे पहले, हम आवश्यक मॉड्यूल और फ़ंक्शंस आयात करते हैं जिनका उपयोग हम डेटा वर्गीकरण की समस्या को हल करने के लिए करेंगे:

#      from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.discriminant_analysis import LinearDiscriminantAnalysis from sklearn.neighbors import KNeighborsClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.naive_bayes import GaussianNB from sklearn.svm import LinearSVC from sklearn.svm import SVC from sklearn.neural_network import MLPClassifier from sklearn.ensemble import BaggingClassifier from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import ExtraTreesClassifier from sklearn.ensemble import AdaBoostClassifier from sklearn.ensemble import GradientBoostingClassifier from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler from sklearn.preprocessing import MinMaxScaler from sklearn.preprocessing import Normalizer from matplotlib import pyplot 

सीधे 'sklearn.datasets' मॉड्यूल से 'अंक' डेटासेट डाउनलोड करें:

 #    dataset = load_digits() 

आईडीई स्पाइडर एक सुविधाजनक उपकरण "वेरिएबल मैनेजर" प्रदान करता है, जो मशीन लर्निंग (कम से कम मेरे लिए) का अध्ययन करने के लिए हर समय उपयोगी है, जैसे अन्य "ट्रिक्स" :

कोड चलाएँ। "चर प्रबंधक" कंसोल में, डेटासेट चर पर क्लिक करें। निम्नलिखित शब्दकोश प्रदर्शित किया गया है:



डेटासेट का विवरण इस प्रकार है:



इस उदाहरण में, हमें 'छवियाँ' कुंजी की आवश्यकता नहीं है, इसलिए हम चर 'डेटा' को चर X के लिए निर्दिष्ट करते हैं, जो कि गुणकों के एक सेट के साथ एक बहुआयामी NumPy सरणी है, 1797 पंक्तियों के 64 स्तंभों का आकार और लक्ष्य के लिए चर Y , प्रत्येक के लिए एक मार्कर के साथ एक बहुआयामी NumPy सरणी है। लाइन।

 #    # dataset = load_digits() X = dataset.data Y = dataset.target 

अगला, हम प्रशिक्षण और परीक्षण भागों में सेट किए गए डेटा को विभाजित करते हैं, एल्गोरिदम के मूल्यांकन के लिए मापदंडों को कॉन्फ़िगर करते हैं (क्रॉस-मान्यता का उपयोग किया जाता है [ एक , दो ]), पैरामीटर 'स्कोरिंग' [ लिंक ] में मीट्रिक 'सटीकता' को परिभाषित करते हुए। सटीकता वस्तुओं की कुल संख्या के सापेक्ष सही ढंग से वर्गीकृत वस्तुओं का अनुपात है। परिणाम के करीब 1, बेहतर [ लिंक ] है। इसके अलावा, पुस्तकों में से एक में यह पाया गया कि 0.95 (या 95%) और उच्चतर से परिणाम उत्कृष्ट माना जाता है।

 #         test_size = 0.2 seed = 7 X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed) #     num_folds = 10 n_estimators = 100 scoring = 'accuracy' 

चर मानों के विकास के लिए X_train और Y_train का उपयोग प्रशिक्षण उद्देश्यों, X_test और Y_test के लिए किया जाता है। इस मामले में, Y_test वैरिएबल पूर्वानुमान की गणना करने में शामिल नहीं है: 'स्कोर' पद्धति का उपयोग करते हुए, जो नीचे दिए गए प्रत्येक एल्गोरिदम के लिए समान है, हम 'सटीकता' मीट्रिक का उपयोग करके सही उत्तरों की गणना करेंगे। यह हमें न्याय करने की अनुमति देगा कि एल्गोरिथ्म कैसे कार्य के साथ मुकाबला करता है। मेरा तर्क नहीं है, हमारे हिस्से के लिए यह सही जवाब के साथ कार को संकेत नहीं देने के लिए इतना मानवीय रूप से व्यर्थ है, लेकिन इसके प्रदर्शन की जांच कैसे करें?

नीचे एल्गोरिदम की एक सूची है जिसे हम सेट किए गए डेटा के साथ फीड करते हैं। गणना के परिणामों के आधार पर, हम यह निष्कर्ष निकालेंगे कि कौन सा एल्गोरिथम (एल्गोरिदम में से कौन सा) सबसे बड़ी दक्षता दिखाता है। इस पद्धति को अच्छी तरह से "मशीन लर्निंग एल्गोरिदम का ब्लिट्ज परीक्षण" कहा जा सकता है (इसके बाद - ब्लिट्ज परीक्षण)।

सुविधा के लिए, जानकारी को प्रत्येक एल्गोरिदम के बगल में संक्षिप्त किया जाएगा। यह ध्यान दिया जाना चाहिए कि प्रत्येक एल्गोरिथ्म की सेटिंग्स डिफ़ॉल्ट (डिफ़ॉल्ट) द्वारा स्वीकार की जाती हैं, कुछ बिंदुओं के अपवाद के साथ, समान स्थिति प्रदान करने के लिए।

रैखिक एल्गोरिदम:

- लॉजिस्टिक रिग्रेशन * / लॉजिस्टिक रिग्रेशन ('LR')
* शब्द "प्रतिगमन" भ्रामक हो सकता है। लेकिन यह मत भूलो कि "लॉजिस्टिक रिग्रेशन" एक वर्गीकरण एल्गोरिथम है
- रेखीय विभेदक विश्लेषण ('LDA')

नॉनलाइनियर एल्गोरिदम:

- k- निकटतम पड़ोसियों की विधि (वर्गीकरण) / के-पड़ोसी वर्गीकरणकर्ता ('KNN')
- निर्णय ट्री क्लासिफायर ('कार्ट')
- नैवे बेस क्लासिफायर ('एनबी')
- रैखिक समर्थन वेक्टर वर्गीकरण विधि (वर्गीकरण) / रैखिक समर्थन वेक्टर वर्गीकरण ('एलएसवीसी')
- सपोर्ट वेक्टर विधि (वर्गीकरण) / C- सपोर्ट वेक्टर वर्गीकरण ('SVC')

कृत्रिम तंत्रिका नेटवर्क एल्गोरिदम:

- बहुपरत परसेप्ट्रॉन / बहुपरत पर्सेप्ट्रॉन ('MLP')

एल्गोरिथम इकट्ठा करना:

- बैगिंग (वर्गीकरण) / बैगिंग क्लासिफायर ('बीजी') (बैगिंग = बूटस्ट्रैप एकत्रीकरण)
- यादृच्छिक वन वर्गीकरण ('आरएफ')
- एक्स्ट्रा ट्रीज़ क्लासिफ़ायर ('ईटी')
- AdaBoost (वर्गीकरण) / AdaBoost क्लासिफायर ('AB') (AdaBoost = अनुकूली बूस्टिंग)
- ग्रेडिंग बूस्टिंग (वर्गीकरण) / ग्रेडिंग बूस्टिंग क्लासिफायर ('जीबी')

इस प्रकार, 'मॉडल' की सूची में निम्नलिखित मॉडल शामिल हैं:

 models = [] models.append(('LR', LogisticRegression())) models.append(('LDA', LinearDiscriminantAnalysis())) models.append(('KNN', KNeighborsClassifier())) models.append(('CART', DecisionTreeClassifier())) models.append(('NB', GaussianNB())) models.append(('LSVC', LinearSVC())) models.append(('SVC', SVC())) models.append(('MLP', MLPClassifier())) models.append(('BG', BaggingClassifier(n_estimators=n_estimators))) models.append(('RF', RandomForestClassifier(n_estimators=n_estimators))) models.append(('ET', ExtraTreesClassifier(n_estimators=n_estimators))) models.append(('AB', AdaBoostClassifier(n_estimators=n_estimators, algorithm='SAMME'))) models.append(('GB', GradientBoostingClassifier(n_estimators=n_estimators))) 

जैसा कि पहले ही उल्लेख किया गया है, क्रॉस-सत्यापन का उपयोग करके प्रत्येक एल्गोरिथ्म की प्रभावशीलता का मूल्यांकन किया जाता है। परिणामस्वरूप, एक संदेश प्रदर्शित होता है (संदेश से संदेश - संक्षिप्त नाम) जिसमें निम्नलिखित जानकारी होती है: एक संक्षिप्त नाम के रूप में मॉडल का नाम, प्रशिक्षण डेटा (मीट्रिक 'सटीकता') पर 10 गुना क्रॉस-सत्यापन का औसत स्कोर, मानक विचलन कोष्ठक में दिखाया गया है , साथ ही परीक्षण डेटा पर 'सटीकता' मीट्रिक का मूल्य।

 #      scores = [] names = [] results = [] predictions = [] msg_row = [] for name, model in models: kfold = KFold(n_splits=num_folds, random_state=seed) cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring) names.append(name) results.append(cv_results) m_fit = model.fit(X_train, Y_train) m_predict = model.predict(X_test) predictions.append(m_predict) m_score = model.score(X_test, Y_test) scores.append(m_score) msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score) msg_row.append(msg) print(msg) 

कोड चलाने के बाद, हमें निम्नलिखित परिणाम मिलते हैं:

 LR: train = 0.957 (0.014) / test = 0.948 LDA: train = 0.951 (0.014) / test = 0.946 KNN: train = 0.985 (0.013) / test = 0.981 CART: train = 0.843 (0.033) / test = 0.830 NB: train = 0.819 (0.048) / test = 0.806 LSVC: train = 0.942 (0.017) / test = 0.928 SVC: train = 0.343 (0.079) / test = 0.342 MLP: train = 0.972 (0.012) / test = 0.961 BG: train = 0.952 (0.021) / test = 0.941 RF: train = 0.968 (0.017) / test = 0.965 ET: train = 0.980 (0.010) / test = 0.975 AB: train = 0.827 (0.049) / test = 0.823 GB: train = 0.964 (0.013) / test = 0.968 

स्पैन चार्ट ( "मूंछ वाला बॉक्स" ) (बॉक्स-और मूंछ आरेख या प्लॉट, बॉक्स प्लॉट):



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

 KNN: train = 0.985 (0.013) / test = 0.981 ET: train = 0.980 (0.010) / test = 0.975 GB: train = 0.964 (0.013) / test = 0.968 RF: train = 0.968 (0.017) / test = 0.965 MLP: train = 0.972 (0.012) / test = 0.961 LR: train = 0.957 (0.014) / test = 0.948 LDA: train = 0.951 (0.014) / test = 0.946 BG: train = 0.952 (0.021) / test = 0.941 LSVC: train = 0.942 (0.017) / test = 0.928 CART: train = 0.843 (0.033) / test = 0.830 AB: train = 0.827 (0.049) / test = 0.823 NB: train = 0.819 (0.048) / test = 0.806 SVC: train = 0.343 (0.079) / test = 0.342 

हालांकि, कई एल्गोरिदम उस डेटा के बारे में बहुत उपयुक्त हैं जो उन्हें परोसा जाता है। इसलिए, आवश्यक कदमों में से एक तथाकथित प्रारंभिक डेटा तैयारी है (डेटा पूर्व-प्रसंस्करण [ लिंक ])

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

प्रारंभिक डेटा तैयारी के लिए सबसे अधिक उपयोग की जाने वाली विधियाँ हैं:

- मानकीकरण;

- स्केलिंग (डिफ़ॉल्ट सीमा [0, 1]) है;

- सामान्यीकरण

बाद के मूल्यांकन के साथ इन कार्यों को स्वचालित किया जा सकता है और पाइपलाइन उपकरण का उपयोग करके कन्वेयर पर रखा जा सकता है।

स्रोत डेटा के मानकीकरण के साथ एक कोड स्निपेट निम्नानुसार है:

 # -      #    ( StandardScaler) pipelines = [] pipelines.append(('SS_LR', Pipeline([('Scaler', StandardScaler()), ('LR', LogisticRegression())]))) pipelines.append(('SS_LDA', Pipeline([('Scaler', StandardScaler()), ('LDA', LinearDiscriminantAnalysis())]))) pipelines.append(('SS_KNN', Pipeline([('Scaler', StandardScaler()), ('KNN', KNeighborsClassifier())]))) pipelines.append(('SS_CART', Pipeline([('Scaler', StandardScaler()), ('CART', DecisionTreeClassifier())]))) pipelines.append(('SS_NB', Pipeline([('Scaler', StandardScaler()), ('NB', GaussianNB())]))) pipelines.append(('SS_LSVC', Pipeline([('Scaler', StandardScaler()), ('LSVC', LinearSVC())]))) pipelines.append(('SS_SVC', Pipeline([('Scaler', StandardScaler()), ('SVC', SVC())]))) pipelines.append(('SS_MLP', Pipeline([('Scaler', StandardScaler()), ('MLP', MLPClassifier())]))) pipelines.append(('SS_BG', Pipeline([('Scaler', StandardScaler()), ('BG', BaggingClassifier(n_estimators=n_estimators))]))) pipelines.append(('SS_RF', Pipeline([('Scaler', StandardScaler()), ('RF', RandomForestClassifier(n_estimators=n_estimators))]))) pipelines.append(('SS_ET', Pipeline([('Scaler', StandardScaler()), ('ET', ExtraTreesClassifier(n_estimators=n_estimators))]))) pipelines.append(('SS_AB', Pipeline([('Scaler', StandardScaler()), ('AB', AdaBoostClassifier(n_estimators=n_estimators, algorithm='SAMME'))]))) pipelines.append(('SS_GB', Pipeline([('Scaler', StandardScaler()), ('GB', GradientBoostingClassifier(n_estimators=n_estimators))]))) #      scores_SS = [] names_SS = [] results_SS = [] predictions_SS = [] msg_SS = [] for name, model in pipelines: kfold = KFold(n_splits=num_folds, random_state=seed) cv_results = cross_val_score(model, X_train, Y_train, cv=kfold) names_SS.append(name) results_SS.append(cv_results) m_fit = model.fit(X_train, Y_train) m_predict = model.predict(X_test) predictions_SS.append(m_predict) m_score = model.score(X_test, Y_test) scores_SS.append(m_score) msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score) msg_SS.append(msg) print(msg) #    (StandardScaler) fig = pyplot.figure() fig.suptitle('     . ') ax = fig.add_subplot(111) red_square = dict(markerfacecolor='r', marker='s') pyplot.boxplot(results_SS, flierprops=red_square) ax.set_xticklabels(names_SS, rotation=45) pyplot.show() 

नामों को सूचीबद्ध करने के लिए '_SS' (StandardScaler के लिए संक्षिप्त) को जोड़ दें। यह परिणामों को ढेर करने के लिए नहीं किया जाता है, साथ ही रूपांतरण किए जाने के बाद "चर प्रबंधक" का उपयोग करके उन्हें आसानी से देखने के लिए किया जाता है।

कोड स्निपेट चलाने से निम्नलिखित परिणाम प्राप्त होते हैं:

 SS_LR: train = 0.958 (0.015) / test = 0.949 SS_LDA: train = 0.951 (0.014) / test = 0.946 SS_KNN: train = 0.968 (0.023) / test = 0.970 SS_CART: train = 0.853 (0.036) / test = 0.835 SS_NB: train = 0.756 (0.046) / test = 0.751 SS_LSVC: train = 0.945 (0.018) / test = 0.941 SS_SVC: train = 0.976 (0.015) / test = 0.990 SS_MLP: train = 0.976 (0.012) / test = 0.973 SS_BG: train = 0.947 (0.018) / test = 0.948 SS_RF: train = 0.973 (0.016) / test = 0.970 SS_ET: train = 0.980 (0.012) / test = 0.975 SS_AB: train = 0.827 (0.049) / test = 0.823 SS_GB: train = 0.964 (0.013) / test = 0.968 

मूंछ बॉक्स (StandardScaler):



मानकीकृत डेटा पर गणना के परिणामों के अनुसार, निम्नलिखित एल्गोरिदम नेता बन गए:

 SS_SVC: train = 0.976 (0.015) / test = 0.990 SS_ET: train = 0.980 (0.012) / test = 0.975 SS_MLP: train = 0.976 (0.012) / test = 0.973 SS_KNN: train = 0.968 (0.023) / test = 0.970 SS_RF: train = 0.973 (0.016) / test = 0.970 SS_GB: train = 0.964 (0.013) / test = 0.968 SS_LR: train = 0.958 (0.015) / test = 0.949 SS_BG: train = 0.947 (0.018) / test = 0.948 SS_LDA: train = 0.951 (0.014) / test = 0.946 SS_LSVC: train = 0.945 (0.018) / test = 0.941 SS_CART: train = 0.853 (0.036) / test = 0.835 SS_AB: train = 0.827 (0.049) / test = 0.823 SS_NB: train = 0.756 (0.046) / test = 0.751 

जैसा कि वे कहते हैं, लत्ता से धन तक: मानक डेटा द्वारा खिलाया गया समर्थन वेक्टर विधि ('एसवीसी') ने उत्कृष्ट परिणाम दिखाया। "मैनुअल" चेक के दौरान, चर Y_test और भविष्यवाणियों_ SS [6] के मूल्यों की तुलना करते हुए, एल्गोरिथ्म ने केवल कुछ मूल्यों को चबाया नहीं था।

इसके बाद, एक ही कोड MinMaxScaler (स्केलिंग) और नॉर्मलाइज़र (सामान्यीकरण) के कार्यों के लिए निष्पादित किया जाता है। मैं लेख में पूरा कोड नहीं दूंगा। आप इसे GitHub: लिंक पर मेरी रिपॉजिटरी से डाउनलोड कर सकते हैं।

बस थोड़ी देर के लिए घूमना और अपने आप को 'शैक्षिक उद्देश्य के लिए' पर हंसना याद रखें! :)

परिणामस्वरूप, पूरे कोड के माध्यम से जाने के बाद, हमें निम्नलिखित परिणाम मिलते हैं:

 LR: train = 0.957 (0.014) / test = 0.948 LDA: train = 0.951 (0.014) / test = 0.946 KNN: train = 0.985 (0.013) / test = 0.981 CART: train = 0.843 (0.033) / test = 0.830 NB: train = 0.819 (0.048) / test = 0.806 LSVC: train = 0.942 (0.017) / test = 0.928 SVC: train = 0.343 (0.079) / test = 0.342 MLP: train = 0.972 (0.012) / test = 0.961 BG: train = 0.952 (0.021) / test = 0.941 RF: train = 0.968 (0.017) / test = 0.965 ET: train = 0.980 (0.010) / test = 0.975 AB: train = 0.827 (0.049) / test = 0.823 GB: train = 0.964 (0.013) / test = 0.968 SS_LR: train = 0.958 (0.015) / test = 0.949 SS_LDA: train = 0.951 (0.014) / test = 0.946 SS_KNN: train = 0.968 (0.023) / test = 0.970 SS_CART: train = 0.853 (0.036) / test = 0.835 SS_NB: train = 0.756 (0.046) / test = 0.751 SS_LSVC: train = 0.945 (0.018) / test = 0.941 SS_SVC: train = 0.976 (0.015) / test = 0.990 SS_MLP: train = 0.976 (0.012) / test = 0.973 SS_BG: train = 0.947 (0.018) / test = 0.948 SS_RF: train = 0.973 (0.016) / test = 0.970 SS_ET: train = 0.980 (0.012) / test = 0.975 SS_AB: train = 0.827 (0.049) / test = 0.823 SS_GB: train = 0.964 (0.013) / test = 0.968 MMS_LR: train = 0.961 (0.013) / test = 0.953 MMS_LDA: train = 0.951 (0.014) / test = 0.946 MMS_KNN: train = 0.985 (0.013) / test = 0.981 MMS_CART: train = 0.850 (0.027) / test = 0.840 MMS_NB: train = 0.796 (0.045) / test = 0.786 MMS_LSVC: train = 0.964 (0.012) / test = 0.958 MMS_SVC: train = 0.963 (0.016) / test = 0.956 MMS_MLP: train = 0.972 (0.011) / test = 0.963 MMS_BG: train = 0.948 (0.024) / test = 0.946 MMS_RF: train = 0.973 (0.014) / test = 0.968 MMS_ET: train = 0.983 (0.010) / test = 0.981 MMS_AB: train = 0.827 (0.049) / test = 0.823 MMS_GB: train = 0.963 (0.013) / test = 0.968 N_LR: train = 0.938 (0.020) / test = 0.919 N_LDA: train = 0.952 (0.013) / test = 0.949 N_KNN: train = 0.981 (0.012) / test = 0.985 N_CART: train = 0.834 (0.028) / test = 0.825 N_NB: train = 0.825 (0.043) / test = 0.805 N_LSVC: train = 0.960 (0.014) / test = 0.953 N_SVC: train = 0.551 (0.053) / test = 0.586 N_MLP: train = 0.963 (0.018) / test = 0.946 N_BG: train = 0.949 (0.016) / test = 0.938 N_RF: train = 0.973 (0.015) / test = 0.970 N_ET: train = 0.982 (0.012) / test = 0.980 N_AB: train = 0.825 (0.040) / test = 0.820 N_GB: train = 0.953 (0.022) / test = 0.956 

'शीर्ष 5' परिणाम:

 SS_SVC: train = 0.976 (0.015) / test = 0.990 N_KNN: train = 0.981 (0.012) / test = 0.985 KNN: train = 0.985 (0.013) / test = 0.981 MMS_KNN: train = 0.985 (0.013) / test = 0.981 MMS_ET: train = 0.983 (0.010) / test = 0.981 

इस प्रकार, 'अंक' डेटासेट की वर्गीकरण समस्या को हल करने के लिए मशीन लर्निंग एल्गोरिदम के ब्लिट्ज परीक्षण के परिणामों के अनुसार, सबसे उपयुक्त मशीन लर्निंग एल्गोरिदम हैं: k- निकटतम पड़ोसी ('KNN') विधि, समर्थन वेक्टर विधि ('SVC') और अतिरिक्त-पेड़ ( 'एट')। इन एल्गोरिदम को गणना की दक्षता बढ़ाने के उद्देश्य से परिणामों के आगे के विकास पर ध्यान देना चाहिए। सब कुछ, जैसा कि वे कहते हैं, हल करने योग्य है।

और इस उठाए गए नोट पर, सुचारू रूप से 2 भाग पर आगे बढ़ें।

पूर्वानुमान की समस्या

हम अंगूठे पर चलते हैं:

 #      from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.linear_model import Ridge from sklearn.linear_model import Lasso from sklearn.linear_model import ElasticNet from sklearn.linear_model import LarsCV from sklearn.linear_model import BayesianRidge from sklearn.neighbors import KNeighborsRegressor from sklearn.tree import DecisionTreeRegressor from sklearn.svm import LinearSVR from sklearn.svm import SVR from sklearn.ensemble import AdaBoostRegressor from sklearn.ensemble import BaggingRegressor from sklearn.ensemble import ExtraTreesRegressor from sklearn.ensemble import GradientBoostingRegressor from sklearn.ensemble import RandomForestRegressor from sklearn.model_selection import KFold from sklearn.model_selection import cross_val_score from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler from sklearn.preprocessing import Normalizer from matplotlib import pyplot #    dataset = load_boston() 

कोड चलाएं और शब्दकोश से निपटें। विवरण और कुंजियाँ इस प्रकार हैं:





हम चर ' एक्स ' को कुंजी 'डेटा' प्रदान करते हैं, जो कि एक गुणक नुमाइंदे सरणी है, जिसमें 13 कॉलम द्वारा 506 पंक्तियों का आयाम, और चर Y- 'लक्ष्य', प्रत्येक पंक्ति के लिए एक मार्कर के साथ बहुआयामी NumPy सरणी है।

 #    #dataset = load_boston() X = dataset.data Y = dataset.target 

हम प्रशिक्षण और परीक्षण भागों में सेट किए गए डेटा को विभाजित करते हैं, एल्गोरिदम के मूल्यांकन के लिए मापदंडों को कॉन्फ़िगर करते हैं। पैरामीटर 'स्कोरिंग' में हम प्रतिगमन विश्लेषण के लिए पारंपरिक 'r2' में से एक को निर्धारित करते हैं :

 #    dataset = load_boston() X = dataset.data Y = dataset.target #         test_size = 0.2 seed = 7 X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed) #     num_folds = 10 n_iter = 1000 n_estimators = 100 scoring = 'r2' 

आर 2 - निर्धारण का गुणांक - यह प्रश्न ( लिंक ) में मॉडल द्वारा समझाया गया आश्रित चर के विचरण का अनुपात है।

"एक स्थिर के साथ एक मॉडल के लिए दृढ़ संकल्प का गुणांक 0 से 1 तक मान लेता है। गुणांक 1 के करीब है, निर्भरता जितनी मजबूत होती है। प्रतिगमन मॉडल का मूल्यांकन करते समय, यह डेटा के साथ मॉडल के मिलान के रूप में व्याख्या की जाती है। स्वीकार्य मॉडल के लिए, यह माना जाता है कि निर्धारण का गुणांक कम से कम 50% होना चाहिए (इस मामले में, एकाधिक सहसंबंध का गुणांक 70% मोडुलो से अधिक है)। 80% से ऊपर एक निर्धारण गुणांक वाले मॉडल को काफी अच्छा माना जा सकता है (सहसंबंध गुणांक 90% से अधिक है)। एकता के निर्धारण के गुणांक की समानता का अर्थ है कि समझाया गया चर बिल्कुल विचार के तहत मॉडल द्वारा वर्णित है " (ibid।)।

पूर्वानुमान की समस्या को हल करने के लिए, हम निम्नलिखित एल्गोरिदम का उपयोग करते हैं:

रैखिक एल्गोरिदम:

- रेखीय प्रतिगमन ('LR')
- रिज रिग्रेशन (रिज रिग्रेशन) / रिज रिग्रेशन ('आर')
- लास्सो प्रतिगमन (अंग्रेजी LASSO से - कम से कम संकोचन और चयन संचालक) / लास्सो प्रतिगमन ('L')
- इलास्टिक नेट रिग्रेशन ('ELN') रिग्रेशन विधि
- लिस्ट एंगल रिग्रेशन (LARS) ('LARS') विधि
- बायेसियन रिज रिग्रेशन / Bayesian रिज रिग्रेशन ('BR')

नॉनलाइनियर एल्गोरिदम:

- k- निकटतम पड़ोसी प्रतिगामी ('KNR') विधि
- डिसीजन ट्री रेजिस्टर ('DTR')
- रैखिक समर्थन वेक्टर मशीन (प्रतिगमन) / रैखिक समर्थन वेक्टर मशीन - प्रतिगमन / ('एलएसवीआर')
- सपोर्ट वेक्टर विधि (रिग्रेशन) / एप्सिलॉन-सपोर्ट वेक्टर रिग्रेशन ('एसवीआर')

एल्गोरिथम इकट्ठा करना:

- AdaBoost (प्रतिगमन) / AdaBoost Regressor ('ABR') (AdaBoost = Adaptive Boosting )
- बैगिंग (प्रतिगमन) / बैगिंग रजिस्ट्रार ('बीआर') ( बैगिंग = बूटस्ट्रैप समुच्चय)
- एक्स्ट्रा ट्रीज रेजिस्टर ('ETR')
- ग्रैडिएंट बूस्टिंग (रिग्रेशन) / ग्रैडिएंट बूस्टिंग रेजिस्टर ('GBR')
- रैंडम फॉरेस्ट क्लासिफिकेशन (प्रतिगमन) / रैंडम फॉरेस्ट क्लासिफायरिफायर ('RFR')

इस प्रकार, 'मॉडल' की सूची में निम्नलिखित मॉडल शामिल हैं:

 models = [] models.append(('LR', LinearRegression())) models.append(('R', Ridge())) models.append(('L', Lasso())) models.append(('ELN', ElasticNet())) models.append(('LARS', Lars())) models.append(('BR', BayesianRidge(n_iter=n_iter))) models.append(('KNR', KNeighborsRegressor())) models.append(('DTR', DecisionTreeRegressor())) models.append(('LSVR', LinearSVR())) models.append(('SVR', SVR())) models.append(('ABR', AdaBoostRegressor(n_estimators=n_estimators))) models.append(('BR', BaggingRegressor(n_estimators=n_estimators))) models.append(('ETR', ExtraTreesRegressor(n_estimators=n_estimators))) models.append(('GBR', GradientBoostingRegressor(n_estimators=n_estimators))) models.append(('RFR', RandomForestRegressor(n_estimators=n_estimators))) 

वर्गीकरण के साथ, प्रत्येक एल्गोरिथ्म की प्रभावशीलता का मूल्यांकन क्रॉस-मान्यता का उपयोग करके किया जाता है। प्रदर्शित संदेश में निम्नलिखित जानकारी है: एक संक्षिप्त नाम के रूप में मॉडल का नाम, प्रशिक्षण डेटा (मीट्रिक 'r2') पर 10 गुना क्रॉस-सत्यापन का औसत स्कोर, मानक विचलन और परीक्षण डेटा पर निर्धारण गुणांक r2 कोष्ठक में दिखाया गया है।

 #      scores = [] names = [] results = [] predictions = [] msg_row = [] for name, model in models: kfold = KFold(n_splits=num_folds, random_state=seed) cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring) names.append(name) results.append(cv_results) m_fit = model.fit(X_train, Y_train) m_predict = model.predict(X_test) predictions.append(m_predict) m_score = model.score(X_test, Y_test) scores.append(m_score) msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score) msg_row.append(msg) print(msg) #   («  ») fig = pyplot.figure() fig.suptitle('   ') ax = fig.add_subplot(111) red_square = dict(markerfacecolor='r', marker='s') pyplot.boxplot(results, flierprops=red_square) ax.set_xticklabels(names, rotation=45) pyplot.show() 

कोड चलाने के बाद, हमें निम्नलिखित परिणाम मिलते हैं:

 LR: train = 0.746 (0.068) / test = 0.579 R: train = 0.744 (0.067) / test = 0.570 L: train = 0.689 (0.070) / test = 0.641 ELN: train = 0.677 (0.074) / test = 0.662 LARS: train = 0.744 (0.069) / test = 0.579 BR: train = 0.739 (0.069) / test = 0.571 KNR: train = 0.434 (0.288) / test = 0.538 DTR: train = 0.671 (0.145) / test = 0.637 LSVR: train = 0.550 (0.144) / test = 0.459 SVR: train = -0.012 (0.048) / test = -0.003 ABR: train = 0.810 (0.078) / test = 0.763 BR: train = 0.854 (0.064) / test = 0.805 ETR: train = 0.889 (0.047) / test = 0.836 GBR: train = 0.878 (0.042) / test = 0.863 RFR: train = 0.852 (0.068) / test = 0.819 

स्पैन चार्ट:



स्पष्ट नेता '' GBR '' (ग्रेडिएंट 'बूस्टिंग'), 'ETR' (एक्स्ट्रा-ट्रीज़), 'RFR' (रैंडम फॉरेस्ट) और 'BR' ('बैगिंग') हैं।

 GBR: train = 0.878 (0.042) / test = 0.863 ETR: train = 0.889 (0.047) / test = 0.836 RFR: train = 0.852 (0.068) / test = 0.819 BR: train = 0.854 (0.064) / test = 0.805 ABR: train = 0.810 (0.078) / test = 0.763 ELN: train = 0.677 (0.074) / test = 0.662 L: train = 0.689 (0.070) / test = 0.641 DTR: train = 0.671 (0.145) / test = 0.637 LR: train = 0.746 (0.068) / test = 0.579 LARS: train = 0.744 (0.069) / test = 0.579 BR: train = 0.739 (0.069) / test = 0.571 R: train = 0.744 (0.067) / test = 0.570 KNR: train = 0.434 (0.288) / test = 0.538 LSVR: train = 0.550 (0.144) / test = 0.459 SVR: train = -0.012 (0.048) / test = -0.003 

एक "एडबस्ट", "लोशारा" की तरह, पीछे रह जाता है।

शायद तीनों नेता मानकीकरण और सामान्यीकरण का मुकाबला कर रहे हैं। आइए बाकी कोड को निष्पादित करके पता करें।

परिणाम इस प्रकार हैं:

 SS_LR: train = 0.746 (0.068) / test = 0.579 SS_R: train = 0.746 (0.068) / test = 0.578 SS_L: train = 0.678 (0.054) / test = 0.510 SS_ELN: train = 0.665 (0.060) / test = 0.513 SS_LARS: train = 0.744 (0.069) / test = 0.579 SS_BR: train = 0.746 (0.066) / test = 0.576 SS_KNR: train = 0.763 (0.098) / test = 0.739 SS_DTR: train = 0.610 (0.242) / test = 0.629 SS_LSVR: train = 0.727 (0.091) / test = 0.482 SS_SVR: train = 0.653 (0.126) / test = 0.610 SS_ABR: train = 0.811 (0.076) / test = 0.819 SS_BR: train = 0.853 (0.074) / test = 0.813 SS_ETR: train = 0.887 (0.048) / test = 0.846 SS_GBR: train = 0.878 (0.038) / test = 0.860 SS_RFR: train = 0.851 (0.071) / test = 0.818 N_LR: train = 0.751 (0.099) / test = 0.576 N_R: train = 0.287 (0.126) / test = 0.271 N_L: train = -0.030 (0.032) / test = -0.000 N_ELN: train = -0.007 (0.030) / test = 0.023 N_LARS: train = 0.751 (0.099) / test = 0.576 N_BR: train = 0.744 (0.100) / test = 0.589 N_KNR: train = 0.485 (0.192) / test = 0.504 N_DTR: train = 0.729 (0.080) / test = 0.765 N_LSVR: train = 0.182 (0.108) / test = 0.136 N_SVR: train = 0.086 (0.076) / test = 0.084 N_ABR: train = 0.795 (0.053) / test = 0.752 N_BR: train = 0.854 (0.054) / test = 0.827 N_ETR: train = 0.877 (0.048) / test = 0.850 N_GBR: train = 0.852 (0.063) / test = 0.872 N_RFR: train = 0.852 (0.051) / test = 0.801 

जैसा कि आप देख सकते हैं, पहनावा के तरीके अभी भी सभी से आगे हैं।

'शीर्ष 5' में निम्नलिखित परिणाम हैं:

 N_GBR: train = 0.852 (0.063) / test = 0.872 GBR: train = 0.878 (0.042) / test = 0.863 SS_GBR: train = 0.878 (0.038) / test = 0.860 N_ETR: train = 0.877 (0.048) / test = 0.850 SS_ETR: train = 0.887 (0.048) / test = 0.846 

हम परिणामों की तुलना करते हुए एक चार्ट प्रदर्शित करेंगे:



Y- परीक्षण मानक है। आरेख में दिखाए गए पांच चयनित परिणाम एक धराशायी रेखा द्वारा दर्शाए गए हैं। यह देखा जा सकता है कि सभी चोटियों को या तो सटीक पुनरावृत्ति के साथ, या एक डिग्री या किसी अन्य के साथ पुन: पेश किया गया था।

टॉप 5 में शामिल एल्गोरिथम के संदर्भ मूल्यों और पूर्वानुमान मूल्यों की मैन्युअल तुलना का संक्षिप्त अंश:



इस प्रकार, 'बस्टन हाउस-प्राइस' डेटासेट के पूर्वानुमान की समस्या को हल करने के लिए मशीन लर्निंग एल्गोरिदम के ब्लिट्ज टेस्ट के परिणामों के अनुसार, सबसे उपयुक्त एल्गोरिदम ग्रेडिएंट "बूस्टिंग" ('GBR' हैं) ') और अतिरिक्त पेड़ (' ETR ')। इन एल्गोरिदम को परिणामों को और विकसित करने और पूर्वानुमानों की प्रभावशीलता को बढ़ाने के लिए करीब से ध्यान दिया जाना चाहिए।

अंतभाषण

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

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

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

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

पुनश्च लेख के अंत तक मैंने पहले से ही खुद को भविष्यवाणी करना शुरू कर दिया था, इसलिए आगामी प्रश्नों के बारे में कि मुझे पहली आकृति में धोखा पत्र कहाँ मिला है: मैं एक ही साइट पर सब कुछ scikit-learn.org ( 'सही अनुमानक का चयन' ): लिंक । और एक प्रस्फुटित समोदेल्किन के रूप में कृत्रिम बुद्धिमत्ता का आत्मसात मेरे सुखद बचपन की स्मृति की लहरों से है।