Comparer les algorithmes de clustering Birch et MiniBatchKMeans

Introduction

Ce laboratoire compare la durée d'exécution de deux algorithmes de clustering, BIRCH et MiniBatchKMeans, sur un ensemble de données synthétiques. Les deux algorithmes sont extensibles et peuvent efficacement regrouper de grands ensembles de données. L'ensemble de données synthétiques a 25 000 échantillons et deux caractéristiques générées à l'aide de make_blobs.

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

Importation des bibliothèques

La première étape consiste à importer les bibliothèques requises. Nous allons importer les bibliothèques suivantes :

numpy
matplotlib
sklearn

from joblib import cpu_count
from itertools import cycle
from time import time
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors

from sklearn.cluster import Birch, MiniBatchKMeans
from sklearn.datasets import make_blobs

Générer des blobs

L'étape suivante consiste à générer des blobs pour comparer MiniBatchKMeans et BIRCH. Nous utiliserons toutes les couleurs que matplotlib fournit par défaut.

## Générer des centres pour les blobs de manière à former une grille 10 X 10.
xx = np.linspace(-22, 22, 10)
yy = np.linspace(-22, 22, 10)
xx, yy = np.meshgrid(xx, yy)
n_centers = np.hstack((np.ravel(xx)[:, np.newaxis], np.ravel(yy)[:, np.newaxis]))

## Générer des blobs pour comparer MiniBatchKMeans et BIRCH.
X, y = make_blobs(n_samples=25000, centers=n_centers, random_state=0)

## Utiliser toutes les couleurs que matplotlib fournit par défaut.
colors_ = cycle(colors.cnames.keys())

Modèle Birch

La troisième étape consiste à calculer le clustering avec Birch avec et sans l'étape finale de clustering et à tracer. Nous allons créer deux modèles Birch, l'un sans l'étape de clustering globale et l'autre avec l'étape de clustering globale.

## Compute clustering with BIRCH with and without the final clustering step and plot.
birch_models = [
    Birch(threshold=1.7, n_clusters=None),
    Birch(threshold=1.7, n_clusters=100),
]
final_step = ["without global clustering", "with global clustering"]

for ind, (birch_model, info) in enumerate(zip(birch_models, final_step)):
    t = time()
    birch_model.fit(X)
    print("BIRCH %s as the final step took %0.2f seconds" % (info, (time() - t)))

    ## Plot result
    labels = birch_model.labels_
    centroids = birch_model.subcluster_centers_
    n_clusters = np.unique(labels).size
    print("n_clusters : %d" % n_clusters)

    ax = fig.add_subplot(1, 3, ind + 1)
    for this_centroid, k, col in zip(centroids, range(n_clusters), colors_):
        mask = labels == k
        ax.scatter(X[mask, 0], X[mask, 1], c="w", edgecolor=col, marker=".", alpha=0.5)
        if birch_model.n_clusters is None:
            ax.scatter(this_centroid[0], this_centroid[1], marker="+", c="k", s=25)
    ax.set_ylim([-25, 25])
    ax.set_xlim([-25, 25])
    ax.set_autoscaley_on(False)
    ax.set_title("BIRCH %s" % info)

Modèle MiniBatchKMeans

La quatrième étape consiste à calculer le clustering avec MiniBatchKMeans. Nous allons ajuster le modèle à notre ensemble de données et afficher le temps pris pour exécuter MiniBatchKMeans.

## Compute clustering with MiniBatchKMeans.
mbk = MiniBatchKMeans(
    init="k-means++",
    n_clusters=100,
    batch_size=256 * cpu_count(),
    n_init=10,
    max_no_improvement=10,
    verbose=0,
    random_state=0,
)
t0 = time()
mbk.fit(X)
t_mini_batch = time() - t0
print("Time taken to run MiniBatchKMeans %0.2f seconds" % t_mini_batch)
mbk_means_labels_unique = np.unique(mbk.labels_)

ax = fig.add_subplot(1, 3, 3)
for this_centroid, k, col in zip(mbk.cluster_centers_, range(n_clusters), colors_):
    mask = mbk.labels_ == k
    ax.scatter(X[mask, 0], X[mask, 1], marker=".", c="w", edgecolor=col, alpha=0.5)
    ax.scatter(this_centroid[0], this_centroid[1], marker="+", c="k", s=25)
ax.set_xlim([-25, 25])
ax.set_ylim([-25, 25])
ax.set_title("MiniBatchKMeans")
ax.set_autoscaley_on(False)
plt.show()

Sommaire

Ce laboratoire a comparé le temps d'exécution de deux algorithmes de clustering, Birch et MiniBatchKMeans, sur un ensemble de données synthétiques. Birch est un algorithme de clustering hiérarchique qui peut efficacement regrouper de grandes bases de données. MiniBatchKMeans est une variante de l'algorithme KMeans qui peut également efficacement regrouper de grandes bases de données. Les deux algorithmes ont été capables de regrouper l'ensemble de données en un temps raisonnable.

Comparer Birch et MiniBatchKMeans