Kaggle ट्यूटोरियल: EDA और मशीन लर्निंग

इस महीने की शुरुआत में, मैंने एक Facebook Live Code Along सत्र किया जिसमें मैंने (और जिन-जिन लोगों ने साथ कोड किया) बढ़ती जटिलता वाले कई एल्गोरिद्म बनाए जो यह भविष्यवाणी करते हैं कि Titanic पर कोई भी यात्री बचा या नहीं, बशर्ते उनके बारे में किराया, चढ़ने का बंदरगाह और आयु जैसी जानकारी दी गई हो।

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

खास तौर पर, आपको याद होगा कि हमने supervised learning मॉडल बनाए थे।

Supervised learning, Machine Learning (ML) की वह शाखा है जिसमें 'Survived' या 'Not' जैसे लेबल की भविष्यवाणी की जाती है। ऐसे मॉडल लेबल वाले डेटा से सीखते हैं, यानी वह डेटा जिसमें यह शामिल होता है कि कोई यात्री बचा था या नहीं (इसे "model training" कहा जाता है), और फिर बिना लेबल वाले डेटा पर भविष्यवाणी करते हैं।

Kaggle पर, जो predictive modelling और analytics प्रतियोगिताओं का एक प्लेटफ़ॉर्म है, इन्हें train और test सेट कहा जाता है क्योंकि

• आप ऐसा मॉडल बनाना चाहते हैं जो training सेट में पैटर्न सीखे, और
• फिर आप उसी मॉडल का उपयोग test सेट पर भविष्यवाणी करने के लिए करें।

इसके बाद Kaggle आपको आपके सही उत्तरों का प्रतिशत बताता है: इसे आपके मॉडल की accuracy कहा जाता है।

Supervised Learning की शुरुआत कैसे करें

जैसा कि आप जानते होंगे, supervised learning को अप्रोच करने का एक अच्छा तरीका यह है:

• अपने डेटा सेट पर Exploratory Data Analysis (EDA) करें;
• एक त्वरित और साधारण, या baseline मॉडल बनाएं, जो बाद में बनने वाले मॉडलों की तुलना के लिए मानक दे सके;
• इस प्रक्रिया को दोहराएँ। आप और EDA करेंगे और एक अन्य मॉडल बनाएँगे;
• फ़ीचर इंजीनियरिंग करें: मौजूदा फ़ीचर्स को मिलाएँ या उनसे अधिक जानकारी निकालें ताकि अंततः आखिरी बिंदु तक पहुँचा जा सके, जो है
• ऐसा मॉडल पाना जो बेहतर प्रदर्शन करे।

इस code along सत्र में, आपने ये सभी कदम किए हैं या करेंगे!

नोट कि हमारे पास ऐसे कोर्स भी हैं जो आपको Titanic डेटा सेट के लिए मशीन लर्निंग में शुरुआत करने में मदद करते हैं, Python और R में।

अपना डेटा इम्पोर्ट करें और देख लें

पहला कदम हमेशा यही होता है कि आप अपना डेटा इम्पोर्ट करें ताकि जिस डेटा पर आप काम करने वाले हैं, उसकी एक त्वरित झलक मिल सके। इस मामले में, आप pandas पैकेज इम्पोर्ट करेंगे और read_csv() फ़ंक्शन का उपयोग करके डेटा पढ़ेंगे:

नोट कि नीचे दिए गए कोड खंडों में, matplotlib, sklearn और seaborn जैसे अन्य पैकेज और उनके मॉड्यूल पहले से इम्पोर्ट किए गए हैं। आप आगे चलकर (सांख्यिकीय) डेटा विज़ुअलाइज़ेशन और मशीन लर्निंग के लिए इनका और व्यापक उपयोग करेंगे!

आप IPython का मैजिक कमांड %matplotlib inline भी इस्तेमाल करते हैं ताकि आपके प्लॉट्स नोटबुक में ही दिखाई दें। आप sns.set() भी जोड़ते हैं ताकि विज़ुअलाइज़ेशन स्टाइल बेस Seaborn स्टाइल में बदल जाए:

