Come utilizzare il metodo elbow in python per trovare cluster ottimali

Uno degli algoritmi di clustering più comuni nell’apprendimento automatico è noto come clustering k-means .

Il clustering K-means è una tecnica in cui inseriamo ciascuna osservazione da un set di dati in uno dei cluster K.

L’obiettivo finale è quello di avere K cluster in cui le osservazioni all’interno di ciascun cluster sono abbastanza simili tra loro mentre le osservazioni nei diversi cluster sono abbastanza diverse l’una dall’altra.

Quando si esegue il clustering k-means, il primo passo è scegliere un valore per K , ovvero il numero di cluster in cui vogliamo inserire le osservazioni.

Uno dei modi più comuni per scegliere un valore per K è noto come metodo del gomito , che prevede la creazione di un grafico con il numero di cluster sull’asse x e il totale della somma dei quadrati sull’asse y, quindi identificare dove nella trama appare un “ginocchio” o una svolta.

Il punto sull’asse x in cui si trova il “ginocchio” ci dice il numero ottimale di cluster da utilizzare nell’algoritmo di clustering k-means.

L’esempio seguente mostra come utilizzare il metodo gomito in Python.

Passaggio 1: importa i moduli necessari

Per prima cosa importeremo tutti i moduli di cui avremo bisogno per eseguire il clustering k-means:

 import pandas as pd
import numpy as np
import matplotlib. pyplot as plt
from sklearn. cluster import KMeans
from sklearn. preprocessing import StandardScaler

Passaggio 2: crea il DataFrame

Successivamente, creeremo un DataFrame contenente tre variabili per 20 diversi giocatori di basket:

 #createDataFrame
df = pd. DataFrame ({' points ': [18, np.nan, 19, 14, 14, 11, 20, 28, 30, 31,
                              35, 33, 29, 25, 25, 27, 29, 30, 19, 23],
                   ' assists ': [3, 3, 4, 5, 4, 7, 8, 7, 6, 9, 12, 14,
                               np.nan, 9, 4, 3, 4, 12, 15, 11],
                   ' rebounds ': [15, 14, 14, 10, 8, 14, 13, 9, 5, 4,
                                11, 6, 5, 5, 3, 8, 12, 7, 6, 5]})

#drop rows with NA values in any columns
df = df. dropna ()

#create scaled DataFrame where each variable has mean of 0 and standard dev of 1
scaled_df = StandardScaler(). fit_transform (df)

Passaggio 3: utilizzare il metodo del gomito per trovare il numero ottimale di cluster

Supponiamo di voler utilizzare il clustering k-means per raggruppare insieme attori simili in base a questi tre parametri.

Per eseguire il clustering k-means in Python, possiamo usare la funzione KMeans dal modulo sklearn .

L’argomento più importante di questa funzione è n_clusters , che specifica in quanti cluster inserire le osservazioni.

Per determinare il numero ottimale di cluster, creeremo un grafico che mostra il numero di cluster e l’SSE (somma degli errori quadrati) del modello.

Cercheremo quindi un “ginocchio” in cui la somma dei quadrati inizia a “piegarsi” o stabilizzarsi. Questo punto rappresenta il numero ottimale di cluster.

Il codice seguente mostra come creare questo tipo di grafico che visualizza il numero di cluster sull’asse x e SSE sull’asse y:

 #initialize kmeans parameters
kmeans_kwargs = {
" init ": " random ",
" n_init ": 10,
" random_state ": 1,
}

#create list to hold SSE values for each k
sse = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, ** kmeans_kwargs)
    kmeans. fit (scaled_df)
    sse. append (kmeans.inertia_)

#visualize results
plt. plot (range(1, 11), sse)
plt. xticks (range(1, 11))
plt. xlabel (" Number of Clusters ")
plt. ylabel (“ SSE ”)
plt. show () 

In questo grafico, sembra che ci sia un nodo o “ginocchio” in k = 3 cluster .

Pertanto, utilizzeremo 3 cluster per adattare il nostro modello di clustering k-mean nel passaggio successivo.

Passaggio 4: eseguire il clustering K-Means con K ottimale

Il codice seguente mostra come eseguire il clustering k-means sul set di dati utilizzando il valore ottimale per k di 3:

 #instantiate the k-means class, using optimal number of clusters
kmeans = KMeans(init=" random ", n_clusters= 3 , n_init= 10 , random_state= 1 )

#fit k-means algorithm to data
kmeans. fit (scaled_df)

#view cluster assignments for each observation
kmeans. labels_

array([1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0]) 

La tabella risultante mostra le assegnazioni dei cluster per ciascuna osservazione nel DataFrame.

Per rendere questi risultati più facili da interpretare, possiamo aggiungere una colonna al DataFrame che mostra l’assegnazione del cluster di ciascun giocatore:

 #append cluster assingments to original DataFrame
df[' cluster '] = kmeans. labels_

#view updated DataFrame
print (df)

points assists rebounds cluster
0 18.0 3.0 15 1
2 19.0 4.0 14 1
3 14.0 5.0 10 1
4 14.0 4.0 8 1
5 11.0 7.0 14 1
6 20.0 8.0 13 1
7 28.0 7.0 9 2
8 30.0 6.0 5 2
9 31.0 9.0 4 0
10 35.0 12.0 11 0
11 33.0 14.0 6 0
13 25.0 9.0 5 0
14 25.0 4.0 3 2
15 27.0 3.0 8 2
16 29.0 4.0 12 2
17 30.0 12.0 7 0
18 19.0 15.0 6 0
19 23.0 11.0 5 0

La colonna cluster contiene un numero di cluster (0, 1 o 2) a cui è stato assegnato ciascun giocatore.

I giocatori appartenenti allo stesso cluster hanno valori approssimativamente simili per le colonne punti , assist e rimbalzi .

Nota : puoi trovare la documentazione completa per la funzione KMeans di sklearn qui .

Risorse addizionali

I seguenti tutorial spiegano come eseguire altre attività comuni in Python:

Come eseguire la regressione lineare in Python
Come eseguire la regressione logistica in Python
Come eseguire la convalida incrociata K-Fold in Python