K-fold cross-validation

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()