Comparando BIRCH y MiniBatchKMeans

Introducción

Esta práctica compara el tiempo de ejecución de dos algoritmos de clustering, BIRCH y MiniBatchKMeans, en un conjunto de datos sintético. Ambos algoritmos son escalables y pueden agrupar eficientemente grandes conjuntos de datos. El conjunto de datos sintético tiene 25.000 muestras y dos características generadas utilizando make_blobs.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y lo resolveremos rápidamente para usted.

Importar bibliotecas

El primer paso es importar las bibliotecas necesarias. Importaremos las siguientes bibliotecas:

• 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

Generar manchas

El siguiente paso es generar manchas para realizar una comparación entre MiniBatchKMeans y BIRCH. Utilizaremos todos los colores que proporciona por defecto matplotlib.

## Generate centers for the blobs so that it forms a 10 X 10 grid.
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]))

## Generate blobs to do a comparison between MiniBatchKMeans and BIRCH.
X, y = make_blobs(n_samples=25000, centers=n_centers, random_state=0)

## Use all colors that matplotlib provides by default.
colors_ = cycle(colors.cnames.keys())

Modelo Birch

El tercer paso es calcular el clustering con Birch con y sin la última etapa de clustering y representarlo gráficamente. Crearemos dos modelos Birch, uno sin la etapa global de clustering y el otro con la etapa global de clustering.

## 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)

Modelo MiniBatchKMeans

El cuarto paso es calcular el clustering con MiniBatchKMeans. Ajustaremos el modelo a nuestro conjunto de datos e imprimiremos el tiempo que toma en ejecutar 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()

Resumen

Esta práctica comparó el tiempo de ejecución de dos algoritmos de clustering, BIRCH y MiniBatchKMeans, en un conjunto de datos sintético. BIRCH es un algoritmo de clustering jerárquico que puede agrupar eficientemente grandes conjuntos de datos. MiniBatchKMeans es una variación del algoritmo KMeans que también puede agrupar eficientemente grandes conjuntos de datos. Ambos algoritmos fueron capaces de agrupar el conjunto de datos en un tiempo razonable.