El forward pass en forma matricial

La red de la lección anterior, sobre XOR y las capas ocultas, quedó completa y sin escribir. Completa porque no le falta ninguna pieza: neuronas agrupadas en capas, cada una con sus pesos y su sesgo, y una $\varphi$ en medio que impide que apilarlas se contraiga en una neurona sola. Sin escribir porque allí cada preactivación se calculó por separado, y una colección de cuentas sueltas no es una fórmula: no se desarrolla sobre ella y no se programa. El recorrido que va de la entrada hasta la salida tiene un nombre —el forward pass— y tiene una forma en la que se escribe siempre. Esta lección es esa forma.

Ponle números antes de escribirla. Toma las diez reseñas de la lección sobre la neurona artificialBloque 2 · Lección 1La neurona artificialUna suma ponderada y un umbral bastan para que un solo objeto convierta un vector en una decisión. Sus pesos son la perpendicular de una frontera que parte el espacio en dos, y el número que calcula antes de decidir mide a qué distancia de esa frontera ha caído la entrada., con aquel vocabulario de ocho entradas. Lo que entra en la red no es la reseña sino su bolsa de palabras: un vector de ocho coordenadas, una por entrada del vocabulario, con las veces que esa entrada aparece en la reseña. Eso es todo lo que la red va a leer. Pon encima una capa oculta de cuatro neuronas: cada una mira esas ocho coordenadas y devuelve un número, de modo que las diez reseñas dan $10 \cdot 4 = 40$ preactivaciones ocultas, cada una de ellas una suma de ocho productos más un sesgo. De una en una son cuarenta cuentas, o dos bucles encajados si prefieres que las haga el ordenador. Las cuarenta caben en un solo producto de matrices, y la capa siguiente vuelve a salir de otro igual. Lo que hay que fijar es qué multiplica a qué, y por dónde entran las diez reseñas. Porque van a entrar juntas: un grupo de ejemplos que atraviesan la red a la vez es un batch, y el de esta lección tiene diez.

Ese producto no es una abreviatura de los dos bucles: es el mismo cálculo con la contabilidad metida en las formas de los arrays. Mira dónde acaba cada número.

Una capa entera en un solo producto

Fijemos una capa cualquiera y llamemos $d_l$ a su anchura, el número de neuronas que tiene. La capa $l$ recibe $d_{l-1}$ números y entrega $d_l$, de modo que sus pesos son una matriz $\mathbf{W}^{(l)} \in \mathbb{R}^{d_l \times d_{l-1}}$ y sus sesgos un vector $\mathbf{b}^{(l)} \in \mathbb{R}^{d_l}$, uno por neurona. Con un solo ejemplo entrando, la lección anterior ya escribió el resultado:

con $\mathbf{h}^{(l-1)} \in \mathbb{R}^{d_{l-1}}$, con $\mathbf{z}^{(l)}, \mathbf{h}^{(l)} \in \mathbb{R}^{d_l}$ y con $\varphi$ aplicada coordenada a coordenada. Los vectores son columnas, como todos los del curso, y por eso el producto está escrito en ese orden.

Cada capa se apoya en la anterior, así que la cadena necesita un principio. La primera capa no tiene ninguna delante: lo que recibe es el ejemplo tal cual, y el convenio es contar la entrada como una capa $0$ que no calcula nada, $\mathbf{h}^{(0)} = \mathbf{x}$. Eso hace de $d_0$ la dimensión de la entrada y no la anchura de ninguna capa de neuronas. Con las reseñas de arriba, $\mathbf{h}^{(0)}$ son las ocho cuentas de la bolsa de palabras y $d_0 = 8$.

Lo que hace falta ver es que dentro de ese producto no hay nada nuevo. Desarrolla la coordenada $j$:

Esa suma es la neurona de la lección sobre la neurona artificialBloque 2 · Lección 1La neurona artificialUna suma ponderada y un umbral bastan para que un solo objeto convierta un vector en una decisión. Sus pesos son la perpendicular de una frontera que parte el espacio en dos, y el número que calcula antes de decidir mide a qué distancia de esa frontera ha caído la entrada., con la fila $j$ de $\mathbf{W}^{(l)}$ haciendo de vector de pesos. El producto de matrices no añade ninguna operación: agrupa las $d_l$ sumas que ya había, y su única aportación es que ahora no hay que escribirlas. La cuenta de lo que cuesta también sale de ahí, $d_l \cdot d_{l-1}$ productos por ejemplo, y esa cifra crece con el tamaño de la capa aunque el número de líneas se quede en una.

