Python मशीन लर्निंग: Scikit-Learn ट्यूटोरियल

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

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

Scikit-learn, जिसे sklearn के नाम से भी जाना जाता है, एक ओपन-सोर्स, मज़बूत Python मशीन लर्निंग लाइब्रेरी है। इसे Python में मशीन लर्निंग और सांख्यिकीय मॉडलों को लागू करने की प्रक्रिया को सरल बनाने के लिए बनाया गया था। 

यह लाइब्रेरी प्रैक्टिशनर्स को एक समान इंटरफ़ेस के माध्यम से सुपरवाइज़्ड और अनसुपरवाइज़्ड मशीन लर्निंग एल्गोरिदम की एक विस्तृत श्रृंखला को तेज़ी से लागू करने में सक्षम बनाती है। Sklearn SciPy के ऊपर बनाई गई है और सभी प्रकार के न्यूमेरिक डेटा पर काम करती है, जो या तो NumPy arrays, SciPy sparse matrices के रूप में संग्रहित हो, या अन्य कोई भी डेटा टाइप जिसे Pandas DataFrames जैसे न्यूमेरिक arrays में बदला जा सके।  

इस हैंड्स-ऑन sklearn ट्यूटोरियल में, हम मशीन लर्निंग लाइफसाइकिल के विभिन्न पहलुओं को कवर करेंगे, जैसे डेटा प्रोसेसिंग, मॉडल ट्रेनिंग और मॉडल इवैल्यूएशन।  

कोड के साथ-साथ चलने के लिए यह DataCamp वर्कस्पेस देखें। 

डेटा

sklearn का पहला पहलू जिसे हम एक्सप्लोर करेंगे, वह है डेटा; Scikit-learn में कुछ मानक मशीन लर्निंग डेटासेट्स शामिल आते हैं, जिसका मतलब है कि आपको उन्हें किसी बाहरी वेबसाइट या डेटाबेस से डाउनलोड करने की आवश्यकता नहीं है। 

sklearn में उपलब्ध टॉय डेटासेट्स के उदाहरणों में वर्गीकरण के लिए iris डेटासेट और रिग्रेशन के लिए diabetes डेटासेट शामिल हैं। हमारे उदाहरण के लिए, हम wine डेटासेट का उपयोग करेंगे। 

इसे मेमोरी में लोड करते हैं:

from sklearn.datasets import load_wine

wine_data = load_wine() संचालित द्वारा

ऊपर दिए गए कोड को चलाने पर डेटा और उससे संबंधित मेटाडेटा के साथ एक डिक्शनरी-जैसी ऑब्जेक्ट मिलता है। 

हमें आवश्यक डेटा .data एट्रिब्यूट में होता है, जो load_wine() द्वारा लौटाया जाता है। हम इसे wine_data इंस्टेंस के एट्रिब्यूट के रूप में इस तरह एक्सेस कर सकते हैं: 

wine_data.dataसंचालित द्वारा

यह N x M का एक array लौटाता है जहाँ N सैंपल्स की संख्या है और M फीचर्स की संख्या।  

आइए इस जानकारी का उपयोग करके अपने डेटा को एक pandas DataFrame में लोड करें, जिसे मैनीपुलेट और विश्लेषण करना कहीं आसान होता है। 

import pandas as pd
from sklearn.datasets import load_wine

wine_data = load_wine()

# Convert data to pandas dataframe
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)

# Add the target label
wine_df["target"] = wine_data.target

# Take a preview
wine_df.head()संचालित द्वारा

अब आप डेटा एक्सप्लोरेशन के लिए तैयार हैं। 

डेटा एक्सप्लोरेशन

Pandas DataFrames दो-आयामी, लेबल्ड डेटा स्ट्रक्चर्स हैं जो कॉलमों से मिलकर बनते हैं, जिनमें अलग-अलग प्रकार के डेटा स्टेप्स हो सकते हैं। DataFrame को समझने का सबसे आसान तरीका है इसे तीन घटकों के एक साथ मिलने के रूप में देखना: 1) डेटा, 2) एक इंडेक्स, और 3) कॉलम्स। 

