Explorer les hypothèses de la classification par K-Means

Introduction

Dans ce laboratoire, nous explorerons l'algorithme de clustering k-means et ses hypothèses. Nous générerons des données avec différentes distributions et visualiserons comment k-means partitionne ces données en clusters. Nous discuterons également de certaines limites de l'algorithme et de possibles solutions pour les surmonter.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous réglerons rapidement le problème pour vous.

Skills Graph

Génération de données

Nous utiliserons la fonction make_blobs de scikit-learn pour générer différents ensembles de données avec des distributions variables. Dans le bloc de code suivant, nous générons quatre ensembles de données :

• Un mélange de grappes gaussiennes
• Des grappes distribuées de manière anisotrope
• Des grappes avec des variances inégales
• Des grappes de tailles inégales

import numpy as np
from sklearn.datasets import make_blobs

n_samples = 1500
random_state = 170
transformation = [[0.60834549, -0.63667341], [-0.40887718, 0.85253229]]

X, y = make_blobs(n_samples=n_samples, random_state=random_state)
X_aniso = np.dot(X, transformation)  ## Grappes anisotropes
X_varied, y_varied = make_blobs(
    n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state
)  ## Variances inégales
X_filtered = np.vstack(
    (X[y == 0][:500], X[y == 1][:100], X[y == 2][:10])
)  ## Grappes de tailles inégales
y_filtered = [0] * 500 + [1] * 100 + [2] * 10

Visualiser les données

Nous utiliserons Matplotlib pour visualiser les ensembles de données générés. Dans le bloc de code suivant, nous créons un graphique 2x2 montrant les clusters de vérité terrain pour chaque ensemble de données.

import matplotlib.pyplot as plt

fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12))

axs[0, 0].scatter(X[:, 0], X[:, 1], c=y)
axs[0, 0].set_title("Mixture of Gaussian Blobs")

axs[0, 1].scatter(X_aniso[:, 0], X_aniso[:, 1], c=y)
axs[0, 1].set_title("Anisotropically Distributed Blobs")

axs[1, 0].scatter(X_varied[:, 0], X_varied[:, 1], c=y_varied)
axs[1, 0].set_title("Unequal Variance")

axs[1, 1].scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_filtered)
axs[1, 1].set_title("Unevenly Sized Blobs")

plt.suptitle("Ground truth clusters").set_y(0.95)
plt.show()

Classification par K-Means

Nous utiliserons la classe KMeans de scikit-learn pour classifier les données. Dans le bloc de code suivant, nous créons un graphique 2x2 montrant les clusters obtenus par k-means pour chaque ensemble de données.

from sklearn.cluster import KMeans

common_params = {
    "n_init": "auto",
    "random_state": random_state,
}

fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12))

y_pred = KMeans(n_clusters=2, **common_params).fit_predict(X)
axs[0, 0].scatter(X[:, 0], X[:, 1], c=y_pred)
axs[0, 0].set_title("Non-optimal Number of Clusters")

y_pred = KMeans(n_clusters=3, **common_params).fit_predict(X_aniso)
axs[0, 1].scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred)
axs[0, 1].set_title("Anisotropically Distributed Blobs")

y_pred = KMeans(n_clusters=3, **common_params).fit_predict(X_varied)
axs[1, 0].scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred)
axs[1, 0].set_title("Unequal Variance")

y_pred = KMeans(n_clusters=3, **common_params).fit_predict(X_filtered)
axs[1, 1].scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_pred)
axs[1, 1].set_title("Unevenly Sized Blobs")

plt.suptitle("Unexpected KMeans clusters").set_y(0.95)
plt.show()

Solutions possibles

Nous allons discuter de quelques solutions possibles aux limitations de la classification par k-means. Dans le bloc de code suivant, nous montrons comment trouver le nombre correct de clusters pour le premier ensemble de données et comment traiter les grappes de tailles inégales en augmentant le nombre d'initialisations aléatoires.

y_pred = KMeans(n_clusters=3, **common_params).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.title("Optimal Number of Clusters")
plt.show()

y_pred = KMeans(n_clusters=3, n_init=10, random_state=random_state).fit_predict(
    X_filtered
)
plt.scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_pred)
plt.title("Unevenly Sized Blobs \nwith several initializations")
plt.show()

Modèle de mélange gaussien

Nous allons explorer l'utilisation du Modèle de mélange gaussien, qui peut gérer les distributions anisotropes et les variances inégales. Dans le bloc de code suivant, nous utilisons GaussianMixture pour classifier les deuxième et troisième ensembles de données.

from sklearn.mixture import GaussianMixture

fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))

y_pred = GaussianMixture(n_components=3).fit_predict(X_aniso)
ax1.scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred)
ax1.set_title("Anisotropically Distributed Blobs")

y_pred = GaussianMixture(n_components=3).fit_predict(X_varied)
ax2.scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred)
ax2.set_title("Unequal Variance")

plt.suptitle("Gaussian mixture clusters").set_y(0.95)
plt.show()

Sommaire

Dans ce laboratoire, nous avons exploré l'algorithme de classification par k-means et ses hypothèses. Nous avons généré différents ensembles de données avec des distributions variables et visualisé la manière dont k-means partitionne ces données en clusters. Nous avons également discuté de certaines limites de l'algorithme et de solutions possibles pour les surmonter, notamment la recherche du nombre correct de clusters, l'augmentation du nombre d'initialisations aléatoires et l'utilisation du Modèle de mélange gaussien.