ROC avec validation croisée

Introduction

Dans ce laboratoire, nous allons apprendre à estimer et à visualiser la variance de la métrique Receiver Operating Characteristic (ROC) à l'aide de la validation croisée en Python. Les courbes ROC sont utilisées dans la classification binaire pour mesurer les performances d'un modèle en traçant le taux de vrais positifs (TPR) en fonction du taux de faux positifs (FPR). Nous utiliserons la bibliothèque Scikit-learn pour charger l'ensemble de données iris, créer des caractéristiques bruitées et classifier l'ensemble de données avec un Support Vector Machine (SVM). Nous tracerons ensuite les courbes ROC avec la validation croisée et calculerons la moyenne de l'aire sous la courbe (AUC) pour voir la variabilité de la sortie du classifieur lorsque l'ensemble d'entraînement est divisé en différents sous-ensembles.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook 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 limites 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.

Charger et préparer les données

Tout d'abord, nous allons charger l'ensemble de données iris à l'aide de la bibliothèque Scikit-learn. L'ensemble de données iris contient 3 classes de plantes d'iris, et nous allons binariser l'ensemble de données en éliminant une classe pour créer un problème de classification binaire. Nous ajouterons également des caractéristiques bruitées pour rendre le problème plus difficile.

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)

Classification et analyse ROC

Ensuite, nous exécuterons un classifieur SVM avec validation croisée et tracerons les courbes ROC par plissement. Nous utiliserons StratifiedKFold de Scikit-learn pour générer les partitions de validation croisée. Nous calculerons également la moyenne de l'aire sous la courbe (AUC) des courbes ROC et verrons la variabilité de la sortie du classifieur en traçant l'écart-type des TPR (taux de vrais positifs).

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"Courbe ROC moyenne (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 écart-type",
)

ax.set(
    xlim=[-0.05, 1.05],
    ylim=[-0.05, 1.05],
    xlabel="Taux de faux positifs",
    ylabel="Taux de vrais positifs",
    title=f"Courbe ROC moyenne avec variabilité\n(Étiquette positive '{target_names[1]}')",
)
ax.axis("square")
ax.legend(loc="bas droite")
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à estimer et à visualiser la variance de la métrique Receiver Operating Characteristic (ROC) à l'aide de la validation croisée en Python. Nous avons chargé l'ensemble de données iris, créé des caractéristiques bruitées et classifié l'ensemble de données avec un SVM. Nous avons ensuite tracé les courbes ROC avec la validation croisée et calculé la moyenne de l'aire sous la courbe (AUC) pour voir la variabilité de la sortie du classifieur lorsque l'ensemble d'entraînement est divisé en différents sous-ensembles. Les courbes ROC peuvent nous aider à évaluer les performances d'un classifieur binaire et à voir le compromis entre les vrais positifs et les faux positifs. La validation croisée peut nous aider à estimer la variabilité de la sortie du classifieur et à choisir le meilleur modèle pour notre problème.