Gli algoritmi di clustering: come organizzare grandi quantità di dati in cluster
Il clustering è un processo di analisi dei dati che consiste nell’organizzare gli oggetti in gruppi, o cluster, sulla base delle loro somiglianze o differenze. Questo tipo di analisi è molto utile per organizzare grandi quantità di dati in modo strutturato e comprensibile. In questo articolo esploreremo gli algoritmi di clustering più comuni e forniremo esempi di codice in Python per implementarli.
K-means clustering
Il K-means clustering è uno dei più noti algoritmi di clustering ed è utilizzato per una vasta gamma di applicazioni, ad esempio nell’analisi dei dati, nella segmentazione dei clienti, nella ricerca di pattern e nella classificazione di immagini. Il suo obiettivo è di dividere un insieme di n oggetti in k cluster in modo da minimizzare la somma dei quadrati delle distanze tra gli oggetti e il centro del cluster. La scelta del valore di k è fatta a priori dall’utente e rappresenta il numero di cluster che si vuole ottenere.
Il funzionamento dell’algoritmo è iterativo e prevede i seguenti passi:
- Inizializzazione: si scelgono casualmente k centroidi dal dataset e si assegnano ad ognuno di essi un cluster.
- Assegnazione degli oggetti al cluster: ogni oggetto viene assegnato al cluster avente il centroide più vicino.
- Calcolo dei nuovi centroidi: si calcolano i nuovi centroidi di ogni cluster come la media degli oggetti appartenenti al cluster stesso.
- Convergenza: i passi 2 e 3 vengono ripetuti fino a che non si raggiunge la convergenza, cioè fino a quando gli oggetti non vengono più spostati da un cluster all’altro e i centroidi non cambiano più di molto.
Una volta ottenuti i k cluster, ogni oggetto viene assegnato al cluster avente il centroide più vicino.
Ecco un esempio di codice in Python per implementare il K-means clustering:
from sklearn.cluster import KMeans import numpy as np import matplotlib.pyplot as plt # Creiamo un dataset fittizio # X = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]]) # ne creiamo uno di 100 elementi casuali X = np.random.rand(100, 2) # Creiamo il modello di KMeans con k=2 kmeans = KMeans(n_clusters=2, random_state=0).fit(X) # Visualizziamo i centroidi centroids = kmeans.cluster_centers_ plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=200, linewidths=3, color='r') # Visualizziamo gli oggetti assegnati ai cluster labels = kmeans.labels_ for i in range(2): plt.scatter(X[labels == i, 0], X[labels == i, 1], s=50, alpha=.5) plt.show()
In questo esempio, abbiamo creato un dataset fittizio con sei oggetti, ciascuno con due attributi. Abbiamo quindi creato un modello di KMeans con k=2 : due cluster e addestrato il modello sul nostro dataset. Infine, abbiamo visualizzato i centroidi dei cluster e gli oggetti assegnati ai cluster.
Clustering gerarchico
Il clustering gerarchico è un algoritmo che organizza gli oggetti in un albero gerarchico, in cui ogni nodo rappresenta un cluster. Ci sono due approcci per il clustering gerarchico: agglomerativo e diviso. Nell’approccio agglomerativo, ogni oggetto inizialmente appartiene a un cluster separato, e poi i cluster vengono fusi in modo iterativo fino a quando tutti gli oggetti appartengono a un unico cluster. Nell’approccio diviso, tutti gli oggetti inizialmente appartengono a un unico cluster, e poi i cluster vengono divisi in modo iterativo fino a quando ogni oggetto appartiene a un cluster separato.
Ecco un esempio di codice in Python per implementare il clustering gerarchico agglomerativo:
from scipy.cluster.hierarchy import linkage, dendrogram
import numpy as np
import matplotlib.pyplot as plt
# Creiamo un dataset fittizio di 100 elementi casuali
X = np.random.rand(100, 2)
# Calcoliamo la matrice di distanza euclidea
dist_mat = linkage(X, method='complete', metric='euclidean')
# Visualizziamo il dendrogramma
plt.figure(figsize=(10, 7))
dendrogram(dist_mat)
plt.title('Dendrogramma')
plt.xlabel('Indice oggetti')
plt.ylabel('Distanza euclidea')
plt.show()
In questo esempio, abbiamo creato un dataset fittizio con 100 oggetti, ciascuno con due attributi. Abbiamo quindi calcolato la matrice di distanza euclidea tra gli oggetti utilizzando il metodo complete linkage, che considera la distanza tra due cluster come la massima distanza tra gli oggetti dei due cluster. Infine, abbiamo visualizzato il dendrogramma, che rappresenta graficamente la gerarchia dei cluster.
Clustering basato sulla densità
Il clustering basato sulla densità è un algoritmo che organizza gli oggetti in cluster in base alla densità locale. Gli oggetti che si trovano in regioni di alta densità sono assegnati a un cluster, mentre gli oggetti che si trovano in regioni di bassa densità sono considerati come punti di rumore e non assegnati a nessun cluster. Uno degli algoritmi più noti per il clustering basato sulla densità è il DBSCAN (Density-Based Spatial Clustering of Applications with Noise).
Ecco un esempio di codice in Python per implementare il clustering basato sulla densità utilizzando il DBSCAN:
from sklearn.cluster import DBSCAN
import numpy as np
import matplotlib.pyplot as plt
# Creiamo un dataset fittizio di 100 elementi casuali
X = np.random.rand(100, 2)
# Creiamo il modello di DBSCAN
dbscan = DBSCAN(eps=0.1, min_samples=10)
# Addestriamo il modello sul dataset
dbscan.fit(X)
# Visualizziamo i punti del dataset colorati in base al cluster
labels = dbscan.labels_
core_samples_mask = np.zeros_like(labels, dtype=bool)
core_samples_mask[dbscan.core_sample_indices_] = True
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
# color map per i cluster
colors = plt.cm.Spectral(np.linspace(0, 1, len(set(labels))))
# visualizzazione dei cluster
for k, col in zip(set(labels), colors):
if k == -1:
col = 'k'
class_member_mask = (labels == k)
xy = X[class_member_mask & core_samples_mask]
plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=6)
xy = X[class_member_mask & ~core_samples_mask]
plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=3)
plt.title('DBSCAN Clustering')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()
In questo esempio, abbiamo creato un dataset fittizio con 100 oggetti, ciascuno con due attributi. Abbiamo quindi creato un modello di DBSCAN con un valore di eps pari a ‘.1 e un valore di min_samples pari a 10, che significa che un cluster deve avere almeno due oggetti e che la distanza massima tra due oggetti per far parte dello stesso cluster è di 0.1. Infine, abbiamo addestrato il modello sul nostro dataset e visualizzato gli oggetti assegnati ai cluster.
Sono amante della tecnologia e delle tante sfumature del mondo IT, ho partecipato, sin dai primi anni di università ad importanti progetti in ambito Internet proseguendo, negli anni, allo startup, sviluppo e direzione di diverse aziende; Nei primi anni di carriera ho lavorato come consulente nel mondo dell’IT italiano, partecipando attivamente a progetti nazionali ed internazionali per realtà quali Ericsson, Telecom, Tin.it, Accenture, Tiscali, CNR. Dal 2010 mi occupo di startup mediante una delle mie società techintouch S.r.l che grazie alla collaborazione con la Digital Magics SpA, di cui sono Partner la Campania, mi occupo di supportare ed accelerare aziende del territorio .
Attualmente ricopro le cariche di :
– CTO MareGroup
– CTO Innoida
– Co-CEO in Techintouch s.r.l.
– Board member in StepFund GP SA
Manager ed imprenditore dal 2000 sono stato,
CEO e founder di Eclettica S.r.l. , Società specializzata in sviluppo software e System Integration
Partner per la Campania di Digital Magics S.p.A.
CTO e co-founder di Nexsoft S.p.A, società specializzata nella Consulenza di Servizi in ambito Informatico e sviluppo di soluzioni di System Integration, CTO della ITsys S.r.l. Società specializzata nella gestione di sistemi IT per la quale ho partecipato attivamente alla fase di startup.
Sognatore da sempre, curioso di novità ed alla ricerca di “nuovi mondi da esplorare“.
