K-Means Clustering con il metodo Elbow

Il clustering K-means è un algoritmo di apprendimento non supervisionato che raggruppa i dati in base alla distanza euclidea di ciascun punto fino a un punto centrale chiamato baricentro. I centroidi sono definiti per mezzo di tutti i punti che si trovano nello stesso cluster. L'algoritmo sceglie prima punti casuali come centroidi e quindi scorre regolandoli fino alla piena convergenza.

Una cosa importante da ricordare quando si utilizza K-mean, è che il numero di cluster è un iperparametro, verrà definito prima di eseguire il modello.

K-means può essere implementato utilizzando Scikit-Learn con solo 3 righe di codice. Scikit-learn ha anche già un metodo di ottimizzazione del centroide disponibile, km=++, che aiuta il modello a convergere più velocemente.

Per applicare l'algoritmo di clustering K-means, carichiamo il file Pinguini Palmer set di dati, scegliere le colonne che verranno raggruppate e utilizzare Seaborn per tracciare un grafico a dispersione con cluster codificati a colori.

Note:: puoi scaricare il set di dati da questo link.

Importiamo le librerie e carichiamo il dataset Penguins, tagliandolo alle colonne scelte e rilasciando le righe con i dati mancanti (ce n'erano solo 2):

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

df = pd.read_csv('penguins.csv')
print(df.shape) 
df = df[['bill_length_mm', 'flipper_length_mm']]
df = df.dropna(axis=0)

Possiamo usare il metodo Elbow per avere un'indicazione dei cluster per i nostri dati. Consiste nell'interpretazione di un grafico a linee con una forma a gomito. Il numero di grappoli erano le curve a gomito. L'asse x del grafico è il numero di cluster e l'asse y è la somma dei quadrati all'interno dei cluster (WCSS) per ogni numero di cluster:

wcss = []

for i in range(1, 11):
    clustering = KMeans(n_clusters=i, init='k-means++', random_state=42)
    clustering.fit(df)
    wcss.append(clustering.inertia_)
    
ks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sns.lineplot(x = ks, y = wcss);

Il metodo del gomito indica che i nostri dati hanno 2 cluster. Tracciamo i dati prima e dopo il raggruppamento:

fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15,5))
sns.scatterplot(ax=axes[0], data=df, x='bill_length_mm', y='flipper_length_mm').set_title('Without clustering')
sns.scatterplot(ax=axes[1], data=df, x='bill_length_mm', y='flipper_length_mm', hue=clustering.labels_).set_title('Using the elbow method');

Questo esempio mostra come il metodo Elbow sia solo un riferimento quando viene utilizzato per scegliere il numero di cluster. Sappiamo già che abbiamo 3 tipi di pinguini nel set di dati, ma se dovessimo determinare il loro numero usando il metodo Elbow, 2 cluster sarebbero il nostro risultato.

Poiché K-means è sensibile alla varianza dei dati, diamo un'occhiata alle statistiche descrittive delle colonne che stiamo raggruppando:

df.describe().T 

Questo risulta in:

 					count 	mean 		std 		min 	25% 	50% 	75% 	max
bill_length_mm 		342.0 	43.921930 	5.459584 	32.1 	39.225 	44.45 	48.5 	59.6
flipper_length_mm 	342.0 	200.915205 	14.061714 	172.0 	190.000 197.00 	213.0 	231.0

Si noti che la media è lontana dalla deviazione standard (std), questo indica una varianza elevata. Proviamo a ridurlo ridimensionando i dati con Standard Scaler:

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
scaled = ss.fit_transform(df)

Ora, ripetiamo il processo del metodo Elbow per i dati in scala:

wcss_sc = []

for i in range(1, 11):
    clustering_sc = KMeans(n_clusters=i, init='k-means++', random_state=42)
    clustering_sc.fit(scaled)
    wcss_sc.append(clustering_sc.inertia_)
    
ks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sns.lineplot(x = ks, y = wcss_sc);

Questa volta, il numero suggerito di cluster è 3. Possiamo tracciare nuovamente i dati con le etichette dei cluster insieme ai due grafici precedenti per il confronto:

fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15,5))
sns.scatterplot(ax=axes[0], data=df, x='bill_length_mm', y='flipper_length_mm').set_title('Without cliustering')
sns.scatterplot(ax=axes[1], data=df, x='bill_length_mm', y='flipper_length_mm', hue=clustering.labels_).set_title('With the Elbow method')
sns.scatterplot(ax=axes[2], data=df, x='bill_length_mm', y='flipper_length_mm', hue=clustering_sc.labels_).set_title('With the Elbow method and scaled data');

Quando si utilizza K-means Clustering, è necessario predeterminare il numero di cluster. Come abbiamo visto quando si utilizza un metodo per scegliere il nostro k numero di cluster, il risultato è solo un suggerimento e può essere influenzato dalla quantità di varianza nei dati. È importante condurre un'analisi approfondita e generare più di un modello con _k_s diversi durante il clustering.

Se non esiste un'indicazione preventiva di quanti cluster sono presenti nei dati, visualizzarli, testarli e interpretarli per vedere se i risultati del clustering hanno senso. In caso contrario, raggruppare di nuovo. Inoltre, guarda più di una metrica e istanzia diversi modelli di clustering: per K-mean, guarda il punteggio della silhouette e forse il clustering gerarchico per vedere se i risultati rimangono gli stessi.