Come generare Dataset specifici per il clustering con Scikit-learn

Scikit-learn, una delle librerie più popolari per il machine learning in Python, offre diverse funzioni per la generazione di dataset adatti per ricoprire molti scopi di clustering. Queste funzioni permettono di creare dei dataset di sintesi, che vengono creati artificialmente con l’obiettivo specifico di essere utilizzati per eseguire operazioni di clustering e per valutare le prestazioni degli algoritmi di clustering.

I Dataset di Sintesi di Scikit-learn

La libreria Scikit-learn fornisce una serie di funzioni che permette di generare in maniera semplice ed automatica una serie di dataset adatti per studi con il clustering. Ogni funzione permette di generare distribuzioni di punti in un datatset con particolari caratteristiche che genera dei cluster naturali con delle forme peculiari, specifiche per ogni caso. Vediamo una lista di queste funzioni:

• make_blobs: Genera un insieme di blob isotropici per il clustering.
• make_moons: Genera due semicerchi disposti uno dentro l’altro per il clustering.
• make_circles: Genera un cerchio di punti disposti attorno a un altro cerchio per il clustering.
• make_gaussian_quantiles: Genera cluster di punti distribuiti secondo una gaussiana multivariata.
• make_s_curve: Genera un’onda 3D a forma di S che può essere utilizzata per il clustering.
• make_swiss_roll: Genera un insieme di dati a forma di rotolo svizzero che può essere utilizzato per il clustering.

Questi dataset possono essere utilizzati per testare algoritmi di clustering o per eseguire esperimenti di clustering in ambienti controllati. Un’importante notifica è che alcune di queste funzioni generano dei dataset etichettati, cioè con in aggiunta (valore y restituito) le etichette di appartenenza al cluster. Vediamo come sono suddivisi il gruppo di funzioni.

Dataset etichettati:

1. make_blobs
2. make_moons
3. make_circles
4. make_gaussian_quantiles

Dataset non etichettati:

1. make_s_curve
2. make_swiss_roll

Questo ti permette di scegliere la funzione giusta in base alle tue esigenze di clustering o classificazione.

La generazione dei dataset di sintesi per il clustering con scikit-learn

Adesso vediamo come possiamo generare nel codice questi dataset di sintesi. La loro implementazione è davvero molto semplice e consiste di una sola chiamata di funzione. Scriviamo il codice

from sklearn.datasets import make_blobs

# Generate a dataset of 1000 points distributed in 5 clusters
# with standard deviation (cluster_std) set to 1.0
X, y = make_blobs(n_samples=1000, centers=5, cluster_std=1.0, random_state=42)

In questo esempio, make_blobs viene utilizzata per generare un dataset con 1000 punti distribuiti in 5 cluster, dove ogni cluster ha una deviazione standard (variabilità) dei punti pari a 1.0. I punti generati sono rappresentati in uno scatter plot dove ogni colore rappresenta una classe di appartenenza.

Eccoti una spiegazione dei parametri utilizzati nella funzione make_blobs:

1. n_samples: Questo parametro specifica il numero totale di punti da generare nel dataset. Nel nostro esempio, n_samples=1000 indica che vogliamo generare un dataset con 1000 punti.
2. centers: Questo parametro indica il numero di cluster da generare nel dataset. Nel nostro esempio, centers=5 specifica che vogliamo generare 5 cluster distinti.
3. cluster_std: Questo parametro controlla la deviazione standard (variabilità) dei cluster generati. Un valore più alto di cluster_std significa che i punti all’interno di ciascun cluster saranno più dispersi, mentre un valore più basso significa che i punti saranno più compatti attorno al centro del cluster. Nel nostro esempio, cluster_std=1.0 indica che vogliamo cluster con deviazione standard pari a 1.0.
4. random_state: Questo parametro viene utilizzato per inizializzare il generatore di numeri pseudo-casuali. Fornire un valore a random_state assicura che i risultati siano riproducibili. Se due chiamate a make_blobs utilizzano lo stesso valore per random_state, genereranno lo stesso dataset. Nel nostro esempio, random_state=42 è un valore arbitrario utilizzato per la riproducibilità dei risultati. Puoi scegliere qualsiasi numero intero per questo parametro.

Per poter visualizzare la distribuzione del dataset ed i cluster in esso costruiti, possiamo utilizzare la libreria matplotlib. Scriviamo quindi il codice seguente

import matplotlib.pyplot as plt

# Plot the generated points
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', s=50, alpha=0.7)
plt.title('Dataset of Isotropic Blobs')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Class')
plt.grid(True)
plt.show()

