Comprendre la validation croisée K-Fold : Un guide étape par étape

📖 Introduction

Lorsqu'un modèle d'apprentissage automatique apprend des données, il fonctionne souvent bien avec les données d'entraînement, mais sous-performe avec des données invisibles ou des données de test. Cela s'appelle le surajustement du modèle. Le surajustement se produit lorsque le modèle s'adapte trop bien aux données d'entraînement, et le sous-ajustement se produit lorsque le modèle ne fonctionne pas bien, même avec les données d'entraînement.

La validation croisée est l'une des techniques qui garantit que le modèle d'apprentissage automatique se généralise bien aux données non vues. Cela fonctionne comme suit :

1. Diviser les données en plis : Tout ensemble de données donné est divisé en plusieurs sous-ensembles, appelés « plis ».
2. Cycles de formation et de validation : Le modèle est formé sur un sous-ensemble des données, et un pli est utilisé pour la validation. Ce processus se répète, avec un pli différent utilisé à chaque fois.
3. Moyenne des résultats : Les métriques de performance de chaque étape de validation sont moyennées pour fournir une estimation plus fiable de l'efficacité du modèle.

Source de l'image

📌 Prérequis

Connaissances de base en apprentissage automatique – Compréhension de l'entraînement des modèles, des métriques d'évaluation et du surapprentissage.
Compétences en programmation Python – Familiarité avec Python et des bibliothèques comme scikit-learn, numpy et pandas.
Préparation du jeu de données – Un jeu de données nettoyé et prétraité prêt pour l'entraînement du modèle.
Scikit-Learn installé – Installez-le en utilisant pip install scikit-learn s'il n'est pas déjà disponible.
Compréhension des métriques de performance des modèles – Connaissance de la précision, de la précision, du rappel, de la RMSE, etc., en fonction de la tâche.

🚀 Méthodes courantes de validation croisée

• Validation croisée K-Fold : Le jeu de données est divisé en k parties égales, et le modèle est entraîné k fois, chaque fois en utilisant un pli différent comme ensemble de validation.
• Validation croisée stratifiée : Cette méthode garantit que chaque pli conserve la même proportion de classes dans les problèmes de classification. Elle est souvent utilisée lorsque les données de la variable cible sont déséquilibrées, c'est-à-dire lorsque la variable cible est une colonne catégorielle et que les classes ne sont pas distribuées également.
• Leave-One-Out (LOO) : Cette méthode utilise une seule instance pour la validation tout en s'entraînant sur le reste, en répétant pour toutes les instances.
• Validation croisée par séries temporelles : Utilisée pour des données séquentielles, garantissant que les données d'entraînement précèdent les données de validation.

La validation croisée aide à sélectionner le meilleur modèle et les meilleurs hyperparamètres tout en prévenant le surajustement.

Dans ce guide, nous allons explorer :

• Ce qu'est la validation croisée K-Fold
• Comment cela se compare à une séparation traditionnelle train-test
• Mise en œuvre étape par étape en utilisant scikit-learn
• Des variations avancées telles que Stratified K-Fold, Group K-Fold et Nested K-Fold
• Gestion des ensembles de données déséquilibrés

🤔 Qu'est-ce que la validation croisée K-Fold ?

La validation croisée K-Fold est une technique de rééchantillonnage utilisée pour évaluer les modèles d'apprentissage automatique en divisant le jeu de données en K plis de taille égale. Le modèle est formé sur K-1 plis et validé sur le pli restant, en répétant le processus K fois. Le score de performance final est la moyenne de toutes les itérations.

Pourquoi utiliser la validation croisée K-Fold ?

