Backpropagation: la derivación completa

Todo lo que hace backpropagation lo hace con la regla de la cadena, y la regla de la cadena ya está derivada. La lección anterior la dejó en su forma vectorial —jacobianas que se multiplican, un gradiente que entra por un extremo y sale convertido en el de la capa anterior— y con ella la razón por la que así, tal cual, no se puede ejecutar: aplicarla parámetro a parámetro cuesta un recorrido completo de la red por cada número que haya que ajustar. Lo que falta no es matemática nueva. Es un orden.

Y el orden se ve mejor pequeño que grande. Toma la red más pequeña que todavía tiene una capa oculta: dos entradas, dos neuronas ocultas y una de salida. Tiene nueve parámetros —cuatro pesos de entrada, dos sesgos ocultos, dos pesos de salida y un sesgo—, así que hay nueve derivadas que calcular. Detrás de las nueve hay tres números, uno por preactivación de la red. Calculados esos tres, cada una de las nueve derivadas es un producto de dos factores, y ninguno de los dos hay que ir a buscarlo lejos.

Un número por preactivación, y las derivadas que cuelgan de él

Fijemos una capa $l$ y un solo ejemplo. Derivar respecto de un peso ya está resuelto; lo que hay que decidir es respecto de qué conviene derivar primero, y la respuesta es la preactivación. Llamemos error de la capa $l$, y $\boldsymbol{\delta}^{(l)}$, al gradiente de la pérdida de ese ejemplo respecto de $\mathbf{z}^{(l)}$:

una coordenada por neurona de la capa, y en columna, que es la transpuesta de la jacobiana de una fila con la que la lección anterior escribía el gradiente de un escalar. Es $\ell$ y no $\mathcal{L}$: la pérdida de un ejemplo, como en todo el bloque desde la lección sobre funciones de pérdidaBlock 2 · Lesson 5Funciones de pérdida: MSE y entropía cruzadaUna pérdida resume en un número lo mal que lo hace la red, y entre dos candidatas decide su derivada. El error cuadrático medio entrega su corrección más pequeña justo donde la red se equivoca con más seguridad; la entropía cruzada, que sale de leer la salida como probabilidad, deja esa derivada en la diferencia entre lo predicho y la etiqueta..

Con ese vector en la mano, los parámetros de la capa $l$ salen sin recorrer nada. Su preactivación es $\mathbf{z}^{(l)} = \mathbf{W}^{(l)}\mathbf{h}^{(l-1)} + \mathbf{b}^{(l)}$, y coordenada a coordenada, $z^{(l)}_i = \sum_k \mathbf{W}^{(l)}_{ik} h^{(l-1)}_k + b^{(l)}_i$. Mira dónde aparece un peso concreto: $\mathbf{W}^{(l)}_{jk}$ está en una sola de las $d_l$ coordenadas, la $j$, así que de la suma sobre caminos de la lección anterior sobrevive un único sumando:

porque $\partial z^{(l)}_i / \partial \mathbf{W}^{(l)}_{jk}$ vale $h^{(l-1)}_k$ cuando $i = j$ y cero en los otros $d_l - 1$ casos, y la derivada respecto del sesgo es la misma cuenta con un $1$ en lugar de una activación. Apiladas, las $d_l \times d_{l-1}$ casillas son un producto exterior:

Una columna de $d_l$ por una fila de $d_{l-1}$, que es exactamente la forma de $\mathbf{W}^{(l)}$ —y esa coincidencia es la comprobación más barata que existe: si el producto exterior no sale con la forma de la matriz que deriva, hay algo transpuesto.