डेटा एक्सप्लोरेशन इस लेख का मुख्य फोकस नहीं है, पर यह किसी भी डेटा प्रोजेक्ट में अत्यंत महत्वपूर्ण चरण है—इसके बारे में अधिक जानने के लिए हमारा Python Exploratory Data Analysis ट्यूटोरियल देखें। हम एक संक्षिप्त एक्सप्लोरेशन करेंगे ताकि हमें अपने डेटासेट की बेहतर समझ हो सके; इससे हमें डेटा को प्रोसेस करने का बेहतर अंदाज़ा मिलेगा। 

हम सबसे पहले अपने pandas DataFrame पर info() मेथड कॉल करेंगे; यह DataFrame में मौजूद wine डेटा का संक्षिप्त सारांश प्रिंट करेगा। 

wine_df.info()

"""
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   alcohol                       178 non-null    float64
 1   malic_acid                    178 non-null    float64
 2   ash                           178 non-null    float64
 3   alcalinity_of_ash             178 non-null    float64
 4   magnesium                     178 non-null    float64
 5   total_phenols                 178 non-null    float64
 6   flavanoids                    178 non-null    float64
 7   nonflavanoid_phenols          178 non-null    float64
 8   proanthocyanins               178 non-null    float64
 9   color_intensity               178 non-null    float64
 10  hue                           178 non-null    float64
 11  od280/od315_of_diluted_wines  178 non-null    float64
 12  proline                       178 non-null    float64
 13  target                        178 non-null    int64  
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""संचालित द्वारा

इस सेल को चलाने के बाद, आप जानेंगे: 

• डेटा में 178 डेटा सैंपल्स हैं
• कुल 14 कॉलम हैं, जिनमें टार्गेट कॉलम (जिसकी हमें भविष्यवाणी करनी है) शामिल है
• मिसिंग वैल्यू वाले 0 कॉलम हैं; यह आप “Non-Null Count” कॉलम से समझ सकते हैं। 
• सभी फीचर्स का डेटा टाइप float64 है, जबकि टार्गेट लेबल int64 है।
• डेटा 19.6 KB मेमोरी उपयोग करता है। 

हम अपने DataFrame पर describe() मेथड भी कॉल कर सकते हैं ताकि डेटासेट के प्रत्येक फीचर के बारे में वर्णनात्मक सांख्यिकी प्राप्त हो सके। 

उदाहरण के लिए: 

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

आप यह भी जानना चाहेंगे कि प्रत्येक फीचर में किस प्रकार के मान हैं। इसे जानने का सबसे तेज़ तरीका है पहली पाँच पंक्तियाँ दिखाने के लिए head() मेथड का उपयोग करना या आखिरी पाँच पंक्तियाँ देखने के लिए tail() मेथड का उपयोग करना। 

wine_df.tail()संचालित द्वारा

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

एक सामान्य मशीन लर्निंग वर्कफ़्लो में, यह प्रक्रिया कहीं अधिक विस्तृत होगी, लेकिन हम डेटा प्रोसेसिंग पर आगे बढ़ेंगे ताकि इस ट्यूटोरियल के मुख्य फोकस Scikit-learn के साथ बने रहें। 

आप पान्डास के बारे में अधिक जान सकते हैं Python Pandas Tutorial: The Ultimate Guide for Beginners में। 

Scikit-learn उदाहरण: डेटा प्रीप्रोसेसिंग

हमें अपने डेटा का एक अच्छा-खासा अंदाज़ा हो चुका है। जब आप इस बिंदु पर पहुँचते हैं, तो आमतौर पर इसका मतलब होता है कि अब आप डेटा को मशीन लर्निंग मॉडल में देने के लिए तैयार करने की दिशा में बढ़ने के लिए तैयार हैं। 

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

• मिसिंग वैल्यूज़,
• अतिरिक्त/दोहराए गए मान
• आउटलायर्स
• त्रुटियाँ
• शोर

इन सबका निपटारा आपको मॉडल में डेटा देने से पहले करना होता है; अन्यथा, मॉडल इन गलतियों को अपने एप्रॉक्सिमेशन फ़ंक्शन में समाहित कर लेगा—वह नई इंस्टेंसेज़ पर गलती करना सीख लेगा। इसी से मशहूर कहावत बनी: “Garbage in, garbage out.” 

एक और कारण यह है कि मशीन लर्निंग मॉडल आमतौर पर संख्यात्मक डेटा की आवश्यकता रखते हैं।  

हमारे डेटा के अलग-अलग स्केल्स पर होने के अलावा, पहली नज़र में ज़्यादा समस्या नहीं दिखती। इस समस्या से निपटने के लिए, आइए sklearn की StandardScaler क्लास का उपयोग करके फीचर्स को स्टैंडर्डाइज़ करें; यह फीचर्स को 0 के औसत (mean) और 1 के मानक विचलन (standard deviation) पर स्टैंडर्डाइज़ कर देगा। 

कोड इस प्रकार है: 

from sklearn.preprocessing import StandardScaler

# Split data into features and label 
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy() 

# Instantiate scaler and fit on features
scaler = StandardScaler()
scaler.fit(X)

# Transform features
X_scaled = scaler.transform(X.values)

# View first instance
print(X_scaled[0])

"""
[ 1.51861254 -0.5622498   0.23205254 -1.16959318  1.91390522  0.80899739
  1.03481896 -0.65956311  1.22488398  0.25171685  0.36217728  1.84791957
  1.01300893]
