Gradient Checkpointing
El checkpointing de gradientes almacena solo algunas activaciones durante la propagación hacia delante y vuelve a calcular las demás durante la retropropagación, intercambiando cómputo por memoria.
El checkpointing de gradientes es una técnica de entrenamiento que ahorra memoria al conservar solo unas pocas activaciones intermedias del pase hacia delante y volver a calcular el resto cuando la retropropagación las necesita. También se conoce como checkpointing de activaciones o rematerialización. Tianqi Chen, Bing Xu, Chiyuan Zhang y Carlos Guestrin popularizaron esta técnica para el aprendizaje profundo en su artículo de abril de 2016, Training Deep Nets with Sublinear Memory Cost, donde mostraron que una red de n capas puede entrenarse con un uso de memoria proporcional a √n a cambio de un pase hacia delante adicional. En una red residual de 1.000 capas para ImageNet, su método redujo la memoria de 48 GB a 7 GB con un aumento del tiempo de entrenamiento de alrededor del 30 %.
Cómo funciona el checkpointing de gradientes#
Durante un pase hacia delante normal, el motor autograd almacena la salida de casi todas las operaciones, porque después necesita esos valores para calcular los gradientes. En las redes profundas, los lotes grandes, las imágenes de alta resolución o las secuencias largas, estas activaciones ocupan mucha más memoria de la GPU que los pesos del modelo. El checkpointing divide la red en segmentos y conserva solo la entrada de cada segmento. Cuando el pase hacia atrás llega a un segmento, vuelve a ejecutar el pase hacia delante de ese segmento a partir de la entrada guardada, calcula la retropropagación y libera las activaciones reconstruidas antes de pasar al segmento anterior:
PyTorch ofrece esta función como torch.utils.checkpoint.checkpoint y JAX, como jax.checkpoint. Contar las activaciones que almacena autograd en una red de ocho bloques muestra el ahorro y que los gradientes no cambian:
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 activaciones almacenadas sin checkpointing, 8 MB con checkpointing y Identical gradients: True. Cada bloque almacena normalmente 9 MB: su entrada de 1 MB más dos tensores ocultos de 4 MB; con checkpointing solo conserva la entrada, y el pase hacia atrás reconstruye 9 MB de un bloque cada vez.
Cómo elegir qué volver a calcular#
Aplicar checkpointing a cada bloque ahorra la mayor cantidad de memoria, pero vuelve a ejecutar casi todo el pase hacia delante, lo que supone aproximadamente un tercio más de cómputo en una capa típica. La recomputación selectiva se centra en operaciones cuyas salidas son grandes, pero cuyo cálculo es barato. Vijay Korthikanti, de NVIDIA, y sus colegas volvieron a calcular únicamente el núcleo de la atención transformer: el cálculo de puntuaciones, softmax, dropout y ponderación de los valores. Al combinarlo con el paralelismo de secuencias, redujeron cinco veces la memoria de activaciones y eliminaron más del 90 % de la sobrecarga de recomputación. Flash attention aplica la misma idea dentro de un único kernel, recalculando las puntuaciones de atención durante el pase hacia atrás en lugar de almacenarlas. GPipe almacena las activaciones solo en los límites entre las etapas del paralelismo de canalización y vuelve a calcular todo lo que hay dentro de cada etapa.
La recomputación debe reproducir exactamente el pase hacia delante original. PyTorch restaura el estado del generador de números aleatorios para que coincidan las máscaras de dropout, y los modelos Transformers de Hugging Face desactivan su caché KV al entrenar con checkpointing, ya que el estado de inferencia en caché entra en conflicto con la repetición de las capas.
Técnicas de memoria relacionadas#
- Acumulación de gradientes: Divide un lote grande en minilotes que se procesan de uno en uno, lo que reduce las activaciones por paso sin añadir cómputo, pero aumenta el número de pasos.
- Precisión mixta: Almacena las activaciones en formatos de 16 bits, como BF16, lo que reduce a la mitad la memoria que ocupan y suele acelerar el entrenamiento.
- Puntos de control de entrenamiento: Archivos de pesos y del estado del optimizador que se guardan para reanudar el entrenamiento o desplegar el modelo; se trata de un uso distinto de la palabra.
El checkpointing es habitual al ajustar modelos de lenguaje grandes (LLM) en una sola GPU, donde Trainer de Hugging Face lo activa con gradient_checkpointing=True, y al entrenar modelos de segmentación de imágenes con imágenes médicas o aéreas grandes, cuyas mapas de características ocupan la mayor parte de la memoria. El entrenamiento de Ultralytics YOLO26 almacena todas las activaciones y ajusta el tamaño del lote para que quepan: batch=-1 en modo de entrenamiento ejecuta AutoBatch, que perfila la memoria con varios tamaños de lote y elige el que, según la predicción, ocupará el 60 % de la memoria de la GPU. Una fracción como batch=0.70 fija ese objetivo en el 70 %.