Cuenta ahora lo que acaba de pasar, porque es el argumento entero. La capa $l$ tiene $d_l \cdot d_{l-1} + d_l$ parámetros, y sus derivadas salen todas de $d_l + d_{l-1}$ números: las coordenadas de $\boldsymbol{\delta}^{(l)}$ y las de $\mathbf{h}^{(l-1)}$, que la pasada hacia adelante ya calculó. En la primera capa de la red de la lección anterior eso son treinta y seis derivadas leídas de doce números. Queda una sola pregunta, y ocupa el resto de la lección: de dónde sale $\boldsymbol{\delta}^{(l)}$.

De dónde sale ese número: la recurrencia hacia atrás

De la capa de al lado, y por eso el recorrido va del final al principio.

Empieza por el final, donde no hay nada que hacer. La última capa entrega $\mathbf{z}^{(L)}$, el softmax lo convierte en $\hat{\mathbf{y}}$ y la entropía cruzada lo compara con la etiqueta; la lección sobre funciones de pérdidaBlock 2 · Lesson 5Funciones de pérdida: MSE y entropía cruzadaUna pérdida resume en un número lo mal que lo hace la red, y entre dos candidatas decide su derivada. El error cuadrático medio entrega su corrección más pequeña justo donde la red se equivoca con más seguridad; la entropía cruzada, que sale de leer la salida como probabilidad, deja esa derivada en la diferencia entre lo predicho y la etiqueta. derivó ese par entero y de las dos cosas juntas salió

Nada de lo que sigue depende de que sea ésa. Cambia la pérdida o la activación de salida y ese vector cambia; el resto del algoritmo no se entera, porque sólo lo recibe. La red del explorable de arriba es el ejemplo: tiene una sigmoide en la salida y la pérdida $\tfrac{1}{2}\left(\hat{y} - y\right)^{2}$ —el $\tfrac{1}{2}$ es la convención que la lección sobre funciones de pérdidaBlock 2 · Lesson 5Funciones de pérdida: MSE y entropía cruzadaUna pérdida resume en un número lo mal que lo hace la red, y entre dos candidatas decide su derivada. El error cuadrático medio entrega su corrección más pequeña justo donde la red se equivoca con más seguridad; la entropía cruzada, que sale de leer la salida como probabilidad, deja esa derivada en la diferencia entre lo predicho y la etiqueta. dijo no adoptar, y aquí está puesto para que los números salgan cortos—, con lo que su capa de salida entra con $\delta^{(2)}_1 = \left(\hat{y} - y\right)\hat{y}\left(1 - \hat{y}\right)$ y no con $\hat{y} - y$: el factor de más es la sigmoide, que aquí no se cancela con nada. Todo lo demás es idéntico.

Ahora el paso hacia atrás. Sea $l < L$. La preactivación de la capa siguiente se construye a partir de la de ésta en dos movimientos, $\mathbf{z}^{(l+1)} = \mathbf{W}^{(l+1)}\varphi\left(\mathbf{z}^{(l)}\right) + \mathbf{b}^{(l+1)}$, y la lección anterior tiene la jacobiana de los dos: la de una aplicación afín es su propia matriz, y la de una $\varphi$ aplicada coordenada a coordenada es diagonal. Componiéndolas,

y esa misma lección dijo qué hacer con una jacobiana cuando lo que se propaga es el gradiente de un escalar: se transpone y se le multiplica el gradiente por la derecha. Como $\text{diag}$ es simétrica y transponer un producto le da la vuelta al orden de los factores,

que escrito con el producto de Hadamard, para no construir la diagonal, es la forma que se implementa:

Léela en dos movimientos, porque hacen dos cosas distintas. El primero, $\left(\mathbf{W}^{(l+1)}\right)^{\top}\boldsymbol{\delta}^{(l+1)}$, transporta: reparte el error de las $d_{l+1}$ neuronas de arriba entre las $d_l$ de abajo, a cada una según el peso con que las alimentaba en la ida. Son los mismos pesos, sin ningún parámetro nuevo. El segundo enmascara: multiplica lo que le llega a cada neurona por su propia pendiente. Con ReLU (rectified linear unit) esa pendiente vale $0$ o $1$, así que una neurona con la preactivación negativa recibe un cero y corta ahí todo lo que venía de arriba.

