पंडों + स्केलेर का उपयोग करके अजगर में डेटा विश्लेषण की मूल बातें

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

समस्या का बयान

इसलिए कार्य का सार एक मॉडल बनाने के लिए मशीन सीखने के तरीकों का उपयोग करना है जो भविष्यवाणी करेगा कि एक व्यक्ति को बचाया जाएगा या नहीं। 2 फाइलें कार्य से जुड़ी हैं:

• train.csv - एक डेटा सेट जिसके आधार पर मॉडल बनाया जाएगा ( प्रशिक्षण सेट )
  
• test.csv - मॉडल सत्यापन के लिए डेटा सेट
  

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

• यात्री आईडी - यात्री आईडी
  
• जीवन रक्षा - वह क्षेत्र जिसमें व्यक्ति को बचाया जाता है (1) या नहीं (0)
  
• Pclass - इसमें सामाजिक-आर्थिक स्थिति शामिल है:
  
  1. लंबा
  2. औसत
  3. कम
• नाम - यात्री का नाम
  
• लिंग - यात्री लिंग
  
• आयु - आयु
  
• SibSp - 2 क्रम के पति (पति, पत्नी, भाइयों, सेतरा) की संख्या के बारे में जानकारी शामिल है
  
• Parch - 1 क्रम पर रिश्तेदारों की संख्या के बारे में जानकारी शामिल है (माँ, पिता, बच्चे)
  
• टिकट - टिकट नंबर
  
• किराया - टिकट की कीमत
  
• केबिन - केबिन
  
• उभारित - बंदरगाह का लैंडिंग
  
  • सी - चेरबर्ग
  • क्यू - क्वीन्सटाउन
  • S - साउथैम्पटन
    

इनपुट विश्लेषण

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

from pandas import read_csv, DataFrame, Series data = read_csv('Kaggle_Titanic/Data/train.csv') 