Eseguendo il codice otteniamo la seguente rappresentazione:

I dataset generati da Scikit-learn per il clustering sono stati creati con l’obiettivo di fornire agli utenti degli strumenti versatili per esplorare e comprendere il funzionamento degli algoritmi di clustering. Questi dataset sono utili in diversi contesti.

Isotropic Blob Dataset

Abbiamo appena visto come la funzione make_blobs di Scikit-learn genera un dataset sintetico composto da cluster di punti, comunemente chiamati “blob“. Questi blob sono distribuiti casualmente nello spazio delle caratteristiche secondo una distribuzione gaussiana isotropica, il che significa che la varianza è la stessa in tutte le direzioni.

Questo tipo di dataset è utile per testare e valutare algoritmi di clustering, in quanto offre un controllo preciso sui parametri dei cluster. È particolarmente utile per valutare algoritmi di clustering che richiedono cluster di forma sferica o isotropica.

Moon-Shaped Dataset

La funzione make_moons di Scikit-learn genera un dataset sintetico composto da due semicerchi sovrapposti. Ecco alcune caratteristiche principali di un dataset generato con make_moons:

• Forma dei cluster: I cluster generati sono costituiti da due semicerchi che si sovrappongono. Questo rende il dataset particolarmente utile per testare algoritmi di clustering che devono gestire cluster non lineari o complessi.
• Rumore: È possibile specificare il livello di rumore nel dataset tramite il parametro noise. Questo consente di controllare quanto i punti generati possono deviare dalla forma ideale dei semicerchi.
• Numero di punti: È possibile specificare il numero di punti generati tramite il parametro n_samples.
• Distribuzione: I punti all’interno di ciascun semicerchio sono distribuiti uniformemente lungo la curva del semicerchio.

from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

X, y = make_moons(n_samples=1000, noise=0.1, random_state=42)

plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', s=50, alpha=0.7)
plt.title('Moon-shaped dataset')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Classe')
plt.grid(True)
plt.show()

Eseguendo otteniamo il seguente dataset:

Rispetto ad altri dataset generati con funzioni come make_blobs, make_circles, make_s_curve, ecc., il dataset generato con make_moons ha una forma più complessa e non lineare. È particolarmente utile per testare algoritmi di clustering in scenari dove i cluster possono avere forme non standard o non lineari. Ad esempio, make_moons è utile per testare algoritmi di clustering che devono identificare cluster che non possono essere separati da semplici iperpiani, come ad esempio il caso di separazione lineare con cui potrebbe avere a che fare un algoritmo di clustering basato su k-means.

Circle-shaped Dataset

Il dataset generato dalla funzione make_circles di Scikit-learn è progettato per simulare un insieme di dati che presentano una struttura circolare o a forma di anello. Questo dataset ha le seguenti caratteristiche:

• Struttura circolare: Il dataset contiene punti distribuiti in cerchi concentrici, simili a un bersaglio. Questa struttura circolare lo rende utile per testare algoritmi di clustering che devono identificare gruppi di dati disposti in un pattern circolare o a forma di anello.
• Rumore: La funzione make_circles consente di aggiungere un livello controllato di rumore ai dati generati. Questo aiuta a rendere il dataset più realistico e adatto per testare l’efficacia degli algoritmi di clustering in presenza di rumore nei dati.
• Parametro factor: Il parametro factor consente di regolare la distanza tra i cerchi concentrici generati. Ciò consente di creare dataset con differenti livelli di separazione tra i gruppi di dati, consentendo di testare l’efficacia degli algoritmi di clustering in contesti con diverse distribuzioni spaziali dei dati.

import matplotlib.pyplot as plt
from sklearn.datasets import make_circles

# Generate the circle-shaped dataset
X, y = make_circles(n_samples=1000, noise=0.1, factor=0.5)

# Visualize the dataset
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', s=50, alpha=0.7)
plt.title("Circle-shaped Dataset")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.grid(True)
plt.show()

Ecco una spiegazione dei parametri utilizzati nella funzione make_circles:

1. n_samples: Questo parametro specifica il numero di punti da generare nel dataset. Nel nostro esempio, n_samples=1000 indica che vogliamo generare un dataset con 1000 punti.
2. noise: Questo parametro controlla il livello di rumore nel dataset generato. Più il valore di noise è alto, maggiore sarà il livello di rumore nei dati generati. Nel nostro esempio, noise=0.1 significa che aggiungeremo un po’ di rumore ai dati, ma non in misura significativa.
3. factor: Questo parametro determina la distanza tra i due cerchi concentrici generati. Un valore più alto di factor produce cerchi più grandi e distanti l’uno dall’altro, mentre un valore più basso produce cerchi più piccoli e vicini. Nel nostro esempio, factor=0.5 indica che i due cerchi saranno relativamente vicini, con un raggio pari alla metà del raggio complessivo.

