Batch Size

La taille du lot correspond au nombre d’exemples d’entraînement qu’un modèle traite ensemble avant de mettre à jour ses poids. Au lieu de faire passer l’ensemble du jeu de données d’entraînement dans un réseau neuronal d’un seul coup, l’entraînement le divise en lots. Pour chaque lot, le modèle effectue des prédictions, la fonction de perte les évalue, la rétropropagation calcule les gradients et l’optimiseur effectue un pas. La taille du lot est un hyperparamètre qui détermine à la fois la quantité de mémoire GPU nécessaire à l’entraînement, la durée de chaque époque et le niveau de bruit de chaque estimation du gradient.

Effet de la taille du lot sur l’entraînement#

Chaque lot fournit à l’algorithme d’optimisation une estimation du gradient sur l’ensemble du jeu de données, et cette estimation devient plus précise à mesure que le lot augmente. L’extrait de code PyTorch ci-dessous mesure directement cette précision en calculant la moyenne des gradients par échantillon sur de nombreux lots aléatoires de chaque taille :

import torch

torch.manual_seed(0)

# Per-sample gradients of a squared-error loss for 10,000 samples
x = torch.randn(10_000)
y = 2 * x + torch.randn(10_000)
w = torch.tensor(0.0)
per_sample_grads = 2 * (w * x - y) * x

# Estimate the gradient from 1,000 random batches at each batch size
for batch_size in (8, 64, 512):
    idx = torch.randint(0, len(x), (1000, batch_size))
    batch_grads = per_sample_grads[idx].mean(dim=1)
    print(f"batch {batch_size:3d}: gradient std {batch_grads.std():.3f}")

La dispersion de l’estimation du gradient passe de 2.248 avec une taille de lot de 8 à 0.771 avec 64 et 0.267 avec 512. Chaque multiplication par 8 de la taille du lot réduit le bruit d’environ 2.9 fois, ce qui est proche de la racine carrée de 8 et correspond au comportement de la moyenne d’échantillons indépendants.

Ce bruit façonne le compromis entre petits et grands lots :

• Petits lots (par exemple, de 8 à 32) : mises à jour bruitées et nombreuses étapes par époque. Le bruit agit comme un léger régularisateur qui aide souvent la descente de gradient stochastique (SGD) à mieux généraliser. Les petits lots conviennent aussi au matériel modeste, mais chaque époque dure plus longtemps, car le GPU reste partiellement inactif.
• Grands lots (par exemple, à partir de 256) : gradients lisses, moins d’étapes par époque et forte utilisation du matériel. Les très grands lots tendent à converger vers des minima pointus qui généralisent moins bien, comme l’ont montré Keskar et ses collègues. Comme ils comportent moins d’étapes par époque, ils nécessitent un taux d’apprentissage proportionnellement plus élevé et une période de montée en charge. En appliquant cette règle de mise à l’échelle linéaire, Goyal et ses collègues ont entraîné ResNet-50 sur ImageNet avec un lot de 8 192 images réparti sur 256 GPU en une heure, tout en obtenant la même précision qu’avec un entraînement à petits lots.

Limites de mémoire et accumulation des gradients#

La mémoire du GPU doit contenir les poids du modèle, l’état de l’optimiseur et les activations intermédiaires nécessaires à la rétropropagation. La mémoire requise pour les activations augmente de façon linéaire avec la taille du lot et la résolution des images. Si un lot ne tient pas en mémoire, l’entraînement s’arrête avec une erreur de mémoire insuffisante (OOM). L’entraînement en précision mixte réduit environ de moitié la mémoire nécessaire aux activations, et l’accumulation des gradients permet d’obtenir un lot effectif plus grand en additionnant les gradients de plusieurs petits lots avant chaque mise à jour des poids.

L’entraînement Ultralytics YOLO intègre cette fonctionnalité : il accumule les gradients jusqu’à avoir traité environ 64 images, la taille nominale du lot nbs, si bien qu’après la phase de montée en charge, la valeur par défaut batch=16 déclenche une mise à jour des poids toutes les quatre itérations. Définir batch=-1 lance AutoBatch, qui choisit le plus grand lot pouvant tenir dans environ 60 % de la mémoire CUDA disponible et revient à une taille de lot de 16 sur les appareils CPU et Apple MPS.

from ultralytics import YOLO

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

# batch=-1 laisse AutoBatch choisir la taille du lot en fonction de la mémoire GPU disponible
# Utilise un entier (batch=16) pour une taille fixe ou un flottant (batch=0.70) pour une fraction de la mémoire
results = model.train(data="coco8.yaml", epochs=5, batch=-1)

Avant le début de l’entraînement, AutoBatch exécute le modèle YOLO26 avec des tailles de lot allant de 1 à 16 (jusqu’à 64 sur les GPU ayant au moins 16 Go), ajuste une droite aux mesures de mémoire, puis résout l’équation pour trouver la taille de lot correspondant à la fraction cible.

La taille du lot et les termes associés#

• Époque et itération : une époque correspond à un passage sur l’ensemble du jeu de données, et une itération à une mise à jour des poids. Le nombre d’itérations par époque correspond à la taille du jeu de données divisée par la taille du lot, arrondie à l’entier supérieur. Ainsi, 1 000 images avec un lot de 100 nécessitent 10 itérations.
• Mini-lot : synonyme de lot dans la plupart des textes sur l’apprentissage profond. Au sens strict, la descente de gradient par lots utilise l’ensemble du jeu de données à chaque mise à jour, la descente de gradient stochastique utilise un seul exemple et la descente de gradient par mini-lots se situe entre les deux ; c’est ainsi que s’entraînent presque tous les réseaux modernes.
• Normalisation par lots : couche qui normalise les activations à partir de la moyenne et de la variance du lot actuel. Ses statistiques deviennent donc peu fiables avec des lots très petits. La normalisation par groupes évite cette dépendance et a réduit de 10,6 % l’erreur de ResNet-50 sur ImageNet par rapport à la normalisation par lots, avec une taille de lot de 2.
• Taille de lot pour l’inférence : lors du déploiement, le traitement par lots établit un compromis entre le temps de latence de l’inférence et le débit. Regrouper les images provenant de plusieurs caméras augmente le nombre d’images traitées par seconde, mais chaque image attend que son lot soit complet.