ShuffleSplit ou GroupKFold

Fonctions :

ShuffleSplit()

La fonction ShuffleSplit() de sklearn.model_selection génère des splits aléatoires de votre jeu de données en un ensemble d'entraînement et un ensemble de test. À chaque itération, une portion du jeu de données est utilisée pour l'entraînement et une autre portion est utilisée pour le test. Ce processus est répété plusieurs fois, ce qui permet de s'assurer que chaque observation du jeu de données est utilisée pour le test au moins une fois. Cette méthode est utile pour éviter le biais de sélection dans les échantillons de test.

Importation :

from sklearn.model_selection import ShuffleSplit

Attributs :

Paramètre	Description
`n_splits`	Le nombre de splits à effectuer. Par défaut, `10`.
`test_size`	La proportion ou le nombre d'échantillons à utiliser pour le test dans chaque split. Par défaut, il est défini à 0.25 (25% des données).
`train_size`	La proportion ou le nombre d'échantillons à utiliser pour l'entraînement dans chaque split. Par défaut, il est défini à `None`, et la taille d'entraînement est déterminée automatiquement par `test_size`.
`random_state`	Permet de fixer la graine pour garantir des résultats reproductibles. Si `None`, la graine est générée de manière aléatoire.
`shuffle`	Si `True`, les données sont mélangées avant la séparation. Par défaut, `True`.

Exemple de code :

import numpy as np
from sklearn.model_selection import ShuffleSplit
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 de ShuffleSplit avec 5 splits, 25% pour le test
ss = ShuffleSplit(n_splits=5, test_size=0.25, random_state=42)

# Liste pour stocker les scores de chaque itération
ss_accuracies = []

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

# Validation croisée ShuffleSplit
for train_index, test_index in ss.split(X):
    # Séparation des données en train et test pour ce split
    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)
    
    ss_accuracies.append(accuracy)

# Affichage de la moyenne des accuracies
print(f'Mean accuracy: {np.mean(ss_accuracies):.4f}')

Explication du code :


 	
Chargement des données :


 	
Le jeu de données Iris est chargé à l'aide de la fonction load_iris() qui contient des informations sur les fleurs d'iris avec quatre caractéristiques par échantillon et une variable cible représentant la classe de l'iris.



 	
Initialisation de ShuffleSplit :


 	
ShuffleSplit() est initialisé avec 5 splits, un test_size de 0.25, et une graine random_state pour garantir des splits reproductibles.

 	
test_size=0.25 signifie que 25% des données seront utilisées pour l'évaluation, et les 75% restants pour l'entraînement.

 	
n_splits=5 indique que le processus sera effectué 5 fois.



 	
Boucle de validation croisée :


 	
ss.split(X) génère les indices pour chaque division entre l'ensemble d'entraînement et l'échantillon de test. À chaque itération, un modèle de régression logistique est entraîné sur l'ensemble d'entraînement et évalué sur l'échantillon de test.



 	
Entraînement et évaluation :


 	
Le modèle est formé sur l'ensemble d'entraînement et testé sur l'ensemble de test. La précision de chaque itération est calculée à l'aide de accuracy_score() et ajoutée à la liste ss_accuracies.



 	
Calcul de la précision moyenne :


 	
À la fin de la validation croisée, la moyenne des précisions est calculée et affichée pour obtenir une idée de la performance globale du modèle.




Points importants :

 	
Évaluation répétée : Contrairement à une simple séparation en jeu d'entraînement et de test, ShuffleSplit permet de répéter l'évaluation plusieurs fois, ce qui permet de mieux estimer la performance du modèle sur différents sous-ensembles de données.

 	
Mélange des données : Les données sont mélangées à chaque split, ce qui permet de minimiser le biais de sélection.

 	
Pratique pour les jeux de données moyens à grands : Si vous travaillez avec de petits jeux de données, il est préférable d'utiliser LeaveOneOut() pour des évaluations plus précises. ShuffleSplit() est plus adapté pour des jeux de données de taille moyenne ou grande.


Applications courantes :

 	
Modèles à évaluer sur plusieurs itérations : Lorsque vous souhaitez obtenir une estimation plus robuste de la performance du modèle sur plusieurs sous-ensembles de vos données.

 	
Équilibre entre performance et calcul : Lorsqu'une validation croisée avec un grand nombre de splits (comme KFold) serait trop coûteuse, ShuffleSplit permet de réduire la charge computationnelle tout en obtenant plusieurs estimations.

GroupKFold()