PassengerId	बच गया	Pclass	नाम	लिंग	आयु	SibSp	सूखना	टिकट	किराया	केबिन	शुरू
1	0	3	ब्रूंड, मि। ओवेन हैरिस	नर	22	1	0	ए / ५ २११ /१	7.2500	NaN	एस
2	1	1	कमिंग्स, श्रीमती। जॉन ब्रैडली (फ्लोरेंस ब्रिग्स थ ...	महिला	38	1	0	पीसी 17599	71.2833	C85	सी
3	1	3	हिककिनन, मिस। Laina	महिला	26	0	0	पत्थर / O2। 3101282	7.9250	NaN	एस
4	1	1	फ्यूट्रेल, श्रीमती। जैक्स हीथ (लिली मे पील)	महिला	35	1	0	113,803	53.1000	C123	एस
5	0	3	एलन, मि। विलियम हेनरी	नर	35	0	0	373,450	8.0500	NaN	एस

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

 data.pivot_table('PassengerId', 'Pclass', 'Survived', 'count').plot(kind='bar', stacked=True) 

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

 fig, axes = plt.subplots(ncols=2) data.pivot_table('PassengerId', ['SibSp'], 'Survived', 'count').plot(ax=axes[0], title='SibSp') data.pivot_table('PassengerId', ['Parch'], 'Survived', 'count').plot(ax=axes[1], title='Parch') 

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

 data.PassengerId[data.Cabin.notnull()].count() 

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

 data.PassengerId[data.Age.notnull()].count() 

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

 data.Age = data.Age.median() 

हमें फील्ड टिकट , एम्ब्र्डेड , फेयर , नाम से निपटना होगा । आइए एम्बार्केड फ़ील्ड को देखें, जहां एम्बार्केशन का पोर्ट स्थित है और जांचें कि क्या कोई यात्री है जिसका पोर्ट निर्दिष्ट नहीं है:

 data[data.Embarked.isnull()] 

PassengerId	बच गया	Pclass	नाम	लिंग	आयु	SibSp	सूखना	टिकट	किराया	केबिन	शुरू
62	1	1	आईकार्ड, मिस। एमीली	महिला	28	0	0	113,572	80	B28	NaN
830	1	1	पत्थर, श्रीमती। जॉर्ज नेल्सन (मार्था एवलिन)	महिला	28	0	0	113,572	80	B28	NaN

तो हमारे पास ऐसे 2 यात्री थे। आइए इन यात्रियों को उस बंदरगाह को सौंपें जिसमें गाँव के लोग सबसे अधिक हैं:

 MaxPassEmbarked = data.groupby('Embarked').count()['PassengerId'] data.Embarked[data.Embarked.isnull()] = MaxPassEmbarked[MaxPassEmbarked == MaxPassEmbarked.max()].index[0] 

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

 data.PassengerId[data.Fare.isnull()] 

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

 data = data.drop(['PassengerId','Name','Ticket','Cabin'],axis=1) 

बच गया	Pclass	लिंग	आयु	SibSp	सूखना	किराया	शुरू
0	3	नर	28	1	0	7.2500	एस
1	1	महिला	28	1	0	71.2833	सी
1	3	महिला	28	0	0	7.9250	एस
1	1	महिला	28	1	0	53.1000	एस
0	3	नर	28	0	0	8.0500	एस

इनपुट प्रीप्रोसेसिंग

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

 from sklearn.preprocessing import LabelEncoder label = LabelEncoder() dicts = {} label.fit(data.Sex.drop_duplicates()) #     dicts['Sex'] = list(label.classes_) data.Sex = label.transform(data.Sex) #       label.fit(data.Embarked.drop_duplicates()) dicts['Embarked'] = list(label.classes_) data.Embarked = label.transform(data.Embarked) 

परिणामस्वरूप, हमारा प्रारंभिक डेटा इस तरह दिखाई देगा:

बच गया	Pclass	लिंग	आयु	SibSp	सूखना	किराया	शुरू
0	3	1	28	1	0	7.2500	2
1	1	0	28	1	0	71.2833	0
1	3	0	28	0	0	7.9250	2
1	1	0	28	1	0	53.1000	2
0	3	1	28	0	0	8.0500	2

अब हमें वेरिफिकेशन फाइल को उस फॉर्म में लाने के लिए कोड लिखना होगा जो हमें चाहिए। ऐसा करने के लिए, आप बस ऊपर दिए गए कोड के टुकड़ों को कॉपी कर सकते हैं (या इनपुट फ़ाइल को संसाधित करने के लिए एक फ़ंक्शन लिखें):

 test = read_csv('Kaggle_Titanic/Data/test.csv') test.Age[test.Age.isnull()] = test.Age.mean() test.Fare[test.Fare.isnull()] = test.Fare.median() #      MaxPassEmbarked = test.groupby('Embarked').count()['PassengerId'] test.Embarked[test.Embarked.isnull()] = MaxPassEmbarked[MaxPassEmbarked == MaxPassEmbarked.max()].index[0] result = DataFrame(test.PassengerId) test = test.drop(['Name','Ticket','Cabin','PassengerId'],axis=1) label.fit(dicts['Sex']) test.Sex = label.transform(test.Sex) label.fit(dicts['Embarked']) test.Embarked = label.transform(test.Embarked) 

ऊपर वर्णित कोड लगभग वही संचालन करता है जो हमने प्रशिक्षण नमूने के साथ किया था। अंतर यह है कि फेयर फील्ड को प्रोसेस करने के लिए एक लाइन जोड़ी गई है, अगर यह अचानक नहीं भरी जाती है।

Pclass	लिंग	आयु	SibSp	सूखना	किराया	शुरू
3	1	34.5	0	0	7.8292	1
3	0	47.0	1	0	7.0000	2
2	1	62.0	0	0	9.6875	1
3	1	27.0	0	0	8.6625	2
3	0	22.0	1	1	12.2875	2

वर्गीकरण मॉडल और उनके विश्लेषण का निर्माण

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

• वेक्टर विधि का समर्थन करें
  
• निकटतम पड़ोसी विधि
  
• बेतरतीब जंगल
  
• लॉजिस्टिक रिग्रेशन
  

हमें जिन पुस्तकालयों की आवश्यकता है, उन्हें डाउनलोड करें:

 from sklearn import cross_validation, svm from sklearn.neighbors import KNeighborsClassifier from sklearn.ensemble import RandomForestClassifier from sklearn.linear_model import LogisticRegression from sklearn.metrics import roc_curve, auc import pylab as pl 

शुरू करने के लिए, हमारे प्रशिक्षण नमूने को उस संकेतक में विभाजित करना आवश्यक है जिसे हम जांच कर रहे हैं, और इसके परिभाषित संकेत:

 target = data.Survived train = data.drop(['Survived'], axis=1) #    Id        kfold = 5 #    itog_val = {} #        

अब हमारा प्रशिक्षण सेट इस तरह दिखता है:

Pclass	लिंग	आयु	SibSp	सूखना	किराया	शुरू
3	1	28	1	0	7.2500	2
1	0	28	1	0	71.2833	0
3	0	28	0	0	7.9250	2
1	0	28	1	0	53.1000	2
3	1	28	0	0	8.0500	2

अब हम ROC घटता की गणना के लिए पहले प्राप्त किए गए संकेतकों को 2 उप-वर्गों (प्रशिक्षण और परीक्षण) में विभाजित करेंगे (आपको रोलिंग नियंत्रण के लिए ऐसा करने की आवश्यकता नहीं है, क्योंकि सत्यापन कार्य यह स्वयं करता है। cross_validation मॉड्यूल का train_test_split फ़ंक्शन हमें इसमें मदद करेगा:

 ROCtrainTRN, ROCtestTRN, ROCtrainTRG, ROCtestTRG = cross_validation.train_test_split(train, target, test_size=0.25) 

इसके लिए निम्नलिखित पैरामीटर दिए गए हैं:

• मापदंडों का सरणी
  
• सूचक मूल्यों की सरणी
  
• जिस अनुपात में प्रशिक्षण नमूना विभाजित किया जाएगा (हमारे मामले में, परीक्षण प्रशिक्षण के लिए प्रारंभिक प्रशिक्षण नमूने का 1/4 डेटा आवंटित किया जाएगा)
  

आउटपुट पर, फ़ंक्शन 4 सरणियाँ देता है:

1. नया प्रशिक्षण पैरामीटर सरणी
   
2. मापदंडों का परीक्षण सरणी
   
3. संकेतक के नए सरणी
   
4. संकेतकों का परीक्षण सरणी
   

प्रयोगात्मक रूप से चयनित सर्वोत्तम मापदंडों के साथ सूचीबद्ध तरीके निम्नलिखित हैं:

 model_rfc = RandomForestClassifier(n_estimators = 70) #   -  model_knc = KNeighborsClassifier(n_neighbors = 18) #   -  model_lr = LogisticRegression(penalty='l1', tol=0.01) model_svc = svm.SVC() #  kernek='rbf' 

अब हम स्लाइडिंग नियंत्रण का उपयोग करके प्राप्त मॉडल की जांच करेंगे। ऐसा करने के लिए, हमें cross_val_score फ़ंक्शन का उपयोग करने की आवश्यकता है

 scores = cross_validation.cross_val_score(model_rfc, train, target, cv = kfold) itog_val['RandomForestClassifier'] = scores.mean() scores = cross_validation.cross_val_score(model_knc, train, target, cv = kfold) itog_val['KNeighborsClassifier'] = scores.mean() scores = cross_validation.cross_val_score(model_lr, train, target, cv = kfold) itog_val['LogisticRegression'] = scores.mean() scores = cross_validation.cross_val_score(model_svc, train, target, cv = kfold) itog_val['SVC'] = scores.mean() 

आइए प्रत्येक मॉडल के औसत क्रॉस-सत्यापन परीक्षण स्कोर के ग्राफ को देखें:

 DataFrame.from_dict(data = itog_val, orient='index').plot(kind='bar', legend=False) 

जैसा कि आप ग्राफ से देख सकते हैं, RandomForest एल्गोरिथ्म ने खुद को सबसे अच्छा दिखाया। अब क्लासीफायर की सटीकता का आकलन करने के लिए आरओसी-कर्व्स के ग्राफ पर एक नजर डालते हैं। हम matplotlib लाइब्रेरी का उपयोग करते हुए ग्राफ खींचेंगे :

 pl.clf() plt.figure(figsize=(8,6)) #SVC model_svc.probability = True probas = model_svc.fit(ROCtrainTRN, ROCtrainTRG).predict_proba(ROCtestTRN) fpr, tpr, thresholds = roc_curve(ROCtestTRG, probas[:, 1]) roc_auc = auc(fpr, tpr) pl.plot(fpr, tpr, label='%s ROC (area = %0.2f)' % ('SVC', roc_auc)) #RandomForestClassifier probas = model_rfc.fit(ROCtrainTRN, ROCtrainTRG).predict_proba(ROCtestTRN) fpr, tpr, thresholds = roc_curve(ROCtestTRG, probas[:, 1]) roc_auc = auc(fpr, tpr) pl.plot(fpr, tpr, label='%s ROC (area = %0.2f)' % ('RandonForest',roc_auc)) #KNeighborsClassifier probas = model_knc.fit(ROCtrainTRN, ROCtrainTRG).predict_proba(ROCtestTRN) fpr, tpr, thresholds = roc_curve(ROCtestTRG, probas[:, 1]) roc_auc = auc(fpr, tpr) pl.plot(fpr, tpr, label='%s ROC (area = %0.2f)' % ('KNeighborsClassifier',roc_auc)) #LogisticRegression probas = model_lr.fit(ROCtrainTRN, ROCtrainTRG).predict_proba(ROCtestTRN) fpr, tpr, thresholds = roc_curve(ROCtestTRG, probas[:, 1]) roc_auc = auc(fpr, tpr) pl.plot(fpr, tpr, label='%s ROC (area = %0.2f)' % ('LogisticRegression',roc_auc)) pl.plot([0, 1], [0, 1], 'k--') pl.xlim([0.0, 1.0]) pl.ylim([0.0, 1.0]) pl.xlabel('False Positive Rate') pl.ylabel('True Positive Rate') pl.legend(loc=0, fontsize='small') pl.show() 

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

 model_rfc.fit(train, target) result.insert(1,'Survived', model_rfc.predict(test)) result.to_csv('Kaggle_Titanic/Result/test.csv', index=False) 

निष्कर्ष

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