Análisis de Clustering con el Método Silueta

Introducción

El clustering es una técnica de aprendizaje no supervisado popular que implica agrupar puntos de datos similares entre sí basados en sus características. El Método Silueta es una técnica comúnmente utilizada para determinar el número óptimo de clusters en un conjunto de datos. En este laboratorio, usaremos el Método Silueta para determinar el número óptimo de clusters utilizando el algoritmo KMeans.

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 operaciones no puede automatizarse debido a las limitaciones de Jupyter Notebook.

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

Skills Graph

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias para realizar el análisis.

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np

Generar datos

Generaremos datos de muestra utilizando la función make_blobs de la biblioteca sklearn.datasets. Esta función genera manchas gaussianas isotrópicas para el clustering.

X, y = make_blobs(
    n_samples=500,
    n_features=2,
    centers=4,
    cluster_std=1,
    center_box=(-10.0, 10.0),
    shuffle=True,
    random_state=1,
)  ## Para reproducibilidad

Determinar el número óptimo de clusters

Usaremos el Método Silueta para determinar el número óptimo de clusters para el algoritmo KMeans. Iteraremos a través de una serie de valores para n_clusters y graficaremos las puntuaciones de silueta para cada valor.

range_n_clusters = [2, 3, 4, 5, 6]

for n_clusters in range_n_clusters:
    ## Crea un subgráfico con 1 fila y 2 columnas
    fig, (ax1, ax2) = plt.subplots(1, 2)
    fig.set_size_inches(18, 7)

    ## El primer subgráfico es la gráfica de silueta
    ax1.set_xlim([-0.1, 1])
    ax1.set_ylim([0, len(X) + (n_clusters + 1) * 10])

    ## Inicializa el clusterizador con el valor de n_clusters y una semilla
    ## aleatoria de 10 para la reproducibilidad.
    clusterer = KMeans(n_clusters=n_clusters, n_init="auto", random_state=10)
    cluster_labels = clusterer.fit_predict(X)

    ## La puntuación de silueta da el valor promedio para todas las muestras.
    silhouette_avg = silhouette_score(X, cluster_labels)

    ## Calcula las puntuaciones de silueta para cada muestra
    sample_silhouette_values = silhouette_samples(X, cluster_labels)

    y_lower = 10
    for i in range(n_clusters):
        ## Agrupa las puntuaciones de silueta para las muestras pertenecientes a
        ## el cluster i, y las ordena
        ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]

        ith_cluster_silhouette_values.sort()

        size_cluster_i = ith_cluster_silhouette_values.shape[0]
        y_upper = y_lower + size_cluster_i

        color = cm.nipy_spectral(float(i) / n_clusters)
        ax1.fill_betweenx(
            np.arange(y_lower, y_upper),
            0,
            ith_cluster_silhouette_values,
            facecolor=color,
            edgecolor=color,
            alpha=0.7,
        )

        ## Etiqueta las gráficas de silueta con sus números de cluster en el centro
        ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))

        ## Calcula el nuevo y_lower para la siguiente gráfica
        y_lower = y_upper + 10  ## 10 para las 0 muestras

    ax1.set_title("La gráfica de silueta para los diversos clusters.")
    ax1.set_xlabel("Los valores del coeficiente de silueta")
    ax1.set_ylabel("Etiqueta de cluster")

    ## La línea vertical para la puntuación de silueta promedio de todos los valores
    ax1.axvline(x=silhouette_avg, color="red", linestyle="--")

    ax1.set_yticks([])  ## Limpia las etiquetas / marcas del eje y
    ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])

    ## Segunda gráfica que muestra los clusters reales formados
    colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
    ax2.scatter(
        X[:, 0], X[:, 1], marker=".", s=30, lw=0, alpha=0.7, c=colors, edgecolor="k"
    )

    ## Etiquetando los clusters
    centers = clusterer.cluster_centers_
    ## Dibuja círculos blancos en los centros de los clusters
    ax2.scatter(
        centers[:, 0],
        centers[:, 1],
        marker="o",
        c="white",
        alpha=1,
        s=200,
        edgecolor="k",
    )

    for i, c in enumerate(centers):
        ax2.scatter(c[0], c[1], marker="$%d$" % i, alpha=1, s=50, edgecolor="k")

    ax2.set_title("La visualización de los datos agrupados.")
    ax2.set_xlabel("Espacio de características para la primera característica")
    ax2.set_ylabel("Espacio de características para la segunda característica")

    plt.suptitle(
        "Análisis de silueta para el clustering KMeans en datos de muestra con n_clusters = %d"
        % n_clusters,
        fontsize=14,
        fontweight="bold",
    )

plt.show()

Interpretar los resultados

Interpretaremos los resultados del Método Silueta. Analizaremos la puntuación de silueta promedio para cada valor de n_clusters y elegiremos el valor que dé la puntuación más alta.

Resumen

En este laboratorio, utilizamos el Método Silueta para determinar el número óptimo de clusters para el algoritmo KMeans. Generamos datos de muestra utilizando la función make_blobs y graficamos las puntuaciones de silueta para una serie de valores de n_clusters. Interpretamos los resultados y elegimos el valor óptimo para n_clusters.