El batch entra por la izquierda, y por eso aparece la transpuesta

Ahora los ejemplos. Llamemos $B$ al tamaño del batch y guardemos los $B$ ejemplos en una matriz $\mathbf{X} \in \mathbb{R}^{B \times d_0}$, con un ejemplo en cada fila. Ese orden, el batch primero, es el del curso entero y el que usa NumPy. Con la misma disposición para lo que sale de cada capa, $\mathbf{H}^{(l)} \in \mathbb{R}^{B \times d_l}$, la fila $i$ de $\mathbf{H}^{(l-1)}$ es el ejemplo $i$ tumbado: es $\left(\mathbf{h}^{(l-1)}_i\right)^{\top}$, con su transpuesta, porque el vector es una columna y la fila de una matriz no lo es.

Esa transpuesta es la que se propaga, y con ella sale todo lo demás. Transpón la ecuación de arriba para el ejemplo $i$, recordando que transponer un producto le da la vuelta al orden de los factores:

que es una igualdad entre filas: a la izquierda, la fila $i$ de $\mathbf{Z}^{(l)}$; a la derecha, la fila $i$ de $\mathbf{H}^{(l-1)}$ multiplicada por la misma matriz que las demás. Apilar las $B$ filas es entonces un solo producto:

con $\mathbf{Z}^{(l)}, \mathbf{H}^{(l)} \in \mathbb{R}^{B \times d_l}$ y con $\mathbf{1}_B \in \mathbb{R}^{B}$ el vector de unos. Ese último factor merece una frase, porque es lo único de la fórmula que no está en el código. $\mathbf{Z}^{(l)}$ tiene $B$ filas y $\mathbf{b}^{(l)}$ tiene $d_l$ coordenadas: sumarlos no es una operación entre matrices, así que lo que hay escrito es el producto $\mathbf{1}_B\left(\mathbf{b}^{(l)}\right)^{\top}$, la misma fila de sesgos repetida $B$ veces. NumPy hace esa repetición él solo cuando escribes + b, sin construir la matriz, y por eso conviene haber visto una vez lo que está haciendo por debajo.

De la entrada a la salida, una capa detrás de otra

Con una capa resuelta, la red es la repetición. Sea $L$ el número de capas —la de salida incluida— y sean $d_0, d_1, \dots, d_L$ las anchuras de la cadena, empezando por la de la entrada. El forward pass es esta recurrencia:

y lo que sale de la última capa es la predicción de la red para los $B$ ejemplos a la vez, $\hat{\mathbf{Y}} = \mathbf{H}^{(L)} \in \mathbb{R}^{B \times d_L}$. Esa cadena es todo lo que calcula un perceptrón multicapa (multilayer perceptron, MLP): no hay más pasos, y los de más adelante en el bloque no añadirán ninguno, sólo cambiarán los números que hay dentro de las matrices.

Dos cosas se leen directamente en las formas. La primera es la única condición que hay que respetar al diseñar una red: $\mathbf{H}^{(l-1)}$ tiene $d_{l-1}$ columnas y $\mathbf{W}^{(l)}$ también, y si las dos anchuras no coinciden el producto no existe. Las anchuras intermedias las eliges tú; $d_0$ te la da la representación de la entrada y $d_L$, cuántas respuestas quieres. La segunda es que $B$ no aparece en ninguna matriz de pesos. Cuántos ejemplos entren a la vez es una decisión de quien ejecuta la red, no una propiedad de la red, y de ahí sale el recuento de lo que ocupa:

Para la red de reseñas de abajo, con $d_0 = 8$, $d_1 = 4$ y $d_2 = 1$, son $41$ números. Cambia el vocabulario por uno de $20\,000$ entradas y la capa oculta por una de $128$ neuronas, y son $2\,560\,257$: casi todos en $\mathbf{W}^{(1)}$, ninguno en función de $B$.

