Agrupamento K-Means em Dígitos Manuscritos

Introdução

Neste laboratório, exploraremos o algoritmo de agrupamento K-Means utilizando a biblioteca scikit-learn em Python. Usaremos o conjunto de dados de dígitos manuscritos, que contém 64 características representando uma imagem 8x8 de um dígito, e tentaremos agrupar as imagens com base no dígito que representam. Compararemos os diferentes métodos de inicialização para K-Means e avaliaremos o desempenho do agrupamento utilizando várias métricas.

Dicas da Máquina Virtual

Após o arranque da VM, 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 o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar o Conjunto de Dados

Começaremos carregando o conjunto de dados de dígitos usando a função load_digits() do scikit-learn. Esta função retorna as características e as etiquetas do conjunto de dados.

import numpy as np
from sklearn.datasets import load_digits

data, labels = load_digits(return_X_y=True)
(n_samples, n_features), n_digits = data.shape, np.unique(labels).size

Definir o Padrão de Avaliação

Definiremos um padrão para comparar diferentes métodos de inicialização para K-Means. O nosso padrão:

• criará um pipeline que escalará os dados usando um StandardScaler;
• treinará e cronometrará o ajuste do pipeline;
• medirá o desempenho do agrupamento obtido através de diferentes métricas.

from time import time
from sklearn import metrics
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

def bench_k_means(kmeans, name, data, labels):
    """Benchmark para avaliar os métodos de inicialização KMeans.

    Parâmetros
    ----------
    kmeans : Instância KMeans
        Uma instância `KMeans` com a inicialização já definida.
    name : str
        Nome atribuído à estratégia. Será usado para mostrar os resultados numa tabela.
    data : ndarray de forma (n_samples, n_features)
        Os dados a agrupar.
    labels : ndarray de forma (n_samples,)
        As etiquetas usadas para calcular as métricas de agrupamento que requerem alguma supervisão.
    """
    t0 = time()
    estimator = make_pipeline(StandardScaler(), kmeans).fit(data)
    fit_time = time() - t0
    results = [name, fit_time, estimator[-1].inertia_]

    ## Defina as métricas que requerem apenas as etiquetas verdadeiras e as etiquetas do estimador
    clustering_metrics = [
        metrics.homogeneity_score,
        metrics.completeness_score,
        metrics.v_measure_score,
        metrics.adjusted_rand_score,
        metrics.adjusted_mutual_info_score,
    ]
    results += [m(labels, estimator[-1].labels_) for m in clustering_metrics]

    ## A pontuação de silhueta requer todo o conjunto de dados
    results += [
        metrics.silhouette_score(
            data,
            estimator[-1].labels_,
            metric="euclidean",
            sample_size=300,
        )
    ]

    ## Mostrar os resultados
    formatter_result = (
        "{:9s}\t{:.3f}s\t{:.0f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}"
    )
    print(formatter_result.format(*results))

Executar o Benchmark

Vamos comparar três abordagens para inicializar o K-Means:

• uma inicialização usando k-means++. Este método é estocástico e executaremos a inicialização 4 vezes;
• uma inicialização aleatória. Este método também é estocástico e executaremos a inicialização 4 vezes;
• uma inicialização baseada numa projeção PCA. Usaremos os componentes da PCA para inicializar o K-Means. Este método é determinístico e uma única inicialização é suficiente.

from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

print(82 * "_")
print("init\t\ttime\tinertia\thomo\tcompl\tv-meas\tARI\tAMI\tsilhouette")

kmeans = KMeans(init="k-means++", n_clusters=n_digits, n_init=4, random_state=0)
bench_k_means(kmeans=kmeans, name="k-means++", data=data, labels=labels)

kmeans = KMeans(init="random", n_clusters=n_digits, n_init=4, random_state=0)
bench_k_means(kmeans=kmeans, name="random", data=data, labels=labels)

pca = PCA(n_components=n_digits).fit(data)
kmeans = KMeans(init=pca.components_, n_clusters=n_digits, n_init=1)
bench_k_means(kmeans=kmeans, name="PCA-based", data=data, labels=labels)

print(82 * "_")

Visualizar os Resultados em Dados Reduzidos por PCA

Usaremos PCA para reduzir o conjunto de dados a 2 dimensões e representar graficamente os dados e os clusters neste novo espaço.

import matplotlib.pyplot as plt

reduced_data = PCA(n_components=2).fit_transform(data)
kmeans = KMeans(init="k-means++", n_clusters=n_digits, n_init=4)
kmeans.fit(reduced_data)

## Passo de tamanho da malha. Diminua para aumentar a qualidade do VQ.
h = 0.02  ## ponto na malha [x_min, x_max]x[y_min, y_max].

## Representar o limite de decisão. Para isso, atribuiremos uma cor a cada
x_min, x_max = reduced_data[:, 0].min() - 1, reduced_data[:, 0].max() + 1
y_min, y_max = reduced_data[:, 1].min() - 1, reduced_data[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

## Obter etiquetas para cada ponto na malha. Utilize o último modelo treinado.
Z = kmeans.predict(np.c_[xx.ravel(), yy.ravel()])

## Colocar o resultado num gráfico de cores
Z = Z.reshape(xx.shape)
plt.figure(1)
plt.clf()
plt.imshow(
    Z,
    interpolation="nearest",
    extent=(xx.min(), xx.max(), yy.min(), yy.max()),
    cmap=plt.cm.Paired,
    aspect="auto",
    origin="lower",
)

plt.plot(reduced_data[:, 0], reduced_data[:, 1], "k.", markersize=2)
## Representar os centróides como um X branco
centroids = kmeans.cluster_centers_
plt.scatter(
    centroids[:, 0],
    centroids[:, 1],
    marker="x",
    s=169,
    linewidths=3,
    color="w",
    zorder=10,
)
plt.title(
    "Agrupamento K-means no conjunto de dados dos dígitos (dados reduzidos por PCA)\n"
    "Os centróides são marcados com uma cruz branca"
)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.xticks(())
plt.yticks(())
plt.show()

Resumo

Neste laboratório, explorámos o algoritmo de agrupamento K-Means e aplicámo-lo ao conjunto de dados de dígitos manuscritos. Comparámos diferentes métodos de inicialização e avaliámos o desempenho do agrupamento utilizando várias métricas. Também visualizámos os resultados num espaço bidimensional utilizando PCA.