Autograd

PyTorch autograd calcula automáticamente los gradientes de las salidas escalares con respecto a las entradas tensoriales. Potencia todo el entrenamiento de redes neuronales a través de la diferenciación automática en modo reverso.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

import torch
 
x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x
y.backward()
print(x.grad)  # dy/dx en x=2: 2*2+3 = 7
 
# Inferencia: sin seguimiento de gradientes
with torch.no_grad():
    pred = model(x)

Cuándo usar esto:

• Para entender por qué funcionan loss.backward() y optimizer.step().
• Para depurar el flujo de gradientes en capas o funciones de pérdida personalizadas.
• Para implementar funciones autograd personalizadas para operaciones no estándar.
• Para deshabilitar gradientes durante la inferencia o evaluación.

Ejemplo de Trabajo

"""autograd.py - cálculo de gradientes y verificación de gradientes."""
import torch
import torch.nn as nn
 
# Grafo de cómputo simple
w = torch.tensor([1.0, 2.0], requires_grad=True)
b = torch.tensor(0.5, requires_grad=True)
x = torch.tensor([3.0, 4.0])
 
# Adelante: y = w . x + b, loss = y^2
y = (w * x).sum() + b
loss = y ** 2
loss.backward()
 
print("w.grad:", w.grad)  # d(loss)/dw
print("b.grad:", b.grad)  # d(loss)/db
 
# Modelo con autograd
model = nn.Linear(3, 1)
x_batch = torch.randn(16, 3)
target = torch.randn(16, 1)
 
model.zero_grad(set_to_none=True)
pred = model(x_batch)
loss = nn.functional.mse_loss(pred, target)
loss.backward()
 
for name, param in model.named_parameters():
    print(f"{name}: grad norm = {param.grad.norm().item():.4f}")

Lo que esto demuestra:

• Los tensores hoja (w, b) acumulan gradientes en .grad.
• loss.backward() recorre el grafo en reversa.
• Los parámetros del modelo reciben gradientes automáticamente.
• zero_grad(set_to_none=True) limpia los gradientes de manera eficiente.

Profundización

Cómo Funciona

• Cada operación tensorial registra las entradas y la función de retroceso en un grafo de cómputo.
• backward() aplica la regla de la cadena desde la salida hacia las hojas.
• Solo los tensores con requires_grad=True acumulan .grad.
• Los gradientes de los tensores no hoja se liberan después de backward a menos que retain_graph=True.
• torch.inference_mode() es más estricto y rápido que no_grad() para la inferencia.

Controles de Gradiente

Notas de Python

# Función autograd personalizada
class MyReLU(torch.autograd.Function):
    @staticmethod
    def forward(ctx, input):
        ctx.save_for_backward(input)
        return input.clamp(min=0)
 
    @staticmethod
    def backward(ctx, grad_output):
        input, = ctx.saved_tensors
        grad_input = grad_output.clone()
        grad_input[input < 0] = 0
        return grad_input

Errores Comunes

• Olvidar zero_grad() - los gradientes se acumulan entre pasos. Solución: llama a optimizer.zero_grad(set_to_none=True) antes de cada backward.
• Llamar a backward dos veces sin retain_graph - el grafo se libera después de la primera llamada a backward. Solución: loss.backward(retain_graph=True) o pases hacia adelante separados.
• Operaciones in-place en tensores que necesitan gradiente - rompe el seguimiento de autograd. Solución: evita x.add_(1) en tensores rastreados; usa x = x + 1.
• Memoria de GPU por grafos guardados - mantener referencias a tensores de pérdida retiene el grafo. Solución: usa .item() para registrar; del loss después de backward.
• Gradientes en tensores enteros - solo los tensores de punto flotante/complejos soportan autograd. Solución: convierte a float antes de operaciones que necesiten gradientes.
• Mezclar numpy y torch - los cambios in-place de numpy en memoria compartida corrompen los gradientes. Solución: usa .detach().cpu().numpy() para exportar.

Alternativas

Preguntas Frecuentes

for name, p in model.named_parameters():
    if p.grad is None:
        print(f"no grad: {name}")

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

loss.backward(create_graph=True)
grad_grad = torch.autograd.grad(loss, model.parameters(), create_graph=True)

with torch.no_grad():
    features = frozen_encoder(x)
output = trainable_head(features)

Relacionado

• Fundamentos de PyTorch - fundamentos de tensores
• Bucles de Entrenamiento - backward en la práctica
• Construcción de Modelos con nn.Module - nn.Parameter
• Aprendizaje por Transferencia y Ajuste Fino - congelación de capas
• GPUs y Precisión Mixta - autocast y escalado de gradientes

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.