Retropropagación (Backpropagation): Cómo la IA detecta al culpable del error (con la regla de la cadena)
1. Introducción: El culpable está dentro
En la publicación anterior descubrimos que la derivada es "una brújula que indica en qué dirección girar los parámetros para reducir el error".
Sin embargo, el aprendizaje profundo presenta un problema crítico: el modelo es demasiado profundo.
El número de capas entre la entrada y la salida puede ser de decenas o cientos.
Situación: En la capa de salida se produce un error (Loss) que indica que el resultado difiere en 10 unidades de la respuesta correcta.
Pregunta: ¿Quién es el culpable?
No se puede saber si el error se debe a un parámetro cercano a la capa de entrada que provocó un efecto dominó, o a un parámetro justo antes de la capa de salida que cometió un error de última hora.
En este caso, el aprendizaje profundo utiliza una técnica ingeniosa para encontrar al culpable: "culpar al que está justo detrás de ti (Regla de la Cadena)".
2. Regla de la Cadena: La definición matemática de "transferencia de responsabilidad"
En los libros de matemáticas la regla de la cadena se escribe así.
$$\frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx}$$
Para nosotros, los desarrolladores, parece solo una fórmula matemática, pero desde la perspectiva de la gestión organizacional es "la distribución de la responsabilidad".
Imaginemos una línea de aprobación: Equipo A (entrada) -> Departamento B (oculto) -> Director C (salida).
- El Director C (capa de salida) falla el proyecto (se produce un error).
- El Director C no quiere asumir toda la culpa, analiza: "El informe que me entregó el Departamento B estaba mal, por eso mi resultado también está mal." ($\frac{dz}{dy}$: cuánto se vio afectado mi resultado por B).
- El Departamento B se siente injustamente acusado: "¡No, el Equipo A me dio datos base incorrectos, por eso mi informe también está mal!" ($\frac{dy}{dx}$: cuánto se vio afectado mi resultado por A).
Al final, el impacto total del Equipo A en el proyecto (z) se calcula como (responsabilidad de C sobre B) × (responsabilidad de B sobre A).
Esta es la regla de la cadena de la derivada. Conecta la causa distante (A) con el resultado (z) mediante la multiplicación de los pasos intermedios.
3. Retropropagación: Depuración que arde al revés
Esta "transferencia de responsabilidad" se extiende a todo el sistema y se llama retropropagación.
- Forward (propagación directa): Se introduce la entrada y se obtiene la salida. (Se hace el trabajo).
- Cálculo de la pérdida: Se compara con la respuesta correcta y se mide cuán lejos está. (Se produce el error).
- Backward (retropropagación): Desde la capa de salida hasta la capa de entrada, se recorre hacia atrás diciendo: "Debo de haber causado este error".
Para un desarrollador, es equivalente a leer un stack trace desde la base hasta arriba para encontrar la causa raíz del bug.
Se observa el mensaje de error (pérdida), se identifica la función que lo llamó, luego la que la llamó, y así sucesivamente, como si se ejecutara git blame.
4. Autograd de PyTorch: El equipo de auditoría automatizado
Cuando construimos aprendizaje profundo con numpy, la parte más dolorosa es derivar manualmente las ecuaciones y codificarlas. (Derivar matrices te hace perder el cabello.)
La grandeza de PyTorch radica en que dibuja todo el proceso de "transferencia de responsabilidad" en un grafo computacional y lo procesa automáticamente.
- Cuando llamas a
loss.backward(), - El motor Autograd (el equipo de auditoría) se activa.
- Desde el extremo del grafo, recorre cada nodo al revés, aplicando la regla de la cadena (multiplicación).
- Luego asigna a cada parámetro (Weight) su "porción de responsabilidad (gradiente)".
Solo necesitamos ajustar los valores según el gradiente (optimizer.step()).
5. Conclusión: ¿Y si la responsabilidad desaparece? (Vanishing Gradient)
Incluso este sistema aparentemente perfecto tiene una falla crítica.
Al transferir la responsabilidad repetidamente (multiplicando y multiplicando), cuando las capas son muy profundas, la responsabilidad puede llegar a cero.
Si multiplicas "no es mi culpa" × 0.1 × 0.1 × 0.1 …, la capa inicial recibe la señal errónea de que "no hay nada que corregir (Gradiente = 0)".
Este es el famoso problema de gradiente que desaparece (Vanishing Gradient). ¿Cómo lo resolvieron las IA modernas? (Pista: ReLU y ResNet)
No hay comentarios.