Anpassung an den Zufall bei der Bewertung der Clusterleistung

Einführung

In diesem Lab wird der Einfluss einer gleichmäßig verteilten zufälligen Belegung auf das Verhalten einiger Clusterbewertungsmetriken untersucht. Clusteralgorithmen sind im Wesentlichen unüberwachte Lernmethoden, und Bewertungsmetriken, die "überwachte" Ground-Truth-Informationen nutzen, um die Qualität der resultierenden Cluster zu quantifizieren. Nicht angepasste Clusterbewertungsmetriken können jedoch irreführend sein, da sie große Werte für feingranulare Belegungen ausgeben, die völlig zufällig sein können. Daher können nur angepasste Maße sicher als Konsensindex verwendet werden, um die durchschnittliche Stabilität von Clusteralgorithmen für einen gegebenen Wert von k auf verschiedenen überlappenden Teilproben des Datensatzes zu evaluieren.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Definition der Liste der Metriken zur Bewertung

Wir definieren zunächst eine Liste von Metriken, die zur Bewertung von Clusteralgorithmen verwendet werden sollen. Beispiele solcher Metriken sind V-Measure, Rand-Index, Adjustierter Rand-Index (ARI), gegenseitige Information (MI), normalisierte gegenseitige Information (NMI) und angepasste gegenseitige Information (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),
]

Experiment 1 - Fixe Ground-Truth-Labels und wachsender Anzahl von Clustern

Wir erstellen eine gleichmäßig verteilte zufällige Belegung und verwenden die Funktion random_labels, um einen fixen Satz von Ground-Truth-Labels (labels_a) zu erstellen, die in n_classes verteilt sind, und bewerten dann mehrere Sätze von zufällig "vorgeschlagenen" Labels (labels_b), um die Variabilität einer gegebenen Metrik bei einem gegebenen n_clusters zu bewerten.

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

Darstellung der Ergebnisse des Experiments 1

Wir stellen die Ergebnisse des ersten Experiments mit den Bibliotheken matplotlib und seaborn dar. Der Rand-Index sättigt sich für n_clusters > n_classes. Andere nicht angepasste Maße wie der V-Measure zeigen eine lineare Abhängigkeit zwischen der Anzahl der Cluster und der Anzahl der Proben. Angepasst an den Zufall gemessene Maße wie ARI und AMI zeigen einige zufällige Schwankungen um einen Mittelwert von 0,0, unabhängig von der Anzahl der Proben und Cluster.

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(
    "Clustering measures for random uniform labeling\n"
    f"against reference assignment with {n_classes} classes"
)
plt.xlabel(f"Number of clusters (Number of samples is fixed to {n_samples})")
plt.ylabel("Score value")
plt.ylim(bottom=-0.05, top=1.05)
plt.legend(plots, names, bbox_to_anchor=(0.5, 0.5))
plt.show()

Experiment 2 - Variierende Anzahl von Klassen und Clustern

In diesem Abschnitt definieren wir eine ähnliche Funktion, die mehrere Metriken verwendet, um zwei gleichmäßig verteilte zufällige Belegungen zu bewerten. In diesem Fall stimmen die Anzahl der Klassen und die zugewiesene Anzahl der Cluster für jede mögliche Zahl in n_clusters_range überein.

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

Darstellung der Ergebnisse des Experiments 2

Wir stellen die Ergebnisse des zweiten Experiments mit der Bibliothek matplotlib dar. Wir stellen ähnliche Ergebnisse wie im ersten Experiment fest: Die auf den Zufall angepassten Metriken bleiben konstant in der Nähe von Null, während andere Metriken mit feineren Belegungen tendenziell größer werden. Die durchschnittliche V-Maße der zufälligen Belegung steigt signifikant, wenn die Anzahl der Cluster der Gesamtzahl der zur Berechnung des Maße verwendeten Proben näher kommt.

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(
    "Clustering measures for 2 random uniform labelings\nwith equal number of clusters"
)
plt.xlabel(f"Number of clusters (Number of samples is fixed to {n_samples})")
plt.ylabel("Score value")
plt.legend(plots, names)
plt.ylim(bottom=-0.05, top=1.05)
plt.show()

Zusammenfassung

In diesem Lab wurde der Einfluss gleichmäßig verteilter zufälliger Belegungen auf das Verhalten einiger Clusterbewertungsmetriken untersucht. Die Ergebnisse zeigten, dass nicht angepasste Clusterbewertungsmetriken irreführend sein können und nur angepasste Maße als Konsensindex sicher verwendet werden können, um die durchschnittliche Stabilität von Clusteralgorithmen für einen gegebenen Wert von k auf verschiedenen überlappenden Teilproben des Datensatzes zu evaluieren.