Agrupamiento K-Means en Dígitos Manuscritos

Introducción

En este laboratorio, exploraremos el algoritmo de agrupamiento K-Means utilizando la librería scikit-learn en Python. Utilizaremos el conjunto de datos de dígitos manuscritos, que contiene 64 características que representan una imagen de 8x8 de un dígito, y intentaremos agrupar las imágenes según el dígito que representan. Compararemos los diferentes métodos de inicialización para K-Means y evaluaremos el rendimiento del agrupamiento utilizando varias métricas.

Consejos sobre la VM

Una vez que se haya iniciado 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 resolveremos el problema para usted de inmediato.

Skills Graph

Cargar el conjunto de datos

Comenzaremos cargando el conjunto de datos de dígitos utilizando la función load_digits() de scikit-learn. Esta función devuelve las características y las etiquetas del conjunto de datos.

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 la referencia de evaluación

Definiremos una referencia para comparar diferentes métodos de inicialización para K-Means. Nuestra referencia:

• creará una tubería que escalará los datos utilizando un StandardScaler
• entrenará y medirá el tiempo de ajuste de la tubería
• medirá el rendimiento del agrupamiento obtenido a travé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):
    """Referencia para evaluar los métodos de inicialización de KMeans.

    Parámetros
    ----------
    kmeans : instancia de KMeans
        Una instancia de `KMeans` con la inicialización ya establecida.
    name : str
        Nombre dado a la estrategia. Se utilizará para mostrar los resultados en una tabla.
    data : ndarray de forma (n_muestras, n_características)
        Los datos a agrupar.
    labels : ndarray de forma (n_muestras,)
        Las etiquetas utilizadas para calcular las métricas de agrupamiento que requieren alguna supervisión.
    """
    t0 = time()
    estimator = make_pipeline(StandardScaler(), kmeans).fit(data)
    fit_time = time() - t0
    results = [name, fit_time, estimator[-1].inertia_]

    ## Definir las métricas que solo requieren las etiquetas reales y las etiquetas del 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]

    ## La puntuación de silueta requiere el conjunto de datos completo
    results += [
        metrics.silhouette_score(
            data,
            estimator[-1].labels_,
            metric="euclidean",
            sample_size=300,
        )
    ]

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

Ejecutar la referencia de evaluación

Compararemos tres enfoques para inicializar K-Means:

• una inicialización utilizando k-means++. Este método es estocástico y ejecutaremos la inicialización 4 veces;
• una inicialización aleatoria. Este método también es estocástico y ejecutaremos la inicialización 4 veces;
• una inicialización basada en una proyección PCA. Utilizaremos los componentes de la PCA para inicializar K-Means. Este método es determinista y una sola inicialización es 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 los resultados en datos reducidos por PCA

Utilizaremos PCA para reducir el conjunto de datos a 2 dimensiones y graficar los datos y los clusters en este nuevo espacio.

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)

## Tamaño del paso de la malla. Disminuya para aumentar la calidad de la VQ.
h = 0.02  ## punto en la malla [x_min, x_max]x[y_min, y_max].

## Grafique el límite de decisión. Para eso, asignaremos un color 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))

## Obtenga las etiquetas para cada punto en la malla. Utilice el último modelo entrenado.
Z = kmeans.predict(np.c_[xx.ravel(), yy.ravel()])

## Coloque el resultado en una gráfica de color
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)
## Grafique los centroides como una X blanca
centroids = kmeans.cluster_centers_
plt.scatter(
    centroids[:, 0],
    centroids[:, 1],
    marker="x",
    s=169,
    linewidths=3,
    color="w",
    zorder=10,
)
plt.title(
    "Clustering K-means en el conjunto de datos de dígitos (datos reducidos por PCA)\n"
    "Los centroides están marcados con una cruz blanca"
)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.xticks(())
plt.yticks(())
plt.show()

Resumen

En este laboratorio, exploramos el algoritmo de clustering K-Means y lo aplicamos al conjunto de datos de dígitos manuscritos. Comparamos diferentes métodos de inicialización y evaluamos el rendimiento del clustering utilizando varias métricas. También visualizamos los resultados en un espacio bidimensional utilizando PCA.