Tutorial > Machine Learning in Python: Classificazione e Clustering - Pt 2

Machine Learning in Python: Classificazione e Clustering - Pt 2

Algoritmi di Clustering e metriche di valutazione

Il clustering è una tecnica non-supervisionata di machine learning che di solito viene usata per effettuare analisi statistiche dei dati su vari campi e domini applicativi. L’obiettivo è quello di dividere l’insieme delle osservazioni in più sottoinsiemi, detti cluster o gruppi. Le osservazioni che appartengono allo stesso gruppo hanno in comune caratteristiche simili che differenziano anche i cluster tra di loro.

Algoritmo K-Means

Il K-means implica una conoscenza a priori del numero di cluster totali. Questo metodo è anche conosciuto come clustering flat ed è una procedura iterativa. Il funzionamento generale dell’algoritmo è il seguente:

  1. bisogna definire il numero K di cluster che si assume siano presenti all’interno dei dati;
  2. classifica i punti dell’input nei vari cluster;
  3. aggiusta iterativamente la dimensione dei cluster, spostando i punti nei cluster più vicini a loro;
  4. ad ogni iterazione, aggiorna i centroidi dei cluster finché non si raggiunge un criterio di ottimalità.
# Vogliamo implementare un algoritmo di clustering
# Importiamo le librerie necessarie
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

# Creiamo un dataset generato casualmente
# Numero esempi = 1000, Numero di centroidi = 6, Deviazione standard dei cluster = 0.40
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=1000, centers=6, cluster_std=0.40)

# Grafichiamo uno scatter plot dei cluster
plt.scatter(X[:, 0], X[:, 1], s=25);
plt.show()
>>>
Il grafico dello scatter plot del cluster, prodotto della funzione 'plt.scatter'. 
# Si vedono 6 cluster distinti
# usiamo il k-means per trovare i centroidi, poi addestriamo il modello sul training set e effettuiamo le predizioni per graficare il risultato
kmeans = KMeans(n_clusters=6)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=75, cmap='viridis')
centers = kmeans.cluster_centers_
>>>
Il grafico dello scatter plot del cluster, prodotto della funzione 'plt.scatter'.

# Ora ogni cluster è identificato da un colore
# Grafichiamo anche i centroidi
plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200, alpha=0.5);
plt.show()
>>>
Il grafico dello scatter plot del cluster, prodotto della funzione 'plt.scatter'.

Metriche di valutazione per il clustering

Dal momento che gli algoritmi di clustering non trattano la predizione di un valore o l’implicazione di una risposta, le metriche come l’accuratezza non sono significative. Esistono comunque diversi metodi con cui è possibile misurare la bontà di un algoritmo di clustering. Comunque, siccome quasi sempre i dati reali non sono divisi in gruppi nettamente separati, definire delle conclusioni corrette è difficoltoso. Per misurare le performance del nostro algoritmo useremo una tecnica detta Analisi della Silhouette.
Analisi dello score di Silhouette: il range di valori della Silhouette è [-1,1]. Analizziamo il significato dei possibili valori:

  • Score +1: uno score positivo indica che i punti del cluster predetto sono lontani dai punti del cluster più vicino;
  • Score 0: uno score neutro indica che gli esempi forniti giacciono sui decision boundary di due cluster vicini, oppure che sono comunque molto vicini al confine;
  • Score -1: uno score negativo indica che un esempio è stato inserito nel cluster errato.

Formula per il calcolo della silhouette: score=(p-q)/max(p,q).

Nella formula precedente, p è la distanza media tra i punti del cluster di riferimento e i punti dei cluster più vicini, mentre q è la distanza media tra i punti dello stesso cluster.

# Importiamo le librerie e le metriche
import matplotlib.pyplot as plt
import seaborn as sns; 
import numpy as np
from sklearn.cluster import KMeans
from sklearn import metrics

# Creiamo uno spazio di 1500 punti con 8 centroidi usando il metodo make_blobs 
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=1500, centers=8, cluster_std=0.60)

# Creiamo un numpy array vuoto per gli score e uno di valori di clustering separati in maniera uniforme
scores = []
values = np.arange(4, 20)

# Iteriamo sull’array dei valori e inizializziamo gli elementi con il rispettivo valore di k 
# usiamo il 'k-means++' per selezionare il numero di cluster iniziale in maniera più efficiente per velocizzare la convergenza del k-means
for num_clusters in values:
    kmeans = KMeans(init='k-means++', n_clusters=num_clusters, n_init=10)
    kmeans.fit(X)

# Importiamo la silhouette e usiamo la distanza euclidea per esprimere la distanza tra centroidi

# Poi stampiamo il numero di cluster aggiornati e lo score di silhouette
score = metrics.silhouette_score(X, kmeans.labels_, metric='euclidean', sample_size=len(X))

print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)
>>> Number of clusters = 19
>>> Silhouette score = 0.3294464776999117

# Per conoscere il numero ottimale di cluster adatti all’insieme dei dati usati, usiamo la funzione argmax
num_clusters = np.argmax(scores) + values[0]
print('\nIdeal number of clusters =', num_clusters)
>>> Ideal number of clusters = 4

Metodi basati sui Nearest Neighbor per raggruppare i dati

Tutti i problemi di classificazione e di clustering usano un meccanismo di raggruppamento dei dati per risolvere il problema. Questo meccanismo è spesso associato alla creazione di cluster di dati e alla predizione del cluster corretto a cui assegnare un nuovo punto. Allo stesso modo, esistono tecniche per identificare i Nearest Neighbor di gruppi di dati. L’idea che sta dietro la ricerca dei nearest neighbor è quella di trovare i punti più vicini ai dati di input che possono essere associati ai dati di training.

  • Gli algoritmi che si basano sul raggruppamento possono essere usati per effettuare previsioni laddove sia necessario fare una scelta. Ad esempio, per consigliare un certo indumento a un utente in base alla propria cronologia di acquisti e di ricerca. In questo scenario, l’algoritmo usa le preferenze dell’utente e la cronologia per raggruppare un insieme di scelte che potrebbero essere adatte a lui/lei.
  • Un altro vantaggio dell’uso del clustering è che, una volta che sono stati formati i cluster, qualsiasi algoritmo si adatta facilmente a nuovi dati. Quando i cluster sono generalizzati con varie forme e dimensioni, lavorare su dati nuovi è più veloce ed è meno probabile che ci siano errori.
  • D’altro canto, così come la classificazione converge su una sola tra più scelte, anche questi algoritmi si basano su un numero ristretto di gruppi. Per cui, identificare nuovi dati è più veloce.

In arrivo…

Questo capitolo si è incentrato sulle tecniche di raggruppamento dei dati, basate sia sulla classificazione che sul clustering. Entrambe queste metodologie, sebbene usino approcci diversi, hanno in comune la suddivisione dei dati in gruppi. Abbiamo anche visto diversi casi d’uso in cui è possibile applicare questi algoritmi.

Prossimamente presenteremo:

  1. comprendere la Regressione;
  2. Feature Engineering e modelli Ensemble in Python;
  3. migliorare le prestazioni degli algoritmi di apprendimento.