Atención de Luong (multiplicativa)

Un modelo con atención puntúa parejas: un número por cada paso de la salida y cada posición de la entrada, y de esos números salen los pesos con los que se mezclan los estados del encoder. La lección anterior, sobre la atención aditiva de Bahdanau, llenó esa casilla con una red pequeña —una capa oculta de $d_a$ unidades y una lectura lineal, entrenada junto al resto— y dejó una factura apuntada: puntuar una pareja obliga a fabricar un vector entero de $d_a$ coordenadas antes de reducirlo al número que hacía falta.

La pregunta de esta lección es si hace falta una capa oculta para decir que dos vectores se corresponden. El álgebra lineal lleva desde el bloque 1 devolviendo ese número sin ninguna red de por medio, y en 2015 Luong, Pham y Manning propusieron usarlo tal cual, con un solo retoque. Lo que sale no se parece a una red: se parece a un producto. Y como la calidad de las dos formas es comparable —eso lo miden los experimentos de sus artículos, no una derivación—, lo que decide entre ellas es todo lo demás: cuánto cuestan, qué memoria mueven y qué forma tiene su cálculo.

Vuelve a lo que la puntuación tiene que hacer. Un número que sube cuando dos vectores apuntan al mismo sitio ya está en el curso desde la lección sobre la bolsa de palabrasBlock 1 · Lesson 5Bolsa de palabras y TF-IDFSumar los vectores one-hot de un documento da un vector de conteos donde mandan las palabras vacías. Pesar cada coordenada por lo rara que es la entrada en el resto del corpus arregla eso, y el logaritmo que lo hace no es un truco: sale de medir información.: el producto escalar $\mathbf{u}^{\top}\mathbf{v}$, que la similitud coseno se limita a normalizar. Sería una puntuación gratis —cero parámetros— y sería función de la pareja, que es la condición que la lección anterior declaró irrenunciable: $\mathbf{s}_{i-1}^{\top}\bar{\mathbf{h}}_j$ no se puede partir en una opinión sobre un estado más otra sobre el otro.

Lo que falla es una suposición escondida. El producto escalar suma coordenada contra coordenada, de modo que da por hecho que la coordenada $k$ del decoder habla de lo mismo que la coordenada $k$ del encoder, y con la misma escala. Son dos recurrencias distintas, con dos juegos de pesos y dos trabajos —una lee español, la otra escribe inglés—, y nada las obliga a haber elegido las mismas direcciones para las mismas cosas; ni siquiera a tener el mismo número de coordenadas. De modo que primero se cambia de base y después se mide.

Multiplicar en vez de sumar

La puntuación multiplicativa mete una matriz entre los dos estados y no hace nada más:

con $\mathbf{W}_a \in \mathbb{R}^{d_h \times d_h}$. Se lee de derecha a izquierda: $\mathbf{W}_a\bar{\mathbf{h}}_j$ es el estado del encoder reescrito en las coordenadas del decoder, y el producto escalar con $\mathbf{s}_{i-1}$ mide lo que mide siempre un producto escalar. No hay capa oculta, no hay saturación y no hay ningún espacio propio de la función: el $d_a$ de la lección anterior desaparece del problema.

Cuenta los pesos: $d_h^2$, y ninguno depende de la pareja ni de las longitudes, igual que antes. Con $d_h = 64$ son $4\,096$, contra los $4\,128$ que pedía la aditiva con $d_a = 32$. Prácticamente los mismos, lo cual es útil saberlo pronto: lo que separa a las dos puntuaciones no es cuántos pesos tienen, sino qué operaciones hacen con ellos.

Aquí conviene decir qué se está dejando fuera. Luong y sus coautores cambian además dónde entra el contexto —puntúan con el estado del paso en curso, $\mathbf{s}_i$, y mezclan el contexto después de la recurrencia en vez de dentro de ella— y este curso no lo sigue: mantiene la colocación de la lección sobre la idea de atenciónBlock 4 · Lesson 3La idea de atención: mirar hacia atrásEl encoder calcula un estado por token y la arquitectura usa uno solo. Dárselos todos al decoder choca con un problema de forma —los estados son tantos como tokens, y el decoder tiene un tamaño fijo—, y la salida es mezclarlos: un vector de contexto propio para cada paso de la salida, suma ponderada de todos los estados, con pesos que suman uno y cambian de paso a paso. Aquí se define la mezcla, se ve que el resumen fijo de las dos lecciones anteriores es esa misma mezcla con los pesos congelados, y se dice de dónde salen los pesos —de una puntuación por pareja, normalizada con un softmax sobre las posiciones de la entrada— sin decir todavía quién calcula esa puntuación., para que entre aquella lección, la anterior y ésta cambie una sola cosa. Lo que se compara es la función $a$, con todo lo demás quieto.

