Retropropagación

Las ecuaciones de la red

La red de la lección tiene entradas $x_1, x_2$, dos neuronas ocultas, una de salida, activación sigmoide $\sigma(z)=1/(1+e^{-z})$ y no usa sesgos:

Con $\mathbf x=(1,\,0.5)$, $t=1$ y $\mathbf w=(0.6,\,-0.3,\,0.7,\,0.5,\,0.8,\,-0.9)$ resulta $\hat y\approx 0.460$ y $L\approx 0.146$. Los pesos de partida se eligieron de modo que cada cuenta mostrada con tres decimales se pueda repetir a mano, con las cifras ya redondeadas, sin discrepancias (el script verify-data.ts de la lección lo comprueba, y compara el gradiente con diferencias finitas).

La regla de la cadena, paso a paso

Si $L$ depende de $\hat y$, este de $z$ y este de $w_5$, la derivada de $L$ respecto de $w_5$ es el producto de las derivadas de cada eslabón:

La derivada de la sigmoide es $\sigma'(z)=\sigma(z)(1-\sigma(z))$, así que se calcula con la activación que ya se guardó. Los dos primeros factores forman la culpa de la neurona $\delta=\partial L/\partial z$. Hacia atrás, capa por capa:

Con los números de la lección: $\delta_y=-0.540\cdot0.248\approx-0.134$; $\partial L/\partial w_5=-0.134\cdot0.611\approx-0.082$; $\delta_1=-0.134\cdot0.8\cdot0.238\approx-0.026$ y $\partial L/\partial w_1=\delta_1\,x_1\approx-0.026$. Como $w_6<0$, $\delta_2$ sale con signo contrario ($+0.024$). Observa que las culpas $\partial L/\partial w_5$ y $\partial L/\partial w_6$ no suman $\delta_y$: cada peso recibe la culpa de la neurona multiplicada por su propia señal, no una parte de ella.

En capas y en forma de matriz

Con $W^{(l)}$ la matriz que lleva $\mathbf a^{(l-1)}$ a $\mathbf z^{(l)}$, las mismas ideas se escriben para cualquier número de capas:

Cada $\boldsymbol\delta^{(l)}$ se calcula una vez a partir de la capa siguiente: eso es lo que hace barato el método. Con ReLU, $\sigma'$ se reemplaza por $1$ si $z>0$ y $0$ en otro caso.

Por qué es barata

Para una pérdida escalar y $N$ pesos, el modo inverso de la diferenciación automática (las técnicas para derivar programas de forma exacta; la retropropagación es su caso particular para redes) entrega las $N$ derivadas en un solo recorrido hacia atrás. El modo directo, o tantear con diferencias finitas, necesita un recorrido por peso. El gradiente completo cuesta una constante pequeña por el costo de evaluar la función: Baydin et al. (2018), citando a Griewank y Walther (2008), dan $c<6$ y típicamente entre 2 y 3, y Griewank (2012) lo llama el «principio del gradiente barato».

En un transformer grande, Kaplan et al. (2020) cuentan unos $2N$ FLOPs por token hacia delante, con $N$ los parámetros sin contar los de embeddings, y observan que el pase hacia atrás cuesta aproximadamente el doble: de ahí su $\approx 6N$ FLOPs por token de entrenamiento. A cambio, hay que guardar las activaciones del pase hacia delante hasta usarlas: el propio artículo de 1986 señala que las salidas de las capas intermedias del pase hacia delante hacen falta para el pase hacia atrás.

Un límite: la culpa puede atenuarse

Como $\sigma'(z)\le \tfrac14$, cada capa de sigmoides aporta un factor de a lo sumo $\tfrac14$ a la culpa: $(\tfrac14)^n$ tras $n$ capas. Los pesos también multiplican en cada capa y podrían compensarlo, pero con pesos moderados el producto se encoge de forma exponencial. Por eso en redes profundas se prefieren otras activaciones, conexiones residuales y variantes como la LSTM, temas de las lecciones 12 y 13.

De dónde viene, con cuidado

El nombre y la fama son de 1986, pero la idea es más vieja y tuvo varios descubridores:

• Linnainmaa. Su tesis de maestría (Universidad de Helsinki, 1970, en finés; resultados en inglés en BIT, 1976) estudia cómo se acumula el error de redondeo de un algoritmo y propone lo que hoy se llama modo inverso. Según Griewank (2012), él no lo presentó como un método para obtener gradientes de forma barata.
• Werbos. Su tesis doctoral en estadística (Harvard, agosto de 1974) desarrolla las «derivadas ordenadas» y la «retroalimentación dinámica» para modelos de predicción. Él mismo cuenta (Werbos, 2006) que de las redes neuronales solo escribió unas palabras en el capítulo 5; Goodfellow et al. (2016) fechan en 1981 su propuesta de aplicarlo a entrenar redes neuronales.
• Rumelhart, Hinton y Williams (Nature, 1986). Usan la misma matemática de esta lección: error $\tfrac12\sum(y-d)^2$, sigmoide, un pase hacia delante y uno hacia atrás que «propaga derivadas». Reconocen que David Parker y Yann LeCun descubrieron variantes de forma independiente. En el artículo, «back-propagation» nombra todo el procedimiento de aprendizaje (con la actualización $\Delta w=-\varepsilon\,\partial E/\partial w$ y una variante con término de aceleración, lo que hoy se llama momento); la distinción de hoy, retropropagación para el gradiente y otro algoritmo para aprender con él, es la que explican Goodfellow et al. (2016). Los autores cierran diciendo que el procedimiento, «en su forma actual, no es un modelo plausible del aprendizaje en los cerebros».

En código

import math

def sigma(z):
    return 1 / (1 + math.exp(-z))

X, T = (1.0, 0.5), 1.0

def forward(w):
    a1 = sigma(w[0] * X[0] + w[1] * X[1])
    a2 = sigma(w[2] * X[0] + w[3] * X[1])
    y = sigma(w[4] * a1 + w[5] * a2)
    return a1, a2, y, 0.5 * (y - T) ** 2

def backward(w):
    a1, a2, y, loss = forward(w)
    d_y = (y - T) * y * (1 - y)            # culpa de la neurona de salida
    d_1 = d_y * w[4] * a1 * (1 - a1)       # culpa de la oculta 1
    d_2 = d_y * w[5] * a2 * (1 - a2)       # culpa de la oculta 2
    grad = [d_1 * X[0], d_1 * X[1], d_2 * X[0], d_2 * X[1], d_y * a1, d_y * a2]
    return loss, grad

w = [0.6, -0.3, 0.7, 0.5, 0.8, -0.9]
loss, grad = backward(w)
print(round(loss, 3), [round(g, 3) for g in grad])
# 0.146 [-0.026, -0.013, 0.024, 0.012, -0.082, -0.097]

# comprobación: tantear cada peso (un pase hacia delante extra por peso)
eps = 1e-6
check = []
for k in range(6):
    w2 = w.copy()
    w2[k] += eps
    check.append((forward(w2)[3] - loss) / eps)
print([round(c, 3) for c in check])
# [-0.026, -0.013, 0.024, 0.012, -0.082, -0.097]

# un paso de descenso del gradiente: lo da el descenso, no la retropropagación
eta = 1.0
w = [wk - eta * g for wk, g in zip(w, grad)]
print(round(forward(w)[3], 3))
# 0.129

Lo que viene

Con datos reales el gradiente se calcula sobre un lote de ejemplos y no sobre uno solo, y optimizadores como el momento o Adam transforman ese gradiente antes de mover los pesos. Todos reciben el gradiente de la retropropagación. Es el tema de la lección 9.