"""संचालित द्वारा

आइए मॉडल ट्रेनिंग की ओर बढ़ते हैं। 

Scikit-learn उदाहरण: मॉडल ट्रेनिंग

किसी मशीन लर्निंग मॉडल के भविष्यवाणी करने से पहले, उसे किसी डेटा सेट पर ट्रेन किया जाना चाहिए ताकि वह एक एप्रॉक्सिमेशन फ़ंक्शन सीख सके। 

लेकिन हम कैसे जानेंगे कि मॉडल उस डेटा पर कैसा करता है जिसे उसने पहले नहीं देखा? तब तक नहीं जब तक हम उसे टेस्ट न करें। 

किसी मशीन लर्निंग मॉडल को वास्तविक परिवेश में रखने से पहले उसे जाँचने का एक तरीका है ट्रेनिंग डेटा को ट्रेन और टेस्ट सेट में बाँटना और टेस्ट सेट का उपयोग करके यह मूल्यांकन करना कि मॉडल ने क्या सीखा है; इसे ऑफ़लाइन इवैल्यूएशन कहा जाता है। 

डेटा को ट्रेन और टेस्ट सेट में बाँटने के कई तरीके हैं, लेकिन scikit-learn में इसके लिए एक बिल्ट-इन फ़ंक्शन है जिसका नाम train_test_split() है। 

हम इस फ़ंक्शन का उपयोग करके अपने डेटा को इस तरह बाँटेंगे कि 70% मॉडल को ट्रेन करने में और 30% अनदेखी इंस्टेंसेज़ पर जनरलाइज़ करने की मॉडल की क्षमता का मूल्यांकन करने में उपयोग होगा। 

from sklearn.model_selection import train_test_split

# Split data into train and test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
                                                                  y,
                                                             train_size=.7,
                                                           random_state=25)

# Check the splits are correct
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")

"""
Train size: 70% 
Test size: 30%
संचालित द्वारा

अब आइए कुछ मॉडल बनाएँ। 

मॉडल बनाना

sklearn की बदौलत, मशीन लर्निंग मॉडल बनाना अत्यंत सरल है। 

हम वाइन की कक्षा (class) की भविष्यवाणी करने के लिए तीन मॉडल बनाएँगे: 

1. लॉजिस्टिक रिग्रेशन
2. सपोर्ट वेक्टर मशीन 
3. डिसीजन ट्री क्लासिफायर

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

# Instnatiating the models 
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()

