K-Means Clustering este o Învățare automată nesupravegheată algoritm, care grupează setul de date neetichetat în grupuri diferite. Articolul își propune să exploreze fundamentele și funcționarea grupării k medii împreună cu implementarea.
Cuprins
- Ce este K-means Clustering?
- Care este obiectivul grupării k-means?
- Cum funcționează gruparea k-means?
- Implementarea grupării K-Means în Python
Ce este K-means Clustering?
Învățare automată nesupravegheată este procesul de predare a unui computer să folosească date neetichetate, neclasificate și care permite algoritmului să opereze pe acele date fără supraveghere. Fără nicio pregătire anterioară a datelor, sarcina mașinii în acest caz este să organizeze datele nesortate în funcție de paralele, modele și variații.
K înseamnă grupare, atribuie puncte de date unuia dintre clusterele K în funcție de distanța lor de la centrul clusterelor. Începe prin alocarea aleatorie a centrului clusterelor din spațiu. Apoi, fiecare punct de date alocă unuia dintre cluster în funcție de distanța sa față de centroidul clusterului. După atribuirea fiecărui punct unuia dintre cluster, sunt atribuiți noi centroizi de cluster. Acest proces rulează iterativ până când găsește un cluster bun. În analiză presupunem că numărul de cluster este dat în avans și trebuie să punem puncte într-unul din grup.
În unele cazuri, K nu este clar definit și trebuie să ne gândim la numărul optim de K. K înseamnă că gruparea are cele mai bune rezultate, datele sunt bine separate. Când punctele de date se suprapun, această grupare nu este adecvată. K Means este mai rapid în comparație cu alte tehnici de grupare. Oferă o cuplare puternică între punctele de date. K Means cluster nu oferă informații clare cu privire la calitatea clusterelor. Atribuirea inițială diferită a centroidului clusterului poate duce la grupuri diferite. De asemenea, algoritmul K Means este sensibil la zgomot. S-ar fi blocat în minimele locale.
Care este obiectivul grupării k-means?
Scopul de gruparea este de a împărți populația sau a stabilit de puncte de date într-un număr de grupuri, astfel încât punctele de date din fiecare grup să fie mai multe comparabil unul față de celălalt și diferit de punctele de date din celelalte grupuri. Este, în esență, o grupare de lucruri bazată pe cât de asemănătoare și diferite sunt acestea unul față de celălalt.
Cum funcționează gruparea k-means?
Ni se oferă un set de date de elemente, cu anumite caracteristici și valori pentru aceste caracteristici (cum ar fi un vector). Sarcina este de a clasifica acele articole în grupuri. Pentru a realiza acest lucru, vom folosi algoritmul K-means, un algoritm de învățare nesupravegheată. „K” din numele algoritmului reprezintă numărul de grupuri/clustere în care dorim să ne clasificăm articolele.
(Va ajuta dacă vă gândiți la elemente ca puncte într-un spațiu n-dimensional). Algoritmul va clasifica elementele în k grupuri sau grupuri de similaritate. Pentru a calcula această similitudine, vom folosi distanța euclidiană ca măsură.
Algoritmul funcționează după cum urmează:
- În primul rând, inițializam aleatoriu k puncte, numite medii sau centroizi cluster.
- Clasificăm fiecare articol la cea mai apropiată medie și actualizăm coordonatele mediei, care sunt mediile articolelor clasificate în acel cluster până acum.
- Repetăm procesul pentru un anumit număr de iterații și, la sfârșit, avem clusterele noastre.
Punctele menționate mai sus se numesc mijloace deoarece sunt valorile medii ale elementelor clasificate în ele. Pentru a inițializa aceste mijloace, avem o mulțime de opțiuni. O metodă intuitivă este inițializarea mijloacelor la elemente aleatorii din setul de date. O altă metodă este de a inițializa mediile la valori aleatorii între limitele setului de date (dacă este pentru o caracteristică X, itemii au valori in [0,3], vom initializa mediile cu valori pt X la [0,3]).
Algoritmul de mai sus în pseudocod este următorul:
Initialize k means with random values -->Pentru un anumit număr de iterații: --> Iterați prin elemente: --> Găsiți media cea mai apropiată de element calculând distanța euclidiană a articolului cu fiecare dintre mijloace --> Atribuiți elementul la medie --> Actualizați media prin mutându-l la media elementelor din acel cluster>
Implementarea grupării K-Means în Python
Exemplul 1
Importați bibliotecile necesare
Importăm Numpy pentru calcule statistice, Matplotlib să comploteze grafic, și make_blobs din sklearn.datasets.
Python3
cheia candidatului
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Creați setul de date personalizat cu make_blobs și trasați-l
Python3
X,y>=> make_blobs(n_samples>=> 500>,n_features>=> 2>,centers>=> 3>,random_state>=> 23>)> fig>=> plt.figure(>0>)> plt.grid(>True>)> plt.scatter(X[:,>0>],X[:,>1>])> plt.show()> |
>
>
Ieșire :
Gruparea setului de date
Inițializați centroizii aleatori
Codul inițializează trei clustere pentru gruparea K-means. Setează o sămânță aleatoare și generează centre aleatoare ale clusterului într-un interval specificat și creează un spațiu gol listă de puncte pentru fiecare cluster.
Python3
k>=> 3> clusters>=> {}> np.random.seed(>23>)> for> idx>in> range>(k):> >center>=> 2>*>(>2>*>np.random.random((X.shape[>1>],))>->1>)> >points>=> []> >cluster>=> {> >'center'> : center,> >'points'> : []> >}> > >clusters[idx]>=> cluster> > clusters> |
>
>
Ieșire:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Trasează centrul de inițializare aleatorie cu puncte de date
Python3
plt.scatter(X[:,>0>],X[:,>1>])> plt.grid(>True>)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '*'>,c>=> 'red'>)> plt.show()> |
>
>
Ieșire :
Puncte de date cu centru aleator
Graficul afișează un grafic de împrăștiere a punctelor de date (X[:,0], X[:,1]) cu linii de grilă. De asemenea, marchează centrele inițiale ale clusterului (stelele roșii) generate pentru gruparea K-means.
Definiți distanța euclidiană
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Creați funcția pentru a atribui și actualiza centrul clusterului
Pasul E alocă puncte de date celui mai apropiat centru de cluster, iar pasul M actualizează centrele de cluster pe baza mediei punctelor alocate în gruparea K-means.
Python3
#Implementing E step> def> assign_clusters(X, clusters):> >for> idx>in> range>(X.shape[>0>]):> >dist>=> []> > >curr_x>=> X[idx]> > >for> i>in> range>(k):> >dis>=> distance(curr_x,clusters[i][>'center'>])> >dist.append(dis)> >curr_cluster>=> np.argmin(dist)> >clusters[curr_cluster][>'points'>].append(curr_x)> >return> clusters> > #Implementing the M-Step> def> update_clusters(X, clusters):> >for> i>in> range>(k):> >points>=> np.array(clusters[i][>'points'>])> >if> points.shape[>0>]>>>> >new_center>=> points.mean(axis>=>0>)> >clusters[i][>'center'>]>=> new_center> > >clusters[i][>'points'>]>=> []> >return> clusters> |
>
>
Pasul 7: Creați funcția pentru a prezice clusterul pentru punctele de date
Python3
t flip flop
def> pred_cluster(X, clusters):> >pred>=> []> >for> i>in> range>(X.shape[>0>]):> >dist>=> []> >for> j>in> range>(k):> >dist.append(distance(X[i],clusters[j][>'center'>]))> >pred.append(np.argmin(dist))> >return> pred> |
>
>
Atribuiți, actualizați și preziceți centrul clusterului
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
applet
>
Trasează punctele de date cu centrul lor de cluster prezis
Python3
plt.scatter(X[:,>0>],X[:,>1>],c>=> pred)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.show()> |
>
>
Ieșire :
K înseamnă Clustering
Graficul arată punctele de date colorate după clusterele lor prezise. Markerii roșii reprezintă centrele de cluster actualizate după pașii E-M din algoritmul de grupare K-means.
Exemplul 2
Importați bibliotecile necesare
Python3
import> pandas as pd> import> numpy as np> import> seaborn as sns> import> matplotlib.pyplot as plt> import> matplotlib.cm as cm> from> sklearn.datasets>import> load_iris> from> sklearn.cluster>import> KMeans> |
>
>
Încărcați setul de date
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
numere blocate
>
>
Metoda cotului
Găsirea numărului ideal de grupuri pentru a împărți datele este o etapă de bază în orice algoritm nesupravegheat. Una dintre cele mai comune tehnici pentru a determina această valoare ideală a lui k este abordarea cot.
Python3
#Find optimum number of cluster> sse>=> []>#SUM OF SQUARED ERROR> for> k>in> range>(>1>,>11>):> >km>=> KMeans(n_clusters>=>k, random_state>=>2>)> >km.fit(X)> >sse.append(km.inertia_)> |
>
>
Trasează graficul Elbow pentru a găsi numărul optim de cluster
Python3
sns.set_style(>'whitegrid'>)> g>=>sns.lineplot(x>=>range>(>1>,>11>), y>=>sse)> g.>set>(xlabel>=>'Number of cluster (k)'>,> >ylabel>=> 'Sum Squared Error'>,> >title>=>'Elbow Method'>)> plt.show()> |
>
>
Ieșire:
Metoda cotului
Din graficul de mai sus, putem observa că la k=2 și k=3 situație asemănătoare cotului. Deci, luăm în considerare K=3
Construiți modelul de clustering Kmeans
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Ieșire:
KMeans KMeans(n_clusters=3, random_state=2)>
Găsiți centrul clusterului
Python3
python reduce
kmeans.cluster_centers_> |
>
>
Ieșire:
array([[5.006 , 3.428 , 1.462 , 0.246 ], [5.9016129 , 2.7483871 , 4.39354839, 1.43387097], [6.85 , 3.07368421, 5.74210526, 2.07105263]])>
Preziceți grupul de cluster:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Ieșire:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)>
Trasează centrul clusterului cu puncte de date
Python3
plt.figure(figsize>=>(>12>,>5>))> plt.subplot(>1>,>2>,>1>)> plt.scatter(X[:,>0>],X[:,>1>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[:>2>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'petal length (cm)'>)> plt.ylabel(>'petal width (cm)'>)> > plt.subplot(>1>,>2>,>2>)> plt.scatter(X[:,>2>],X[:,>3>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[>2>:>4>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'sepal length (cm)'>)> plt.ylabel(>'sepal width (cm)'>)> plt.show()> |
>
>
Ieșire:
K înseamnă grupare
Subplotul din stânga afișează lungimea petale în raport cu lățimea petalelor cu puncte de date colorate prin grupuri, iar marcajele roșii indică K-means centrele clusterului. Subplotul din dreapta arată lungimea sepalului față de lățimea sepalului în mod similar.
Concluzie
În concluzie, gruparea K-means este un algoritm puternic de învățare automată nesupravegheată pentru gruparea seturi de date neetichetate. Obiectivul său este de a împărți datele în grupuri, făcând puncte de date similare parte din același grup. Algoritmul inițializează centroizii clusterului și atribuie iterativ puncte de date celui mai apropiat centroid, actualizând centroizii pe baza mediei punctelor din fiecare cluster.
Întrebări frecvente (FAQs)
1. Ce este gruparea k-means pentru analiza datelor?
K-means este o metodă de partiționare care împarte un set de date în „k” subseturi (clustere) distincte, care nu se suprapun, pe baza similitudinii, cu scopul de a minimiza varianța în cadrul fiecărui cluster.
2.Care este un exemplu de k-means în viața reală?
Segmentarea clienților în marketing, unde k-means grupează clienții pe baza comportamentului de cumpărare, permițând companiilor să adapteze strategiile de marketing pentru diferite segmente.
3. Ce tip de date este modelul de clustering k-means?
K-means funcționează bine cu datele numerice, unde conceptul de distanță dintre punctele de date este semnificativ. Se aplică de obicei variabilelor continue.
4.Se folosesc K-means pentru predicție?
K-means este folosit în primul rând pentru gruparea și gruparea punctelor de date similare. Nu prezice etichete pentru date noi; le atribuie clusterelor existente pe baza similitudinii.
5.Care este obiectivul grupării k-means?
Obiectivul este de a împărți datele în „k” clustere, minimizând varianța intra-cluster. Se urmărește să formeze grupuri în care punctele de date din fiecare cluster sunt mai asemănătoare între ele decât cu cele din alte clustere.