Backpropagation

Definición

El backpropagation (retropropagación) es el algoritmo central que permite entrenar redes neuronales profundas. Su trabajo: calcular, para cada uno de los miles de millones de parámetros del modelo, cuánto debe cambiar y en qué dirección para reducir el error. Lo hace propagando los gradientes desde la salida hacia atrás a través de todas las capas, usando la regla de la cadena del cálculo diferencial.

Sin backpropagation, no existirían los LLMs, ni los modelos de visión, ni los transformers, ni los diffusion models. Es el algoritmo invisible que hace que el deep learning funcione. Cada vez que un modelo "aprende algo", está pasando por billones de aplicaciones de backpropagation.

Su importancia es difícil de exagerar: el deep learning como disciplina existe porque tenemos un método práctico para entrenar redes profundas, y ese método es backpropagation + gradient descent. Sin estos dos, toda la revolución actual de la IA sería imposible.

Cómo funciona

El ciclo de entrenamiento estándar tiene cuatro fases:

1. Forward pass: pasas un batch de datos por la red. Cada capa transforma los datos. Al final obtienes una predicción.

2. Cálculo del loss: comparas la predicción con la respuesta correcta. La diferencia es el "error" o loss. Una función de loss común en LLMs es cross-entropy.

3. Backward pass (backpropagation): calculas, para cada parámetro de cada capa, la derivada parcial del loss con respecto a ese parámetro. Esto se hace propagando los gradientes hacia atrás capa por capa, usando la regla de la cadena:

   ∂L/∂w_capa_n = ∂L/∂output × ∂output/∂capa_n × ∂capa_n/∂w_capa_n
   

4. Actualización (gradient descent): ajustas cada parámetro en la dirección opuesta al gradiente, escalado por un learning rate:

   w_nuevo = w_viejo − learning_rate × gradiente
   

Repites el ciclo billones de veces con distintos batches. El modelo va mejorando: error baja, calidad sube.

Intuición sin matemáticas

Imagina que estás bajando una montaña con niebla. No ves el fondo del valle, pero sí puedes sentir bajo tus pies la pendiente del terreno.

• Forward pass: estás en una posición, miras dónde estás.
• Loss: tu altura sobre el nivel del mar.
• Backward pass: calculas la pendiente del terreno bajo tus pies (¿hacia dónde baja?).
• Update: das un paso pequeño en la dirección de la pendiente descendente.

Repites millones de veces. Acabas en el fondo del valle (mínimo local del loss). En entrenar una red neuronal, la "montaña" es el espacio de los miles de millones de parámetros y el "valle" es la configuración donde el error es mínimo.

La importancia de la diferenciación automática

La magia técnica de backprop moderno es que no calculas las derivadas a mano. Los frameworks (PyTorch, JAX, TensorFlow) construyen un grafo computacional durante el forward pass y luego lo recorren al revés calculando gradientes automáticamente. Esto se llama autodiff (automatic differentiation).

# PyTorch, simplificado
y = model(x)              # forward pass
loss = criterion(y, label)
loss.backward()           # backpropagation completa, una sola línea
optimizer.step()          # update con gradient descent

Sin autodiff, implementar el backprop de un transformer de 64 capas con 96 cabezas de atención sería un infierno. Con autodiff, son tres líneas de código.

Ejemplo práctico

Imaginemos entrenar un pequeño clasificador de defectos en piezas industriales para IMDICA con una red simple:

1. Forward: imagen de pieza → red de 5 capas → predicción "OK" (90% prob) cuando la respuesta correcta es "DEFECTUOSA".
2. Loss: cross-entropy con la etiqueta verdadera → loss alto (ej: 2.3).
3. Backward: el algoritmo calcula que para reducir ese loss, los pesos de la última capa deben moverse en cierta dirección, los de la penúltima en otra, etc. Esto se hace propagando el error capa por capa hacia atrás.
4. Update: cada peso se ajusta un poquito (learning rate típico: 0.0001-0.001).

Tras miles de iteraciones, el modelo empieza a predecir "DEFECTUOSA" correctamente. Cada paso ha sido un ciclo de backprop.

A escala de un LLM como Llama 3 70B: cada step procesa 4 millones de tokens, calcula gradientes de 70.000 millones de parámetros, y actualiza. Esto se repite 500.000+ veces. Por eso entrenar cuesta semanas y millones de €.

Problemas clásicos del backpropagation

A pesar de su elegancia, backprop tiene problemas conocidos:

• Vanishing gradients: en redes muy profundas, el gradiente se reduce a casi cero al llegar a las primeras capas → no aprenden. Mitigado con ReLU, residual connections (clave en transformers), layer normalization.
• Exploding gradients: lo contrario. Mitigado con gradient clipping.
• Mínimos locales: backprop te lleva a un mínimo local del loss, no necesariamente al global. En la práctica, el "mínimo local" suele ser bastante bueno.
• Saddle points: zonas planas en el espacio de loss donde el gradiente es casi cero. Solucionado por optimizadores modernos (Adam, AdamW).
• Memory cost: el grafo computacional debe mantenerse en memoria durante el forward para hacer el backward. En transformers grandes, esto consume decenas de GB por GPU.
• Sequential: backprop es inherentemente secuencial capa por capa, lo cual limita paralelización en algunos contextos.

Variantes y avances modernos

• Gradient checkpointing: para ahorrar memoria, recomputas activaciones en lugar de guardarlas. Trade-off compute/memoria.
• Mixed precision (BF16, FP16, FP8): gradientes calculados en precisión reducida → menos memoria, más velocidad.
• Distributed training (DDP, FSDP, tensor parallelism): cómo paralelizar backprop entre muchas GPUs.
• Zero Redundancy Optimizer (ZeRO): técnica para escalar a modelos masivos compartiendo gradientes entre nodos.
• Optimizers beyond SGD: Adam, AdamW, Lion, Shampoo. Cada uno modifica cómo se usan los gradientes para mejorar convergencia.
• Forward-only learning (investigación): intentos de evitar el backward pass entero. Aún experimental.

Errores comunes al hablar de backpropagation

• "Es magia": no. Es la regla de la cadena del cálculo, automatizada.
• Confundir backprop con gradient descent: backprop calcula los gradientes; gradient descent los usa para actualizar. Son pasos distintos.
• "Solo funciona porque hay datos suficientes": cierto en parte, pero también arquitectura, optimizador, regularización importan.
• Pensar que es "cómo aprende el cerebro": no. Es una analogía vaga. El cerebro biológico no hace backprop.
• Subestimar el coste de memoria: en LLMs grandes el forward+backward es el cuello de botella, no el cómputo.
• "Se puede sustituir fácilmente": a pesar de décadas de búsqueda de alternativas, nada ha desplazado a backprop a escala.

Cuándo importa entender backpropagation

Sí, profundiza si:

• Investigas, entrenas o fine-tuneas modelos.
• Optimizas training pipelines o debugeas problemas de convergencia.
• Te interesa el fundamento conceptual del deep learning.
• Trabajas en hardware de IA (NVIDIA, accelerators custom).

Es menos crítico si:

• Solo consumes APIs de modelos preentrenados.
• Tu trabajo es producto donde el entrenamiento es opaco.

Referencias

• Rumelhart, Hinton, Williams (1986) · Learning representations by back-propagating errors — el paper canónico que estableció backprop en deep learning
• 3Blue1Brown · Backpropagation calculus (vídeo) — la mejor explicación visual del algoritmo
• PyTorch Autograd tutorial — cómo usar autodiff en práctica