K-Means Clustering è un algoritmo di apprendimento non supervisionato utilizzato per risolvere i problemi di clustering nell'apprendimento automatico o nella scienza dei dati. In questo argomento impareremo cos'è l'algoritmo di clustering K-means, come funziona l'algoritmo, insieme all'implementazione Python del clustering k-means.
Cos'è l'algoritmo K-Means?
Il clustering K-Means è un Algoritmo di apprendimento non supervisionato , che raggruppa il set di dati senza etichetta in diversi cluster. Qui K definisce il numero di cluster predefiniti che devono essere creati nel processo, come se K=2 ci saranno due cluster e per K=3 ci saranno tre cluster e così via.
È un algoritmo iterativo che divide il set di dati senza etichetta in k cluster diversi in modo tale che ciascun set di dati appartenga a un solo gruppo che ha proprietà simili.
Ci consente di raggruppare i dati in diversi gruppi e rappresenta un modo conveniente per scoprire autonomamente le categorie di gruppi nel set di dati senza etichetta senza la necessità di alcuna formazione.
È un algoritmo basato sul centroide, in cui ciascun cluster è associato a un centroide. Lo scopo principale di questo algoritmo è ridurre al minimo la somma delle distanze tra il punto dati e i cluster corrispondenti.
L'algoritmo prende come input il set di dati senza etichetta, divide il set di dati in un numero k di cluster e ripete il processo finché non trova i cluster migliori. Il valore di k dovrebbe essere predeterminato in questo algoritmo.
Il k-significa raggruppamento L’algoritmo svolge principalmente due compiti:
- Determina il valore migliore per i punti centrali o i centroidi K mediante un processo iterativo.
- Assegna ciascun punto dati al relativo centro k più vicino. Quei punti dati che sono vicini al particolare k-centro creano un cluster.
Pertanto ogni cluster ha punti dati con alcuni punti in comune ed è lontano dagli altri cluster.
coda di priorità Java
Il diagramma seguente spiega il funzionamento dell'algoritmo di clustering K-means:
Come funziona l'algoritmo K-Means?
Il funzionamento dell'algoritmo K-Means è spiegato nei passaggi seguenti:
Passo 1: Selezionare il numero K per decidere il numero di cluster.
Passo 2: Seleziona K punti o centroidi casuali. (Può essere diverso dal set di dati di input).
Passaggio 3: Assegna ciascun punto dati al centroide più vicino, che formerà i K cluster predefiniti.
Passaggio 4: Calcola la varianza e posiziona un nuovo baricentro di ciascun cluster.
Passaggio 5: Ripeti i terzi passaggi, il che significa riassegnare ciascun punto dati al nuovo baricentro più vicino di ciascun cluster.
Passaggio 6: Se si verifica una riassegnazione, andare al passaggio 4 altrimenti andare a FINE.
classe di oggetti in Java
Passaggio 7 : Il modello è pronto.
Comprendiamo i passaggi precedenti considerando i grafici visivi:
Supponiamo di avere due variabili M1 e M2. Il diagramma di dispersione sugli assi xy di queste due variabili è riportato di seguito:
- Prendiamo il numero k di cluster, ovvero K=2, per identificare il set di dati e inserirli in cluster diversi. Significa che qui proveremo a raggruppare questi set di dati in due cluster diversi.
- Dobbiamo scegliere alcuni k punti casuali o baricentro per formare il cluster. Questi punti possono essere i punti del set di dati o qualsiasi altro punto. Quindi, qui stiamo selezionando i due punti seguenti come k punti, che non fanno parte del nostro set di dati. Considera l'immagine qui sotto:
- Ora assegneremo ciascun punto dati del grafico a dispersione al punto K o baricentro più vicino. Lo calcoleremo applicando alcuni calcoli matematici che abbiamo studiato per calcolare la distanza tra due punti. Quindi, disegneremo una mediana tra entrambi i centroidi. Considera l'immagine qui sotto:
Dall'immagine sopra, è chiaro che i punti sul lato sinistro della linea sono vicini al baricentro K1 o blu, mentre i punti a destra della linea sono vicini al baricentro giallo. Coloriamoli in blu e giallo per una visualizzazione chiara.
- Poiché dobbiamo trovare il cluster più vicino, ripeteremo il processo scegliendo un nuovo baricentro . Per scegliere i nuovi centroidi, calcoleremo il centro di gravità di questi centroidi e troveremo nuovi centroidi come di seguito:
- Successivamente, riassegneremo ciascun punto dati al nuovo centroide. Per questo, ripeteremo lo stesso processo per trovare una linea mediana. La mediana sarà come nell'immagine qui sotto:
Dall'immagine sopra possiamo vedere che un punto giallo si trova sul lato sinistro della linea e due punti blu sono a destra della linea. Quindi, questi tre punti verranno assegnati a nuovi centroidi.
Una volta effettuata la riassegnazione, andremo nuovamente al passaggio 4, che consiste nel trovare nuovi centroidi o punti K.
- Ripeteremo il processo trovando il centro di gravità dei centroidi, quindi i nuovi centroidi saranno come mostrato nell'immagine seguente:
- Una volta ottenuti i nuovi centroidi, disegneremo nuovamente la linea mediana e riassegneremo i punti dati. Quindi, l'immagine sarà:
- Possiamo vedere nell'immagine sopra; non ci sono punti dati diversi su entrambi i lati della linea, il che significa che il nostro modello è formato. Considera l'immagine qui sotto:
Poiché il nostro modello è pronto, ora possiamo rimuovere i centroidi assunti e i due cluster finali saranno come mostrato nell'immagine seguente:
Come scegliere il valore di 'Numero K di cluster' in K-means Clustering?
Le prestazioni dell'algoritmo di clustering K-means dipendono dai cluster altamente efficienti che forma. Ma scegliere il numero ottimale di cluster è un compito arduo. Esistono diversi modi per trovare il numero ottimale di cluster, ma qui stiamo discutendo il metodo più appropriato per trovare il numero di cluster o il valore di K. Il metodo è riportato di seguito:
Metodo del gomito
Il metodo Elbow è uno dei metodi più diffusi per trovare il numero ottimale di cluster. Questo metodo utilizza il concetto di valore WCSS. WCSS sta per All'interno del cluster Somma dei quadrati , che definisce le variazioni totali all'interno di un cluster. Di seguito la formula per calcolare il valore del WCSS (per 3 cluster):
WCSS= ∑Pio nel Cluster1distanza (PioC1)2+∑Pio nel Cluster2distanza (PioC2)2+∑Pio nel CLuster3distanza (PioC3)2Nella formula sopra di WCSS,
∑Pio nel Cluster1distanza (PioC1)2: È la somma del quadrato delle distanze tra ciascun punto dati e il suo baricentro all'interno di un cluster1 e lo stesso per gli altri due termini.
Per misurare la distanza tra i punti dati e il baricentro, possiamo utilizzare qualsiasi metodo come la distanza euclidea o la distanza di Manhattan.
Per trovare il valore ottimale dei cluster, il metodo del gomito segue i passaggi seguenti:
- Esegue il clustering delle medie K su un dato set di dati per diversi valori K (intervalli da 1 a 10).
- Per ogni valore di K, calcola il valore WCSS.
- Traccia una curva tra i valori WCSS calcolati e il numero di cluster K.
- Il punto acuto di piega o un punto della trama assomiglia ad un braccio, quindi quel punto viene considerato come il miglior valore di K.
Poiché il grafico mostra una curva stretta, che assomiglia ad un gomito, è noto come metodo del gomito. Il grafico per il metodo del gomito è simile all'immagine seguente:
Nota: possiamo scegliere il numero di cluster pari ai punti dati forniti. Se scegliamo il numero di cluster pari ai punti dati, il valore di WCSS diventa zero e quello sarà il punto finale del grafico.
Implementazione Python dell'algoritmo di clustering K-means
Nella sezione precedente abbiamo discusso l'algoritmo K-means, ora vediamo come può essere implementato utilizzando Pitone .
Prima dell'implementazione, capiamo che tipo di problema risolveremo qui. Quindi, abbiamo un set di dati di Centro commerciale_Clienti , ovvero i dati dei clienti che visitano il centro commerciale e vi spendono.
Nel set di dati fornito, abbiamo Customer_Id, sesso, età, reddito annuo ($) e punteggio di spesa (che è il valore calcolato di quanto un cliente ha speso nel centro commerciale, maggiore è il valore, più ha speso). Da questo set di dati dobbiamo calcolare alcuni modelli, poiché si tratta di un metodo non supervisionato, quindi non sappiamo cosa calcolare esattamente.
Di seguito vengono riportati i passaggi da seguire per la realizzazione:
Passaggio 1: passaggio di pre-elaborazione dei dati
Il primo passo sarà la pre-elaborazione dei dati, come abbiamo fatto nei nostri precedenti argomenti di Regressione e Classificazione. Ma per quanto riguarda il problema del clustering, sarà diverso dagli altri modelli. Discutiamone:
Come abbiamo fatto negli argomenti precedenti, in primo luogo importeremo le librerie per il nostro modello, che fa parte della pre-elaborazione dei dati. Il codice è riportato di seguito:
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd
Nel codice precedente, il insensato abbiamo importato per l'esecuzione del calcolo matematico, matplotlib serve per tracciare il grafico e panda servono per la gestione del set di dati.
javafx
Successivamente, importeremo il set di dati che dobbiamo utilizzare. Quindi qui stiamo utilizzando il set di dati Mall_Customer_data.csv. Può essere importato utilizzando il codice seguente:
# Importing the dataset dataset = pd.read_csv('Mall_Customers_data.csv')
Eseguendo le righe di codice sopra, otterremo il nostro set di dati nell'IDE Spyder. Il set di dati è simile all'immagine seguente:
Dal set di dati di cui sopra, dobbiamo trovare alcuni modelli al suo interno.
In questo caso non abbiamo bisogno di alcuna variabile dipendente per la fase di pre-elaborazione dei dati poiché si tratta di un problema di clustering e non abbiamo idea di cosa determinare. Quindi aggiungeremo semplicemente una riga di codice per la matrice delle funzionalità.
x = dataset.iloc[:, [3, 4]].values
Come possiamo vedere, ne stiamo estraendo solo 3rde 4thcaratteristica. È perché abbiamo bisogno di un grafico 2D per visualizzare il modello e alcune funzionalità non sono richieste, come customer_id.
Passaggio 2: trovare il numero ottimale di cluster utilizzando il metodo del gomito
Nella seconda fase, proveremo a trovare il numero ottimale di cluster per il nostro problema di clustering. Quindi, come discusso sopra, qui utilizzeremo il metodo del gomito per questo scopo.
Come sappiamo, il metodo del gomito utilizza il concetto WCSS per tracciare il grafico riportando i valori WCSS sull'asse Y e il numero di cluster sull'asse X. Quindi calcoleremo il valore per WCSS per diversi valori k compresi tra 1 e 10. Di seguito è riportato il codice:
#finding optimal number of clusters using the elbow method from sklearn.cluster import KMeans wcss_list= [] #Initializing the list for the values of WCSS #Using for loop for iterations from 1 to 10. for i in range(1, 11): kmeans = KMeans(n_clusters=i, init='k-means++', random_state= 42) kmeans.fit(x) wcss_list.append(kmeans.inertia_) mtp.plot(range(1, 11), wcss_list) mtp.title('The Elobw Method Graph') mtp.xlabel('Number of clusters(k)') mtp.ylabel('wcss_list') mtp.show()
Come possiamo vedere nel codice sopra, abbiamo utilizzato i KMean classe di sklearn. libreria cluster per formare i cluster.
Successivamente, abbiamo creato il file wcss_list variabile per inizializzare una lista vuota, che viene utilizzata per contenere il valore di wcss calcolato per diversi valori di k compresi tra 1 e 10.
Successivamente, abbiamo inizializzato il ciclo for per l'iterazione su un diverso valore di k compreso tra 1 e 10; poiché il ciclo for in Python esclude il limite in uscita, quindi viene considerato 11 per includere 10thvalore.
La parte restante del codice è simile a quella degli argomenti precedenti, poiché abbiamo adattato il modello a una matrice di caratteristiche e quindi tracciato il grafico tra il numero di cluster e WCSS.
Produzione: Dopo aver eseguito il codice sopra, otterremo l'output seguente:
Dal grafico sopra, possiamo vedere che si trova il punto del gomito 5. Quindi il numero di cluster qui sarà 5.
Passaggio 3: addestramento dell'algoritmo K-means sul set di dati di addestramento
Poiché abbiamo il numero di cluster, ora possiamo addestrare il modello sul set di dati.
Per addestrare il modello, utilizzeremo le stesse due righe di codice che abbiamo utilizzato nella sezione precedente, ma qui invece di utilizzare i, utilizzeremo 5, poiché sappiamo che ci sono 5 cluster che devono essere formati. Il codice è riportato di seguito:
#training the K-means model on a dataset kmeans = KMeans(n_clusters=5, init='k-means++', random_state= 42) y_predict= kmeans.fit_predict(x)
La prima riga è la stessa di sopra per creare l'oggetto della classe KMeans.
Nella seconda riga di codice abbiamo creato la variabile dipendente y_predict per addestrare il modello.
Eseguendo le righe di codice sopra, otterremo la variabile y_predict. Possiamo controllarlo qui sotto l'esploratore variabile opzione nell'IDE Spyder. Ora possiamo confrontare i valori di y_predict con il nostro set di dati originale. Considera l'immagine qui sotto:
stringa di formato Java
Dall'immagine sopra, ora possiamo stabilire che CustomerID 1 appartiene a un cluster
3(poiché l'indice inizia da 0, quindi 2 sarà considerato come 3) e 2 appartiene al cluster 4 e così via.
Passaggio 4: visualizzazione dei cluster
L'ultimo passaggio è visualizzare i cluster. Poiché abbiamo 5 cluster per il nostro modello, visualizzeremo ciascun cluster uno per uno.
Per visualizzare i cluster utilizzerà il grafico a dispersione utilizzando la funzione mtp.scatter() di matplotlib.
#visulaizing the clusters mtp.scatter(x[y_predict == 0, 0], x[y_predict == 0, 1], s = 100, c = 'blue', label = 'Cluster 1') #for first cluster mtp.scatter(x[y_predict == 1, 0], x[y_predict == 1, 1], s = 100, c = 'green', label = 'Cluster 2') #for second cluster mtp.scatter(x[y_predict== 2, 0], x[y_predict == 2, 1], s = 100, c = 'red', label = 'Cluster 3') #for third cluster mtp.scatter(x[y_predict == 3, 0], x[y_predict == 3, 1], s = 100, c = 'cyan', label = 'Cluster 4') #for fourth cluster mtp.scatter(x[y_predict == 4, 0], x[y_predict == 4, 1], s = 100, c = 'magenta', label = 'Cluster 5') #for fifth cluster mtp.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s = 300, c = 'yellow', label = 'Centroid') mtp.title('Clusters of customers') mtp.xlabel('Annual Income (k$)') mtp.ylabel('Spending Score (1-100)') mtp.legend() mtp.show()
Nelle righe di codice sopra, abbiamo scritto il codice per ciascun cluster, che va da 1 a 5. La prima coordinata di mtp.scatter, cioè x[y_predict == 0, 0] contenente il valore x per mostrare la matrice di presenta valori e y_predict varia da 0 a 1.
Produzione:
L'immagine di output mostra chiaramente i cinque diversi cluster con colori diversi. I cluster sono formati tra due parametri del dataset; Reddito annuo del cliente e spesa. Possiamo cambiare i colori e le etichette secondo il requisito o la scelta. Possiamo anche osservare alcuni punti dei modelli di cui sopra, che sono riportati di seguito:
- Il cluster2 mostra che il cliente ha un reddito elevato ma una spesa bassa, quindi possiamo classificarlo come attento .
- Il cluster 3 mostra il reddito basso e anche la spesa bassa in modo che possano essere classificati come sensati.
- Il Cluster4 mostra i clienti a basso reddito con una spesa molto elevata in modo che possano essere classificati come negligente .
- Il cluster 5 mostra i clienti con reddito elevato e spesa elevata in modo che possano essere classificati come target e questi clienti possano essere i clienti più redditizi per il proprietario del centro commerciale.