Ajustando para el Azar en la Evaluación del Rendimiento del Clustering

Introducción

Esta práctica explora el impacto de la etiquetación aleatoria uniformemente distribuida en el comportamiento de algunas métricas de evaluación de clustering. Los algoritmos de clustering son fundamentalmente métodos de aprendizaje no supervisado y las métricas de evaluación que aprovechan información de verdad básica "supervisada" para cuantificar la calidad de los clusters resultantes. Sin embargo, las métricas de evaluación de clustering no ajustadas pueden ser engañosas ya que producen valores grandes para etiquetaciones de gran detalle, que pueden ser completamente aleatorias. Por lo tanto, solo las medidas ajustadas se pueden utilizar con seguridad como un índice de consenso para evaluar la estabilidad media de los algoritmos de clustering para un valor dado de k en varias submuestras superpuestas del conjunto de datos.

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 sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Definiendo la lista de métricas para evaluar

Primero definimos una lista de métricas que se utilizarán para evaluar los algoritmos de clustering. Ejemplos de tales métricas son la V-medida, el índice Rand, el índice Rand ajustado (ARI), la información mutua (MI), la información mutua normalizada (NMI) y la información mutua ajustada (AMI).

from sklearn import metrics

score_funcs = [
    ("V-medida", metrics.v_measure_score),
    ("Índice Rand", metrics.rand_score),
    ("ARI", metrics.adjusted_rand_score),
    ("MI", metrics.mutual_info_score),
    ("NMI", metrics.normalized_mutual_info_score),
    ("AMI", metrics.adjusted_mutual_info_score),
]

Experimento 1 - Etiquetas de verdad básica fijas y número creciente de clusters

Creamos una etiquetación aleatoria uniformemente distribuida y utilizamos la función random_labels para crear un conjunto fijo de etiquetas de verdad básica (labels_a) distribuidas en n_classes y luego evaluamos varios conjuntos de etiquetas "predichas" al azar (labels_b) para evaluar la variabilidad de una métrica dada para un n_clusters dado.

rng = np.random.RandomState(0)

def random_labels(n_samples, n_classes):
    return rng.randint(low=0, high=n_classes, size=n_samples)

def fixed_classes_uniform_labelings_scores(
    score_func, n_samples, n_clusters_range, n_classes, n_runs=5
):
    scores = np.zeros((len(n_clusters_range), n_runs))
    labels_a = random_labels(n_samples=n_samples, n_classes=n_classes)

    for i, n_clusters in enumerate(n_clusters_range):
        for j in range(n_runs):
            labels_b = random_labels(n_samples=n_samples, n_classes=n_clusters)
            scores[i, j] = score_func(labels_a, labels_b)
    return scores

Graficando los resultados del Experimento 1

Graficamos los resultados del primer experimento utilizando las bibliotecas matplotlib y seaborn. El índice Rand se estabiliza para n_clusters > n_classes. Otras medidas no ajustadas, como la V-Measure, muestran una dependencia lineal entre el número de clusters y el número de muestras. Las medidas ajustadas para el azar, como el ARI y el AMI, presentan algunas variaciones aleatorias centradas en una puntuación media de 0.0, independientemente del número de muestras y clusters.

import matplotlib.pyplot as plt
import seaborn as sns

n_samples = 1000
n_classes = 10
n_clusters_range = np.linspace(2, 100, 10).astype(int)
plots = []
names = []

sns.color_palette("colorblind")
plt.figure(1)

for marker, (score_name, score_func) in zip("d^vx.,", score_funcs):
    scores = fixed_classes_uniform_labelings_scores(
        score_func, n_samples, n_clusters_range, n_classes=n_classes
    )
    plots.append(
        plt.errorbar(
            n_clusters_range,
            scores.mean(axis=1),
            scores.std(axis=1),
            alpha=0.8,
            linewidth=1,
            marker=marker,
        )[0]
    )
    names.append(score_name)

plt.title(
    "Medidas de clustering para etiquetado uniforme aleatorio\n"
    f"en contra de la asignación de referencia con {n_classes} clases"
)
plt.xlabel(f"Número de clusters (El número de muestras está fijo en {n_samples})")
plt.ylabel("Valor de puntuación")
plt.ylim(bottom=-0.05, top=1.05)
plt.legend(plots, names, bbox_to_anchor=(0.5, 0.5))
plt.show()

Experimento 2 - Número variable de clases y clusters

En esta sección, definimos una función similar que utiliza varias métricas para evaluar dos etiquetaciones aleatorias uniformemente distribuidas. En este caso, el número de clases y el número asignado de clusters se corresponden para cada valor posible en n_clusters_range.

def uniform_labelings_scores(score_func, n_samples, n_clusters_range, n_runs=5):
    scores = np.zeros((len(n_clusters_range), n_runs))

    for i, n_clusters in enumerate(n_clusters_range):
        for j in range(n_runs):
            labels_a = random_labels(n_samples=n_samples, n_classes=n_clusters)
            labels_b = random_labels(n_samples=n_samples, n_classes=n_clusters)
            scores[i, j] = score_func(labels_a, labels_b)
    return scores

Graficando los resultados del Experimento 2

Graficamos los resultados del segundo experimento utilizando la biblioteca matplotlib. Observamos resultados similares al del primer experimento: las métricas ajustadas para el azar se mantienen constantemente cerca de cero, mientras que otras métricas tienden a aumentar con etiquetaciones más detalladas. La V-medida media del etiquetado aleatorio aumenta significativamente a medida que el número de clusters se acerca al total de muestras utilizadas para calcular la medida.

n_samples = 100
n_clusters_range = np.linspace(2, n_samples, 10).astype(int)

plt.figure(2)

plots = []
names = []

for marker, (score_name, score_func) in zip("d^vx.,", score_funcs):
    scores = uniform_labelings_scores(score_func, n_samples, n_clusters_range)
    plots.append(
        plt.errorbar(
            n_clusters_range,
            np.median(scores, axis=1),
            scores.std(axis=1),
            alpha=0.8,
            linewidth=2,
            marker=marker,
        )[0]
    )
    names.append(score_name)

plt.title(
    "Medidas de clustering para 2 etiquetados uniformes aleatorios\ncon igual número de clusters"
)
plt.xlabel(f"Número de clusters (El número de muestras está fijo en {n_samples})")
plt.ylabel("Valor de puntuación")
plt.legend(plots, names)
plt.ylim(bottom=-0.05, top=1.05)
plt.show()

Resumen

Esta práctica exploró el impacto del etiquetado aleatorio uniformemente distribuido en el comportamiento de algunas métricas de evaluación de clustering. Los resultados indicaron que las métricas de evaluación de clustering no ajustadas pueden ser engañosas, y solo las medidas ajustadas se pueden utilizar con seguridad como un índice de consenso para evaluar la estabilidad promedio de los algoritmos de clustering para un valor dado de k en varias sub-muestras superpuestas del conjunto de datos.