Ajustement pour le hasard dans l'évaluation des performances de regroupement

Introduction

Ce laboratoire explore l'impact d'un étiquetage aléatoire uniformément distribué sur le comportement de certaines métriques d'évaluation de regroupement. Les algorithmes de regroupement sont fondamentalement des méthodes d'apprentissage non supervisé et les métriques d'évaluation qui utilisent des informations de vérité terrain « supervisées » pour quantifier la qualité des regroupements résultants. Cependant, les métriques d'évaluation de regroupement non ajustées peuvent être trompeuses car elles produisent de grandes valeurs pour des étiquetages fins, qui peuvent être totalement aléatoires. Par conséquent, seule la mesure ajustée peut être utilisée en toute sécurité comme indice de consensus pour évaluer la stabilité moyenne des algorithmes de regroupement pour une valeur donnée de k sur diverses sous-échantillons superposés du jeu de données.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session et nous résoudrons rapidement le problème pour vous.

Skills Graph

Définition de la liste de métriques à évaluer

Nous définissons tout d'abord une liste de métriques à utiliser pour évaluer les algorithmes de regroupement. Parmi les exemples de telles métriques, on trouve la mesure V, l'indice de Rand, l'indice de Rand ajusté (ARI), l'information mutuelle (MI), l'information mutuelle normalisée (NMI) et l'information mutuelle ajustée (AMI).

from sklearn import metrics

score_funcs = [
    ("V-measure", metrics.v_measure_score),
    ("Rand index", 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),
]

Expérience 1 - Etiquettes de vérité terrain fixes et nombre croissant de groupes

Nous créons un étiquetage aléatoire uniformément distribué et utilisons la fonction random_labels pour créer un ensemble fixe d'étiquettes de vérité terrain (labels_a) distribuées dans n_classes, puis évaluons plusieurs ensembles d'étiquettes "prédites" aléatoirement (labels_b) pour évaluer la variabilité d'une métrique donnée pour un nombre donné de groupes (n_clusters).

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

Traçage des résultats de l'expérience 1

Nous traçons les résultats de la première expérience en utilisant les bibliothèques matplotlib et seaborn. L'indice de Rand atteint un plateau pour n_clusters > n_classes. D'autres mesures non ajustées telles que la mesure V montrent une dépendance linéaire entre le nombre de groupes et le nombre d'échantillons. Les mesures ajustées pour le hasard, telles que l'ARI et l'AMI, présentent quelques variations aléatoires centrées autour d'une valeur moyenne de 0,0, indépendamment du nombre d'échantillons et de groupes.

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(
    "Mesures de regroupement pour un étiquetage uniforme aléatoire\n"
    f"par rapport à une affectation de référence avec {n_classes} classes"
)
plt.xlabel(f"Nombre de groupes (Le nombre d'échantillons est fixé à {n_samples})")
plt.ylabel("Valeur du score")
plt.ylim(bottom=-0.05, top=1.05)
plt.legend(plots, names, bbox_to_anchor=(0.5, 0.5))
plt.show()

Expérience 2 - Nombre variable de classes et de groupes

Dans cette section, nous définissons une fonction similaire qui utilise plusieurs métriques pour évaluer deux étiquetages aléatoires uniformément distribués. Dans ce cas, le nombre de classes et le nombre de groupes assignés sont alignés pour chaque valeur possible dans 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

Traçage des résultats de l'expérience 2

Nous traçons les résultats de la deuxième expérience en utilisant la bibliothèque matplotlib. Nous observons des résultats similaires à ceux de la première expérience : les métriques ajustées pour le hasard restent constamment proches de zéro tandis que les autres métriques tendent à augmenter avec des étiquetages plus fins. La mesure V-moyenne de l'étiquetage aléatoire augmente considérablement lorsque le nombre de groupes est plus proche du nombre total d'échantillons utilisés pour calculer la mesure.

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(
    "Mesures de regroupement pour 2 étiquetages uniformes aléatoires\navec un nombre égal de groupes"
)
plt.xlabel(f"Nombre de groupes (Le nombre d'échantillons est fixé à {n_samples})")
plt.ylabel("Valeur du score")
plt.legend(plots, names)
plt.ylim(bottom=-0.05, top=1.05)
plt.show()

Sommaire

Ce laboratoire a exploré l'impact de l'étiquetage aléatoire uniformément distribué sur le comportement de certaines métriques d'évaluation de regroupement. Les résultats ont indiqué que les métriques d'évaluation de regroupement non ajustées peuvent être trompeuses, et que seule la mesure ajustée peut être utilisée en toute sécurité comme indice de consensus pour évaluer la stabilité moyenne des algorithmes de regroupement pour une valeur donnée de k sur diverses sous-échantillons superposés du jeu de données.