Comparação de Desempenho entre K-Means Bisecting e K-Means Regular

Introdução

Este é um tutorial passo a passo para comparar o desempenho do algoritmo Regular K-Means e do algoritmo Bisecting K-Means. O tutorial demonstrará as diferenças entre esses algoritmos em termos de agrupamento com um aumento em n_clusters.

Dicas da Máquina Virtual

Após o início da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você encontrar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para você.

Importar Bibliotecas

Neste passo, iremos importar as bibliotecas necessárias para este tutorial.

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

Gerar Dados de Amostra

Neste passo, geraremos dados de amostra utilizando a função make_blobs() do scikit-learn. Geraremos 10000 amostras com 2 centros.

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

Definir o Número de Clusters e Algoritmos

Neste passo, definiremos o número de centros de clusters para KMeans e BisectingKMeans. Também definiremos os algoritmos a serem comparados.

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

Visualizar Resultados

Neste passo, visualizaremos os resultados dos algoritmos usando subplots. Usaremos o gráfico de dispersão para representar os pontos de dados e os centroides dos clusters. Iteraremos por cada algoritmo e o número de clusters a serem comparados e plotaremos os resultados.

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

Resumo

Este tutorial comparou o desempenho do algoritmo K-Means regular e do algoritmo Bisecting K-Means usando dados de amostra gerados a partir do scikit-learn. Visualizamos os resultados usando subplots com gráficos de dispersão representando os pontos de dados e os centroides dos clusters. Observamos que o algoritmo Bisecting K-Means tende a criar clusters com uma estrutura mais regular em larga escala, enquanto o algoritmo K-Means regular cria agrupamentos diferentes ao aumentar o valor de n_clusters.