ROC mit Kreuzvalidierung

Einführung

In diesem Lab werden wir lernen, wie man die Varianz der Receiver Operating Characteristic (ROC)-Metrik mit Hilfe von Kreuzvalidierung in Python abschätzt und visualisiert. ROC-Kurven werden bei der binären Klassifikation verwendet, um die Leistung eines Modells zu messen, indem die wahre Positivrate (TPR) gegen die falsche Positivrate (FPR) aufgetragen wird. Wir werden die Scikit-learn-Bibliothek verwenden, um den Iris-Datensatz zu laden, rauschende Merkmale zu erstellen und den Datensatz mit Support Vector Machine (SVM) zu klassifizieren. Anschließend werden wir die ROC-Kurven mit Kreuzvalidierung plotten und die durchschnittliche Fläche unter der Kurve (AUC) berechnen, um die Variabilität der Klassifikatorausgabe zu sehen, wenn der Trainingssatz in verschiedene Teilmengen unterteilt wird.

Tipps für die VM

Nachdem der VM-Start abgeschlossen 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 der 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

Daten laden und vorbereiten

Zunächst werden wir den Iris-Datensatz mit der Scikit-learn-Bibliothek laden. Der Iris-Datensatz enthält 3 Klassen von Iris-Pflanzen, und wir werden den Datensatz durch das Entfernen einer Klasse binarisieren, um ein binäres Klassifikationsproblem zu erstellen. Wir werden auch rauschende Merkmale hinzufügen, um das Problem schwieriger zu machen.

import numpy as np
from sklearn.datasets import load_iris

iris = load_iris()
target_names = iris.target_names
X, y = iris.data, iris.target
X, y = X[y!= 2], y[y!= 2]
n_samples, n_features = X.shape

## add noisy features
random_state = np.random.RandomState(0)
X = np.concatenate([X, random_state.randn(n_samples, 200 * n_features)], axis=1)

Klassifikation und ROC-Analyse

Als nächstes werden wir einen SVM-Klassifikator mit Kreuzvalidierung ausführen und die ROC-Kurven pro Fold plotten. Wir werden StratifiedKFold aus Scikit-learn verwenden, um die Kreuzvalidierungs-Splits zu generieren. Wir werden auch die durchschnittliche AUC der ROC-Kurven berechnen und die Variabilität der Klassifikatorausgabe durch das Plotten der Standardabweichung der TPRs betrachten.

import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.metrics import auc
from sklearn.metrics import RocCurveDisplay
from sklearn.model_selection import StratifiedKFold

n_splits = 6
cv = StratifiedKFold(n_splits=n_splits)
classifier = svm.SVC(kernel="linear", probability=True, random_state=random_state)

tprs = []
aucs = []
mean_fpr = np.linspace(0, 1, 100)

fig, ax = plt.subplots(figsize=(6, 6))
for fold, (train, test) in enumerate(cv.split(X, y)):
    classifier.fit(X[train], y[train])
    viz = RocCurveDisplay.from_estimator(
        classifier,
        X[test],
        y[test],
        name=f"ROC fold {fold}",
        alpha=0.3,
        lw=1,
        ax=ax,
        plot_chance_level=(fold == n_splits - 1),
    )
    interp_tpr = np.interp(mean_fpr, viz.fpr, viz.tpr)
    interp_tpr[0] = 0.0
    tprs.append(interp_tpr)
    aucs.append(viz.roc_auc)

mean_tpr = np.mean(tprs, axis=0)
mean_tpr[-1] = 1.0
mean_auc = auc(mean_fpr, mean_tpr)
std_auc = np.std(aucs)
ax.plot(
    mean_fpr,
    mean_tpr,
    color="b",
    label=r"Mean ROC (AUC = %0.2f $\pm$ %0.2f)" % (mean_auc, std_auc),
    lw=2,
    alpha=0.8,
)

std_tpr = np.std(tprs, axis=0)
tprs_upper = np.minimum(mean_tpr + std_tpr, 1)
tprs_lower = np.maximum(mean_tpr - std_tpr, 0)
ax.fill_between(
    mean_fpr,
    tprs_lower,
    tprs_upper,
    color="grey",
    alpha=0.2,
    label=r"$\pm$ 1 std. dev.",
)

ax.set(
    xlim=[-0.05, 1.05],
    ylim=[-0.05, 1.05],
    xlabel="False Positive Rate",
    ylabel="True Positive Rate",
    title=f"Mean ROC curve with variability\n(Positive label '{target_names[1]}')",
)
ax.axis("square")
ax.legend(loc="lower right")
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Varianz der Receiver Operating Characteristic (ROC)-Metrik mit Hilfe von Kreuzvalidierung in Python abschätzt und visualisiert. Wir haben den Iris-Datensatz geladen, rauschende Merkmale erstellt und den Datensatz mit SVM klassifiziert. Anschließend haben wir die ROC-Kurven mit Kreuzvalidierung geplottet und die durchschnittliche AUC berechnet, um die Variabilität der Klassifikatorausgabe zu sehen, wenn der Trainingssatz in verschiedene Teilmengen unterteilt wird. Die ROC-Kurven können uns helfen, die Leistung eines binären Klassifikators zu evaluieren und das Kompromissverhältnis zwischen wahren Positiven und falschen Positiven zu betrachten. Die Kreuzvalidierung kann uns helfen, die Variabilität der Klassifikatorausgabe abzuschätzen und das beste Modell für unser Problem auszuwählen.