K-fold cross-validation

La K-Fold Cross-Validation est une méthode utilisée pour évaluer la performance d’un modèle d’apprentissage supervisé de manière robuste. L’objectif est de réduire le risque de surapprentissage et d’obtenir une estimation fiable de la capacité de généralisation du modèle.

Le principe consiste à diviser le jeu de données en K sous-ensembles (folds) de taille à peu près égale. Le modèle est entraîné K fois : à chaque itération, un fold différent est utilisé comme jeu de test, tandis que les K-1 folds restants servent au train. Les performances sont ensuite moyennées sur les K itérations pour obtenir une estimation globale.

La K-Fold Cross-Validation est utilisée en science des données, machine learning et statistique pour comparer des modèles, ajuster des hyperparamètres et évaluer la robustesse des prédictions.

Les performances peuvent être mesurées à l’aide de métriques adaptées au problème, comme l’exactitude, la précision, le rappel, la F1-score ou l’erreur quadratique moyenne.

En résumé, la K-Fold Cross-Validation permet d’évaluer de manière fiable un modèle en utilisant l’ensemble des données disponibles et en minimisant les biais liés à un seul découpage train/test.

Fonctions :

KFold()

La fonction KFold() de la bibliothèque sklearn.model_selection permet de diviser un jeu de données en plusieurs sous-ensembles (ou "folds") pour effectuer une validation croisée. Cela permet d'évaluer la performance d'un modèle en utilisant différentes portions de l'ensemble de données pour l'entraînement et la validation, réduisant ainsi le biais du modèle.

Importation :

from sklearn.model_selection import KFold

Attributs :

Paramètre	Description
`n_splits`	Le nombre de "folds" (divisions) à réaliser. Par défaut, il est égal à 5.
`shuffle`	Si `True`, les données sont mélangées avant la division. Par défaut, c'est `False`.
`random_state`	Permet de fixer la graine pour la génération aléatoire des folds si `shuffle=True`.
`max_train_size`	Nombre maximum d'échantillons à inclure dans les données d'entraînement pour chaque fold. Si None, il n'y a pas de limite.

Exemple de code :

import numpy as np
from sklearn.model_selection import KFold
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

# Chargement du jeu de données Iris
data = load_iris()
X = data.data
y = data.target

# Initialisation du KFold avec 5 folds
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Liste pour stocker les scores de chaque fold
fold_accuracies = []

# Création du modèle
model = LogisticRegression(max_iter=200)

# Validation croisée
for train_index, test_index in kf.split(X):
    # Séparation des données en train et test pour ce fold
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    
    # Entraînement du modèle
    model.fit(X_train, y_train)
    
    # Prédiction et évaluation
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    
    fold_accuracies.append(accuracy)

# Affichage de la moyenne des accuracies sur tous les folds
print(f'Mean accuracy: {np.mean(fold_accuracies):.4f}')

Explication du code :

Chargement des données :
- Nous chargeons le jeu de données Iris avec load_iris() depuis sklearn.datasets.
Initialisation de KFold :
- Nous créons une instance de KFold avec 5 splits, shuffle=True pour mélanger les données, et une graine aléatoire fixée à 42.
Boucle de validation croisée :
- Nous utilisons kf.split(X) pour diviser les données en indices de training et de test. Cela va itérer 5 fois (puisque nous avons spécifié n_splits=5), et pour chaque itération, les données d'entraînement et de test sont créées.
Entraînement et évaluation :
- À chaque itération, nous entraînons un modèle de régression logistique sur les données d'entraînement et évaluons la précision sur les données de test.
Calcul des résultats :
- Les résultats de chaque fold sont stockés dans la liste fold_accuracies, et à la fin, nous affichons la moyenne des précisions sur tous les folds.

Points importants :

Validation croisée : Le but de la validation croisée avec KFold est de réduire le biais dans l'évaluation du modèle en s'assurant que le modèle est testé sur différents sous-ensembles de données.
Mélange des données : Le paramètre shuffle=True est utile pour mélanger les données avant de les diviser. Cela peut être particulièrement utile si les données sont ordonnées d'une manière qui pourrait introduire un biais (par exemple, si elles sont triées par classe).
Répétabilité : Fixer un random_state permet de rendre les résultats reproductibles, c'est-à-dire que les mêmes données seront utilisées à chaque exécution du code.

Applications courantes :

Évaluation de modèle : Utilisé dans les tâches de validation croisée pour évaluer la performance des modèles sans les surajuster à un sous-ensemble particulier de données.
Hyperparameter tuning : KFold est également souvent utilisé lors de la recherche des meilleurs hyperparamètres pour un modèle, en s'assurant que les performances ne dépendent pas d'un seul ensemble de données.

cross_val_score()