Validation croisée k-fold avec Ultralytics#

Introduction#

Ce guide complet présente la mise en œuvre de la validation croisée k-fold pour les jeux de données de détection d'objets dans l'écosystème Ultralytics. Nous utiliserons le format de détection YOLO et des bibliothèques Python clés telles que sklearn, pandas et PyYAML pour te guider dans la configuration nécessaire, la génération de vecteurs de caractéristiques et la création de partitions k-fold du jeu de données.

Que ton projet porte sur le jeu de données Fruit Detection ou sur une source de données personnalisée, ce tutoriel vise à t'aider à comprendre et à appliquer la validation croisée k-fold pour renforcer la fiabilité et la robustesse de tes modèles de machine learning. Nous utilisons k=5 plis dans ce tutoriel, mais garde à l'esprit que le nombre optimal de plis peut varier selon ton jeu de données et les spécificités de ton projet. La validation croisée k-fold est particulièrement utile lorsque ton jeu de données est petit, bruité ou très variable ; pour les grands jeux de données diversifiés, une partition train/val/test bien conçue suffit généralement.

Commençons.

Configuration#

• Tes annotations doivent être au format de détection YOLO.

• Ce guide suppose que les fichiers d'annotation sont disponibles localement.

• Pour notre démonstration, nous utilisons le jeu de données Fruit Detection.

  • Ce jeu de données contient au total 8479 images.
  • Il comprend 6 étiquettes de classe, dont le nombre total d'instances est indiqué ci-dessous.

• Les packages Python nécessaires comprennent :

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Ce tutoriel utilise k=5 plis. Tu dois toutefois déterminer le nombre de plis le mieux adapté à ton jeu de données.

1. Crée et active un nouvel environnement virtuel Python (venv) pour ton projet. Utilise pip (ou le gestionnaire de paquets de ton choix) pour installer :

   • La bibliothèque Ultralytics : pip install -U ultralytics. Tu peux aussi cloner le dépôt officiel.
   • Scikit-learn, pandas et PyYAML : pip install -U scikit-learn pandas pyyaml.

2. Vérifie que tes annotations sont au format de détection YOLO.

   • Pour ce tutoriel, tous les fichiers d'annotation se trouvent dans le répertoire Fruit-Detection/labels.

Génération de vecteurs de caractéristiques pour un jeu de données de détection d'objets#

1. Commence par créer un nouveau fichier Python example.py pour suivre les étapes ci-dessous.

2. Charge les images d'entraînement et de validation configurées à l'aide du propriétaire du jeu de données du package, sans toucher à la partition de test.

   from pathlib import Path
   
   from ultralytics.data.dataset import YOLODataset
   from ultralytics.data.utils import check_det_dataset
   
   yaml_file = "path/to/data.yaml"
   data = check_det_dataset(yaml_file)
   dataset_path = Path(data["path"])
   sources = []
   for split in ("train", "val"):
       source = data.get(split)
       if source:
           sources.extend(source if isinstance(source, list) else [source])
   dataset = YOLODataset(sources, data=data, augment=False)
   images = [Path(p) for p in dataset.im_files]

3. Lis ensuite le contenu du fichier YAML du jeu de données et extrais les indices des étiquettes de classe.

   classes = data["names"]
   cls_idx = sorted(classes.keys())

4. Initialise un DataFrame pandas vide.

   import pandas as pd
   
   labels_df = pd.DataFrame(0.0, columns=cls_idx, index=images)

5. Compte les instances de chaque classe présente dans les fichiers d'annotation.

   from collections import Counter
   
   for image, label in zip(images, dataset.labels):
       lbl_counter = Counter(label["cls"].flatten().astype(int))
       labels_df.loc[image, list(lbl_counter)] = list(lbl_counter.values())

6. Voici un exemple du DataFrame renseigné :

                                                          0    1    2    3    4    5
   '0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...'  0.0  0.0  0.0  0.0  0.0  7.0
   '0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...'  0.0  0.0  0.0  0.0  0.0  7.0
   '0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...'  0.0  0.0  0.0  0.0  0.0  7.0
   '00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...'  0.0  0.0  0.0  1.0  0.0  0.0
   '00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...'  0.0  0.0  0.0  1.0  0.0  0.0
    ...                                                  ...  ...  ...  ...  ...  ...
   'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...'  0.0  0.0  0.0  0.0  0.0  2.0
   'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...'  0.0  0.0  0.0  0.0  0.0  2.0
   'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...'  1.0  0.0  0.0  0.0  0.0  0.0
   'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...'  1.0  0.0  0.0  0.0  0.0  0.0
   'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...'  0.0  6.0  0.0  0.0  0.0  0.0

Les lignes utilisent des chemins d'accès absolus aux images, et les colonnes correspondent aux indices des classes. Les étiquettes manquantes restent des lignes d'arrière-plan entièrement composées de zéros. Cette structure de données permet d'appliquer la validation croisée k-fold à un jeu de données de détection d'objets.

Partitionnement du jeu de données en k-folds#

1. Nous allons maintenant utiliser la classe KFold de sklearn.model_selection pour générer k partitions du jeu de données.

   • Important :
     • Définir shuffle=True garantit une répartition aléatoire des classes dans tes partitions.
     • En définissant random_state=M avec M égal à un entier choisi, tu peux obtenir des résultats reproductibles.

   from sklearn.model_selection import KFold
   
   ksplit = 5
   kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # définir random_state pour obtenir des résultats reproductibles
   
   kfolds = list(kf.split(labels_df))

