Kaggle प्रतियोगिता ट्यूटोरियल: Titanic से मशीन लर्निंग

इस ट्यूटोरियल में, हम Titanic डेटासेट पर चलेंगे, उसका विश्लेषण करेंगे, और परिणाम वास्तविक प्रतियोगिता में सबमिट करेंगे। आपने इस ट्यूटोरियल में डेटा को फ़ेच करना और उसे अपने Kaggle Notebook में इम्पोर्ट करना सीख लिया है। अब हम DataLab को डेटा साइंस नोटबुक के रूप में इस्तेमाल करेंगे। आप अलग-अलग प्लेटफ़ॉर्म्स पर दोनों टूल्स का उपयोग करना सीखेंगे, ताकि आप अपनी पसंद चुन सकें।

सबसे पहले, Kaggle के "Competitions" सेक्शन में जाएँ और Titanic खोजें (चित्र 5.4)। सीधे नोटबुक में जाने से पहले, आपको "Description and Rules" सेक्शंस में साझा सारी जानकारी समझनी चाहिए। अन्य उपयोगकर्ताओं की नोटबुक्स देखना भी महत्वपूर्ण है, क्योंकि इससे समाधान के लिए और विचार मिल सकते हैं।

यह प्रतियोगिता मशीन लर्निंग का उपयोग करके ऐसा मॉडल बनाने के बारे में है जो भविष्यवाणी करे कि Titanic जहाज़ दुर्घटना में किन यात्रियों की जान बची होती। हम एक ऐसे डेटासेट का उपयोग करेंगे जिसमें यात्रियों की जानकारी जैसे नाम, लिंग, उम्र आदि शामिल हैं। हम 2 अलग-अलग डेटासेट्स का उपयोग करेंगे। पहला 'train.csv' है। इस डेटासेट में यात्री जानकारी के साथ-साथ 'survived' और 'not survived' जैसे ground truth मान भी होते हैं। दूसरे डेटासेट 'test.csv' में कोई ground truth मान नहीं होंगे, क्योंकि हमें उनकी भविष्यवाणी करके अपने परिणाम सबमिट करने होते हैं।

सबमिशन फ़ाइल में केवल 2 कॉलम होंगे: PassengerId और Survived। यदि आप 2 से अधिक मानों वाली फ़ाइल अपलोड करने का प्रयास करेंगे तो सबमिशन सिस्टम त्रुटि देगा। कृपया ध्यान दें कि आप एक दिन में 10 सबमिशन कर सकते हैं।

"Competition Description" सेक्शन में दी गई जानकारी के साथ, अगला चरण हमारे DataLab में डेटा फ़ेच करना और उसका विश्लेषण करना होगा।

सबसे पहले, Data टैब में जाकर Data Explorer में डेटासेट डाउनलोड करें (चित्र 5.5)। आपको 'train.csv' और 'test.csv' दोनों डाउनलोड करने चाहिए।

फ़ाइलें डाउनलोड करने के बाद, आपको DataLab पर जाना चाहिए। कृपया ध्यान दें कि आपको पहले एक अकाउंट बनाना होगा। अकाउंट बनाना और DataLab का उपयोग निःशुल्क है।

आप नोटबुक के बाएँ हिस्से में फ़ाइलों को आसानी से ड्रैग और ड्रॉप कर सकते हैं (चित्र 5.6)।

अगला चरण डेटासेट विवरण सेक्शन में दिए गए डेटा डिक्शनरी की जाँच करना है। इससे हमें तय करने में मदद मिलेगी कि किन कॉलम्स को विज़ुअलाइज़ करना है।

• survival: जीवित रहना
• pclass: टिकट श्रेणी
• sex: लिंग
• Age: उम्र (वर्षों में)
• sibsp: Titanic पर भाई-बहनों / जीवनसाथियों की संख्या
• parch: Titanic पर माता-पिता / बच्चों की संख्या
• ticket: टिकट नंबर
• fare: यात्री किराया
• cabin: केबिन नंबर
• embarked: चढ़ने का बंदरगाह

डेटा इम्पोर्ट करना

आप jupyter notebooks में किसी सेल के सामने विस्मयादिबोधक चिह्न लगाकर bash कमांड्स का उपयोग कर सकते हैं। हम अपलोड किए गए डेटासेट फ़ाइलों का लोकेशन pwd और ls कमांड्स से जाँचेंगे।

!pwd; ls
संचालित द्वारा

/work/files/workspace

notebook.ipynb test.csv train.csv

Pandas एक Python लाइब्रेरी है और इसे डेटा मैनिपुलेशन और डेटा विश्लेषण प्रक्रियाओं के लिए उपयोग किया जाता है। हमने अब Ticket, Name और PassengerId कॉलम हटा दिए हैं क्योंकि इनमें कोई सार्थक संख्यात्मक या श्रेणीगत डेटा नहीं है। अब आप उपयोग के लिए बाकी फीचर्स देख पाएँगे।

