K-significa clustering è un Apprendimento automatico non supervisionato algoritmo, che raggruppa il set di dati senza etichetta in diversi cluster. L'articolo mira a esplorare i fondamenti e il funzionamento del k mean clustering insieme all'implementazione.
Tabella dei contenuti
- Cos'è il clustering K-mean?
- Qual è l'obiettivo del clustering k-means?
- Come funziona il clustering k-means?
- Implementazione del clustering K-Means in Python
Cos'è il clustering K-mean?
Apprendimento automatico non supervisionato è il processo che insegna a un computer a utilizzare dati non etichettati e non classificati e consente all'algoritmo di operare su tali dati senza supervisione. Senza alcun addestramento precedente sui dati, il compito della macchina in questo caso è organizzare i dati non ordinati secondo paralleli, modelli e variazioni.
K significa clustering, assegna punti dati a uno dei cluster K in base alla loro distanza dal centro dei cluster. Si inizia assegnando in modo casuale il centroide dei cluster nello spazio. Quindi ciascun punto dati viene assegnato a uno dei cluster in base alla sua distanza dal centroide del cluster. Dopo aver assegnato ciascun punto a uno dei cluster, vengono assegnati i nuovi centroidi del cluster. Questo processo viene eseguito in modo iterativo finché non trova un cluster valido. Nell'analisi assumiamo che il numero di cluster sia dato in anticipo e dobbiamo inserire i punti in uno dei gruppi.
In alcuni casi, K non è chiaramente definito e dobbiamo pensare al numero ottimale di K. K Significa che il clustering funziona meglio, i dati sono ben separati. Quando i punti dati si sovrappongono, questo clustering non è adatto. K Means è più veloce rispetto ad altre tecniche di clustering. Fornisce un forte accoppiamento tra i punti dati. K Significa che i cluster non forniscono informazioni chiare sulla qualità dei cluster. Una diversa assegnazione iniziale del centroide del cluster può portare a cluster diversi. Inoltre, l'algoritmo K Means è sensibile al rumore. Potrebbe essersi bloccato nei minimi locali.
Qual è l'obiettivo del clustering k-means?
L'obiettivo di raggruppamento è dividere la popolazione o impostato di punti dati in un numero di gruppi in modo che i punti dati all'interno di ciascun gruppo siano più numerosi paragonabile tra loro e diversi dai punti dati all'interno degli altri gruppi. È essenzialmente un raggruppamento di cose in base a quanto simili e diverse sono tra loro.
Come funziona il clustering k-means?
Ci viene fornito un set di dati di elementi, con determinate caratteristiche e valori per queste caratteristiche (come un vettore). Il compito è classificare tali elementi in gruppi. Per raggiungere questo obiettivo, utilizzeremo l'algoritmo K-means, un algoritmo di apprendimento non supervisionato. La 'K' nel nome dell'algoritmo rappresenta il numero di gruppi/cluster in cui vogliamo classificare i nostri elementi.
(Sarà utile pensare agli oggetti come punti in uno spazio n-dimensionale). L'algoritmo classificherà gli elementi in k gruppi o cluster di somiglianza. Per calcolare tale somiglianza, utilizzeremo la distanza euclidea come misura.
L'algoritmo funziona come segue:
- Innanzitutto, inizializziamo casualmente k punti, chiamati medie o centroidi del cluster.
- Classifichiamo ciascun elemento in base alla media più vicina e aggiorniamo le coordinate della media, che sono le medie degli elementi finora classificati in quel cluster.
- Ripetiamo il processo per un dato numero di iterazioni e alla fine abbiamo i nostri cluster.
I punti sopra menzionati sono chiamati mezzi perché sono i valori medi degli elementi in essi classificati. Per inizializzare questi mezzi, abbiamo molte opzioni. Un metodo intuitivo consiste nell'inizializzare le medie in base a elementi casuali nel set di dati. Un altro metodo consiste nell'inizializzare le medie a valori casuali tra i confini del set di dati (se per una caratteristica X, gli elementi hanno valori in [0,3], inizializzeremo le medie con valori for X a [0,3]).
L'algoritmo di cui sopra in pseudocodice è il seguente:
Initialize k means with random values -->Per un dato numero di iterazioni: --> Itera attraverso gli elementi: --> Trova la media più vicina all'elemento calcolando la distanza euclidea dell'elemento con ciascuna delle medie --> Assegna l'elemento alla media --> Aggiorna media per spostandolo sulla media degli elementi in quel cluster>
Implementazione del clustering K-Means in Python
Esempio 1
Importa le librerie necessarie
Stiamo importando Insensibile per calcoli statistici, Matplotlib per tracciare il grafico, e make_blobs da sklearn.datasets.
Python3
formattatore di stringhe
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Crea il set di dati personalizzato con make_blobs e traccialo
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()> |
>
>
Produzione :
Set di dati in cluster
Inizializza i centroidi casuali
Il codice inizializza tre cluster per il clustering K-means. Imposta un seme casuale e genera centri di cluster casuali all'interno di un intervallo specificato e crea un vuoto elenco di punti per ciascun 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> |
>
>
Produzione:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Traccia il centro di inizializzazione casuale con punti dati
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()> |
>
>
Produzione :
Punti dati con centro casuale
Il grafico visualizza un grafico a dispersione di punti dati (X[:,0], X[:,1]) con linee griglia. Segna anche i centri iniziali dell'ammasso (stelle rosse) generati per il clustering K-means.
Definire la distanza euclidea
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Creare la funzione per assegnare e aggiornare il centro cluster
Il passaggio E assegna i punti dati al centro cluster più vicino, mentre il passaggio M aggiorna i centri cluster in base alla media dei punti assegnati nel clustering 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>]>>0>:> >new_center>=> points.mean(axis>=>0>)> >clusters[i][>'center'>]>=> new_center> > >clusters[i][>'points'>]>=> []> >return> clusters> |
>
>
Passaggio 7: creare la funzione per prevedere il cluster per i punti dati
Python3
nazionalità di pete davidson
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> |
>
>
Assegna, aggiorna e prevedi il centro del cluster
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
cos'è un monitor
Traccia i punti dati con il centro del cluster previsto
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()> |
>
>
Produzione :
K-significa clustering
Il grafico mostra i punti dati colorati in base ai cluster previsti. I marcatori rossi rappresentano i centri dei cluster aggiornati dopo i passaggi E-M nell'algoritmo di clustering K-means.
Esempio 2
Importa le librerie necessarie
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> |
>
>
Carica il set di dati
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
come ha inventato la scuola
>
>
Metodo del gomito
Trovare il numero ideale di gruppi in cui dividere i dati è una fase fondamentale in qualsiasi algoritmo non supervisionato. Una delle tecniche più comuni per determinare questo valore ideale di k è l'approccio del gomito.
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_)> |
>
>
Traccia il grafico del gomito per trovare il numero ottimale di 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()> |
>
>
Produzione:
Metodo del gomito
Dal grafico sopra, possiamo osservare che a k=2 ek=3 si trova una situazione a gomito. Quindi, stiamo considerando K=3
Costruisci il modello di clustering Kmeans
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Produzione:
KMeans KMeans(n_clusters=3, random_state=2)>
Trova il centro del cluster
Python3
stampa Java
kmeans.cluster_centers_> |
>
>
Produzione:
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]])>
Prevedere il gruppo di cluster:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Produzione:
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)>
Traccia il centro del cluster con i punti dati
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()> |
>
>
Produzione:
K-significa clustering
La sottotrama a sinistra mostra la lunghezza del petalo rispetto alla larghezza del petalo con punti dati colorati in base ai cluster e gli indicatori rossi indicano i centri dei cluster K-mean. La sottotrama a destra mostra la lunghezza dei sepali rispetto alla larghezza dei sepali in modo simile.
Conclusione
In conclusione, il clustering K-means è un potente algoritmo di apprendimento automatico non supervisionato per raggruppare set di dati senza etichetta. Il suo obiettivo è dividere i dati in cluster, rendendo i punti dati simili parte dello stesso gruppo. L'algoritmo inizializza i centroidi del cluster e assegna iterativamente i punti dati al centroide più vicino, aggiornando i centroidi in base alla media dei punti in ciascun cluster.
Domande frequenti (FAQ)
1. Cos'è il clustering k-means per l'analisi dei dati?
K-means è un metodo di partizionamento che divide un set di dati in 'k' sottoinsiemi distinti e non sovrapposti (cluster) in base alla somiglianza, con l'obiettivo di ridurre al minimo la varianza all'interno di ciascun cluster.
2.Qual è un esempio di k-mean nella vita reale?
Segmentazione della clientela nel marketing, dove k-means raggruppa i clienti in base al comportamento di acquisto, consentendo alle aziende di personalizzare le strategie di marketing per diversi segmenti.
3. Che tipo di dati è il modello di clustering k-means?
K-medie funziona bene con i dati numerici, dove il concetto di distanza tra i punti dati è significativo. È comunemente applicato a variabili continue.
4.Le medie K vengono utilizzate per la previsione?
Le medie K vengono utilizzate principalmente per raggruppare e raggruppare punti dati simili. Non prevede etichette per i nuovi dati; li assegna ai cluster esistenti in base alla somiglianza.
5.Qual è l'obiettivo del clustering k-means?
L’obiettivo è partizionare i dati in cluster “k”, riducendo al minimo la varianza all’interno del cluster. Cerca di formare gruppi in cui i punti dati all'interno di ciascun cluster siano più simili tra loro rispetto a quelli di altri cluster.