El algoritmo entero, escrito para dos capas ocultas

Con $L = 3$ cabe entero y sin puntos suspensivos. Hacia adelante, que es la lección sobre el forward passBlock 2 · Lesson 4El forward pass en forma matricialUna capa entera cabe en un producto de matrices, y un batch entero cabe en ese mismo producto con una fila por ejemplo. De ahí sale la transpuesta —los ejemplos se apilan por filas y un ejemplo es una columna— y de encadenar esos productos de la entrada a la salida sale el forward pass, cuyo coste en parámetros no depende de cuántos ejemplos entren a la vez.:

guardando por el camino los $\mathbf{h}^{(l-1)}$ y los $\mathbf{z}^{(l)}$. Hacia atrás, del final al principio:

y de esos tres vectores salen los seis gradientes, $\nabla_{\mathbf{W}^{(l)}}\ell = \boldsymbol{\delta}^{(l)}\left(\mathbf{h}^{(l-1)}\right)^{\top}$ y $\nabla_{\mathbf{b}^{(l)}}\ell = \boldsymbol{\delta}^{(l)}$ para $l = 1, 2, 3$. Eso es backpropagation completo. Tres errores, seis gradientes, y no hay un paso más.

Lo que cuesta se lee en las formas. La vuelta hace un producto de matriz por vector en cada capa, con las mismas matrices de la ida: el mismo orden de operaciones, una sola vez, sea cual sea $L$. Sondear los parámetros de uno en uno cuesta dos pasadas hacia adelante por parámetro, y el número de parámetros no lo acota nada. En la red de abajo son $63$ parámetros, $126$ pasadas contra una; con el vocabulario de veinte mil entradas de la lección sobre el forward passBlock 2 · Lesson 4El forward pass en forma matricialUna capa entera cabe en un producto de matrices, y un batch entero cabe en ese mismo producto con una fila por ejemplo. De ahí sale la transpuesta —los ejemplos se apilan por filas y un ejemplo es una columna— y de encadenar esos productos de la entrada a la salida sale el forward pass, cuyo coste en parámetros no depende de cuántos ejemplos entren a la vez. la proporción no cambia de forma, sólo de tamaño.

Hay un precio y conviene decirlo, porque no es el tiempo. La vuelta necesita los $\mathbf{h}^{(l-1)}$ y los $\mathbf{z}^{(l)}$ de todas las capas, así que hay que conservarlos mientras se calcula hacia adelante. Una red que sólo predice puede tirar cada capa en cuanto la ha usado; una que va a entrenar, no, y esa memoria crece con la profundidad y con el batch.

Del explorable a una red con dos capas ocultas

La primera celda es la red del explorable con sus mismos pesos, para que puedas comparar cifra a cifra. Ejecútala y ve leyendo la salida contra los pasos de arriba: los tres errores primero, los nueve gradientes después. La última línea sondea los nueve parámetros de uno en uno, que es la comprobación de la lección anterior aplicada aquí.

Los números son los del explorable a la tercera cifra, y los nombres también, así que puedes leer las dos cosas en paralelo. La tercera línea enseña los dos movimientos por separado. El transporte deja $\partial \ell / \partial \mathbf{h}^{(1)} = (-0.079,\ 0.068)$: un solo error, $-0.113$, repartido entre las dos neuronas ocultas según sus pesos $0.7$ y $-0.6$, y por eso la segunda coordenada sale con el signo cambiado. El enmascarado son los $(0.238,\ 0.222)$ de al lado, que es la derivada de la sigmoide en cada preactivación.

