Comparaison des performances de Bisecting K-Means et de K-Means classique

Introduction

Ceci est un tutoriel étape par étape pour comparer les performances de l'algorithme K-Means classique et de l'algorithme Bisecting K-Means. Le tutoriel montrera les différences entre ces algorithmes en termes de regroupement avec un nombre croissant de n_clusters.

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 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 limites 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ésoudrons rapidement le problème pour vous.

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires pour ce tutoriel.

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import BisectingKMeans, KMeans

Générer des données d'échantillonnage

Dans cette étape, nous allons générer des données d'échantillonnage à l'aide de la fonction make_blobs() de scikit-learn. Nous allons générer 10 000 échantillons avec 2 centres.

n_samples = 10000
random_state = 0
X, _ = make_blobs(n_samples=n_samples, centers=2, random_state=random_state)

Définir le nombre de clusters et les algorithmes

Dans cette étape, nous allons définir le nombre de centres de cluster pour KMeans et BisectingKMeans. Nous allons également définir les algorithmes à comparer.

n_clusters_list = [4, 8, 16]
clustering_algorithms = {
    "Bisecting K-Means": BisectingKMeans,
    "K-Means": KMeans,
}

Visualiser les résultats

Dans cette étape, nous allons visualiser les résultats des algorithmes à l'aide de sous-graphiques. Nous utiliserons le nuage de points pour représenter les points de données et les centroïdes de cluster. Nous allons itérer sur chaque algorithme et le nombre de clusters à comparer et tracer les résultats.

fig, axs = plt.subplots(len(clustering_algorithms), len(n_clusters_list), figsize=(12, 5))
axs = axs.T

for i, (algorithm_name, Algorithm) in enumerate(clustering_algorithms.items()):
    for j, n_clusters in enumerate(n_clusters_list):
        algo = Algorithm(n_clusters=n_clusters, random_state=random_state, n_init=3)
        algo.fit(X)
        centers = algo.cluster_centers_

        axs[j, i].scatter(X[:, 0], X[:, 1], s=10, c=algo.labels_)
        axs[j, i].scatter(centers[:, 0], centers[:, 1], c="r", s=20)

        axs[j, i].set_title(f"{algorithm_name} : {n_clusters} clusters")

for ax in axs.flat:
    ax.label_outer()
    ax.set_xticks([])
    ax.set_yticks([])

plt.show()

Sommaire

Ce tutoriel a comparé les performances de l'algorithme K-Means classique et de l'algorithme Bisecting K-Means en utilisant des données d'échantillonnage générées à partir de scikit-learn. Nous avons visualisé les résultats à l'aide de sous-graphiques avec des nuages de points représentant les points de données et les centroïdes de cluster. Nous avons constaté que l'algorithme Bisecting K-Means tend à créer des clusters ayant une structure large-échelle plus régulière, tandis que l'algorithme K-Means classique crée des partitions différentes lorsqu'on augmente le nombre de clusters (n_clusters).