# Training the models 
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)

# Making predictions with each model
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)संचालित द्वारा

अगला चरण है यह मूल्यांकन करना कि मॉडल अनदेखी इंस्टेंसेज़ पर कितना अच्छा जनरलाइज़ करता है। 

Scikit-learn उदाहरण: मॉडल इवैल्यूएशन

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

हमारे उपयोग-केस के लिए, हम classification_report() का उपयोग करेंगे जो कि metrics मॉड्यूल से आता है, और यह precision, recall, f1_score, accuracy आदि जैसे मुख्य क्लासिफिकेशन मेट्रिक्स दिखाने वाली एक टेक्स्ट रिपोर्ट बनाता है। 

कोड में यह इस प्रकार दिखता है:

from sklearn.metrics import classification_report

# Store model predictions in a dictionary
# this makes it easier to iterate through each model
# and print the results. 
model_preds = {
    "Logistic Regression": log_reg_preds,
    "Support Vector Machine": svm_preds,
    "Decision Tree": tree_preds
}

for model, preds in model_preds.items():
    print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")

"""
Logistic Regression Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      0.92      0.96        25
           2       0.86      1.00      0.92        12

    accuracy                           0.96        54
   macro avg       0.95      0.97      0.96        54
weighted avg       0.97      0.96      0.96        54

Support Vector Machine Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      1.00      1.00        25
           2       1.00      1.00      1.00        12

    accuracy                           1.00        54
   macro avg       1.00      1.00      1.00        54
weighted avg       1.00      1.00      1.00        54

Decision Tree Results:
              precision    recall  f1-score   support

           0       0.94      0.94      0.94        17
           1       0.96      0.88      0.92        25
           2       0.86      1.00      0.92        12

    accuracy                           0.93        54
   macro avg       0.92      0.94      0.93        54
weighted avg       0.93      0.93      0.93        54
"""संचालित द्वारा

पहली नज़र में, लगता है कि सपोर्ट वेक्टर मशीन सबसे अच्छा मॉडल है। एक सामान्य वर्कफ़्लो में, यह मॉडल के प्रति जिज्ञासा जगाएगा—क्या यह सच में उतना ही अच्छा है जितना दिख रहा है, या हमने कहीं कोई गलती कर दी है? आपको अपने मॉडलों और वे क्या सीख रहे हैं, इसके बारे में और जानने की उत्सुकता होनी चाहिए, क्योंकि इससे आपको उनकी खूबियों और खामियों की बेहतर समझ मिलेगी। 

यह जानकारी स्टेकहोल्डर्स के लिए अत्यंत सूचनाप्रद होती है, क्योंकि इससे वे वहाँ समाधान ढूँढ सकते हैं जहाँ मॉडल कमज़ोर पड़ता है। 

निष्कर्ष

scikit-learn लाइब्रेरी में कई मॉड्यूल शामिल हैं जो मशीन लर्निंग मॉडल्स को लागू करना आसान बनाते हैं। ये मॉड्यूल प्रीप्रोसेसिंग टूल्स से लेकर—जो आपके डेटा को मशीन लर्निंग मॉडल में देने के लिए तैयार करने में मदद करते हैं—ऐसे मॉडलों तक फैले हैं जिनसे आप अपने डेटा में पैटर्न ढूँढ सकते हैं, और ऐसे इवैल्यूएशन मेट्रिक्स तक जिनसे आप अपने मॉडल के प्रदर्शन का आकलन कर सकते हैं। 

इस ट्यूटोरियल में, हमने sklearn की क्षमताओं की बस झलक भर देखी है। लाइब्रेरी से आप और क्या-क्या कर सकते हैं, इसमें गहराई से जाने के लिए हमारे पास कई संसाधन हैं। शुरू करने के लिए कुछ यहाँ दिए गए हैं: 

• scikit-learn के साथ सुपरवाइज़्ड लर्निंग
• Python में अनसुपरवाइज़्ड लर्निंग
• scikit-learn के साथ K-Nearest neighbors (KNN) क्लासिफिकेशन