Python में मशीन लर्निंग का परिचय

आप प्रसिद्ध Iris डेटासेट पर KNN लागू करेंगे।

ध्यान दें: आप Machine Learning with Python कोर्स करने पर विचार कर सकते हैं, या ML कैसे विकसित हुआ और बहुत कुछ जानने के लिए यह पोस्ट पढ़ सकते हैं।

परिचय

मशीन लर्निंग कंप्यूटर विज्ञान से विकसित हुई है जहाँ मुख्य रूप से ऐसे एल्गोरिद्म के डिज़ाइन का अध्ययन होता है जो अनुभव से सीख सकते हैं। सीखने के लिए, उन्हें ऐसे डेटा की आवश्यकता होती है जिसमें कुछ गुण/एट्रिब्यूट्स हों, जिनके आधार पर एल्गोरिद्म अर्थपूर्ण पूर्वानुमेय पैटर्न खोजने की कोशिश करते हैं। व्यापक रूप से, ML कार्यों को कॉन्सेप्ट लर्निंग, क्लस्टरिंग, प्रेडिक्टिव मॉडलिंग आदि में वर्गीकृत किया जा सकता है। ML एल्गोरिद्म का अंतिम लक्ष्य यह है कि वे बिना किसी मानवीय हस्तक्षेप के सही ढंग से निर्णय ले सकें। स्टॉक्स या मौसम का पूर्वानुमान मशीन लर्निंग एल्गोरिद्म के कुछ अनुप्रयोग हैं।

मशीन लर्निंग के विभिन्न एल्गोरिद्म होते हैं जैसे Decision trees, Naive Bayes, Random forest, Support vector machine, K-nearest neighbor, K-means clustering, आदि।

मशीन लर्निंग एल्गोरिद्म के परिवार में, आज आप जिस एल्गोरिद्म का उपयोग करेंगे, वह है k-nearest neighbor।

अब सवाल यह है कि K-Nearest Neighbor एल्गोरिद्म वास्तव में है क्या? चलिए पता लगाते हैं!

एक k-Nearest Neighbor क्या है?

KNN या k-nearest neighbor एल्गोरिद्म एक सुपरवाइज़्ड लर्निंग एल्गोरिद्म है; सुपरवाइज़ का अर्थ है कि यह लर्निंग फेज़ के दौरान ट्रेनिंग डेटा के क्लास लेबल्स का उपयोग करता है। यह एक इंस्टेंस-आधारित मशीन लर्निंग एल्गोरिद्म है, जिसमें नए डेटा पॉइंट्स को संग्रहीत, लेबल वाले इंस्टेंस (डेटा पॉइंट्स) के आधार पर वर्गीकृत किया जाता है। KNN का उपयोग क्लासिफिकेशन और रिग्रेशन दोनों के लिए किया जा सकता है; हालांकि, इसे अधिकतर क्लासिफिकेशन के लिए उपयोग किया जाता है।

KNN में k एक महत्वपूर्ण वेरिएबल है जिसे हाइपरपैरामीटर भी कहा जाता है, जो किसी डेटा पॉइंट को सटीक रूप से वर्गीकृत करने में मदद करता है। सटीक रूप से कहें तो, k वह संख्या है जितने निकटतम पड़ोसियों से आप किसी नए डेटा पॉइंट को वर्गीकृत करते समय वोट लेना चाहते हैं।

आप देख सकते हैं कि जैसे-जैसे k का मान 1 से 7 तक बढ़ता है, दो क्लासों के बीच की निर्णय-सीमा, जिनमें कुछ डेटा पॉइंट्स हैं, अधिक स्मूथ हो जाती है।

अब सवाल यह है कि यह सारा जादू कैसे होता है, जहाँ हर बार कोई नया डेटा पॉइंट आता है तो उसे संग्रहीत डेटा पॉइंट्स के आधार पर वर्गीकृत कर दिया जाता है?

तो, आइए इसे जल्दी से निम्न तरीकों से समझते हैं:

• सबसे पहले, आप सारा डेटा लोड करते हैं और k का मान इनिशियलाइज़ करते हैं,
• फिर, संग्रहीत डेटा पॉइंट्स और उस नए डेटा पॉइंट के बीच की दूरी, जिसे आप वर्गीकृत करना चाहते हैं, विभिन्न समानता या दूरी मीट्रिक्स जैसे Manhattan distance (L1), Euclidean distance (L2), Cosine similarity, Bhattacharyya distance, Chebyshev distance, आदि का उपयोग करके निकाली जाती है।
• अगला, दूरी के मानों को आरोही या अवरोही क्रम में सॉर्ट किया जाता है और शीर्ष या निचले k निकटतम पड़ोसी निर्धारित किए जाते हैं।
• k निकटतम पड़ोसियों के लेबल इकट्ठे किए जाते हैं, और नए डेटा पॉइंट को वर्गीकृत करने के लिए बहुमत वोट या वेटेड वोट का उपयोग किया जाता है। नए डेटा पॉइंट को उस क्लास लेबल के आधार पर असाइन किया जाता है जिसका स्कोर सभी संग्रहीत डेटा पॉइंट्स में सबसे अधिक होता है।
• अंत में, नए इंस्टेंस के लिए भविष्यवाणी की गई क्लास लौटाई जाती है।

प्रेडिक्शन दो प्रकार के हो सकते हैं: या तो classification जिसमें किसी नए डेटा पॉइंट को एक क्लास लेबल असाइन किया जाता है या regression जिसमें नए डेटा पॉइंट को एक मान असाइन किया जाता है। क्लासिफिकेशन के विपरीत, रिग्रेशन में, सभी k निकटतम पड़ोसियों का औसत नए डेटा पॉइंट को असाइन किया जाता है।

KNN की कमियाँ: पहला, प्रत्येक नए डेटा पॉइंट के लिए निकटतम पड़ोसी खोजने की जटिलता। दूसरा, k का मान निर्धारित करना कभी-कभी थकाऊ कार्य हो जाता है। अंततः, यह भी स्पष्ट नहीं होता कि निकटतम पड़ोसियों की गणना करते समय किस प्रकार की दूरी मीट्रिक का उपयोग किया जाए।

काफी थ्योरी हो गई, है न? तो, आइए उस डेटा को लोड, विश्लेषित और समझते हैं जिसका उपयोग आप आज के इस छोटे से ट्यूटोरियल में करेंगे।

Iris डेटा लोड करना

Iris डेटा सेट में 150 सैंपल होते हैं जिनमें तीन क्लास हैं: Iris-Setosa, Iris-Versicolor, और Iris-Virginica। चार फीचर्स/एट्रिब्यूट्स जो किसी एक क्लास के रूप में विशिष्ट पहचान में योगदान करते हैं, वे हैं sepal-length, sepal-width, petal-length और petal-width।

आप चाहें तो कोई अन्य सार्वजनिक डेटासेट या अपना निजी डेटासेट भी इस्तेमाल कर सकते हैं।

Sklearn एक मशीन लर्निंग Python लाइब्रेरी है जिसका डेटा-साइंस संबंधी कार्यों में व्यापक उपयोग होता है। इसमें विभिन्न क्लासिफिकेशन, रिग्रेशन और क्लस्टरिंग एल्गोरिद्म शामिल हैं जैसे support vector machines, random forests, gradient boosting, k-means, KNN, आदि। sklearn के अंतर्गत datasets नामक एक लाइब्रेरी है जिसमें कई डेटासेट हैं जिन्हें अलग-अलग कार्यों के लिए उपयोग किया जा सकता है, जिनमें Iris डेटासेट भी शामिल है—ये सभी डेटासेट बॉक्स से बाहर लोड किए जा सकते हैं। यह काफी सहज और सीधा है। तो, आइए जल्दी से iris डेटासेट लोड करते हैं।

from sklearn.datasets import load_iris

load_iris में प्रत्येक सैंपल के लिए डेटा और क्लास लेबल्स दोनों होते हैं। आइए इन्हें जल्दी से एक्सट्रैक्ट कर लेते हैं।

data = load_iris().data

data वेरिएबल (150,4) आकार का एक numpy array होगा, जिसमें 150 सैंपल होंगे और प्रत्येक में चार अलग-अलग एट्रिब्यूट्स होंगे। प्रत्येक क्लास में 50 सैंपल होते हैं।

data.shape

(150, 4)

आइए क्लास लेबल्स निकालते हैं।

labels = load_iris().target

labels.shape

(150,)