# Import modules
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import tree
from sklearn.metrics import accuracy_score

# Figures inline and set visualization style
%matplotlib inline
sns.set()
संचालित द्वारा

अब बिना देर किए, डेटा इम्पोर्ट करते हैं और अपने डेटा की पड़ताल का पहला कदम उठाते हैं:

# Import test and train datasets
df_train = pd.read_csv('../data/train.csv')
df_test = pd.read_csv('../data/test.csv')

# View first lines of training data
df_train.head(n=4)
संचालित द्वारा

यदि आप देखना चाहते हैं कि ये सभी फ़ीचर्स क्या हैं, तो Kaggle डेटा डाक्यूमेंटेशन यहाँ देखें।

आगे बढ़ने से पहले, शब्दावली से जुड़ी निम्न बातें ध्यान में रखना अच्छा है:

• Target variable वह चर है जिसकी आप भविष्यवाणी करने की कोशिश कर रहे हैं;
• अन्य चर "features" (या "predictor variables", यानी वे फ़ीचर्स जिनका प्रयोग आप target variable की भविष्यवाणी करने के लिए कर रहे हैं) कहलाते हैं।

इसे ध्यान में रखते हुए, आप head() फ़ंक्शन की मदद से अपना डेटा देखना जारी रख सकते हैं, जिससे आप अपने डेटा सेट की पहली पाँच पंक्तियाँ देख सकते हैं:

# View first lines of test data
df_test.head()
संचालित द्वारा

ध्यान दें कि df_test DataFrame में 'Survived' कॉलम नहीं है क्योंकि यही वह चीज है जिसकी आप भविष्यवाणी करेंगे!

• आप DataFrame की .info() मेथड का उपयोग करके ( df_train का) डेटा प्रकार, मिसिंग वैल्यू आदि भी देख सकते हैं।

df_train.info()
संचालित द्वारा

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId    891 non-null int64
Survived       891 non-null int64
Pclass         891 non-null int64
Name           891 non-null object
Sex            891 non-null object
Age            714 non-null float64
SibSp          891 non-null int64
Parch          891 non-null int64
Ticket         891 non-null object
Fare           891 non-null float64
Cabin          204 non-null object
Embarked       889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB
संचालित द्वारा

इस मामले में, आप देखते हैं कि DataFrame में 891 पंक्तियाँ हैं, लेकिन 'Age' कॉलम में केवल 714 non-null मान हैं। इसका मतलब है कि 177 मान null या missing हैं।

• इसके अलावा, DataFrame की .describe() मेथड का उपयोग करके ( df_train की) संख्यात्मक कॉलम्स के सार-सांख्यिकी देखें।

df_train.describe()
संचालित द्वारा

दृश्यात्मक Exploratory Data Analysis (EDA) और आपका पहला मॉडल

अब जबकि आपको अपने डेटा का अंदाज़ा हो गया है और कुछ सांख्यिकी देख ली हैं, तो अब seaborn पैकेज की मदद से डेटा को विज़ुअलाइज़ करने का समय है:

• उदाहरण के लिए, seaborn का उपयोग करके Titanic में survival का बार प्लॉट बनाएं, जो आपका target variable है।

sns.countplot(x='Survived', data=df_train);
संचालित द्वारा

निष्कर्ष: training सेट में, न बचने वाले लोगों की संख्या, बचने वालों से अधिक है। चलिए फिर एक पहला मॉडल बनाते हैं जो यह भविष्यवाणी करे कि कोई भी नहीं बचा।

यह एक खराब मॉडल है क्योंकि आपको पता है कि लोग बचे थे। लेकिन यह हमें एक baseline देता है: आगे जो भी मॉडल हम बनाएँगे, उसे इससे बेहतर करना होगा।

आप यह इन चरणों से कर सकते हैं:

• df_test के लिए एक 'Survived' कॉलम बनाएँ जो सभी पंक्तियों के लिए 'नहीं बचे' को एन्कोड करे;
• df_test के 'PassengerId' और 'Survived' कॉलम्स को .csv में सेव करें और Kaggle पर सबमिट करें।