2. Le jeu de données est maintenant divisé en k plis, chacun contenant une liste d'indices train et val. Nous allons créer un DataFrame pour présenter ces résultats plus clairement.

   folds = [f"split_{n}" for n in range(1, ksplit + 1)]
   folds_df = pd.DataFrame(index=labels_df.index, columns=folds)
   
   for i, (train, val) in enumerate(kfolds, start=1):
       folds_df.loc[labels_df.index[train], f"split_{i}"] = "train"
       folds_df.loc[labels_df.index[val], f"split_{i}"] = "val"

3. Nous allons maintenant calculer la répartition des étiquettes de classe pour chaque pli, sous forme de ratio entre les classes présentes dans val et celles présentes dans train.

   fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)
   
   for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
       train_totals = labels_df.iloc[train_indices].sum()
       val_totals = labels_df.iloc[val_indices].sum()
   
       # To avoid division by zero, we add a small value (1E-7) to the denominator
       ratio = val_totals / (train_totals + 1e-7)
       fold_lbl_distrb.loc[f"split_{n}"] = ratio

   L'idéal est que les ratios de classes soient assez similaires dans chaque partition et d'une classe à l'autre. Cela dépend toutefois des spécificités de ton jeu de données.

4. Écris les listes d'images et un fichier YAML de jeu de données pour chaque partition. Les listes de fichiers texte évitent de copier le jeu de données k fois.

   import yaml
   
   save_path = dataset_path.parent / f"{ksplit}-Fold_Cross-val"
   save_path.mkdir(parents=True, exist_ok=True)
   ds_yamls = []
   
   for split in folds_df.columns:
       for partition in ("train", "val"):
           split_images = folds_df.index[folds_df[split] == partition]
           paths = "\n".join(map(str, split_images))
           (save_path / f"{split}_{partition}.txt").write_text(f"{paths}\n")
   
       dataset_yaml = save_path / f"{split}.yaml"
       ds_yamls.append(dataset_yaml)
       with open(dataset_yaml, "w") as ds_y:
           yaml.safe_dump(
               {
                   "path": save_path.as_posix(),
                   "train": f"{split}_train.txt",
                   "val": f"{split}_val.txt",
                   "names": classes,
               },
               ds_y,
           )

Enregistrer les résultats (facultatif)#

Tu peux éventuellement enregistrer les DataFrames de partitionnement k-fold et de répartition des étiquettes dans des fichiers CSV pour t'y référer ultérieurement.

folds_df.to_csv(save_path / "kfold_datasplit.csv")
fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")

Entraîner YOLO avec les partitions de données k-fold#

1. Commence par charger le modèle YOLO.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # utiliser yolo26n.pt pour un petit modèle
   model = YOLO(weights_path, task="detect")

2. Parcours ensuite les fichiers YAML du jeu de données pour lancer l'entraînement. Les résultats seront enregistrés dans un répertoire spécifié par les arguments project et name. Par défaut, ce répertoire est 'runs/detect/train#', où # est un indice entier.

   results = {}
   
   # Define your additional arguments here
   batch = 16
   project = "kfold_demo"
   epochs = 100
   
   for k, dataset_yaml in enumerate(ds_yamls):
       model = YOLO(weights_path, task="detect")
       results[k] = model.train(
           data=dataset_yaml, epochs=epochs, batch=batch, project=project, name=f"fold_{k + 1}"
       )  # include any additional train arguments

3. Tu peux aussi utiliser la fonction Ultralytics data.split.autosplit pour diviser automatiquement le jeu de données :

   from ultralytics.data.split import autosplit
   
   # Diviser automatiquement le jeu de données en ensembles train/val/test
   autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

Conclusion#

Dans ce guide, nous avons exploré l'utilisation de la validation croisée k-fold pour entraîner le modèle YOLO de détection d'objets. Nous avons appris à diviser l'ensemble d'entraînement et de validation en K partitions et à utiliser le tableau de ratios généré pour examiner l'équilibre des classes après une répartition aléatoire.

Nous avons également vu comment créer des DataFrames de rapport pour visualiser les partitions de données et la répartition des étiquettes dans celles-ci, ce qui nous donne une vue claire de la structure de nos ensembles d'entraînement et de validation.

Nous avons aussi enregistré nos résultats pour pouvoir les consulter ultérieurement, ce qui peut s'avérer particulièrement utile dans les projets à grande échelle ou lors du diagnostic des performances du modèle.

Enfin, nous avons mis en œuvre l'entraînement proprement dit en entraînant le modèle sur chaque partition dans une boucle, puis en enregistrant les résultats pour les analyser et les comparer.

La validation croisée k-fold est une méthode robuste pour tirer le meilleur parti des données disponibles et contribue à garantir que les performances de ton modèle sont fiables et cohérentes sur différents sous-ensembles de données. Elle permet d'obtenir un modèle plus généralisable et plus fiable, moins susceptible de surapprendre les motifs propres à certaines données.

Même si nous avons utilisé YOLO dans ce guide, n'oublie pas que ces étapes sont largement transposables à d'autres modèles de machine learning. En les comprenant, tu pourras appliquer efficacement la validation croisée à tes propres projets de machine learning.

FAQ#