अगली कुछ लाइनों में, प्रशिक्षण और परीक्षण डेटासेट फ़ाइलों को Pandas की read_csv विधि से पढ़ा गया है। ध्यान दें कि Survived और PassengerId कॉलम क्रमशः train और test डेटाफ़्रेम्स में जोड़े गए हैं। हम मॉडल को अलग-अलग columns_to_be_added_as_features के फीचर्स और Survived कॉलम के लेबल्स से फ़ीड करेंगे। लेकिन प्रीप्रोसेसिंग को सरल बनाने के लिए, अभी हम उन्हें मिला सकते हैं। test_df_matcher वेरिएबल में PassengerId भी शामिल है। हम इसका उपयोग PassengerId को टेस्ट सेट प्रिडिक्शंस से मिलाने में करेंगे, ताकि उस CSV फ़ाइल को बनाया जा सके जिसे Kaggle पर हमारे परिणाम के रूप में अपलोड किया जाएगा।

import pandas as pd
columns_to_be_added_as_features = ['Sex','Age','SibSp','Parch','Pclass','Fare','Embarked']
train_df = pd.read_csv('train.csv', usecols=columns_to_be_added_as_features + ['Survived'])
test_df_matcher = pd.read_csv('test.csv', usecols=columns_to_be_added_as_features + ['PassengerId'])
test_df = test_df[columns_to_be_added_as_features]
संचालित द्वारा

head() विधि से हम पहले 5 पंक्तियाँ उनके कॉलम नामों के साथ देख सकते हैं। आप head() में पैरामीटर के रूप में शुरुआती पंक्तियों की संख्या निर्धारित कर सकते हैं। नीचे की सेल में प्रशिक्षण सेट और परीक्षण सेट की पंक्तियों की संख्या क्रमशः प्रिंट की गई है।

print(train_df.head())
संचालित द्वारा

print("Number of rows in training set: {}".format(len(train_df)))
print("Number of rows in test set: {}".format(len(test_df)))
संचालित द्वारा

Number of rows in training set: 891 Number of rows in test set: 418

प्रीप्रोसेसिंग

हमें उन मानों के प्रकार को float में बदलना चाहिए जो मॉडल में फीचर्स के रूप में उपयोग होंगे। यह रूपांतरण डेटा को नॉर्मलाइज़ करते समय कुछ संख्यात्मक ऑपरेशंस करने की अनुमति देगा।

for column_title in columns_to_be_added_as_features:
    if column_title in ['Embarked', "Sex"]:
        continue
    train_df[column_title] = pd.to_numeric(train_df[column_title], downcast="float")
    test_df[column_title] = pd.to_numeric(test_df[column_title], downcast="float")

train_df["Survived"] = pd.to_numeric(train_df["Survived"], downcast="float")
संचालित द्वारा

हमें मॉडल को संख्यात्मक मानों से फ़ीड करना है। नीचे दिए गए कोड भाग में स्ट्रिंग्स को संख्यात्मक मानों में बदला जा रहा है

train_df['Embarked'].replace('Q', 0,inplace=True)
train_df['Embarked'].replace('S', 1,inplace=True)
train_df['Embarked'].replace('C', 2,inplace=True)

test_df['Embarked'].replace('Q', 0,inplace=True)
test_df['Embarked'].replace('S', 1,inplace=True)
test_df['Embarked'].replace('C', 2,inplace=True)

train_df['Sex'].replace('male', 0,inplace=True)
train_df['Sex'].replace('female', 1,inplace=True)

test_df['Sex'].replace('male', 0,inplace=True)
test_df['Sex'].replace('female', 1,inplace=True)

print(train_df.head())
संचालित द्वारा

नीचे, सभी फीचर्स को नॉर्मलाइज़ किया गया है, यानी इस स्थिति में 0 और 1 के बीच स्केल किया गया है।

#Credit: Michael Aquilina,
#https://stackoverflow.com/questions/26414913/normalize-columns-of-pandas-data-frame
def normalize(df):
    result = df.copy()
    for feature_name in df.columns:
        max_value = df[feature_name].max()
        min_value = df[feature_name].min()
        result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
    return result

train_df = normalize(train_df)
test_df = normalize(test_df)

print(train_df.head())
संचालित द्वारा

क्योंकि डेटासेट को प्रशिक्षण और वैलिडेशन में बाँटा जाएगा, हम किसी एक सेट में समूह बनने से बचने के लिए पहले डेटासेट को शफ़ल करेंगे।

#Credit: Kris, https://stackoverflow.com/questions/29576430/shuffle-dataframe-rows
train_df = train_df.sample(frac=1).reset_index(drop=True)
संचालित द्वारा

सभी खाली मानों को 0 से बदला जाएगा; यह निर्णय समय बचाने के उद्देश्य से लिया गया है। हालाँकि, आप मशीन लर्निंग में missing values को संभालने के तरीकों के लिए यह ट्यूटोरियल पढ़ सकते हैं।