Y mira $\nabla_{\mathbf{W}^{(1)}}\ell$, que vale $(-0.019,\ -0.009)$ arriba y $(0.015,\ 0.008)$ abajo. Su primera columna es $\boldsymbol{\delta}^{(1)}$ tal cual, porque $x_1 = 1$; la segunda es $\boldsymbol{\delta}^{(1)}$ a la mitad, porque $x_2 = 0.5$. Eso es un producto exterior visto de cerca, y es la razón de que nueve derivadas quepan en tres números y dos entradas.

La segunda celda es la red de reseñas con una capa oculta más, que es donde la recurrencia se aplica dos veces en lugar de una: ocho entradas, cuatro neuronas ocultas, tres, y tres salidas con softmax. Los pesos los he elegido yo para que las preactivaciones salgan redondas. Ejecútala y mira dos cosas: dónde aparecen ceros, y las dos últimas líneas.

Los ceros son ReLU trabajando, y hay dos. La cuarta neurona de la primera capa oculta tiene $z^{(1)}_4 = -1$ y la segunda de la segunda tiene $z^{(2)}_2 = -1$: las dos están apagadas para esta reseña y las dos asignan un cero a su $\boldsymbol{\delta}$. Ese cero se ve dos veces en $\nabla_{\mathbf{W}^{(2)}}\ell$, y por motivos distintos. Su segunda fila es nula porque $\delta^{(2)}_2 = 0$, o sea que ninguno de los cuatro pesos de esa neurona se corrige; su cuarta columna es nula porque $h^{(1)}_4 = 0$, o sea que la entrada que esos pesos leen no aporta nada. Fila y columna son las dos mitades del producto exterior, y cada una se anula por su cuenta.

Las dos últimas líneas son la lección. Los $63$ gradientes coinciden con el sondeo hasta $10^{-10}$, que es el error del sondeo y no del algoritmo. Y conseguirlos sondeando ha costado $126$ pasadas hacia adelante contra la única que hace backpropagation. Eso en una red de juguete, con tres capas y ocho entradas: el factor es el número de parámetros multiplicado por dos, así que crece con cada peso que se añada y no deja de crecer nunca.

Comprueba tu intuición

Cinco preguntas —un gradiente leído de un error, qué es exactamente lo que se reutiliza, las formas de la vuelta, la máscara de ReLU y qué pasa si se tira la ida— y un desafío que es el algoritmo entero.

import numpy as np
 
z = np.array([2., -1., 0., 3.])
g = np.array([0.5, -0.5, 1.5, -1.5])
print(np.round(g * (z > 0), 2))
 

El algoritmo está completo y no ha entrenado nada. Las dos celdas calculan el gradiente de un ejemplo con unos pesos que puse yo, lo imprimen, y ahí se acaban: nadie ha restado nada y nadie ha vuelto a empezar. Lo que falta para cerrar el círculo lleva escrito desde la lección sobre descenso de gradienteBlock 2 · Lesson 6Descenso de gradienteEl gradiente reúne una derivada parcial por parámetro y apunta, entre todas las direcciones posibles, a la que más sube la pérdida; restarlo un poco cada vez es todo el método. Cuánto es «un poco» decide entre converger, rebotar y divergir, y la cuenta sale entera sobre una parábola. —$\theta_{t+1} = \theta_t - \eta\,\nabla_{\theta}\mathcal{L}$—, esperando exactamente al gradiente que esta lección acaba de producir.

Juntar las dos mitades exige tres decisiones que ninguna de las dos lecciones ha tomado. Los ejemplos entran de $B$ en $B$, así que los errores dejan de ser columnas y $\mathcal{L}$ vuelve a ser la media de las $\ell$. Los pesos tienen que empezar en algún sitio, y el sitio evidente —todos a cero— falla por una razón que se lee en la fórmula de $\boldsymbol{\delta}$ que acabas de derivar. Y hay que decidir cuándo parar. Tomar las tres, montarlas sobre un perceptrón multicapa (multilayer perceptron, MLP) escrito desde cero y ver caer la pérdida es la siguiente lección, sobre implementar un MLP.