अगला चरण है डेटा और क्लास लेबल्स को संयोजित करना, और इसके लिए आप NumPy नाम की उत्कृष्ट Python लाइब्रेरी का उपयोग करेंगे। NumPy बड़े, बहु-आयामी ऐरे और मैट्रिस का समर्थन जोड़ती है, साथ ही इन ऐरे पर ऑपरेशन करने के लिए उच्च-स्तरीय गणितीय फंक्शंस का विस्तृत संग्रह प्रदान करती है। तो, चलिए इसे इम्पोर्ट करते हैं!

import numpy as np

क्योंकि data एक 2-डी ऐरे है, इसलिए आपको labels को भी 2-डी ऐरे में रीशेप करना होगा।

labels = np.reshape(labels,(150,1))

अब, आप numpy लाइब्रेरी में उपलब्ध concatenate फंक्शन का उपयोग करेंगे, और axis=-1 का प्रयोग करेंगे जो दूसरी डाइमेंशन के आधार पर कंसकैटिनेट करेगा।

data = np.concatenate([data,labels],axis=-1)

data.shape

(150, 5)

अगला, आप Python की डेटा विश्लेषण लाइब्रेरी pandas इम्पोर्ट करेंगे जो तब उपयोगी होती है जब आप अपने डेटा को सारणीबद्ध रूप में व्यवस्थित करना चाहते हैं और डेटा पर कुछ ऑपरेशन व मैनिपुलेशन करना चाहते हैं। विशेष रूप से, यह न्यूमेरिकल टेबल्स और टाइम सीरीज़ को मैनिपुलेट करने के लिए डेटा स्ट्रक्चर और ऑपरेशन प्रदान करती है।

आज के ट्यूटोरियल में, आप pandas का काफी उपयोग करेंगे।

import pandas as pd

names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'species']

dataset = pd.DataFrame(data,columns=names)

अब, आपके पास dataset डेटा फ्रेम है जिसमें वह डेटा और क्लास लेबल्स दोनों हैं जिनकी आपको आवश्यकता है!

आगे बढ़ने से पहले, याद रखें कि labels वेरिएबल में क्लास लेबल्स न्यूमेरिक वैल्यूज़ के रूप में हैं, लेकिन आप इन न्यूमेरिक वैल्यूज़ को फूलों के नाम या स्पीशीज़ में कन्वर्ट करेंगे।

इसके लिए, आप केवल class कॉलम का चयन करेंगे और तीनों न्यूमेरिक वैल्यूज़ को संबंधित स्पीशीज़ से बदल देंगे। आप inplace=True का उपयोग करेंगे जो डेटा फ्रेम dataset को सीधे संशोधित करेगा।

dataset['species'].replace(0, 'Iris-setosa',inplace=True)
dataset['species'].replace(1, 'Iris-versicolor',inplace=True)
dataset['species'].replace(2, 'Iris-virginica',inplace=True)

आइए dataset की पहली पाँच पंक्तियाँ प्रिंट करते हैं और देखते हैं यह कैसा दिखता है!

dataset.head(5)

अपने डेटा का विश्लेषण करें

आइए जल्दी से देखें कि जब विज़ुअलाइज़ किया जाए तो तीनों फूल कैसे दिखते हैं और वे एक-दूसरे से न केवल संख्याओं में बल्कि वास्तविक रूप से भी कितने अलग हैं!

(स्रोत)

ऊपर लोड किए गए डेटा को scatterplot का उपयोग करके विज़ुअलाइज़ करते हैं ताकि पता चले कि एक वेरिएबल दूसरे वेरिएबल से कितना प्रभावित होता है, या कहें कि दो वेरिएबल्स के बीच कितनी सहसंबद्धता (correlation) है।

आप डेटा को scatterplot से विज़ुअलाइज़ करने के लिए matplotlib लाइब्रेरी का उपयोग करेंगे।

import matplotlib.pyplot as plt

सुझाव: क्या आप Python में डेटा विज़ुअलाइज़ करने के विभिन्न तरीकों को सीखने के इच्छुक हैं? तो Introduction to data visualization with matplotlib कोर्स देखें।

plt.figure(4, figsize=(10, 8))

plt.scatter(data[:50, 0], data[:50, 1], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 0], data[50:100, 1], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 0], data[100:, 1], c='b',label='Iris-virginica')

