Backpropagation

La retropropagación (backpropagation) es el algoritmo que permite a una red neuronal aprender de sus errores. Calcula cuánto contribuyó cada peso al error final y en qué dirección ajustarlo, para luego mejorar con descenso de gradiente. Es el motor que hizo posible el deep learning.

El problema: ¿quién tiene la culpa del error?

Una red profunda puede tener millones de pesos. Tras un paso hacia adelante, obtenemos una predicción y medimos su error con una función de pérdida. La pregunta es brutal: de todos esos pesos, ¿cuánto debe cambiar cada uno para reducir el error? Backpropagation responde eso de forma eficiente.

La idea: propagar el error hacia atrás

El nombre lo dice todo. El error se calcula al final (en la salida) y se propaga hacia atrás, capa por capa, repartiendo "responsabilidad" entre las neuronas que lo causaron.

1. Forward: la entrada avanza por la red y produce una predicción.
2. Pérdida: se compara la predicción con la respuesta real.
3. Backward: el error viaja de vuelta, de la salida a la entrada, calculando el gradiente de cada peso.
4. Actualizar: cada peso se corrige con descenso de gradiente.

Este ciclo se repite millones de veces sobre los datos.

La herramienta matemática: la regla de la cadena

Como cada capa es una función que envuelve a la anterior, el efecto de un peso sobre el error se obtiene multiplicando las derivadas de cada paso intermedio. Eso es la regla de la cadena del cálculo:

$$\frac{\partial \mathcal{L}}{\partial w}=\frac{\partial \mathcal{L}}{\partial a}\cdot \frac{\partial a}{\partial z}\cdot \frac{\partial z}{\partial w}$$

Backpropagation es, esencialmente, aplicar esta regla de forma ordenada y reutilizando cálculos, para no repetir trabajo entre millones de parámetros.

En código

Hoy nadie deriva a mano: las librerías hacen la diferenciación automática. En PyTorch, backward() ejecuta toda la retropropagación:

import torch

x = torch.tensor([1.0, 2.0])
w = torch.tensor([0.5, -0.3], requires_grad=True)  # pesos a aprender

y_pred = (x @ w).sigmoid()      # forward
loss = (y_pred - 1.0) ** 2      # pérdida

loss.backward()                 # backpropagation: calcula los gradientes
print(w.grad)                   # ∂loss/∂w para cada peso

with torch.no_grad():
    w -= 0.1 * w.grad           # un paso de descenso de gradiente

Ese w.grad es exactamente lo que backpropagation calcula; el resto del entrenamiento es repetirlo.

Para llevar

Backpropagation reparte el error de la red entre todos sus pesos aplicando la regla de la cadena de atrás hacia adelante, y entrega los gradientes que el descenso de gradiente necesita para mejorar. Es la combinación de ambos —propagar el error y dar un paso— lo que hace que una red profunda aprenda. Con esto cerramos los fundamentos y quedamos listos para la arquitectura que domina hoy: el Transformer.