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:

1. Innanzitutto, inizializziamo casualmente k punti, chiamati medie o centroidi del cluster.
2. 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.
3. 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

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

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)>

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> )>

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

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.