Il dataset generato da make_circles è comunemente utilizzato per testare e valutare algoritmi di clustering che sono capaci di identificare e distinguere gruppi di dati disposti in modo circolare o a forma di anello. Ad esempio, algoritmi come il clustering agglomerativo, il K-means o il DBSCAN possono essere testati su questo dataset per valutarne la capacità di identificare e distinguere i cerchi concentrici o la struttura a forma di anello dei dati.

Rispetto ad altri dataset generati da funzioni simili, come make_blobs o make_moons, il dataset generato da make_circles presenta una struttura diversa e può essere utilizzato per testare algoritmi di clustering su pattern dati circolari o a forma di anello, invece che su gruppi di dati lineari o globulari.

Gaussian Quantiles Dataset

Il dataset generato da make_gaussian_quantiles è composto da campioni distribuiti secondo una distribuzione gaussiana multivariata. Questo significa che i punti nel dataset sono disposti in cluster che seguono una distribuzione normale in più dimensioni. Le principali caratteristiche di questo dataset includono:

1. Distribuzione gaussiana: I campioni sono distribuiti in modo che i valori di ogni feature seguano una distribuzione normale.
2. Cluster: Il dataset contiene un numero specificato di cluster gaussiani, ognuno con una propria media e varianza.
3. Quantili: I cluster possono essere generati in modo che siano separati in quantili, cioè regioni della distribuzione.

from sklearn.datasets import make_gaussian_quantiles
import matplotlib.pyplot as plt

# Generate a dataset with 2 Gaussian clusters
X, y = make_gaussian_quantiles(n_samples=1000, n_features=2, n_classes=2)

# Plot the dataset
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolors='k')
plt.title('Gaussian Quantiles Dataset')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.colorbar(label='Class')
plt.grid(True)
plt.show()

Analizziamo i parametri utilizzati per controllare la generazione del dataset tramite la funzione make_gaussian_quantiles:

1. n_samples: Questo parametro specifica il numero totale di campioni che si desidera generare nel dataset. Nel caso dell’esempio, n_samples=1000 significa che il dataset conterrà complessivamente 1000 campioni.
2. n_features: Questo parametro specifica il numero di features o variabili per ogni campione nel dataset. Ad esempio, n_features=2 indica che ogni campione avrà due features.
3. n_classes: Questo parametro specifica il numero di classi o cluster che si desidera generare nel dataset. Con n_classes=2, la funzione genera due cluster distinti nel dataset.

Quindi, nel contesto dell’esempio, make_gaussian_quantiles(n_samples=1000, n_features=2, n_classes=2) indica che stiamo generando un dataset con 1000 campioni, ognuno con due features, divisi in due cluster distinti.

Questo tipo di dataset viene spesso utilizzato nel clustering per testare algoritmi e valutare le prestazioni degli stessi. Rispetto ad altri dataset generati dalle funzioni make_ simili in Scikit-learn, come make_blobs o make_moons, il dataset generato da make_gaussian_quantiles può essere più adatto quando si desidera testare algoritmi di clustering che sono efficaci su dati con distribuzioni gaussiane o quando si desidera creare un dataset con cluster più complessi e sovrapposti. Ad esempio, in situazioni in cui i cluster non sono chiaramente separati, questa funzione può generare cluster con sovrapposizioni controllate.

S-Curve Dataset (3D e Non etichettato)

Il dataset generato da make_s_curve è un insieme di dati sintetici che segue una forma curva “S” nello spazio tridimensionale. Questo dataset è principalmente caratterizzato dalle seguenti proprietà:

• Forma curva “S”: I dati sono distribuiti lungo una curva “S” nello spazio tridimensionale. Questo conferisce al dataset una struttura non lineare.
• Rumore: È possibile introdurre del rumore nei dati generati tramite il parametro noise. Questo può rendere la curva “S” più irregolare e aggiungere variazioni ai dati.
• Parametro t: Ogni punto nel dataset ha un parametro associato denominato t, che rappresenta la coordinata lungo la curva “S”. Questo parametro può essere utilizzato per colorare i punti nel plot per visualizzare la posizione lungo la curva.

from sklearn.datasets import make_s_curve
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate the "S" shaped dataset with 1000 points
X, t = make_s_curve(n_samples=1000, noise=0.1, random_state=42)