• Contrairement à une simple division train-test, le K-Fold utilise plusieurs divisions, ce qui réduit la variance des estimations de performance. Ainsi, le modèle devient plus capable de faire des prédictions sur des ensembles de données non vus.
• Chaque point de données est utilisé pour l'entraînement et la validation, maximisant les données disponibles et conduisant à une évaluation de performance plus robuste.
• Étant donné que le modèle est validé plusieurs fois à travers différents segments de données, cela aide à détecter et à atténuer le surapprentissage. Cela garantit que le modèle ne mémorise pas des échantillons d'entraînement spécifiques mais se généralise bien aux nouvelles données.
• En moyenne les résultats sur plusieurs folds, la validation croisée K-Fold fournit une estimation plus fiable de la véritable performance du modèle, réduisant ainsi le biais et la variance.
• La validation croisée K-fold est souvent utilisée en combinaison avec la recherche par grille et la recherche aléatoire pour trouver des hyperparamètres optimaux sans surajuster à un seul split train-test.

🔍 K-Fold contre séparation train-test

🏁 Mise en œuvre de la validation croisée K-Fold en Python

Mettons en œuvre la validation croisée K-Fold en utilisant scikit-learn.

Étape 1 : Importer les dépendances

Tout d'abord, nous allons commencer par importer les bibliothèques nécessaires.

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold, cross_val_score, train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn import linear_model, tree, ensemble

Étape 2 : Charger et explorer le jeu de données Titanic

Pour cette démonstration, nous utiliserons le jeu de données Titanic, un jeu de données très célèbre qui nous aidera à comprendre comment effectuer une validation croisée en k plis.

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
print(df.head(3))
print(df.info())

  PassengerId  Survived  Pclass  \
0            1         0       3   
1            2         1       1   
2            3         1       3   

                                                Name     Sex   Age  SibSp  \
0                            Braund, Mr. Owen Harris    male  22.0      1   
1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   
2                             Heikkinen, Miss. Laina  female  26.0      0   

   Parch            Ticket     Fare Cabin Embarked  
0      0         A/5 21171   7.2500   NaN        S  
1      0          PC 17599  71.2833   C85        C  
2      0  STON/O2. 3101282   7.9250   NaN        S  
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
None

Étape 3 : Prétraitement des données

Maintenant, il est très courant de commencer par le traitement des données et l'ingénierie des caractéristiques avant de construire un modèle.

df = df[['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare']]  # Select relevant features
df.dropna(inplace=True)  # Remove missing values

Encode categorical variable
label_encoder = LabelEncoder()
df['Sex'] = label_encoder.fit_transform(df['Sex'])

Split features and target
X = df.drop(columns=['Survived'])
y = df['Survived']
df.shape

(714, 7)

Étape 4 : Définir la division K-Fold

kf = KFold(n_splits=5, shuffle=True, random_state=42)

Ici, nous spécifions n_splits=5, ce qui signifie que les données sont divisées en cinq plis. Le shuffle=True garantit l'aléatoire.

Étape 5 : Entraînez et évaluez le modèle

model = RandomForestClassifier(n_estimators=100, random_state=42)
scores = cross_val_score(model, X, y, cv=kf, scoring='accuracy')
print(f'Cross-validation accuracy scores: {scores}')
print(f'Average Accuracy: {np.mean(scores):.4f}')

Scores de précision en validation croisée : [0.77622378 0.8041958 0.79020979 0.88111888 0.80985915] Précision moyenne : 0.8123

score = cross_val_score(tree.DecisionTreeClassifier(random_state= 42), X, y, cv= kf, scoring="accuracy")  
print(f'Scores for each fold are: {score}')  
print(f'Average score: {"{:.2f}".format(score.mean())}')

Les scores pour chaque pli sont : [0.72727273 0.79020979 0.76923077 0.81818182 0.8028169] Score moyen : 0.78

⚡ Techniques avancées de validation croisée

1. K-Fold Stratifié (Pour les ensembles de données déséquilibrés)

Pour les ensembles de données avec des classes déséquilibrées, le K-Fold stratifié garantit que chaque fold a la même distribution des classes que l'ensemble de données complet. Cette distribution des classes en fait le choix idéal pour les problèmes de classification déséquilibrée.

from sklearn.model_selection import StratifiedKFold
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring='accuracy')
print(f'Average Accuracy (Stratified K-Fold): {np.mean(scores):.4f}')

Précision Moyenne (K-Fold Stratifié) : 0.8124

2. Validation croisée K-Fold répétée