El gradiente es más corto que el de la aditiva, y por la misma razón por la que el cálculo lo es. Las tres derivadas de una puntuación salen de derivar un producto de tres factores:

Ninguna lleva un factor $1 - \tanh^{2}$, porque no hay $\tanh$ que derivar. Y todo lo que hay por encima de $e_{ij}$ en la cadena es de la lección anterior, sin tocar una coma: el paso por el softmax y la derivada $\partial\ell/\partial e_{ij} = \alpha_{ij}\left(\nabla_{\mathbf{c}_i}\ell\right)^{\top}\left(\bar{\mathbf{h}}_j - \mathbf{c}_i\right)$ nunca mencionaron qué forma tenía $a$. La atención se queda igual; lo que cambia es el modelo de alineación.

Sin matriz: el producto escalar

El caso extremo es tomar $\mathbf{W}_a$ igual a la identidad, con lo que la puntuación se queda en

y la función $a$ se queda sin un solo parámetro que entrenar. Lo que pide a cambio es justo lo que la matriz servía para no pedir: que los dos lados midan lo mismo —$d_h$ coordenadas en los dos— y que además hayan aprendido a usarlas de la misma forma. Es una exigencia fuerte cuando el encoder y el decoder son dos redes distintas, entrenadas cada una para su idioma, y por eso la matriz es la opción que Luong deja por defecto. La variante sin parámetros no se va del curso —es la forma más barata de puntuar que existe—, pero sólo se sostiene donde los dos lados comparten base.

La rejilla entera en un producto de matrices

Hasta aquí las puntuaciones se han escrito de una en una. Apílalas. Guarda los estados del encoder por filas en $\bar{\mathbf{H}} \in \mathbb{R}^{T_x \times d_h}$ —la fila $j$ es $\bar{\mathbf{h}}_j^{\top}$, transpuesta porque en este curso los vectores son columnas— y los del decoder en $\mathbf{S} \in \mathbb{R}^{T_y \times d_h}$, cuya fila $i$ es $\mathbf{s}_{i-1}^{\top}$, el estado con el que se puntúa el paso $i$. Entonces las $T_x \cdot T_y$ puntuaciones son un solo objeto:

con el softmax aplicado por filas, que es sobre las posiciones de la entrada, como en la lección sobre la idea de atenciónBlock 4 · Lesson 3La idea de atención: mirar hacia atrásEl encoder calcula un estado por token y la arquitectura usa uno solo. Dárselos todos al decoder choca con un problema de forma —los estados son tantos como tokens, y el decoder tiene un tamaño fijo—, y la salida es mezclarlos: un vector de contexto propio para cada paso de la salida, suma ponderada de todos los estados, con pesos que suman uno y cambian de paso a paso. Aquí se define la mezcla, se ve que el resumen fijo de las dos lecciones anteriores es esa misma mezcla con los pesos congelados, y se dice de dónde salen los pesos —de una puntuación por pareja, normalizada con un softmax sobre las posiciones de la entrada— sin decir todavía quién calcula esa puntuación.. Comprueba la casilla $(i, j)$: la fila $i$ de $\mathbf{S}\mathbf{W}_a$ es $\mathbf{s}_{i-1}^{\top}\mathbf{W}_a$ y la columna $j$ de $\bar{\mathbf{H}}^{\top}$ es $\bar{\mathbf{h}}_j$, así que su producto es $e_{ij}$ y no otra cosa.

La aditiva no admite esta escritura, y no por falta de maña. Sus dos proyecciones sí se sacan fuera, pero entre la suma y la lectura está el $\tanh$, de modo que hay que materializar un bloque de tres dimensiones —una pareja, y dentro de cada pareja $d_a$ coordenadas— antes de poder reducirlo a números.

Los recuentos ponen precio a esa diferencia. Toma $T_x = T_y = 60$ y $d_h = d_a = 256$, que es una frase larga y un modelo pequeño. En productos y sumas las dos andan cerca: unos $8.8$ millones la aditiva contra unos $4.9$ millones la multiplicativa, un factor menor que dos, y en ambas la mayor parte se la llevan las proyecciones. Donde se separan es en lo otro. La aditiva evalúa $921\,600$ veces el $\tanh$ y la multiplicativa ninguna. Y sobre todo, la aditiva tiene que guardar esos $921\,600$ números —$7.4$ MB por cada pareja de frases, antes de multiplicar por el tamaño del batch— mientras que a la multiplicativa le bastan las $3\,600$ puntuaciones y los $60$ estados ya proyectados. Entre las dos rejillas el factor es exactamente $d_a$: un número por pareja contra $d_a$ números por pareja.

