Cómo funciona realmente la retropropagación

La retropropagación suena a mecanismo misterioso del cerebro artificial y es bastante más mundana: es la forma eficiente de calcular las derivadas del costo respecto de cada peso. Quien aprende es el descenso por gradiente; esto sólo le entrega los números.

Cuánto cambia el costo si muevo este peso

El problema es concreto. Para ajustar un peso hace falta saber cuánto cambia el costo si ese peso cambia un poquito. En una red con millones de pesos hay que calcular millones de derivadas.

Calcularlas por diferencias numéricas —mover cada peso y ver qué pasa— costaría una pasada completa por peso: imposible. La retropropagación obtiene todas con una sola pasada hacia adelante y una hacia atrás.

La regla de la cadena, aplicada de atrás para adelante

La herramienta es la regla de la cadena: si el costo depende de la salida, la salida de la capa anterior y así sucesivamente, la derivada respecto de un peso profundo es el producto de las derivadas del camino.

La clave de eficiencia es el orden. Yendo desde el costo hacia atrás, cada capa recibe la derivada

acumulada de todo lo que está más adelante y sólo tiene que multiplicarla por su derivada local. Los factores compartidos se calculan una vez y se reutilizan, en lugar de recalcularse por cada peso.

Adelante y atrás

En la práctica son dos pasadas. Adelante: se calculan las salidas capa por capa y se guardan los valores intermedios, porque hacen falta después. Atrás: se propaga la derivada desde el costo, capa por capa, obteniendo en cada una el gradiente de sus pesos.

Guardar los valores intermedios es lo que hace que el entrenamiento consuma tanta memoria: no alcanza con los pesos, hay que retener las activaciones de todos los lotes en vuelo. De ahí que la memoria de la GPU limite el tamaño de lote antes que la velocidad.

El gradiente se desvanece o explota

Como la derivada es un producto de factores, uno por capa, su magnitud se comporta de forma multiplicativa. Si los factores son menores que uno, el producto tiende a cero rápido: el gradiente se desvanece y las capas iniciales no aprenden.

Si son mayores que uno, el producto explota y los pasos se vuelven enormes. Ese es el problema central de entrenar redes profundas, y buena parte del diseño moderno existe para controlarlo: activaciones sin saturación, inicialización con la escala adecuada, normalización entre capas y conexiones residuales que le dan al gradiente un camino directo hacia atrás.

El grafo de cómputo generaliza todo esto

Las bibliotecas generalizan esto con un grafo de cómputo: cada operación es un nodo que sabe calcular su salida y su derivada local. Definida la pasada hacia adelante, la hacia atrás sale sola.

Por eso uno escribe el modelo y nunca la derivada, y por eso se puede cambiar la arquitectura sin rehacer ninguna cuenta. También explica un error común: cualquier operación fuera del grafo —convertir a otro tipo de dato, salir a código que la biblioteca no rastrea— corta la cadena y deja pesos que no reciben gradiente y por lo tanto no aprenden.

Las señales que dicen qué se rompió

Para depurar hay señales concretas. Un gradiente en cero en una capa indica cadena cortada o activación saturada. Gradientes enormes anuncian inestabilidad, y el recorte por norma es el parche estándar.

Y una verificación que sigue siendo útil al implementar algo a mano: comparar el gradiente calculado contra una aproximación numérica en unos pocos parámetros. Es lento y es la forma más confiable de detectar un error en la derivación.

Lo que hay que saber cuando no entrena

Cierre

Regla de la cadena aplicada de atrás hacia adelante, reutilizando factores: todas las derivadas con una pasada de ida y una de vuelta, a costa de guardar las activaciones. El carácter multiplicativo explica el desvanecimiento y la explosión, y el grafo de cómputo es lo que automatiza todo.