K-Fold répété effectue K-Fold plusieurs fois avec des divisions différentes pour réduire encore la variance. Cela se fait généralement lorsque les données sont simples et que des modèles tels que la régression logistique peuvent être ajustés au jeu de données.

from sklearn.model_selection import RepeatedKFold
rkf = RepeatedKFold(n_splits=5, n_repeats=10, random_state=42)
scores = cross_val_score(model, X, y, cv=rkf, scoring='accuracy')
print(f'Average Accuracy (Repeated K-Fold): {np.mean(scores):.4f}')

Précision Moyenne (K-Fold Répété): 0.8011

3. Validation croisée K-fold imbriquée (Pour l'optimisation des hyperparamètres)

La validation croisée K-Fold imbriquée effectue un ajustement des hyperparamètres dans la boucle interne tout en évaluant la performance dans la boucle externe, réduisant ainsi le surapprentissage.

from sklearn.model_selection import GridSearchCV, cross_val_score
param_grid = {'n_estimators': [50, 100, 150], 'max_depth': [None, 10, 20]}
gs = GridSearchCV(model, param_grid, cv=5)
scores = cross_val_score(gs, X, y, cv=5)
print(f'Average Accuracy (Nested K-Fold): {np.mean(scores):.4f}')

4. K-Fold Groupé (Pour Échantillons Non-Indépendants)

Si votre ensemble de données contient des groupes (par exemple, plusieurs images du même patient), Group K-Fold garantit que les échantillons du même groupe ne sont pas répartis entre l'entraînement et la validation, ce qui est utile pour les données hiérarchiques.

from sklearn.model_selection import GroupKFold
gkf = GroupKFold(n_splits=5)
groups = np.random.randint(0, 5, size=len(y))
scores = cross_val_score(model, X, y, cv=gkf, groups=groups, scoring='accuracy')
print(f'Average Accuracy (Group K-Fold): {np.mean(scores):.4f}')

💡 FAQ

Comment exécuter la validation croisée K-Fold en Python ?

Utilisez cross_val_score() de scikit-learn avec KFold comme paramètre cv.

Quelle est la différence entre K-Fold et Stratified K-Fold ?

K-Fold divise aléatoirement les données, tandis que le Stratified K-Fold maintient l'équilibre des classes dans chaque pli.

Comment choisir le bon nombre de pliages ?

• 5 ou 10 fois est standard pour la plupart des cas.
• Des plis plus élevés (par exemple, 20) réduisent le biais mais augmentent le temps de calcul.

Que fait la classe KFold en Python ?

Il divise l'ensemble de données en n_splits plis pour l'entraînement et la validation.

🔚 Conclusion

Pour s'assurer que tout modèle d'apprentissage automatique que vous construisez fonctionne de manière optimale lorsqu'il est confronté à des données non vues. La validation croisée devient une étape cruciale pour rendre le modèle fiable. La validation croisée en k-plis est l'une des meilleures façons de s'assurer que le modèle ne surapprend pas les données d'entraînement, maintenant ainsi le compromis biais-variance. Diviser les données en différents plis et entraîner et valider le modèle de manière itérative à travers chaque phase permet d'obtenir une meilleure estimation de la façon dont le modèle se comportera lorsqu'il sera confronté à un ensemble de données inconnu.

En Python, la mise en œuvre de la validation croisée K-Fold est simple en utilisant des bibliothèques comme scikit-learn, qui propose KFold et StratifiedKFold pour gérer les ensembles de données déséquilibrés. Intégrer la validation croisée K-Fold dans votre flux de travail vous permet d'ajuster efficacement les hyperparamètres, de comparer les modèles en toute confiance et d'améliorer la généralisation pour les applications réelles.

Que ce soit pour construire des modèles de régression, de classification ou d'apprentissage profond, cette approche de validation est un élément clé des pipelines d'apprentissage automatique.

Références

• Une Introduction Douce à la Validation Croisée k-fold
• Un guide complet sur la validation croisée en K-Fold
• Technique de validation croisée K-Fold et ses éléments essentiels
• Comment construire un modèle d'apprentissage profond pour prédire la rétention des employés en utilisant Keras et TensorFlow