train_df = train_df.fillna(0)
test_df = test_df.fillna(0)
संचालित द्वारा

नीचे, वैलिडेशन का अनुपात 0.2 रखा गया है, यानी 20% डेटा वैलिडेशन के लिए उपयोग होगा। डेटासेट को प्रशिक्षण और वैलिडेशन सेट्स में बाँटने के लिए हम Sklearn की train_test_split विधि का उपयोग करेंगे। फिर, नीचे दिए गए कोड के अंतिम 4 लाइनों में दिखाए अनुसार फीचर्स और लेबल्स को अलग करेंगे।

validation_set_ratio = 0.2
validation_set_size = int(len(train_df)*validation_set_ratio)
training_set_size = len(train_df) - validation_set_size

print("Total set size: {}".format(len(train_df)))
print("Training set size: {}".format(training_set_size))
print("Validation set size: {}".format(validation_set_size))

from sklearn.model_selection import train_test_split

train, val = train_test_split(train_df, test_size=validation_set_ratio)

train_X = train[columns_to_be_added_as_features]
train_Label = train[['Survived']]

val_X = val[columns_to_be_added_as_features]
val_Label = val[['Survived']]
संचालित द्वारा

प्रशिक्षण

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

from sklearn.svm import SVC

SVM_KERNEL = "linear"
SVM_C = 10
SVM_GAMMA = 0.00001

svm_model = SVC(kernel = SVM_KERNEL, C = SVM_C, gamma = SVM_GAMMA)
svm_model.fit(train_X, train_Label)
संचालित द्वारा

वैलिडेशन सेट प्रिडिक्शंस प्राप्त करना

इस भाग में, हम मॉडल को वैलिडेशन सेट के फीचर्स से फ़ीड करेंगे और प्रिडिक्शंस प्राप्त करेंगे। फिर हम उनकी तुलना ground truth मानों से करेंगे। सटीकता की गणना आसान बनाने के लिए Sklearn की metrics.accuracy_score विधि का उपयोग किया गया। वैलिडेशन सेट सटीकता 0.799 निकली, जो एक अच्छी शुरुआत है।

from sklearn import metrics

y_pred = svm_model.predict(val_X)
print("Accuracy:",metrics.accuracy_score(val_Label, y_pred))
संचालित द्वारा

Accuracy: 0.7988826815642458

टेस्ट सेट प्रिडिक्शंस प्राप्त करना

अब हम वास्तविक टेस्ट सेट के लिए प्रिडिक्शंस प्राप्त करने की ओर बढ़ते हैं। क्योंकि टेस्ट सेट के लिए कोई ground truth मान नहीं हैं, हम सटीकता केवल तभी जान पाएँगे जब प्रिडिक्शंस फ़ाइल को Kaggle पर अपलोड किया जाएगा।

test_pred = svm_model.predict(test_df)
संचालित द्वारा

आउटपुट डेटाफ़्रेम बनाना

test_df_matcher नामक डेटाफ़्रेम से PassengerId कॉलम फ़ेच किया जाता है। सीधे लौटाने पर, रिटर्न वैल्यू का प्रकार Series होगा। इसी कारण, हम इसे Pandas DataFrame प्रकार में कास्ट करेंगे। फिर हम टेस्ट सेट प्रिडिक्शंस को डेटाफ़्रेम के दूसरे कॉलम के रूप में इन्सर्ट करेंगे।

result = pd.DataFrame(test_df_matcher['PassengerId'])
print(result.head(10))
संचालित द्वारा

result.insert(1, "Survived", test_pred, True)
result["Survived"] = pd.to_numeric(result["Survived"], downcast="integer")
print(result.head(10))
संचालित द्वारा

आउटपुट फ़ाइल बनाना

अंततः, आउटपुट फ़ॉर्मेट तैयार है। अंतिम चरण के रूप में, index पैरामीटर को False देकर इंडेक्स मानों को हटा दिया जाएगा। अब आप बनी हुई फ़ाइल डाउनलोड कर सकते हैं और उसे Kaggle पर अपलोड कर सकते हैं। इस तरह, आपको टेस्ट सेट की सटीकता पता चल जाएगी, जिसके बाद आपको लीडरबोर्ड पर स्थान मिलेगा।

result.to_csv("out.csv", index=False)
संचालित द्वारा

अब हम प्रतियोगिता पेज पर वापस जाएँगे, "Submit Predictions" पर क्लिक करेंगे और प्रिडिक्शंस फ़ाइल अपलोड करेंगे। कुछ ही सेकंड में, आपको अपनी टेस्ट सटीकता मिल जाएगी (चित्र 5.12)।

निष्कर्ष

इस ट्यूटोरियल में, आपने एक डेटासेट का विश्लेषण करना और अपने परिणामों को Kaggle प्रतियोगिता में सबमिट करना सीखा। यदि आपको डेटा साइंस प्रतियोगिताएँ पसंद हैं तो आप DataCamp Competitions के बारे में और यहाँ सीख सकते हैं।