df_test['Survived'] = 0
df_test[['PassengerId', 'Survived']].to_csv('data/predictions/no_survivors.csv', index=False)
संचालित द्वारा

इससे आपको क्या accuracy मिली? Kaggle पर accuracy 62.7 है।

बुरा नहीं!

महत्वपूर्ण नोट! आप accuracy के अलावा अन्य मेट्रिक्स का उपयोग भी करना चाहेंगे!

फ़ीचर वेरिएबल्स पर EDA

अब जब आपने एक त्वरित-सरल मॉडल बना लिया है, तो दोबारा शुरुआत करने का समय है: आइए कुछ और Exploratory Data Analysis करें और जल्द ही एक और मॉडल बनाएं!

• seaborn का उपयोग करके Titanic डेटा सेट के फ़ीचर 'Sex' ( df_train का) का बार प्लॉट बनाएं।

sns.countplot(x='Sex', data=df_train);
संचालित द्वारा

• साथ ही, seaborn का उपयोग करके फ़ीचर 'Survived' के बार प्लॉट बनाएं जो फ़ीचर 'Sex' पर विभाजित (faceted) हों।

sns.factorplot(x='Survived', col='Sex', kind='count', data=df_train);
संचालित द्वारा

निष्कर्ष: महिलाओं के बचने की संभावना पुरुषों से अधिक थी।

• इस निष्कर्ष के साथ, आप pandas का उपयोग करके पता कर सकते हैं कि कितनी महिलाएँ और कितने पुरुष बचे:

df_train.groupby(['Sex']).Survived.sum()
संचालित द्वारा

Sex
female    233
male      109
Name: Survived, dtype: int64
संचालित द्वारा

• pandas का उपयोग करके यह निकालें कि महिलाओं का कितना अनुपात बचा और पुरुषों का कितना:

print(df_train[df_train.Sex == 'female'].Survived.sum()/df_train[df_train.Sex == 'female'].Survived.count())
print(df_train[df_train.Sex == 'male'].Survived.sum()/df_train[df_train.Sex == 'male'].Survived.count())
संचालित द्वारा

0.742038216561
0.188908145581
संचालित द्वारा

74% महिलाएँ बचीं, जबकि 19% पुरुष बचे।

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

• df_test के लिए 'Survived' कॉलम बनाएँ जो ऊपर दी गई भविष्यवाणी को एन्कोड करे।
• df_test के 'PassengerId' और 'Survived' कॉलम्स को .csv में सेव करें और Kaggle पर सबमिट करें।

df_test['Survived'] = df_test.Sex == 'female'
df_test['Survived'] = df_test.Survived.apply(lambda x: int(x))
df_test.head()
संचालित द्वारा

df_test[['PassengerId', 'Survived']].to_csv('../data/predictions/women_survive.csv', index=False)
संचालित द्वारा

अब, जब आप इसे Kaggle पर सबमिट करते हैं, तो इस मॉडल ने आपको क्या accuracy दी?

Kaggle पर accuracy 76.6% है:

इस submission के साथ, आप लीडरबोर्ड पर करीब 2,000 स्थान ऊपर चले गए! साथ ही, आपने अपना स्कोर बेहतर किया है, तो आपने बहुत अच्छा काम किया है!

अपने डेटा का और अन्वेषण करें!

• seaborn का उपयोग करके फ़ीचर 'Survived' के बार प्लॉट बनाएं जो फ़ीचर 'Pclass' पर विभाजित (faceted) हों।

sns.factorplot(x='Survived', col='Pclass', kind='count', data=df_train);
संचालित द्वारा

निष्कर्ष: प्रथम श्रेणी में यात्रा करने वाले यात्रियों के बचने की संभावना अधिक थी। दूसरी ओर, तृतीय श्रेणी में यात्रा करने वाले यात्रियों के न बचने की संभावना अधिक थी।

