इष्टतम क्लस्टर खोजने के लिए पायथन में एल्बो विधि का उपयोग कैसे करें

मशीन लर्निंग में सबसे आम क्लस्टरिंग एल्गोरिदम में से एक को के-मीन्स क्लस्टरिंग के रूप में जाना जाता है।

के-मीन्स क्लस्टरिंग एक ऐसी तकनीक है जिसमें हम डेटासेट से प्रत्येक अवलोकन को के क्लस्टर में से एक में रखते हैं।

अंतिम लक्ष्य K क्लस्टर बनाना है जिसमें प्रत्येक क्लस्टर के भीतर अवलोकन एक-दूसरे के समान होते हैं जबकि विभिन्न समूहों में अवलोकन एक-दूसरे से काफी भिन्न होते हैं।

के-मीन्स क्लस्टरिंग करते समय, पहला कदम के के लिए एक मान चुनना है – क्लस्टर की संख्या जिसमें हम अवलोकन रखना चाहते हैं।

K के लिए मान चुनने के सबसे आम तरीकों में से एक को कोहनी विधि के रूप में जाना जाता है, जिसमें x-अक्ष पर समूहों की संख्या और y-अक्ष पर वर्गों के योग के साथ एक प्लॉट बनाना शामिल है, फिर पहचानें जहां कथानक में “घुटना” या मोड़ दिखाई देता है।

एक्स-अक्ष पर वह बिंदु जहां “घुटना” होता है, हमें के-मीन्स क्लस्टरिंग एल्गोरिदम में उपयोग करने के लिए क्लस्टर की इष्टतम संख्या बताता है।

निम्नलिखित उदाहरण दिखाता है कि पायथन में एल्बो विधि का उपयोग कैसे करें।

चरण 1: आवश्यक मॉड्यूल आयात करें

सबसे पहले, हम उन सभी मॉड्यूल को आयात करेंगे जिनकी हमें k-मीन्स क्लस्टरिंग करने के लिए आवश्यकता होगी:

 import pandas as pd
import numpy as np
import matplotlib. pyplot as plt
from sklearn. cluster import KMeans
from sklearn. preprocessing import StandardScaler

चरण 2: डेटाफ़्रेम बनाएं

इसके बाद, हम एक डेटाफ़्रेम बनाएंगे जिसमें 20 अलग-अलग बास्केटबॉल खिलाड़ियों के लिए तीन वेरिएबल होंगे:

 #createDataFrame
df = pd. DataFrame ({' points ': [18, np.nan, 19, 14, 14, 11, 20, 28, 30, 31,
                              35, 33, 29, 25, 25, 27, 29, 30, 19, 23],
                   ' assists ': [3, 3, 4, 5, 4, 7, 8, 7, 6, 9, 12, 14,
                               np.nan, 9, 4, 3, 4, 12, 15, 11],
                   ' rebounds ': [15, 14, 14, 10, 8, 14, 13, 9, 5, 4,
                                11, 6, 5, 5, 3, 8, 12, 7, 6, 5]})

#drop rows with NA values in any columns
df = df. dropna ()

#create scaled DataFrame where each variable has mean of 0 and standard dev of 1
scaled_df = StandardScaler(). fit_transform (df)

चरण 3: समूहों की इष्टतम संख्या ज्ञात करने के लिए कोहनी विधि का उपयोग करें

मान लीजिए कि हम इन तीन मैट्रिक्स के आधार पर समान अभिनेताओं को एक साथ समूहित करने के लिए k-मीन्स क्लस्टरिंग का उपयोग करना चाहते हैं।

पायथन में k-मीन्स क्लस्टरिंग करने के लिए, हम sklearn मॉड्यूल से KMeans फ़ंक्शन का उपयोग कर सकते हैं।

इस फ़ंक्शन का सबसे महत्वपूर्ण तर्क n_clusters है, जो निर्दिष्ट करता है कि कितने समूहों में अवलोकन रखना है।

