Il clustering dei dati è una pratica sempre più diffusa tra i marketer, soprattutto con l’avvento di strumenti avanzati come ChatGPT che permettono di eseguire analisi direttamente in Excel. Sebbene questa tecnica sia estremamente utile per varie applicazioni, come l’analisi comportamentale e la segmentazione dei clienti, è necessario capire come funziona un algoritmo di clustering e quali accortezze adottare per ottenere risultati affidabili e significativi.

L’Importanza della Normalizzazione o Standardizzazione

Uno degli aspetti importanti del clustering è la normalizzazione o standardizzazione dei dati. Quando le variabili del dataset hanno scale diverse, è essenziale normalizzarle per evitare che alcune dimensioni predominino sulle altre, distorcendo così i risultati. La normalizzazione riduce i valori delle variabili a una scala comune, mentre la standardizzazione li trasforma in distribuzioni con media zero e deviazione standard uno.

import pandas as pd
from sklearn.preprocessing import StandardScaler

# Creiamo un dataset di esempio
data = {'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

# Standardizziamo i dati
scaler = StandardScaler()
df_standardized = scaler.fit_transform(df)
print(df_standardized)

Gestione delle Asimmetrie

Le distribuzioni asimmetriche, spesso causate da outliers, possono influenzare negativamente gli algoritmi di clustering. Gli outliers possono creare falsi cluster o distorcere la struttura dei dati, rendendo difficile l’identificazione di pattern significativi. È quindi importante gestire correttamente queste asimmetrie, tramite tecniche di trasformazione dei dati o rimozione degli outliers.

import numpy as np
from sklearn.preprocessing import PowerTransformer

# Creiamo un dataset di esempio con asimmetrie
data = {'A': [1, 2, 3, 4, 1000], 'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

# Trasformiamo i dati per ridurre l'asimmetria
pt = PowerTransformer(method='yeo-johnson')
df_transformed = pt.fit_transform(df)
print(df_transformed)

Riduzione della Dimensionalità

Un altro passo importante nel processo di clustering è la riduzione della dimensionalità, che può essere effettuata utilizzando tecniche come la Principal Component Analysis (PCA). La riduzione della dimensionalità aiuta a ridurre il rumore nei dati e a migliorare la separabilità dei cluster, facilitando così l’identificazione di pattern significativi e la visualizzazione dei dati.

from sklearn.decomposition import PCA

# Creiamo un dataset di esempio
data = np.random.rand(100, 10)
df = pd.DataFrame(data)

# Applichiamo PCA
pca = PCA(n_components=2)
df_pca = pca.fit_transform(df)
print(df_pca)

Selezione delle Variabili Rilevanti

Non tutte le variabili presenti in un dataset sono rilevanti per il clustering. È importante eliminare le variabili ridondanti o non informative per migliorare la qualità del clustering. Questo passaggio aiuta a concentrare l’attenzione sulle caratteristiche che realmente distinguono i vari cluster, migliorando così l’accuratezza dei risultati.

from sklearn.feature_selection import SelectKBest, f_classif

# Creiamo un dataset di esempio
data = np.random.rand(100, 10)
target = np.random.randint(2, size=100)
df = pd.DataFrame(data)

# Selezioniamo le migliori 5 variabili
selector = SelectKBest(f_classif, k=5)
df_selected = selector.fit_transform(df, target)
print(df_selected)

Determinazione del Numero Ottimale di Cluster

Determinare il numero ottimale di cluster, soprattutto nel caso del K-Means, è una delle sfide principali del clustering. Esistono vari metodi per trovare il numero ideale di cluster, come l’Elbow Method, il Silhouette Score o il Gap Statistic. La scelta del giusto numero di cluster è fondamentale per ottenere una segmentazione significativa e utilizzabile.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Creiamo un dataset di esempio
data = np.random.rand(100, 2)
df = pd.DataFrame(data)

# Determiniamo il numero ottimale di cluster usando l'Elbow Method
inertia = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k)
    kmeans.fit(df)
    inertia.append(kmeans.inertia_)

# Plot dell'Elbow Method
plt.plot(range(1, 11), inertia, marker='o')
plt.xlabel('Numero di Cluster')
plt.ylabel('Inertia')
plt.show()

Valutazione della Stabilità dei Cluster

La valutazione della stabilità dei cluster è un passaggio essenziale per garantire la robustezza dei risultati. Utilizzare tecniche di cross-validation aiuta a valutare quanto i cluster ottenuti siano consistenti e riproducibili su diversi subset del dataset, garantendo che i risultati non siano frutto di coincidenze o particolarità del campione.

from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
from sklearn.metrics import adjusted_rand_score

# Creiamo un dataset di esempio
data = np.random.rand(100, 2)
df = pd.DataFrame(data)

# Split dei dati in train e test
X_train, X_test = train_test_split(df, test_size=0.5)

# Eseguiamo K-Means su train e test
kmeans_train = KMeans(n_clusters=3).fit(X_train)
kmeans_test = KMeans(n_clusters=3).fit(X_test)

# Valutiamo la stabilità con l'Adjusted Rand Index
score = adjusted_rand_score(kmeans_train.labels_, kmeans_test.labels_)
print(f'Stabilità dei cluster: {score}')

Valutazione del Consenso Clustering

Eseguire il clustering più volte e valutare il consenso tra i risultati è una tecnica utile per aumentare la fiducia nei risultati ottenuti. Confrontare i cluster derivati da diverse esecuzioni permette di identificare i cluster stabili e coerenti, riducendo l’incidenza di variazioni casuali.

from sklearn.cluster import KMeans
import numpy as np

# Creiamo un dataset di esempio
data = np.random.rand(100, 2)
df = pd.DataFrame(data)

# Eseguiamo il clustering più volte
labels = []
for _ in range(10):
    kmeans = KMeans(n_clusters=3)
    kmeans.fit(df)
    labels.append(kmeans.labels_)

# Valutiamo il consenso tra i clustering
consensus = np.mean(labels, axis=0)
print(f'Consenso tra i clustering: {consensus}')

Conoscenza degli Algoritmi di Clustering

Infine, è cruciale avere una buona conoscenza degli algoritmi di clustering disponibili. Oltre al noto K-Means, esistono altri algoritmi come DBSCAN, adatto per dati con rumore e densità variabile, e Agglomerative Clustering, che gestisce forme di cluster più complesse. Ogni algoritmo ha i suoi punti di forza e debolezza, e la scelta dell’algoritmo giusto dipende dalle specificità del dataset e dagli obiettivi dell’analisi.

from sklearn.cluster import DBSCAN, AgglomerativeClustering

# Creiamo un dataset di esempio
data = np.random.rand(100, 2)
df = pd.DataFrame(data)

# Eseguiamo DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=5)
dbscan_labels = dbscan.fit_predict(df)
print(f'Cluster DBSCAN: {np.unique(dbscan_labels)}')

# Eseguiamo Agglomerative Clustering
agg_clustering = AgglomerativeClustering(n_clusters=3)
agg_labels = agg_clustering.fit_predict(df)
print(f'Cluster Agglomerative Clustering: {np.unique(agg_labels)}')

Conclusione

Sebbene gli strumenti avanzati come ChatGPT possano facilitare il processo, è importante avere una solida base di conoscenze per interpretare correttamente i risultati e fare scelte con cognizione di causa. Questo è solo un esempio di quanto sia complesso il corretto funzionamento di un algoritmo. Possiamo chiedere tutto ai nostri LLM, ma prima di chiedere bisogna avere la giusta consapevolezza di cosa si cela dietro una richiesta fatta con un prompt. Come sempre, sottolineo l’importanza di conoscere la materia prima di “chiedere” al nostro super intelligentone ChatGPT.

Giuseppe Cristofaro

Data Scientist
Sono un Data Scientist con esperienza nell’applicazione di tecniche avanzate di Machine Learning per l’analisi di complessi set di dati nel campo del marketing digitale. Specializzato nell’uso di Python, sviluppo modelli predittivi e di analisi dei dati che permettono di identificare e risolvere criticità nei progetti.