Gli algoritmi di clustering: come organizzare grandi quantità di dati in cluster

AI, INTELLIGENZA ARTIFICIALE

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:

  1. Inizializzazione: si scelgono casualmente k centroidi dal dataset e si assegnano ad ognuno di essi un cluster.
  2. Assegnazione degli oggetti al cluster: ogni oggetto viene assegnato al cluster avente il centroide più vicino.
  3. Calcolo dei nuovi centroidi: si calcolano i nuovi centroidi di ogni cluster come la media degli oggetti appartenenti al cluster stesso.
  4. 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.

Se vuoi farmi qualche richiesta o contattarmi per un aiuto riempi il seguente form

    Comments

    Copyright © Domenico Soriano - All Rights Reserved