Comparando os Algoritmos de Agrupamento BIRCH e MiniBatchKMeans

Introdução

Este laboratório compara o tempo de execução de dois algoritmos de agrupamento, BIRCH e MiniBatchKMeans, num conjunto de dados sintético. Ambos os algoritmos são escaláveis e podem agrupar eficientemente conjuntos de dados grandes. O conjunto de dados sintético possui 25.000 amostras e duas características geradas usando make_blobs.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente.

Importar Bibliotecas

O primeiro passo é importar as bibliotecas necessárias. Vamos importar as seguintes 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

Gerar Blobs

O próximo passo é gerar blobs para fazer uma comparação entre MiniBatchKMeans e BIRCH. Usaremos todas as cores fornecidas por padrão pelo matplotlib.

## Gerar centros para os blobs de forma a formar uma grade de 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]))

## Gerar blobs para fazer uma comparação entre MiniBatchKMeans e BIRCH.
X, y = make_blobs(n_samples=25000, centers=n_centers, random_state=0)

## Usar todas as cores fornecidas por padrão pelo matplotlib.
colors_ = cycle(colors.cnames.keys())

Modelo BIRCH

O terceiro passo é calcular o agrupamento com BIRCH com e sem a etapa de agrupamento final e plotar os resultados. Criaremos dois modelos BIRCH, um sem a etapa de agrupamento global e outro com a etapa de agrupamento global.

## Calcular o agrupamento com BIRCH com e sem a etapa de agrupamento final e plotar.
birch_models = [
    Birch(threshold=1.7, n_clusters=None),
    Birch(threshold=1.7, n_clusters=100),
]
final_step = ["sem agrupamento global", "com agrupamento global"]

for ind, (birch_model, info) in enumerate(zip(birch_models, final_step)):
    t = time()
    birch_model.fit(X)
    print("BIRCH %s como etapa final levou %0.2f segundos" % (info, (time() - t)))

    ## Plotar o resultado
    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

O quarto passo é calcular o agrupamento com MiniBatchKMeans. Ajustaremos o modelo ao nosso conjunto de dados e imprimiremos o tempo necessário para executar o MiniBatchKMeans.

## Calcular o agrupamento com 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("Tempo gasto para executar MiniBatchKMeans %0.2f segundos" % 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()

Resumo

Este laboratório comparou o tempo de execução de dois algoritmos de agrupamento, BIRCH e MiniBatchKMeans, em um conjunto de dados sintético. O BIRCH é um algoritmo de agrupamento hierárquico que pode agrupar eficientemente grandes conjuntos de dados. O MiniBatchKMeans é uma variação do algoritmo KMeans que também pode agrupar eficientemente grandes conjuntos de dados. Ambos os algoritmos conseguiram agrupar o conjunto de dados em um tempo razoável.

Comparando BIRCH e MiniBatchKMeans