Gradient Accumulation

L’accumulation des gradients est une technique d’entraînement qui exécute plusieurs petits lots, appelés micro-lots, lors de la propagation avant et de la rétropropagation, additionne leurs gradients, puis met à jour les poids du modèle. La mise à jour approche une étape effectuée sur un lot aussi grand que l’ensemble des micro-lots, alors que le GPU ne conserve en mémoire que les activations d’un seul micro-lot à la fois. Cette méthode permet à un appareil limité en mémoire d’utiliser la taille de lot prévue par une configuration, sans réduire la résolution des images ni la taille du modèle. La taille effective du lot correspond à la taille d’un micro-lot multipliée par le nombre d’étapes d’accumulation et le nombre d’appareils. Ainsi, des micro-lots de 4 images accumulés sur 8 étapes avec 4 GPU équivalent à un lot de 128 images.

Fonctionnement de l’accumulation des gradients#

Dans PyTorch et la plupart des autres frameworks, chaque appel à backward() ajoute de nouveaux gradients à ceux déjà stockés dans les paramètres, au lieu de les remplacer. L’accumulation exploite directement ce comportement : exécute la propagation avant et la rétropropagation pour chaque micro-lot, appelle l’optimiseur une fois le nombre défini de micro-lots atteint, puis efface les gradients et commence la fenêtre suivante :

La plupart des fonctions de perte calculent une moyenne sur les exemples d’un lot. Il faut donc diviser la perte de chaque micro-lot par le nombre d’étapes pour transformer la somme des gradients en moyenne. Avec cette mise à l’échelle, quatre micro-lots de 8 produisent le même gradient qu’un lot de 32 :

import torch
from torch import nn

torch.manual_seed(0)
model = nn.Linear(16, 1)
x, y = torch.randn(32, 16), torch.randn(32, 1)
loss_fn = nn.MSELoss()

# Reference: one batch of 32 samples
loss_fn(model(x), y).backward()
batch_grad = model.weight.grad.clone()
model.zero_grad()

# Four micro-batches of 8: backward() adds into .grad, and dividing each loss by 4 turns the sum into a mean
steps = 4
for x_micro, y_micro in zip(x.chunk(steps), y.chunk(steps)):
    (loss_fn(model(x_micro), y_micro) / steps).backward()

print("Matches the full-batch gradient:", torch.allclose(model.weight.grad, batch_grad, atol=1e-6))
print(f"Largest difference: {(model.weight.grad - batch_grad).abs().max():.1e}")

Il affiche Matches the full-batch gradient: True, avec une différence maximale de 1.6e-07 due aux arrondis en virgule flottante lorsqu’on additionne les mêmes nombres dans un ordre différent.

En quoi l’accumulation diffère d’un grand lot#

L’équivalence tient pour les fonctions de perte qui calculent la moyenne d’échantillons indépendants, mais elle est rompue dans trois cas courants :

• Normalisation par lot : calcule sa moyenne et sa variance sur chaque micro-lot ; les statistiques de 4 images sont donc plus bruitées que celles de 128.
• Séquences de longueur variable : lorsqu’un modèle de langage calcule la moyenne de sa perte sur les jetons de chaque micro-lot, les micro-lots contenant peu de jetons ont le même poids que les longs.
• Écrêtage du gradient : s’applique une seule fois au gradient accumulé, juste avant l’étape de l’optimiseur ; l’appliquer à chaque micro-lot modifie le résultat.

Hugging Face et Unsloth ont corrigé l’incohérence du nombre de jetons en octobre 2024 pour le réglage fin des grands modèles de langage (LLM), en divisant la somme des pertes par le nombre total de jetons de toute la fenêtre d’accumulation. L’accumulation n’accélère pas non plus l’entraînement : le même nombre d’échantillons traverse toujours le réseau, un micro-lot à la fois, et les petits micro-lots utilisent moins efficacement le GPU. En entraînement distribué, le DistributedDataParallel de PyTorch propose un contexte no_sync() qui ignore la réduction globale des gradients pour tous les micro-lots sauf le dernier, ce qui réduit les communications. Une taille de lot effective plus grande nécessite généralement un taux d’apprentissage plus élevé : des chercheurs de Facebook ont entraîné ResNet-50 sur ImageNet en une heure avec des lots de 8 192 images sur 256 GPU, en augmentant linéairement le taux d’apprentissage avec la taille du lot et en le faisant monter progressivement au début.

Techniques connexes#

• Vérification de gradient : recalcule les activations pendant la rétropropagation au lieu de les stocker, ce qui réduit la mémoire nécessaire pour chaque micro-lot au prix d’un calcul supplémentaire.
• Précision mixte : stocke les activations dans des formats 16 bits, ce qui permet d’utiliser des micro-lots plus grands. Son facteur de mise à l’échelle de la perte remet les gradients à l’échelle une fois, après le dernier micro-lot.
• Parallélisme en pipeline : divise chaque lot en micro-lots qui traversent des étapes du modèle exécutées sur différents GPU, puis accumule leurs gradients avant une seule étape de l’optimiseur.

Par défaut, l’entraînement Ultralytics YOLO26 accumule les gradients : en mode entraînement, l’entraîneur met à jour l’optimiseur toutes les round(nbs / batch) fournies. Les valeurs par défaut batch=16 et la taille de lot nominale nbs=64 produisent donc quatre lots par mise à jour, et batch=8 en produit huit. Le nombre augmente progressivement à partir de un pendant la phase d’échauffement, et la décroissance des poids est mise à l’échelle par batch × accumulation / nbs ; les hyperparamètres par défaut, prévus pour un lot de 64 images, restent donc adaptés même sur un GPU qui ne peut contenir que quelques images à la fois.