Y hay una diferencia de forma que no aparece en ninguno de esos números. El trabajo de la multiplicativa son dos productos de matrices; el de la aditiva son sumas y $\tanh$ sobre un bloque tridimensional, coordenada a coordenada. La misma cantidad de aritmética repartida de las dos maneras no cuesta lo mismo en el hardware que entrena estas redes, que está construido justamente para lo primero —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., medida allí con un bucle contra un producto—.

Falta lo honesto, y es lo que abre el bloque siguiente. Escribir $\mathbf{S}$ supone tener los $T_y$ estados del decoder, y el decoder es recurrente: $\mathbf{s}_{i-1}$ necesita $\mathbf{c}_{i-1}$, que necesita la fila $i-1$ de $\mathbf{A}$, que necesita $\mathbf{s}_{i-2}$. Mientras traduce, la rejilla se llena fila a fila y el producto grande no llega a ocurrir; lo que sí se saca del bucle es $\mathbf{W}_a\bar{\mathbf{H}}^{\top}$, que sólo depende de la fuente y se calcula una vez por frase, dejando cada paso del decoder en un solo producto de matriz por vector:

la fila $i$ de puntuaciones sin normalizar. La puntuación ya no es el cuello de botella del cálculo. Lo que estrangula el paralelismo, ahora, es la recurrencia que produce los estados.

Las dos puntuaciones, en NumPy

La primera celda calcula la alineación multiplicativa de la forma corta y comprueba que el producto no dice nada distinto de puntuar las parejas una a una. Mira también las dos últimas líneas: con $\mathbf{W}_a$ igual a la identidad, la puntuación se queda en el producto escalar de los dos estados.

La línea que importa es la del bucle: puntuar pareja a pareja da los mismos números que el producto, que es lo único que hay que comprobar de la forma corta. La del mayor peso de cada fila trae una sorpresa. Con los pesos recién inicializados el mapa ya reparte de forma desigual —una fila se lleva $0.851$ cuando el reparto uniforme sería $0.167$—, y eso no pasaba en la lección anterior con un tamaño parecido, donde el mayor peso de cada fila rondaba el uniforme. La diferencia está en el $\tanh$: acota cada coordenada antes de que $\mathbf{v}_a$ la lea, así que la puntuación aditiva nace pequeña. La multiplicativa no tiene nada que la acote, y su tamaño crece con el de los estados. Ese pico no es una alineación, es la dirección que $\mathbf{W}_a$ tomó al azar; lo que la fórmula garantiza no es empezar diciendo algo, sino que haya por dónde entrenarlo. Que las puntuaciones sin acotar se disparen al crecer el modelo es un problema de verdad, con un arreglo de una línea que llega en el bloque siguiente.

Las tres primeras líneas son la sección anterior contada por el código: la aritmética se parece, el $\tanh$ y los $7.4$ MB intermedios no. La última depende de la máquina y del navegador, y aun así dice algo, porque no está midiendo una diferencia pequeña: la multiplicativa tarda alrededor de un orden de magnitud menos, y el factor exacto cambia de una ejecución a otra sin acercarse nunca a uno. Y hay un experimento que lo deja claro. Cambia $d_a$ a $64$ y ejecuta otra vez: la aditiva pasa a hacer menos aritmética que la multiplicativa —$2.2$ millones de operaciones contra $4.9$— y sigue tardando varias veces más que ella. Lo que se está midiendo no es cuántas operaciones hay.

Comprueba tu intuición

Cuatro preguntas: qué añade la matriz, cuánto pesa la puntuación, qué guarda la aditiva que la otra no guarda, y si la rejilla se puede calcular de una vez.

Con las dos puntuaciones delante hay algo que se ve mejor que con una sola. En las dos, el estado del encoder entra en el mecanismo dos veces y por puertas distintas: una como argumento de $a$, que es donde se decide cuánto peso se lleva, y otra como sumando de $\mathbf{c}_i$, que es donde su contenido acaba llegando al decoder. El estado del decoder, en cambio, entra una sola vez, y siempre del mismo lado: es el que pregunta. Tres papeles, y ninguna de las dos fórmulas exige que los dos primeros los haga el mismo vector —lo hace porque nadie ha propuesto todavía separarlos.

Separarlos y ponerles nombre —consulta, clave y valor— es la lección siguiente, la última del bloque, y es la más importante de este curso. No cambia ni una ecuación de las que ya has visto: reescribe las mismas con las palabras y los símbolos con los que el bloque 5 lo escribe todo, incluida la elección de puntuación que esta lección acaba de justificar. Lo que aquí quedó pendiente —que los estados sigan llegando de uno en uno— tampoco lo arregla ese cambio de nombre, y por eso conviene llegar al bloque siguiente con los nombres ya puestos.