Epoch

Une époque correspond à un passage complet d'un modèle d'apprentissage automatique sur l'ensemble de son jeu de données d'entraînement. Pendant une époque, chaque exemple d'entraînement contribue exactement une fois à la mise à jour des poids du modèle. Les modèles d'apprentissage profond apprennent rarement assez en un seul passage. L'entraînement se poursuit donc pendant de nombreuses époques, et l'erreur sur les données d'entraînement diminue généralement à chacune d'elles, à mesure que le réseau affine ses prédictions.

Époque, lot et itération#

Trois termes décrivent la structure d'un entraînement, chacun s'inscrivant dans le précédent :

• Époque : un passage complet sur le jeu de données d'entraînement.
• Lot : groupe d'exemples traités ensemble en une étape. Les jeux de données tiennent rarement tous à la fois dans la mémoire du GPU ; chaque époque est donc divisée en lots, généralement après avoir mélangé les données.
• Itération : une mise à jour des poids, effectuée après le calcul de la fonction de perte sur un lot et la propagation de ses gradients par rétropropagation. « Étape » est un synonyme.

Le nombre d'itérations par époque correspond à la taille du jeu de données divisée par la taille des lots, arrondie à l'entier supérieur. Avec 1 000 images et des lots de 100, il faut 10 itérations par époque ; 50 époques produisent donc 500 mises à jour des poids. Dans PyTorch, cette structure se présente sous la forme de deux boucles imbriquées : une boucle externe sur les époques et une boucle interne sur les lots servis par DataLoader.

import torch
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)

# 1,000 noisy samples of the line y = 3x + 2, served in shuffled batches of 100
x = torch.rand(1000, 1)
y = 3 * x + 2 + 0.1 * torch.randn(1000, 1)
loader = DataLoader(TensorDataset(x, y), batch_size=100, shuffle=True)

model = torch.nn.Linear(1, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(5):  # one epoch = one full pass over all 1,000 samples
    for xb, yb in loader:  # 1,000 / 100 = 10 iterations per epoch
        loss = torch.nn.functional.mse_loss(model(xb), yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch + 1}: {len(loader)} iterations, last batch loss {loss.item():.4f}")

Chaque époque comporte 10 itérations, et la perte sur le dernier lot passe de 0.1096 après la première époque à 0.0088 après la cinquième, tandis que le modèle converge vers la vraie droite. Lorsque l'entraînement utilise l'augmentation des données, chaque époque voit une version transformée différemment de chaque image, ce qui apporte de la variété au lieu de répéter exactement les mêmes images.

Choisir le nombre d'époques#

Le nombre d'époques est l'un des principaux paramètres du réglage des hyperparamètres. Trop peu d'époques conduisent au sous-apprentissage, avec une erreur élevée sur les données d'entraînement et de validation. Un nombre excessif mène au surapprentissage : la perte d'entraînement continue de diminuer tandis que le score de validation stagne ou baisse, car le modèle commence à mémoriser ses exemples d'entraînement. Le nombre approprié dépend de la taille du jeu de données, de celle du modèle, du calendrier du taux d'apprentissage et du fait que l'entraînement démarre ou non à partir de poids préentraînés par apprentissage par transfert. L'échelle change aussi la donne : les petits jeux de données de vision sont souvent utilisés pendant des centaines d'époques, tandis que les grands modèles de langage parcourent souvent leurs données moins d'une fois, et GPT-3 a effectué 0.44 époque sur ses données Common Crawl filtrées.

L'arrêt anticipé automatise ce choix. Le modèle est évalué sur les données de validation après chaque époque, le meilleur checkpoint est conservé et l'entraînement s'arrête dès que le score de validation n'a pas progressé pendant un nombre défini d'époques, appelé patience.

Calendriers d'entraînement fondés sur les époques#

Outre le point d'arrêt, de nombreux paramètres d'entraînement évoluent selon un calendrier en époques, notamment l'échauffement et la décroissance du taux d'apprentissage ou l'intensité de l'augmentation. Pour l'entraînement Ultralytics YOLO, epochs et patience sont tous deux réglés par défaut sur 100, le taux d'apprentissage s'échauffe pendant les 3 premières époques, et l'augmentation mosaïque est désactivée pendant les 10 dernières époques (close_mosaic=10) afin que le modèle termine son entraînement sur des images semblables aux entrées réelles. La recette d'entraînement YOLO26 montre à quel point le nombre d'époques varie selon la taille du modèle : après 150 époques de préentraînement sur Objects365, le réglage fin sur COCO a duré 245 époques pour YOLO26n et 40 pour YOLO26x.

from ultralytics import YOLO

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

# Entraîner pendant 50 époques : 50 passages complets sur les images d'entraînement COCO8
results = model.train(data="coco8.yaml", epochs=50, imgsz=640)

Pendant cet entraînement, l'entraîneur valide le modèle YOLO26 après chaque époque, écrase last.pt à chaque fois et enregistre best.pt dès que le score d'aptitude sur la validation, qui correspond à mAP_50-95 pour la détection, atteint un nouveau maximum.