क्लस्टरों की इष्टतम संख्या निर्धारित करने के लिए, हम एक ग्राफ़ बनाएंगे जो क्लस्टरों की संख्या के साथ-साथ मॉडल के एसएसई (वर्ग त्रुटियों का योग) को प्रदर्शित करता है।

फिर हम एक “घुटने” की तलाश करेंगे जहां वर्गों का योग “झुकना” या स्थिर होना शुरू हो जाता है। यह बिंदु समूहों की इष्टतम संख्या का प्रतिनिधित्व करता है।

निम्नलिखित कोड दिखाता है कि इस प्रकार का प्लॉट कैसे बनाया जाए जो x-अक्ष पर क्लस्टर की संख्या और y-अक्ष पर SSE प्रदर्शित करता है:

 #initialize kmeans parameters
kmeans_kwargs = {
" init ": " random ",
" n_init ": 10,
" random_state ": 1,
}

#create list to hold SSE values for each k
sse = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, ** kmeans_kwargs)
    kmeans. fit (scaled_df)
    sse. append (kmeans.inertia_)

#visualize results
plt. plot (range(1, 11), sse)
plt. xticks (range(1, 11))
plt. xlabel (" Number of Clusters ")
plt. ylabel (“ SSE ”)
plt. show () 

इस ग्राफ़ में, ऐसा प्रतीत होता है कि k = 3 समूहों पर एक किंक या “घुटना” है।

इसलिए, अगले चरण में अपने k-मीन्स क्लस्टरिंग मॉडल को फिट करते समय हम 3 क्लस्टर का उपयोग करेंगे।

चरण 4: ऑप्टिमल K के साथ K-मीन्स क्लस्टरिंग करें

निम्नलिखित कोड दिखाता है कि 3 में से k के लिए इष्टतम मान का उपयोग करके डेटासेट पर k-मीन्स क्लस्टरिंग कैसे करें:

 #instantiate the k-means class, using optimal number of clusters
kmeans = KMeans(init=" random ", n_clusters= 3 , n_init= 10 , random_state= 1 )

#fit k-means algorithm to data
kmeans. fit (scaled_df)

#view cluster assignments for each observation
kmeans. labels_

array([1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0]) 

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

इन परिणामों की व्याख्या करना आसान बनाने के लिए, हम डेटाफ़्रेम में एक कॉलम जोड़ सकते हैं जो प्रत्येक खिलाड़ी के क्लस्टर असाइनमेंट को दिखाता है:

 #append cluster assingments to original DataFrame
df[' cluster '] = kmeans. labels_

#view updated DataFrame
print (df)

points assists rebounds cluster
0 18.0 3.0 15 1
2 19.0 4.0 14 1
3 14.0 5.0 10 1
4 14.0 4.0 8 1
5 11.0 7.0 14 1
6 20.0 8.0 13 1
7 28.0 7.0 9 2
8 30.0 6.0 5 2
9 31.0 9.0 4 0
10 35.0 12.0 11 0
11 33.0 14.0 6 0
13 25.0 9.0 5 0
14 25.0 4.0 3 2
15 27.0 3.0 8 2
16 29.0 4.0 12 2
17 30.0 12.0 7 0
18 19.0 15.0 6 0
19 23.0 11.0 5 0

क्लस्टर कॉलम में एक क्लस्टर नंबर (0, 1, या 2) होता है जिसे प्रत्येक खिलाड़ी को सौंपा गया है।

एक ही क्लस्टर से संबंधित खिलाड़ियों के पास अंक , सहायता और रिबाउंड कॉलम के लिए लगभग समान मूल्य होते हैं।

नोट : आप sklearn के KMeans फ़ंक्शन के लिए संपूर्ण दस्तावेज़ यहां पा सकते हैं।

अतिरिक्त संसाधन

निम्नलिखित ट्यूटोरियल बताते हैं कि पायथन में अन्य सामान्य कार्य कैसे करें:

पायथन में लीनियर रिग्रेशन कैसे करें
पायथन में लॉजिस्टिक रिग्रेशन कैसे करें
पायथन में के-फोल्ड क्रॉस-वैलिडेशन कैसे करें