Gradient Checkpointing
Le checkpointing des gradients ne conserve que certaines activations lors de la passe avant et recalcule les autres pendant la rétropropagation, au prix d’un calcul plus important pour réduire l’utilisation mémoire.
Le checkpointing des gradients est une technique d’entraînement qui économise de la mémoire en conservant seulement quelques activations intermédiaires de la passe avant et en recalculant les autres lorsque la rétropropagation en a besoin. On l’appelle aussi checkpointing des activations ou rematérialisation. Tianqi Chen, Bing Xu, Chiyuan Zhang et Carlos Guestrin l’ont popularisé pour l’apprentissage profond dans leur article d’avril 2016, Training Deep Nets with Sublinear Memory Cost, montrant qu’un réseau de n couches peut être entraîné avec une mémoire proportionnelle à √n, au prix d’une passe avant supplémentaire. Sur un réseau résiduel de 1 000 couches pour ImageNet, leur méthode a réduit la mémoire de 48 GB à 7 GB, avec un temps d’entraînement supérieur d’environ 30 %.
Fonctionnement du checkpointing des gradients#
Lors d’une passe avant normale, le moteur autograd stocke la sortie de presque chaque opération, car leur calcul est nécessaire ensuite pour obtenir les gradients. Pour les réseaux profonds, les grands lots, les images haute résolution ou les longues séquences, ces activations occupent bien plus de mémoire GPU que les poids du modèle. Le checkpointing divise le réseau en segments et ne conserve que l’entrée de chaque segment. Lorsque la passe arrière atteint un segment, elle réexécute sa passe avant à partir de l’entrée enregistrée, effectue la rétropropagation, puis libère les activations reconstruites avant de passer au segment précédent :
PyTorch expose cette fonctionnalité sous torch.utils.checkpoint.checkpoint, et JAX sous jax.checkpoint. Le comptage des activations stockées par autograd pour un réseau de huit blocs met en évidence les économies et montre que les gradients ne changent pas :
import torch
from torch import nn
from torch.utils.checkpoint import checkpoint
torch.manual_seed(0)
model = nn.Sequential(*[nn.Sequential(nn.Linear(1024, 4096), nn.GELU(), nn.Linear(4096, 1024)) for _ in range(8)])
x = torch.randn(256, 1024)
weights = {p.data_ptr() for p in model.parameters()}
saved, grads = [], []
for use_checkpoint in (False, True):
saved.clear()
# Record every tensor autograd keeps for the backward pass
with torch.autograd.graph.saved_tensors_hooks(lambda t: saved.append(t) or t, lambda t: t):
h = x
for block in model: # a checkpointed block keeps only its input and reruns its forward pass in backward
h = checkpoint(block, h, use_reentrant=False) if use_checkpoint else block(h)
h.square().mean().backward()
activations = sum(t.numel() * t.element_size() for t in saved if t.data_ptr() not in weights)
print(f"checkpoint={use_checkpoint}: {activations / 2**20:.0f} MB of stored activations")
grads.append(model[0][0].weight.grad.clone())
model.zero_grad()
print("Identical gradients:", torch.equal(*grads))Le résultat affiche 72 MB d’activations stockées sans checkpointing, 8 MB avec cette technique, puis Identical gradients: True. Chaque bloc stocke normalement 9 MB : son entrée de 1 MB plus deux tenseurs cachés de 4 MB. Avec le checkpointing, seule l’entrée est conservée et la passe arrière reconstruit les 9 MB d’un bloc à la fois.
Choisir ce qu’il faut recalculer#
Le checkpointing de chaque bloc économise le plus de mémoire, mais relance presque toute la passe avant, ce qui ajoute environ un tiers de calcul pour une couche typique. Le recalcul sélectif cible les opérations dont les sorties sont volumineuses, mais peu coûteuses à calculer. Vijay Korthikanti, de NVIDIA, et ses collègues n’ont recalculé que le cœur de l’attention Transformer — le calcul des scores, softmax, dropout et pondération des valeurs — et, en combinant cette méthode au parallélisme de séquence, ont réduit la mémoire des activations d’un facteur cinq tout en éliminant plus de 90 % du surcoût de recalcul. Flash attention applique la même idée dans un seul noyau en recalculant les scores d’attention pendant la passe arrière au lieu de les stocker. GPipe ne stocke les activations qu’aux frontières des étapes du parallélisme de pipeline et recalcule tout à l’intérieur de chaque étape.
Le recalcul doit reproduire exactement la passe avant d’origine. PyTorch restaure l’état du générateur de nombres aléatoires afin que les masques de dropout correspondent. Les modèles Transformers de Hugging Face désactivent leur cache KV lorsqu’ils sont entraînés avec le checkpointing, car l’état de mise en cache de l’inférence entre en conflit avec la réexécution des couches.
Techniques connexes de gestion de la mémoire#
- Accumulation des gradients : Divise un grand lot en micro-lots exécutés l’un après l’autre. Cela réduit le nombre d’activations par étape sans calcul supplémentaire, mais ajoute des étapes.
- Précision mixte : Stocke les activations dans des formats 16 bits comme BF16, ce qui divise par deux leur occupation mémoire et accélère généralement l’entraînement.
- Points de contrôle d’entraînement : Fichiers contenant les poids et l’état de l’optimiseur, enregistrés pour reprendre l’entraînement ou déployer le modèle ; il s’agit d’un autre sens du terme.
Le checkpointing est courant lors du réglage fin de grands modèles de langage (LLM) sur un seul GPU, où Trainer de Hugging Face l’active avec gradient_checkpointing=True, ainsi que lors de l’entraînement de modèles de segmentation d’images sur de grandes images médicales ou aériennes dont les cartes de caractéristiques dominent l’utilisation mémoire. L’entraînement d’Ultralytics YOLO26 stocke toutes les activations et ajuste leur occupation au moyen de la taille de lot : batch=-1 en mode entraînement exécute AutoBatch, qui mesure l’utilisation mémoire pour plusieurs tailles de lot et choisit celle dont on prévoit qu’elle remplira 60 % de la mémoire GPU. Une fraction telle que batch=0.70 définit cette cible à 70 %.










