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

📖 Introduction

Lorsqu’un modèle de machine learning apprend à connaître les données, il fonctionne souvent bien avec les données d’entraînement, mais moins performant avec les données invisibles ou les données de test. C’est ce qu’on appelle le surajustement du modèle.\nLe surajustement du modèle se produit lorsque le modèle épouse bien les 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 permet de s’assurer que le modèle d’apprentissage automatique se généralise bien aux données invisibles. Il fonctionne comme suit :

1. Fractionnement des données en plis : Tout ensemble de données donné est divisé en plusieurs sous-ensembles, appelés « plis ».
2. Cycles d’entraînement et de validation : le modèle est entraîné 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. Calcul de la moyenne des résultats : la moyenne des mesures de performance de chaque étape de validation est calculée pour fournir une estimation plus fiable de l’efficacité du modèle.

Source de l’image

📌 Conditions préalables

Connaissance de base de l’apprentissage automatique – Comprendre l’entraînement des modèles, les mesures d’évaluation et le surapprentissage.
\nCompétences en programmation Python - Familiarité avec Python et les bibliothèques telles que scikit-learn, numpy et pandas.
\nPréparation de l’ensemble de données – Un ensemble de données nettoyé et prétraité prêt pour l’entraînement du modèle.
\nScikit-Learn Installed – Installez-le à l’aide de pip install scikit-learn s’il n’est pas déjà disponible.
\nCompréhension des mesures de performance du modèle – Connaissance de l’exactitude, de la précision, du rappel, de l’EQM, etc., selon la tâche.

🚀 Méthodes courantes de validation croisée

• K-Fold Cross-Validation : L’ensemble de données est divisé en k parties égales, et le modèle est entraîné k fois, chaque fois qu’un pli différent est utilisé comme ensemble de validation.
• K-Fold stratifié : Cette méthode garantit que chaque pli conserve la même proportion de classes dans les problèmes de classification. Il est souvent utilisé 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 de manière égale.
• Leave-One-Out (LOO) : cette méthode n’utilise qu’une seule instance pour la validation lors de l’entraînement sur les autres, en répétant l’opération pour toutes les instances.
• Validation croisée des séries chronologiques : Utilisé pour les données séquentielles, garantissant que les données d’entraînement précèdent les données de validation.

La validation croisée permet de sélectionner le meilleur modèle et les meilleurs hyperparamètres tout en évitant le surapprentissage.

Dans ce guide, nous allons explorer :

• Qu’est-ce que la validation croisée K-Fold
• Comparaison avec une séparation train-test traditionnelle
• Mise en œuvre étape par étape à l’aide de scikit-learn
• Variantes avancées telles que le pliage en K stratifié, le pliage en K en groupe et le pliage en K imbriqué
• Gestion d’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 l’ensemble de données en K plis de taille égale. Le modèle est entraîné sur les plis K-1 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 seule division d’essai, K-Fold utilise plusieurs divisions, ce qui réduit la variance des estimations de performance. Par conséquent, le modèle devient plus capable de faire des prédictions sur des ensembles de données invisibles.
• Chaque point de données est utilisé pour l’entraînement et la validation, ce qui permet d’optimiser les données disponibles et d’obtenir une évaluation plus robuste des performances.
• Étant donné que le modèle est validé plusieurs fois sur différents segments de données, il permet de détecter et d’atténuer le surapprentissage. Cela permet de s’assurer que le modèle ne mémorise pas d’échantillons d’apprentissage spécifiques, mais qu’il se généralise bien à de nouvelles données.
• En faisant la moyenne des résultats sur plusieurs plis, la validation croisée K-Fold fournit une estimation plus fiable des performances réelles 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 les hyperparamètres optimaux sans surajuster à une seule division train-test.

🔍 K-Fold contre séparation Train-Test

🏁 Implémentation de la validation croisée K-fold en Python

Implémentons la validation croisée K-Fold à l’aide de 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 : Chargez et explorez l’ensemble de données du Titanic

Pour cette démo, 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 k-fold.

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, c’est une excellente pratique de commencer par le traitement des données et l’ingénierie des fonctionnalités 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 le caractère aléatoire.

Étape 5 : Entraîner et évaluer 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 de validation croisée : [0,77622378 0,8041958 0,79020979 0,88111888 0,80985915]\nPré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]\nNote moyenne : 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 jeux de données avec des classes déséquilibrées, le K-Fold stratifié garantit que chaque pli a la même distribution de classe que le jeu de données complet. Cette distribution des classes en fait le choix idéal pour les problèmes de classification des déséquilibres.

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 (pliage K stratifié) : 0,8124

2. Validation croisée répétée par pliage K

Le K-Fold répété exécute K-Fold plusieurs fois avec différentes divisions pour réduire davantage la variance. Cela se produit généralement lorsque les données sont simples et que des modèles tels que la régression logistique peuvent être intégrés à l’ensemble 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 (pliage en K répété) : 0,8011

3. Validation croisée K-fold imbriquée (pour le réglage des hyperparamètres)

Le K-Fold imbriqué effectue le réglage des hyperparamètres dans la boucle intérieure tout en évaluant les performances 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. Groupe K-fold (pour les échantillons non indépendants)

Si votre ensemble de données comporte des groupes (par exemple, plusieurs images du même patient), Group K-Fold s’assure 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}')

💡 Foire aux questions

Comment exécuter K-Fold Cross-Validation en Python ?

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

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

K-Fold divise les données de manière aléatoire, tandis que K-Fold stratifié maintient l’équilibre des classes dans chaque pli.

Comment choisir le bon nombre de plis ?

• 5 ou 10 fois est standard dans 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 plis n_splits pour l’entraînement et la validation.

🔚 Conclusion

Pour vous assurer que tout modèle d’apprentissage automatique que vous créez fonctionne mieux lorsqu’il est fourni avec des données invisibles. La validation croisée devient une étape cruciale pour fiabiliser le modèle. –La validation croisée des plis est l’un des meilleurs moyens de s’assurer que le modèle ne surajuste pas les données d’entraînement, maintenant ainsi le compromis biais-variance. La division des données en différents plis, ainsi que l’entraînement et la validation itératifs du modèle à chaque phase permettent de mieux estimer les performances du modèle lorsqu’il est fourni avec un ensemble de données inconnu.

En Python, l’implémentation de la validation croisée K-Fold est simple à l’aide de bibliothèques comme scikit-learn, qui propose KFold et StratifiedKFold pour gérer des ensembles de données déséquilibrés. L’intégration de la validation croisée K-Fold dans votre flux de travail vous permet d’affiner efficacement les hyperparamètres, de comparer les modèles en toute confiance et d’améliorer la généralisation pour des applications réelles.

Qu’il s’agisse de créer des modèles de régression, de classification ou de deep learning, cette approche de validation est un composant clé pour les pipelines de machine learning.

Références

• Une introduction en douceur à la validation croisée k-fold
• Un guide complet pour la validation croisée K-Fold
• La technique de validation croisée K-Fold et ses éléments essentiels
• Comment créer un modèle de Deep Learning pour prédire la rétention des employés à l’aide de Keras et TensorFlow