• seaborn का उपयोग करके फ़ीचर 'Survived' के बार प्लॉट बनाएं जो फ़ीचर 'Embarked' पर विभाजित (faceted) हों।

sns.factorplot(x='Survived', col='Embarked', kind='count', data=df_train);
संचालित द्वारा

निष्कर्ष: Southampton से चढ़ने वाले यात्रियों के बचने की संभावना कम थी।

संख्यात्मक वेरिएबल्स के साथ EDA

• seaborn का उपयोग करके df_train के 'Fare' कॉलम का histogram प्लॉट करें।

sns.distplot(df_train.Fare, kde=False);
संचालित द्वारा

निष्कर्ष: अधिकांश यात्रियों ने Titanic से यात्रा करने के लिए 100 से कम किराया दिया था।

• एक pandas plotting मेथड का उपयोग करके, 'Survived' के प्रत्येक मान के लिए 'Fare' कॉलम को एक ही प्लॉट पर प्लॉट करें।

df_train.groupby('Survived').Fare.hist(alpha=0.6);
संचालित द्वारा

निष्कर्ष: लगता है कि जिन्होंने अधिक किराया दिया उनकी बचने की संभावना अधिक थी।

• seaborn का उपयोग करके df_train के 'Age' कॉलम का histogram प्लॉट करें। ऐसा करने से पहले आपको null मान हटाने होंगे।

df_train_drop = df_train.dropna()
sns.distplot(df_train_drop.Age, kde=False);
संचालित द्वारा

• 'Fare' का strip plot और swarm plot बनाएं, जिसमें x-अक्ष पर 'Survived' हो।

sns.stripplot(x='Survived', y='Fare', data=df_train, alpha=0.3, jitter=True);
संचालित द्वारा

sns.swarmplot(x='Survived', y='Fare', data=df_train);
संचालित द्वारा

निष्कर्ष: Fare का Titanic पर survival के साथ स्पष्ट सह-संबंध दिखता है।

• DataFrame मेथड .describe() का उपयोग करके 'Survived' के फ़ंक्शन के रूप में 'Fare' की सार-सांख्यिकी देखें।

df_train.groupby('Survived').Fare.describe()
संचालित द्वारा

• seaborn का उपयोग करके 'Age' बनाम 'Fare' का scatter plot बनाएं, जिसे 'Survived' के आधार पर रंग दिया गया हो।

sns.lmplot(x='Age', y='Fare', hue='Survived', data=df_train, fit_reg=False, scatter_kws={'alpha':0.5});
संचालित द्वारा

निष्कर्ष: लगता है कि जो बचे वे या तो अपने टिकट के लिए काफ़ी भुगतान कर रहे थे या वे कम उम्र के थे।

• seaborn का उपयोग करके df_train का pairplot बनाएं, जिसे 'Survived' के आधार पर रंग दिया गया हो। pairplot एक बढ़िया तरीका है जिससे आप एक ही ग्रिड में वह अधिकांश जानकारी दिखा सकते हैं जो आपने अब तक खोजी है।

sns.pairplot(df_train_drop, hue='Survived');
संचालित द्वारा

EDA से Machine Learning मॉडल तक

इस ट्यूटोरियल में, आपने सफलतापूर्वक:

• हमारा डेटा लोड किया और उसे देखा।
• अपने target variable का दृश्यात्मक अन्वेषण किया और अपनी पहली भविष्यवाणियाँ कीं।
• अपने कुछ feature variables का दृश्यात्मक अन्वेषण किया और EDA के आधार पर बेहतर भविष्यवाणियाँ कीं।
• फ़ीचर वेरिएबल्स, श्रेणीबद्ध और संख्यात्मक, की गहन EDA की।

अगली पोस्ट में, आप यहाँ की अपनी EDA से मिली सीख के आधार पर कुछ Machine Learning मॉडल बनाने के लिए समय निकालेंगे। हम यह इस प्रोजेक्ट की अगली पोस्ट में करेंगे (जो 27 दिसंबर को लॉन्च होगी)।