K-Fold Cross-Validation for Robust Model Evaluation

1. Le problème d'une seule division (Train-Test Split)

Jusqu'à présent, nous avons toujours évalué nos modèles en divisant nos données une seule fois en un ensemble d'entraînement et un ensemble de test.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Le problème est que cette division est aléatoire. Selon la "chance" que nous avons eue lors de la division, l'ensemble de test peut contenir des exemples particulièrement "faciles" ou particulièrement "difficiles".

• Scénario "chanceux" : Tous les exemples difficiles se retrouvent dans X_train. Le modèle apprend à les gérer, et l'ensemble X_test ne contient que des cas simples. Le score de précision sera artificiellement élevé et trop optimiste.
• Scénario "malchanceux" : Par hasard, beaucoup d'exemples difficiles ou atypiques se retrouvent dans X_test. Le modèle n'a pas eu l'occasion d'apprendre de cas similaires et son score de précision sera injustement bas.

Dans les deux cas, le score que nous obtenons n'est pas une mesure fiable de la capacité du modèle à généraliser sur de nouvelles données inconnues. Il reflète simplement sa performance sur cette division particulière.

La vidéo suivante de StatQuest explique très clairement pourquoi nous avons besoin d'une meilleure approche que cette simple division.

2. La solution : la validation croisée à k-plis (K-Fold Cross-Validation)

Plutôt que de faire une seule division, l'idée de la validation croisée est d'en faire plusieurs et de moyenner les résultats. La méthode la plus courante est la validation croisée à k-plis (ou k-folds). Voici comment elle fonctionne :

1. Diviser : On divise l'ensemble de données d'entraînement en k sous-ensembles de taille égale, appelés "plis" (folds). Une valeur commune pour k est 5 ou 10.
2. Itérer : On effectue k itérations. À chaque itération :
   • On choisit un pli pour servir d'ensemble de test (ou de validation).
   • On utilise les k-1 autres plis pour former l'ensemble d'entraînement.
   • On entraîne le modèle sur l'ensemble d'entraînement et on l'évalue sur l'ensemble de test, puis on enregistre le score.
3. Moyenne : Après les k itérations, nous avons k scores de performance. La performance finale du modèle est la moyenne de ces k scores.

L'image suivante illustre parfaitement ce processus pour k=5 :

L'article suivant, en arabe, explique ce concept en détail.

3. Validation croisée vs. Division simple

Pour bien consolider votre compréhension, comparons directement les deux approches.

Ce tableau est inspiré de l'excellent article suivant de DigitalOcean, qui propose également une comparaison claire.

4. Application avec Scikit-learn

Heureusement, Scikit-learn rend la validation croisée extrêmement simple à mettre en œuvre. Il n'est pas nécessaire d'écrire la boucle manuellement. On utilise la fonction cross_val_score.

Cette fonction prend en arguments :

1. estimator : L'instance de votre modèle (ex: RandomForestClassifier()).
2. X : L'ensemble de vos caractéristiques.
3. y : L'ensemble de vos cibles.
4. cv : Le nombre de plis (le k).

Elle s'occupe de tout le processus de division, d'entraînement et de test itératif, puis retourne un tableau NumPy contenant les k scores.

Appliquons cela à notre classificateur de forêt aléatoire de la leçon précédente.

# 1. Importer les bibliothèques
import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestClassifier




# 2. Charger les données (cette fois, nous n'avons pas besoin de les diviser nous-mêmes)
data = load_breast_cancer()
X = data.data
y = data.target




# 3. Créer une instance du modèle
# Nous utilisons les mêmes paramètres que dans la leçon précédente
rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)




# 4. Évaluation avec une seule division (l'ancienne méthode)
# Nous le faisons juste pour comparer
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
rf_classifier.fit(X_train, y_train)
single_split_score = rf_classifier.score(X_test, y_test)
print(f"Score avec une seule division (train_test_split) : {single_split_score:.4f}\n")





# 5. Évaluation avec la validation croisée à 5 plis (la nouvelle méthode robuste)
# cross_val_score utilise l'intégralité de X et y
scores = cross_val_score(rf_classifier, X, y, cv=5) # cv=5 signifie 5 plis

print(f"Scores pour chaque pli : {scores}")
print(f"Précision moyenne avec la validation croisée : {scores.mean():.4f}")
print(f"Écart-type des scores : {scores.std():.4f}")

Analyse des résultats :

• Le score de la division unique vous donne un seul chiffre, par exemple 0.9649. C'est le résultat "chanceux" ou "malchanceux" que nous avons obtenu avec random_state=42.
• La validation croisée vous donne un tableau de 5 scores, par exemple [0.973, 0.947, 0.956, 0.938, 0.982].
• La moyenne (.mean()) de ces scores, environ 0.959, est une estimation beaucoup plus fiable de la performance réelle de votre modèle. C'est le chiffre que vous devriez rapporter.
• L'écart-type (.std()) vous indique la variabilité des scores entre les plis. Un faible écart-type signifie que la performance du modèle est stable, quelle que soit la partie des données utilisée pour le test.

Les vidéos et articles suivants montrent également comment utiliser cross_val_score en pratique.

Conclusion

Aujourd'hui, vous avez appris une technique fondamentale pour évaluer rigoureusement les modèles de machine learning. Au lieu de vous fier à un score unique et potentiellement trompeur, vous pouvez maintenant calculer une estimation de performance robuste et fiable.

Points clés à retenir :

• Une simple division train_test_split produit une estimation de performance variable et peu fiable, car elle dépend de la répartition aléatoire des données.
• La validation croisée à k-plis (k-fold cross-validation) résout ce problème en créant k divisions des données, en entraînant k modèles et en moyennant leurs scores.
• Le résultat est une estimation plus stable et réaliste de la capacité du modèle à généraliser.
• Le principal inconvénient est un coût de calcul plus élevé, car on entraîne k modèles au lieu d'un seul.
• Dans Scikit-learn, la fonction cross_val_score implémente ce processus de manière simple et efficace.

Maintenant que nous disposons d'une méthode robuste pour évaluer un modèle, nous pouvons aborder la question posée à la fin de la leçon précédente : comment trouver la meilleure combinaison d'hyperparamètres pour notre modèle ? Dans la prochaine leçon, nous verrons comment combiner la puissance de la validation croisée avec une recherche systématique pour optimiser nos modèles à l'aide de GridSearchCV.