Kmeans क्लस्टरिंग एल्गोरिथम का परिचय

के-मीन्स क्लस्टरिंग क्या है?

के-मीन्स क्लस्टरिंग एक अनपर्यवाइज्ड मशीन लर्निंग एल्गोरिथम है जिसका उपयोग डेटासेट में समान डेटा बिंदुओं को एक साथ क्लस्टर करने या समूहीकृत करने के लिए किया जाता है। यह एक विभाजन एल्गोरिथम है, जो डेटा को गैर-अतिव्यापी समूहों में विभाजित करता है, जहां प्रत्येक डेटा बिंदु एक क्लस्टर से संबंधित होता है। K- साधन क्लस्टरिंग का उद्देश्य प्रत्येक डेटा बिंदु और उसके नियत केन्द्रक के बीच वर्ग दूरी के योग को कम करना है।

सिद्धांत - यह कैसे काम करता है?

चरण 1. सबसे पहले, हमें K का मान तय करना होगा, जो कि हम कितने क्लस्टर बनाना चाहते हैं। K का मान या तो यादृच्छिक रूप से या कोहनी, सिल्हूट जैसी कुछ विधियों का उपयोग करके तय किया जा सकता है।

चरण 2। इसके बाद, हम प्रत्येक क्लस्टर के प्रारंभिक केन्द्रक के रूप में कार्य करने के लिए डेटासेट से यादृच्छिक रूप से K बिंदुओं का चयन करते हैं।

चरण 3. फिर हम प्रत्येक डेटा बिंदु और सेंट्रोइड्स के बीच यूक्लिडियन दूरी की गणना करते हैं और K क्लस्टर बनाते हुए डेटा बिंदु को निकटतम सेंट्रोइड पर असाइन करते हैं।

चरण 4. सभी डेटा बिंदुओं को उनके निकटतम सेंट्रोइड पर निर्दिष्ट करने के बाद, हम उस सेंट्रोइड को निर्दिष्ट सभी डेटा बिंदुओं के माध्य की गणना करके प्रत्येक सेंट्रोइड के स्थान को अपडेट करते हैं।

चरण 5. हम चरण 3 और 4 को तब तक दोहराते हैं जब तक कि एल्गोरिथम अभिसरण नहीं हो जाता, जिसका अर्थ है कि सेंट्रोइड्स अब आगे नहीं बढ़ते हैं या डेटा बिंदुओं और उनके असाइन किए गए सेंट्रोइड के बीच वर्ग दूरी के योग में सुधार नगण्य हो जाता है।

कोड कैसे काम करता है?

आवश्यक पुस्तकालय आयात करें:

import numpy as np
import matplotlib.pyplot as plt

X = np.random.rand(100, 2) * 2
plt.scatter(X[:, 0], X[:, 1])
plt.show()

      
                

                    
                    
                
            

K = 7
centroids = X[np.random.choice(len(X), K, replace=False)]
plt.scatter(X[:, 0], X[:, 1])
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.show()

      
                

                    
                    
                
            
while True:
    # Assign data points to the nearest centroid
    distances = np.sqrt(((X - centroids[:, np.newaxis])**2).sum(axis=2))
    labels = np.argmin(distances, axis=0)

    # Calculate new centroids
    new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(K)])

    # Check for convergence
    if np.all(centroids == new_centroids):
        break

    # Update centroids
    centroids = new_centroids
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r')
plt.show()

      
                

                    
                    
                
            

K की सीमाएँ एल्गोरिथम हैं

1. K का अर्थ है कि क्लस्टरिंग प्रारंभिक केन्द्रक चयन के प्रति संवेदनशील है। एल्गोरिथम एक उपइष्टतम समाधान में परिवर्तित हो सकता है यदि प्रारंभिक सेंट्रोइड्स को उचित रूप से नहीं चुना गया है।
2. K का मतलब है कि क्लस्टरिंग आउटलेयर के प्रति संवेदनशील है
3. K का अर्थ है कि क्लस्टरिंग K के मान के प्रति संवेदनशील है। यदि K को सही ढंग से नहीं चुना गया है तो यह सबऑप्टिमल क्लस्टर दे सकता है।