ROC moyen pour une validation croisée répétée de 10 fois avec des estimations de probabilité

Je prévois d'utiliser une validation croisée stratifiée répétée (10 fois) sur environ 10 000 cas en utilisant un algorithme d'apprentissage automatique. Chaque fois, la répétition sera effectuée avec différentes graines aléatoires.

Dans ce processus, je crée 10 instances d'estimations de probabilité pour chaque cas. 1 instance d'estimation de probabilité pour chacune des 10 répétitions de la validation croisée multipliée par 10

Puis-je faire la moyenne de 10 probabilités pour chaque cas, puis créer une nouvelle courbe ROC moyenne (représentant les résultats de CV multipliés par 10), qui peut être comparée à d'autres courbes ROC par des comparaisons par paires?

D'après votre description, cela semble parfaitement logique: non seulement vous pouvez calculer la courbe ROC moyenne, mais aussi la variance autour d'elle pour construire des intervalles de confiance. Cela devrait vous donner une idée de la stabilité de votre modèle.

Par exemple, comme ceci:

Ici, je mets des courbes ROC individuelles ainsi que la courbe moyenne et les intervalles de confiance. Il y a des domaines où les courbes sont d'accord, donc nous avons moins de variance, et il y a des domaines où ils ne sont pas d'accord.

Pour un CV répété, vous pouvez simplement le répéter plusieurs fois et obtenir la moyenne totale sur tous les plis individuels:

Il est assez similaire à l'image précédente, mais donne des estimations plus stables (c'est-à-dire fiables) de la moyenne et de la variance.

Voici le code pour obtenir l'intrigue:

import matplotlib.pyplot as plt
import numpy as np
from scipy import interp

from sklearn.datasets import make_classification
from sklearn.cross_validation import KFold
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_curve

X, y = make_classification(n_samples=500, random_state=100, flip_y=0.3)

kf = KFold(n=len(y), n_folds=10)

tprs = []
base_fpr = np.linspace(0, 1, 101)

plt.figure(figsize=(5, 5))

for i, (train, test) in enumerate(kf):
    model = LogisticRegression().fit(X[train], y[train])
    y_score = model.predict_proba(X[test])
    fpr, tpr, _ = roc_curve(y[test], y_score[:, 1])

    plt.plot(fpr, tpr, 'b', alpha=0.15)
    tpr = interp(base_fpr, fpr, tpr)
    tpr[0] = 0.0
    tprs.append(tpr)

tprs = np.array(tprs)
mean_tprs = tprs.mean(axis=0)
std = tprs.std(axis=0)

tprs_upper = np.minimum(mean_tprs + std, 1)
tprs_lower = mean_tprs - std


plt.plot(base_fpr, mean_tprs, 'b')
plt.fill_between(base_fpr, tprs_lower, tprs_upper, color='grey', alpha=0.3)

plt.plot([0, 1], [0, 1],'r--')
plt.xlim([-0.01, 1.01])
plt.ylim([-0.01, 1.01])
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.axes().set_aspect('equal', 'datalim')
plt.show()

Pour les CV répétés:

idx = np.arange(0, len(y))

for j in np.random.randint(0, high=10000, size=10):
    np.random.shuffle(idx)
    kf = KFold(n=len(y), n_folds=10, random_state=j)

    for i, (train, test) in enumerate(kf):
        model = LogisticRegression().fit(X[idx][train], y[idx][train])
        y_score = model.predict_proba(X[idx][test])
        fpr, tpr, _ = roc_curve(y[idx][test], y_score[:, 1])

        plt.plot(fpr, tpr, 'b', alpha=0.05)
        tpr = interp(base_fpr, fpr, tpr)
        tpr[0] = 0.0
        tprs.append(tpr)

Source d'inspiration: http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc_crossval.html

Il n'est pas correct de faire la moyenne des probabilités car cela ne représenterait pas les prédictions que vous essayez de valider et implique une contamination entre les échantillons de validation.

Notez que 100 répétitions de validation croisée 10 fois peuvent être nécessaires pour obtenir une précision adéquate. Ou utilisez le bootstrap d'optimisme Efron-Gong qui nécessite moins d'itérations pour la même précision (voir par exemple rmsles validatefonctions du package R ).

Les courbes ROC ne sont en aucun cas pertinentes pour ce problème. Utilisez un score de précision approprié et accompagnez-le du$c$-index (probabilité de concordance; AUROC) qui est beaucoup plus facile à traiter que la courbe, car il est calculé facilement et rapidement en utilisant la statistique de Wilcoxon-Mann-Whitney.