El bucle, el producto y la red de reseñas en NumPy

La primera celda pone las dos versiones frente a frente sobre una capa de treinta y dos neuronas: el doble bucle que se sigue de la definición, y el producto. Ejecútala y mira tres cosas: si dan lo mismo, cuánto tarda cada una, y qué pasa cuando el producto se escribe sin transponer.

Las dos versiones coinciden hasta el orden de $10^{-14}$, que es lo que separa a dos maneras de sumar los mismos números en coma flotante. Obtenerlas no cuesta lo mismo: el producto tarda entre uno y dos órdenes de magnitud menos, y el factor exacto depende de la máquina y del navegador. De dónde sale ese factor no depende de ninguno de los dos. No es que el producto haga menos operaciones —hace exactamente las mismas—, sino que las $4\,096$ vueltas del bucle las da Python una a una, mientras el producto las da dentro de una rutina compilada sin volver a pasar por el intérprete.

Los dos últimos experimentos son las dos trampas de forma. X @ W no existe, y NumPy lo dice nombrando las dos dimensiones que no encajan; y la diferencia entre $\mathbf{Z}$ y el producto sin sesgo es la misma terna $-0.761$, $3.221$, $0.221$ en la fila $0$ y en la fila $127$, que es $\mathbf{1}_B\mathbf{b}^{\top}$ hecho visible.

La segunda celda monta la red entera sobre las diez reseñas: ocho entradas, cuatro neuronas ocultas con ReLU (rectified linear unit) y una de salida con sigmoide, para que lo que entregue sea un número entre $0$ y $1$. Ejecútala y quédate con la columna de formas y con la última línea.

Cinco líneas de código para la red entera, y en la columna de formas está la razón: el $10$ de la primera dimensión no vuelve a aparecer en ningún sitio y llega intacto hasta el final, mientras la segunda dimensión va cambiando $8 \to 4 \to 1$ al ritmo de las anchuras. La red tiene los $41$ parámetros de la cuenta de arriba.

Y ahora la última línea, que es la que importa. Cinco aciertos de diez. Las diez salidas están por debajo de $0.5$ —la mayor es $0.357$, para divertida y buena—, así que la red contesta que no a las diez reseñas, y acierta exactamente las cinco que eran negativas. Es la puntuación de quien no lee nada y dice que no siempre. Los pesos salieron de np.random.randn, y no hay ninguna razón para que fueran otra cosa.

Comprueba tu intuición

Cuatro preguntas —cuántos números guarda una red, de dónde sale la transpuesta, qué hace NumPy con el sesgo y qué fija la cadena— y un desafío que es el forward pass completo.

import numpy as np
 
H = np.ones((3, 4))
W = np.ones((2, 4))
b = np.array([0.5, -0.5])
Z = H @ W.T + b
print(Z.shape, Z[0])
 

La red ya sabe contestar, a un ejemplo o a mil, y lo que ha contestado es inservible. Esas dos cosas caben juntas porque el forward pass no contiene ninguna noción de acierto: es una cadena de productos que transforma $\mathbf{X}$ en $\hat{\mathbf{Y}}$ y que habría corrido exactamente igual con los pesos buenos, si alguien supiera cuáles son. Para corregirlos hay que empezar por medirlos, y medir no es contar aciertos. La cuenta de la última línea vale lo mismo con una salida de $0.499$ que con una de $0.036$, y no se mueve cuando un peso cambia un poco: no distingue entre equivocarse por poco y equivocarse del todo, que es justo lo único que sirve para decidir hacia dónde mover un peso.

Hace falta un número que sí lo distinga. Uno solo para todo el batch, que crezca cuando $\hat{\mathbf{Y}}$ se aleja de las etiquetas, que baje cuando se acerca, y que cambie de forma continua para que tenga derivada. Cómo se construye ese número, por qué el primer candidato que se le ocurre a cualquiera —elevar al cuadrado la diferencia— es el correcto para unas tareas y una mala idea para clasificar, y qué se usa en su lugar, es la siguiente lección, sobre funciones de pérdida: el error cuadrático medio y la entropía cruzada.