Training Data

Les données d’entraînement sont l’ensemble des exemples à partir desquels un modèle d’apprentissage automatique apprend. Pendant l’entraînement, un optimiseur ajuste à plusieurs reprises les poids du modèle pour réduire son erreur sur ces exemples, qui définissent donc ce que le modèle peut apprendre. En apprentissage supervisé, chaque exemple associe une entrée à la bonne réponse, par exemple une photo de rue avec une boîte englobante et un nom de classe pour chaque voiture et chaque piéton. L’apprentissage auto-supervisé et l’apprentissage non supervisé s’effectuent sur des entrées brutes sans étiquettes. « Jeu d’entraînement » est un synonyme ; dans la plupart des projets, il s’agit de la plus grande partition des données disponibles, qui en représente souvent 70 à 80 %.

Comment les modèles utilisent les données d’entraînement#

Un modèle traite ses données d’entraînement par lots. Pour chaque lot, il produit des prédictions, une fonction de perte mesure leur écart par rapport aux étiquettes, la rétropropagation calcule la contribution de chaque poids à l’erreur, puis l’optimiseur ajuste légèrement les poids pour la réduire. Un passage complet sur le jeu d’entraînement constitue une époque, et l’entraînement dure généralement de quelques dizaines à quelques centaines d’époques.

Comme le modèle est optimisé sur ces exemples précis, son score sur ceux-ci surestime ses performances sur de nouvelles données. Deux partitions mises à l’écart corrigent ce biais. Les données de validation sont évaluées pendant le développement pour choisir les hyperparamètres et les points de contrôle, tandis que les données de test sont évaluées une seule fois à la fin pour estimer les performances en conditions réelles. Un grand écart entre les scores d’entraînement et de validation signale un surapprentissage : le modèle mémorise les exemples d’entraînement au lieu d’apprendre des motifs qui se généralisent. De mauvais scores sur les deux partitions signalent un sous-apprentissage. Les partitions ne doivent pas partager d’images : des images quasi identiques extraites d’une même vidéo ou des examens d’un même patient répartis des deux côtés provoquent une fuite de données et gonflent tous les scores obtenus sur les partitions mises à l’écart.

Quantité, qualité et couverture#

Trois caractéristiques d’un jeu d’entraînement déterminent la capacité de généralisation d’un modèle :

• Quantité : Un plus grand nombre d’exemples est utile, avec des rendements décroissants. Partir d’un modèle préentraîné grâce à l’apprentissage par transfert réduit le nombre d’exemples annotés nécessaires à une nouvelle tâche.
• Qualité : Chaque étiquette erronée, manquante ou tracée de façon incohérente enseigne quelque chose de faux au modèle. Des consignes cohérentes d’annotation des données sont aussi importantes que le nombre d’étiquettes.
• Couverture : Les exemples doivent couvrir les conditions auxquelles le modèle sera confronté, notamment l’éclairage, la météo, les angles de caméra, les arrière-plans et les classes rares. Un détecteur entraîné uniquement sur des images diurnes échoue la nuit ; si les lacunes suivent des lignes démographiques, comme l’absence de certaines carnations dans un jeu de données de visages, elles deviennent un biais du jeu de données.

Le script scikit-learn ci-dessous entraîne le même classificateur sur le jeu de données intégré de chiffres manuscrits, avec différentes tailles de jeux d’entraînement, puis évalue chaque modèle sur une même partition de test fixe :

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# 1,797 labeled 8x8 digit images; hold out 30% to score every model
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0, stratify=y)

# Reassign 30% of the training labels at random to simulate careless labeling
rng = np.random.default_rng(0)
y_noisy = y_train.copy()
flip = rng.random(len(y_train)) < 0.3
y_noisy[flip] = rng.integers(0, 10, flip.sum())

# Train the same model on three different training sets
for name, n, labels in [("50 clean", 50, y_train), ("1,257 clean", 1257, y_train), ("1,257 noisy", 1257, y_noisy)]:
    model = LogisticRegression(max_iter=5000).fit(X_train[:n], labels[:n])
    print(f"{name}: test accuracy {model.score(X_test, y_test):.3f}")

L’augmentation du jeu d’entraînement propre de 50 à 1,257 images fait passer la précision sur le jeu de test de 0.863 à 0.961. L’exécution avec bruit, où 315 des 1,257 étiquettes (25 %) sont erronées, obtient un score de 0.861, pas meilleur que celui du modèle entraîné sur 50 images propres.

Créer un jeu d’entraînement#

Les équipes réunissent des données d’entraînement à partir de jeux de données publics, de leurs propres caméras et journaux, et de plus en plus souvent de données synthétiques. Les références publiques constituent un bon point de départ : le jeu de données COCO fournit 118,287 images d’entraînement annotées pour la détection, la segmentation et le sous-titrage. Les collections brutes passent ensuite par un nettoyage des données afin de supprimer les doublons, les fichiers corrompus et les images hors sujet, puis par l’annotation et la révision. L’augmentation des données multiplie la variété du résultat pendant l’entraînement grâce aux retournements, aux recadrages, aux modifications de couleurs et aux mosaïques ; elle ne peut toutefois que recombiner les éléments collectés, et il faut donc toujours photographier les conditions manquantes.

Ultralytics YOLO lit les données d’entraînement à partir du chemin train d’un fichier YAML de jeu de données et associe chaque image à un fichier d’étiquettes .txt contenant une ligne par objet : un indice de classe suivi du centre, de la largeur et de la hauteur de la boîte, normalisés par rapport à la taille de l’image. Le même format de jeu de données YOLO s’applique à toutes les partitions ; pour les rééquilibrer, il faut donc déplacer les images et leurs fichiers d’étiquettes entre les dossiers.

from ultralytics import YOLO

# Charger un modèle nano YOLO26 pré-entraîné
model = YOLO("yolo26n.pt")

# coco8.yaml répertorie les images d’entraînement (train: images/train) et les images de validation (val: images/val)
results = model.train(data="coco8.yaml", epochs=5)

Le modèle YOLO26 affine son entraînement sur les quatre images d’entraînement de COCO8, un minuscule échantillon qui permet de vérifier qu’un pipeline d’entraînement fonctionne de bout en bout.

Les données d’entraînement et les termes apparentés#

• Données de validation : Une partition mise à l’écart qui guide les décisions pendant le développement, par exemple le moment où arrêter l’entraînement. Le modèle ne met jamais ses poids à jour à partir de ces données.
• Données de test : Une partition mise à l’écart, évaluée une seule fois à la fin, dont le résultat fournit une estimation non biaisée des performances sur de nouvelles données.
• Vérité terrain : Les réponses correctes associées aux exemples. En apprentissage supervisé, les données d’entraînement comprennent la vérité terrain, mais toutes les partitions en ont besoin pour être évaluées.
• Jeu de données de référence : Petit ensemble vérifié par des experts, utilisé comme référence fiable pour l’évaluation et le contrôle de la qualité de l’annotation.
• Jeu de données de référence : Jeu de données public avec des partitions fixes, utilisé pour comparer les modèles. Sa partition d’entraînement sert souvent aussi de données de préentraînement, et sa partition de validation devient le classement, comme la partition val2017 de COCO, qui contient 5 000 images et sur laquelle de nombreux articles sur la détection publient leurs résultats en mAP.