plt.xlabel('Sepal length',fontsize=20)
plt.ylabel('Sepal width',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.title('Sepal length vs. Sepal width',fontsize=20)
plt.legend(prop={'size': 18})
plt.show()

ऊपर दिए गए प्लॉट से यह स्पष्ट है कि sepal length और sepal width के संदर्भ में Iris setosa फूलों के बीच उच्च सहसंबंध है। दूसरी ओर, Iris versicolor और Iris virginica के बीच सहसंबंध कम है। versicolor और virginica के डेटा पॉइंट्स setosa की तुलना में अधिक फैलाव में हैं, जो अधिक घने हैं।

आइए जल्दी से petal-length और petal-width के लिए भी ग्राफ़ प्लॉट कर लेते हैं।

plt.figure(4, figsize=(8, 8))

plt.scatter(data[:50, 2], data[:50, 3], c='r', label='Iris-setosa')

plt.scatter(data[50:100, 2], data[50:100, 3], c='g',label='Iris-versicolor')

plt.scatter(data[100:, 2], data[100:, 3], c='b',label='Iris-virginica')
plt.xlabel('Petal length',fontsize=15)
plt.ylabel('Petal width',fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.title('Petal length vs. Petal width',fontsize=15)
plt.legend(prop={'size': 20})
plt.show()

petal-length और petal-width के मामले में भी, ऊपर दिया गया ग्राफ़ setosa फूलों के लिए मजबूत सहसंबंध दर्शाता है जो घनी क्लस्टरिंग में हैं।

अगला, यह और सत्यापित करने के लिए कि petal-length और petal-width कैसे सहसंबद्ध हैं, आइए तीनों स्पीशीज़ के लिए कोरिलेशन मैट्रिक्स प्लॉट करें।

dataset.iloc[:,2:].corr()

ऊपर दी गई तालिका दर्शाती है कि जब तीनों स्पीशीज़ को एक साथ लिया जाता है, तो petal-length और petal-width के लिए 0.96 का मजबूत सहसंबंध है।

आइए तीनों स्पीशीज़ के बीच सहसंबंध को अलग-अलग भी विश्लेषित करते हैं।

dataset.iloc[:50,:].corr() #setosa

dataset.iloc[50:100,:].corr() #versicolor

dataset.iloc[100:,:].corr() #virginica

ऊपर दी गई तीनों तालिकाओं से यह स्पष्ट होता है कि setosa और virginica की petal-length और petal-width के बीच सहसंबंध क्रमशः 0.33 और 0.32 है, जबकि versicolor के लिए यह 0.78 है।

अगला, फीचर वितरण को हिस्टोग्राम्स प्लॉट करके विज़ुअलाइज़ करते हैं:

fig = plt.figure(figsize = (8,8))
ax = fig.gca()
dataset.hist(ax=ax)
plt.show()

petal-length, petal-width, और sepal-length एक यूनिमोडल वितरण दिखाते हैं, जबकि sepal-width एक प्रकार का Gaussian वितरण दर्शाता है। यह सब उपयोगी विश्लेषण है क्योंकि तब आप ऐसे एल्गोरिद्म के उपयोग के बारे में सोच सकते हैं जो इस प्रकार के वितरण के साथ अच्छा काम करते हों।

अगला, आप विश्लेषण करेंगे कि क्या सभी चार एट्रिब्यूट्स एक ही स्केल पर हैं या नहीं; यह ML का एक महत्वपूर्ण पहलू है। pandas डेटा फ्रेम में describe नामक एक इनबिल्ट फंक्शन है जो टेबलर फॉर्मेट में count, mean, max, min देता है।

dataset.describe()

आप देख सकते हैं कि चारों एट्रिब्यूट्स का स्केल 0 से 8 के बीच समान है और ये सेंटीमीटर में हैं; चाहें तो आप इसे 0 से 1 के बीच और स्केल कर सकते हैं।

हालाँकि आप जानते हैं कि प्रति क्लास 50 सैंपल हैं, यानी कुल वितरण का ~33.3%, फिर भी चलिए इसे दोबारा जाँच लेते हैं!

print(dataset.groupby('species').size())

species
Iris-setosa        50
Iris-versicolor    50
Iris-virginica     50
dtype: int64

अपने डेटा का प्रीप्रोसेसिंग

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

अपने डेटा को नॉर्मलाइज़ करना

अपने डेटा को नॉर्मलाइज़ करने के दो तरीके हो सकते हैं:

• उदाहरण-आधारित नॉर्मलाइज़ेशन जिसमें आप प्रत्येक सैंपल को अलग-अलग नॉर्मलाइज़ करते हैं,
• फीचर-आधारित नॉर्मलाइज़ेशन जिसमें आप सभी सैंपल्स में प्रत्येक फीचर को एक ही तरीके से नॉर्मलाइज़ करते हैं।

अब प्रश्न यह है कि आपको डेटा को नॉर्मलाइज़ क्यों या कब करना चाहिए? और क्या आपको Iris डेटा को स्टैंडर्डाइज़ करने की ज़रूरत है?

खैर, जवाब अक्सर यही है—लगभग हर समय। अपने डेटा को नॉर्मलाइज़ करना एक अच्छी प्रैक्टिस है क्योंकि यह सभी सैंपल्स को एक ही स्केल और रेंज में लाता है। जब आपका डेटा सुसंगत नहीं होता है, तो डेटा को नॉर्मलाइज़ करना महत्वपूर्ण हो जाता है। आप ऊपर पढ़े गए describe() फंक्शन का उपयोग कर असंगति की जाँच कर सकते हैं जो आपको max और min मान देता है। यदि किसी एक फीचर के max और min मान दूसरे फीचर की तुलना में काफी बड़े हैं, तो दोनों फीचर्स को एक ही स्केल में नॉर्मलाइज़ करना बहुत महत्वपूर्ण है।

मान लीजिए X एक फीचर है जिसकी रेंज बड़ी है और Y दूसरा फीचर है जिसकी रेंज छोटी है। तब फीचर Y का प्रभाव फीचर X के प्रभाव से दब सकता है। ऐसे में, X और Y दोनों फीचर्स को नॉर्मलाइज़ करना महत्वपूर्ण हो जाता है।

Iris डेटा में, नॉर्मलाइज़ेशन आवश्यक नहीं है।

आइए describe() फंक्शन को फिर से प्रिंट करते हैं और देखते हैं कि आपको नॉर्मलाइज़ेशन की आवश्यकता क्यों नहीं है।

dataset.describe()

sepal-length एट्रिब्यूट के मान 4.3 से 7.9 तक जाते हैं और sepal-width में मान 2 से 4.4 तक हैं, जबकि petal-length के मान 1 से 6.9 तक और petal-width 0.1 से 2.5 तक हैं। सभी फीचर्स के मान 0.1 और 7.9 की रेंज में हैं, जिसे आप स्वीकार्य मान सकते हैं। इसलिए, आपको Iris डेटासेट पर किसी नॉर्मलाइज़ेशन को लागू करने की आवश्यकता नहीं है।

डेटा को विभाजित करना

यह मशीन लर्निंग का एक और महत्वपूर्ण पहलू है क्योंकि आपका लक्ष्य ऐसा मॉडल बनाना है जो टेस्ट वातावरण में बिना किसी मानवीय हस्तक्षेप के निर्णय लेने या डेटा को वर्गीकृत करने में सक्षम हो। इसलिए, उद्योग में अपना ML मॉडल डिप्लॉय करने से पहले, आपको यह सुनिश्चित करना होगा कि मॉडल टेस्टिंग डेटा पर अच्छी तरह सामान्यीकरण (generalize) कर सकता है।

इसके लिए, आपको ट्रेनिंग और टेस्टिंग सेट चाहिए। Iris डेटा पर वापस आते हैं, आपके पास 150 सैंपल हैं; आप अपने ML मॉडल को 80% डेटा पर ट्रेन करेंगे और शेष 20% डेटा टेस्टिंग के लिए उपयोग होगा।

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

ट्रेनिंग और टेस्टिंग सेट स्प्लिट के लिए, आप sklearn लाइब्रेरी का उपयोग करेंगे जिसमें train_test_split नामक इन-बिल्ट स्प्लिटिंग फंक्शन है। तो, आइए डेटा स्प्लिट करते हैं।

from sklearn.model_selection import train_test_split

train_data, test_data, train_label, test_label = train_test_split(dataset.iloc[:,:3], dataset.iloc[:,3], test_size=0.2, random_state=42) 

ध्यान दें कि random_state एक सीड है जो इनपुट के रूप में random_state लेता है—यदि आप संख्या बदलते हैं तो डेटा का स्प्लिट भी बदल जाएगा। हालांकि, यदि आप random_state को समान रखते हैं और सेल को कई बार चलाते हैं, तो डेटा स्प्लिटिंग अपरिवर्तित रहेगी।

आइए जल्दी से ट्रेनिंग और टेस्टिंग डेटा के साथ उनके लेबल्स का आकार प्रिंट करते हैं।

train_data.shape,train_label.shape,test_data.shape,test_label.shape

((120, 3), (120,), (30, 3), (30,))

अंततः, अब डेटा को k-nearest neighbor एल्गोरिद्म को फीड करने का समय है!

KNN मॉडल

सारा डेटा लोड, विश्लेषित और प्रीप्रोसेस करने के बाद, अब समय है जब आप डेटा को KNN मॉडल में फीड करेंगे। ऐसा करने के लिए, आप sklearn की इनबिल्ट neighbors फंक्शनैलिटी का उपयोग करेंगे, जिसमें KNeigborsClassifier नामक एक क्लास है।

आइए क्लासिफायर इम्पोर्ट करके शुरू करें।

from sklearn.neighbors import KNeighborsClassifier

ध्यान दें: k (n_neighbors) पैरामीटर अक्सर विषम संख्या में चुना जाता है ताकि वोटिंग स्कोर में टाई से बचा जा सके।

हाइपरपैरामीटर k के लिए सबसे अच्छा मान तय करने के लिए, आप grid-search जैसा कुछ करेंगे। आप अपने मॉडल को 10 अलग-अलग k मानों पर ट्रेन और टेस्ट करेंगे और अंततः उसी का उपयोग करेंगे जो आपको सर्वोत्तम परिणाम देता है।

आइए एक वेरिएबल neighbors(k) इनिशियलाइज़ करें जिसका मान 1-9 तक होगा और दो numpy शून्य मैट्रिसेस train_accuracy और test_accuracy—क्रमशः ट्रेनिंग और टेस्टिंग एक्यूरेसी के लिए। आपको इन्हें बाद में एक ग्राफ़ प्लॉट करने के लिए चाहिए ताकि सबसे अच्छा neighbor मान चुना जा सके।

neighbors = np.arange(1,9)
train_accuracy =np.zeros(len(neighbors))
test_accuracy = np.zeros(len(neighbors))

अगले कोड में सारा जादू होगा। आप सभी नौ neighbor मानों पर enumerate करेंगे और प्रत्येक neighbor के लिए ट्रेनिंग और टेस्टिंग डेटा—दोनों पर प्रेडिक्ट करेंगे। अंत में, एक्यूरेसी को train_accuracy और test_accuracy numpy ऐरेज़ में स्टोर करेंगे।

for i,k in enumerate(neighbors):
    knn = KNeighborsClassifier(n_neighbors=k)

    #Fit the model
    knn.fit(train_data, train_label)

    #Compute accuracy on the training set
    train_accuracy[i] = knn.score(train_data, train_label)

    #Compute accuracy on the test set
    test_accuracy[i] = knn.score(test_data, test_label)

अगला, आप matplotlib का उपयोग करके ट्रेनिंग और टेस्टिंग एक्यूरेसी प्लॉट करेंगे; accuracy vs. varying number of neighbors ग्राफ़ के साथ आप वह सर्वश्रेष्ठ k मान चुन पाएँगे जिस पर आपका मॉडल सबसे अच्छा प्रदर्शन करता है।

plt.figure(figsize=(10,6))
plt.title('KNN accuracy with varying number of neighbors',fontsize=20)
plt.plot(neighbors, test_accuracy, label='Testing Accuracy')
plt.plot(neighbors, train_accuracy, label='Training accuracy')
plt.legend(prop={'size': 20})
plt.xlabel('Number of neighbors',fontsize=20)
plt.ylabel('Accuracy',fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.show()

ऊपर दिए गए ग्राफ़ को देखकर लगता है कि जब n_neighbors=3 होता है, तो मॉडल सबसे अच्छा प्रदर्शन करता है। तो, n_neighbors=3 पर ही बने रहते हैं और ट्रेनिंग को पुनः चलाते हैं।

knn = KNeighborsClassifier(n_neighbors=3)

#Fit the model
knn.fit(train_data, train_label)

#Compute accuracy on the training set
train_accuracy = knn.score(train_data, train_label)

#Compute accuracy on the test set
test_accuracy = knn.score(test_data, test_label)

अपने मॉडल का मूल्यांकन

ट्यूटोरियल के अंतिम खंड में, आप अपने मॉडल का टेस्टिंग डेटा पर confusion_matrix और classification_report जैसी कुछ तकनीकों का उपयोग करके मूल्यांकन करेंगे।

आइए पहले टेस्टिंग डेटा पर मॉडल की एक्यूरेसी जाँचते हैं।

test_accuracy

0.9666666666666667

वाह! लगता है मॉडल ने टेस्टिंग डेटा का 96.66% सही तरीके से वर्गीकृत किया। क्या यह शानदार नहीं है? कुछ पंक्तियों के कोड से, आपने एक ऐसा ML मॉडल ट्रेन कर लिया जो अब सिर्फ चार फीचर्स का उपयोग करके 96.66% एक्यूरेसी के साथ आपको फूल का नाम बता सकता है। कौन जानता है, शायद यह किसी इंसान से भी बेहतर प्रदर्शन कर गया हो।

कन्फ्यूज़न मैट्रिक्स

कन्फ्यूज़न मैट्रिक्स का उपयोग मुख्य रूप से आपके मॉडल के उस टेस्ट डेटा पर प्रदर्शन का वर्णन करने के लिए किया जाता है जिसके सच्चे मान या लेबल ज्ञात हैं।

Scikit-learn आपके लिए कन्फ्यूज़न मैट्रिक्स की गणना करने वाला फंक्शन प्रदान करता है।

prediction = knn.predict(test_data)

निम्नलिखित plot_confusion_matrix() फंक्शन को इस स्रोत से संशोधित कर लिया गया है।

import itertools
def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):


    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.ylabel('True label',fontsize=30)
    plt.xlabel('Predicted label',fontsize=30)
    plt.tight_layout()
    plt.xticks(fontsize=18)
    plt.yticks(fontsize=18)
class_names = load_iris().target_names


# Compute confusion matrix
cnf_matrix = confusion_matrix(test_label, prediction)
np.set_printoptions(precision=2)

# Plot non-normalized confusion matrix
plt.figure(figsize=(10,8))
plot_confusion_matrix(cnf_matrix, classes=class_names)
plt.title('Confusion Matrix',fontsize=30)
plt.show()

ऊपर दिए गए confusion_matrix प्लॉट से आप देख सकते हैं कि मॉडल ने सभी फूलों को सही वर्गीकृत किया, सिवाय एक virginica फूल के जिसे versicolor के रूप में वर्गीकृत किया गया।

क्लासिफिकेशन रिपोर्ट

क्लासिफिकेशन रिपोर्ट आपको मिसक्लासिफाइड क्लासेज़ की पहचान अधिक विस्तार से करने में मदद करती है, क्योंकि यह प्रत्येक क्लास के लिए precision, recall और F1 score देती है। आप क्लासिफिकेशन रिपोर्ट को विज़ुअलाइज़ करने के लिए sklearn लाइब्रेरी का उपयोग करेंगे।

from sklearn.metrics import classification_report

print(classification_report(test_label, prediction))

                 precision    recall  f1-score   support

    Iris-setosa       1.00      1.00      1.00        10
Iris-versicolor       0.90      1.00      0.95         9
 Iris-virginica       1.00      0.91      0.95        11

      micro avg       0.97      0.97      0.97        30
      macro avg       0.97      0.97      0.97        30
   weighted avg       0.97      0.97      0.97        30

और आगे बढ़ें!

सबसे पहले, उन सभी को बधाई जिन्होंने सफलतापूर्वक अंत तक पहुँचा! लेकिन यह तो बस शुरुआत थी। अभी बहुत लंबा सफ़र तय करना बाकी है!

इस ट्यूटोरियल में मुख्यतः मशीन लर्निंग के मूलभूत सिद्धांतों और Python के साथ KNN नामक एक प्रकार के ML एल्गोरिद्म के इम्प्लीमेंटेशन पर चर्चा हुई। जिस Iris डेटा सेट का आपने उपयोग किया, वह काफी छोटा और थोड़ा सरल था।

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

यदि आपने इस ट्यूटोरियल में प्रस्तुत बेसिक्स और अन्य मशीन लर्निंग एल्गोरिद्म के साथ पर्याप्त प्रयोग कर लिया है, तो आप Python और डेटा विश्लेषण में और आगे बढ़ना चाहेंगे।