La fonction GroupKFold() de sklearn.model_selection est une variation de la validation croisée K-Fold qui garantit que les échantillons appartenant à un même groupe (ou une même catégorie) apparaissent dans les mêmes ensembles d'entraînement et de test à chaque itération. Elle est particulièrement utile lorsque vous avez des données groupées, comme des données de patients ou des mesures répétées pour le même individu, où il est important de ne pas diviser les groupes entre les ensembles d'entraînement et de test.

Importation :

from sklearn.model_selection import GroupKFold

Attributs :

Paramètre	Description
`n_splits`	Le nombre de splits (partitions) pour la validation croisée. Par défaut, il est défini à 5.
`shuffle`	Si `True`, les indices des échantillons sont mélangés avant d'effectuer les splits. Par défaut, il est défini à `False`.
`random_state`	La graine pour garantir la reproductibilité des résultats lorsque `shuffle` est activé. Par défaut, il est défini à `None`.

Exemple de code :

import numpy as np
from sklearn.model_selection import GroupKFold
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

# Exemple de groupes (simulé ici avec des indices arbitraires)
# Imaginons que tous les échantillons ayant le même indice dans 'groups' appartiennent au même groupe
groups = np.array([0, 1, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5])

# Initialisation de GroupKFold avec 3 splits
gkf = GroupKFold(n_splits=3)

# Liste pour stocker les scores de chaque itération
gkf_accuracies = []

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

# Validation croisée GroupKFold
for train_index, test_index in gkf.split(X, y, groups):
    # Séparation des données en train et test pour ce split
    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)
    
    gkf_accuracies.append(accuracy)

# Affichage de la moyenne des accuracies
print(f'Mean accuracy: {np.mean(gkf_accuracies):.4f}')

Explication du code :

Chargement des données :
- Le jeu de données Iris est chargé via load_iris() qui contient des informations sur les fleurs d'iris avec quatre caractéristiques et une variable cible représentant la classe de l'iris.
Définition des groupes :
- groups est un tableau d'indices représentant les groupes auxquels chaque échantillon appartient. Ici, nous simulons des groupes pour chaque échantillon avec des indices arbitraires.
Initialisation de GroupKFold :
- GroupKFold(n_splits=3) initialise la validation croisée en garantissant que les échantillons des mêmes groupes apparaissent dans les mêmes sous-ensembles d'entraînement et de test.
Boucle de validation croisée :
- gkf.split(X, y, groups) génère les indices pour chaque itération de validation croisée, en tenant compte des groupes.
- À chaque itération, un modèle de régression logistique est entraîné sur l'ensemble d'entraînement et testé sur l'ensemble de test.
Entraînement et évaluation :
- Le modèle est formé sur l'ensemble d'entraînement et testé sur l'ensemble de test. La précision de chaque itération est calculée avec accuracy_score() et ajoutée à la liste gkf_accuracies.
Affichage de la précision moyenne :
- À la fin de la validation croisée, la moyenne des précisions est calculée et affichée.

Points importants :

Garantir l'intégrité des groupes : GroupKFold garantit que les groupes d'échantillons ne sont pas divisés entre les ensembles d'entraînement et de test, ce qui est essentiel lorsque les données sont naturellement groupées (par exemple, plusieurs observations provenant du même patient).
Mélange des données : Si shuffle=True est utilisé, les échantillons seront mélangés avant de les diviser en groupes, ce qui peut être utile si vous souhaitez éviter des biais dans la répartition des groupes.
Éviter les fuites de données : Cette méthode est particulièrement utile pour éviter les fuites de données entre les ensembles d'entraînement et de test, qui peuvent survenir si les observations du même groupe sont présentes dans les deux ensembles.

Applications courantes :

Données groupées : Lorsqu'il existe des groupes ou des entités dans les données qui doivent être traités ensemble, comme des séries temporelles par sujet ou des données par groupe démographique.
Problèmes de validation croisée dans des contextes de regroupement : Lorsque des données provenant de différents groupes sont analysées, il est crucial d'éviter que des observations du même groupe soient utilisées à la fois pour l'entraînement et pour les tests, ce que GroupKFold garantit.

Exemple d'application pratique :

Supposons que vous ayez un jeu de données de patients où chaque patient a plusieurs mesures enregistrées à différents moments dans le temps. Vous ne voulez pas que les données de chaque patient soient présentes à la fois dans l'ensemble d'entraînement et dans l'ensemble de test. GroupKFold permet de garantir que toutes les données d'un patient donné se retrouvent dans un même ensemble, évitant ainsi toute fuite de données entre les ensembles d'entraînement et de test.