# Plot the dataset
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=t, cmap='viridis')
ax.set_title('S-Curve Dataset')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

Questo tipo di dataset può essere utilizzato nel clustering per testare algoritmi che possono affrontare dati con struttura non lineare. A differenza di dataset generati da funzioni make_ come make_blobs o make_moons, make_s_curve offre una struttura più complessa e non lineare, che può essere utile per valutare la capacità degli algoritmi di clustering di rilevare e gestire tale complessità. Ad esempio, algoritmi di clustering basati su densità o algoritmi non lineari come DBSCAN o t-SNE potrebbero essere testati su questo tipo di dataset per vedere come si comportano rispetto a cluster non lineari.

Swiss Roll Dataset (3D e non etichettato)

Il dataset generato da make_swiss_roll è una rappresentazione sintetica di un rotolo svizzero tridimensionale, che è una forma comune utilizzata per testare algoritmi di riduzione della dimensionalità e di clustering. Questo tipo di dataset ha le seguenti caratteristiche principali:

• Forma a rotolo svizzero: I punti nel dataset sono distribuiti lungo una spirale tridimensionale, che ricorda la forma di un rotolo svizzero. Questo aspetto conferisce al dataset una struttura geometrica complessa e non lineare.
• Dimensionalità tridimensionale: Ogni campione nel dataset è rappresentato da tre coordinate spaziali (X, Y, Z), che rappresentano la posizione del punto nello spazio tridimensionale.
• Rumore opzionale: È possibile aggiungere del rumore al dataset tramite il parametro noise, che può influenzare la distribuzione dei punti e la forma della spirale.

from sklearn.datasets import make_swiss_roll
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate the Swiss roll dataset with 1000 samples
X, color = make_swiss_roll(n_samples=1000, noise=0.1)

# Extract coordinates
x = X[:, 0]
y = X[:, 1]
z = X[:, 2]

# Plot the dataset
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

ax.scatter(x, y, z, c=color, cmap=plt.cm.viridis, s=50)
ax.set_title('Swiss Roll Dataset')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

In questo esempio, make_swiss_roll genera un dataset a forma di “rotolo svizzero” in 3D con 1000 campioni. Il parametro noise controlla la quantità di rumore aggiunto ai dati.

Successivamente, i dati vengono visualizzati utilizzando matplotlib con una visualizzazione 3D. Ogni punto nel dataset ha tre coordinate (X, Y, Z) e viene colorato in base a un valore di colore estratto dal dataset stesso, che può essere utile per rappresentare informazioni aggiuntive come etichette di classe o altro.

Questo tipo di dataset viene spesso utilizzato nel clustering per testare algoritmi su dati con una struttura complessa e non lineare. Rispetto ad altri dataset generati da funzioni make_ simili in Scikit-learn, come make_blobs o make_moons, il dataset generato da make_swiss_roll presenta una struttura più intricata e tridimensionale, il che lo rende adatto per valutare l’efficacia degli algoritmi di clustering su dati con forme più complesse e non lineari. Inoltre, può essere utilizzato anche per testare algoritmi di riduzione della dimensionalità, poiché offre una rappresentazione tridimensionale che può essere proiettata in spazi di dimensionalità inferiore.

Dataset etichettati in 3D

I cluster non etichettati sono tutti tridimensionali. Per quanto riguarda le funzioni make_blobs, make_moons, make_circles, make_gaussian_quantiles e simili di Scikit-learn sono progettate principalmente per generare dataset in due dimensioni (2D) per scopi di visualizzazione e analisi dei dati. Tuttavia, nulla vieta di utilizzare alcune di queste funzioni per generare dataset in più di due dimensioni (3D o superiori), ma la rappresentazione e la visualizzazione dei dati diventano più complesse.

Si possono generare dataset in 3D utilizzando make_blobs e make_gaussian_quantiles (le altre no) specificando il numero appropriato di features tramite il parametro n_features. Ad esempio, impostando n_features=3, i dati verranno generati con tre dimensioni.

Ecco un esempio di come potresti utilizzare make_blobs per generare un dataset in 3D:

from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate a dataset with 3 features (3D)
X, y = make_blobs(n_samples=1000, n_features=3, centers=5, random_state=42)

# Plot the dataset in 3D
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, cmap='viridis', edgecolors='k')
ax.set_title('Example of 3D dataset with make_blobs')
ax.set_xlabel('Feature 1')
ax.set_ylabel('Feature 2')
ax.set_zlabel('Feature 3')
plt.show()