Gradient Checkpointing
O checkpointing de gradientes armazena apenas algumas ativações durante a passagem direta e recalcula as restantes durante a retropropagação, trocando computação por memória.
O checkpointing de gradientes é uma técnica de treino que poupa memória ao manter apenas algumas ativações intermédias da passagem direta e recalcular as restantes quando a retropropagação precisa delas. Também é chamado checkpointing de ativações ou rematerialização. Tianqi Chen, Bing Xu, Chiyuan Zhang e Carlos Guestrin popularizaram-no para a aprendizagem profunda no seu artigo de abril de 2016 Training Deep Nets with Sublinear Memory Cost, demonstrando que uma rede com n camadas pode ser treinada com memória proporcional a √n ao custo de uma passagem direta adicional. Numa rede residual de 1.000 camadas para ImageNet, o método reduziu a memória de 48 GB para 7 GB, com um aumento de cerca de 30% no tempo de treino.
Como funciona o checkpointing de gradientes#
Durante uma passagem direta normal, o motor autograd armazena a saída de quase todas as operações, porque o cálculo posterior dos gradientes precisa delas. Em redes profundas, lotes grandes, imagens de alta resolução ou sequências longas, estas ativações ocupam muito mais memória GPU do que os pesos do modelo. O checkpointing divide a rede em segmentos e mantém apenas a entrada de cada segmento. Quando a passagem inversa chega a um segmento, executa novamente a passagem direta desse segmento a partir da entrada guardada, propaga os gradientes através dele e liberta as ativações reconstruídas antes de avançar para o segmento anterior:
O PyTorch expõe esta funcionalidade como torch.utils.checkpoint.checkpoint, e o JAX, como jax.checkpoint. Contar as ativações armazenadas pelo autograd numa rede com oito blocos mostra a poupança e que os gradientes não mudam:
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))Imprime 72 MB de ativações armazenadas sem checkpointing, 8 MB com checkpointing e Identical gradients: True. Normalmente, cada bloco armazena 9 MB: a entrada de 1 MB mais dois tensores ocultos de 4 MB; com checkpointing, mantém apenas a entrada, e a passagem inversa reconstrói 9 MB de um bloco de cada vez.
Escolher o que recalcular#
O checkpointing de cada bloco poupa mais memória, mas repete quase toda a passagem direta, exigindo cerca de um terço mais de cálculo numa camada típica. O recálculo seletivo visa operações cujas saídas são grandes, mas baratas de calcular. Vijay Korthikanti, da NVIDIA, e colegas recalcularam apenas o núcleo da atenção transformer: o cálculo das pontuações, softmax, dropout e ponderação dos valores. Em conjunto com o paralelismo de sequências, reduziram a memória de ativações em cinco vezes e eliminaram mais de 90% da sobrecarga de recálculo. A atenção Flash aplica a mesma ideia dentro de um único kernel, recalculando as pontuações de atenção durante a passagem inversa em vez de as armazenar. O GPipe armazena ativações apenas nos limites entre estágios de paralelismo de pipeline e recalcula tudo dentro de cada estágio.
O recálculo tem de reproduzir exatamente a passagem direta original. O PyTorch restaura o estado do gerador de números aleatórios para que as máscaras de dropout coincidam, e os modelos Transformers do Hugging Face desativam a cache KV quando são treinados com checkpointing ativado, porque o estado de inferência em cache entra em conflito com a nova execução das camadas.
Técnicas de memória relacionadas#
- Acumulação de gradientes: Divide um lote grande em microlotes que são executados um de cada vez, reduzindo as ativações por passo sem cálculo adicional, mas acrescentando passos.
- Precisão mista: Armazena ativações em formatos de 16 bits, como BF16, reduzindo para metade a memória ocupada e, normalmente, acelerando o treino.
- Pontos de controlo do treino: Ficheiros de pesos e do estado do otimizador guardados para retomar o treino ou fazer a implementação; trata-se de um uso não relacionado da palavra.
O checkpointing é comum ao ajustar modelos de linguagem grandes (LLMs) numa única GPU, onde o Trainer do Hugging Face o ativa com gradient_checkpointing=True, e ao treinar modelos de segmentação de imagens com imagens médicas ou aéreas grandes, cujos mapas de características ocupam a maior parte da memória. O treino do Ultralytics YOLO26 armazena todas as ativações e adapta-se à memória através do tamanho do lote: batch=-1 no modo de treino executa o AutoBatch, que analisa a memória com vários tamanhos de lote e escolhe aquele que deverá ocupar 60% da memória da GPU; uma fração como batch=0.70 define essa meta como 70%.










