Una sola columna: el modelo de lenguaje causal

20 min de lectura

El curso anterior se despidió, con sus propias palabras, dejándote «delante de un artículo que puedes discutir» y no delante de un modelo que funcione: un Transformer entero en NumPy, y unos pesos ajenos afinados una vez en un cuaderno fuera del navegadorDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 11Fine-tuning en la prácticaLa lección anterior afirmó que los pesos de un modelo preentrenado no caben en el navegador, y lo dejó sin número. Aquí está el número: doce bloques de 768, un vocabulario de 31 002 entradas y unos 110 millones de parámetros que, con sus gradientes y lo que el optimizador guarda al lado, pasan de 1.5 GB antes de la primera activación. De ahí sale que esta lección no tenga celdas, sino un cuaderno de Colab que se ejecuta fuera del navegador. Lo que corre allí es el bucle del bloque 2 sin una línea nueva: la misma actualización, la misma entropía cruzada y una capa de salida de 1 538 números; lo único que ha cambiado es de dónde parte theta y cuánto se le deja moverse.. Una lección antes había tomado la decisión de la que vive todo lo que sigue: de las dos columnas del artículo, GPT se queda con la derecha y pone la máscara en todas sus auto-atencionesDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 10BERT y GPT: una columna cada unoEl modelo de la lección anterior sabe correr y para aprender pide lo más caro que hay: pares de frases con su traducción, escritos uno a uno a mano. Texto suelto, en cambio, sobra. Las dos familias que salieron del artículo en 2018 contestan a esa escasez quitando una columna, moviendo la máscara y cambiando qué se les pide predecir, y ninguna de las tres cosas es una operación nueva. Por el camino pagan una deuda del bloque 1: la firma de la representación deja de recibir una entrada del vocabulario y pasa a recibir la frase, que es lo único que puede darle a banco dos vectores. La celda lo mide en la misma posición de dos frases, y de los tres números que imprime, dos valen 1 por construcción., y se le pide el token siguiente. Ese objeto se llama modelo de lenguaje, y aquel curso lo definió dos veces como una pérdida por posición: sobre una RNN de caracteres, y sobre el Transformer.

Hay una pregunta que ninguna de esas dos veces hizo, y esta lección existe para hacerla: ¿qué probabilidad le da el modelo a un texto entero? No a la posición siete de un texto: al texto. Resulta ser la pregunta que ordena todo lo demás. De su respuesta sale por qué la máscara causal no es una restricción que se paga sino la razón de que entrenar quepa en una pasada, qué número exacto mide un modelo de lenguaje y, al final del bloque, cómo un modelo entrenado sólo para continuar texto acaba haciendo tareas que nadie le enseñó. Hoy toca lo primero.

Tapa con la mano lo que sigue a En un lugar de la y di qué viene. Lo has dicho antes de terminar de leer: tras En un lugar de cabían cien cosas; tras En un lugar de la, casi sólo Mancha. Un modelo de lenguaje es ese jugador. Lee lo que hay a la izquierda y reparte su «apuesta» entre las entradas del vocabulario para la posición siguiente, y el texto, sin que nadie lo etiquete, trae escrita la respuesta correcta de cada posición.

Lo que el curso anterior no dijo es que ese juego, jugado posición a posición, es una probabilidad para el texto entero. La probabilidad de que salga En y luego un es la de En por la de un sabiendo que vino En; añade lugar y multiplicas otra vez. Multiplica las apuestas en orden y tienes la apuesta del modelo por el texto.

Y la máscara es lo que permite hacer las $T$ apuestas de un texto a la vez. La posición $t$ sólo ve lo que hay a su izquierda, así que su apuesta es la misma con el resto del texto a su derecha que sin él: puedes poner el texto entero sobre la mesa, con las respuestas a la vista, y leer las $T$ apuestas de una sola pasada.

Una distribución sobre textos, y la cadena que la factoriza

Fijemos el vocabulario $V$ y llamemos $x_t \in V$ al token que ocupa la posición $t$ de un texto: $x_{1:T}$ es el texto entero, $x_{<t}$ lo que hay antes de la posición $t$ y $x_{\le t}$ lo mismo con esa posición incluida. (El curso anterior escribía $w_t$ ; aquí es $x_t$ , la letra que allí era la fuente de un traductor.) Un modelo de lenguaje asigna a cada texto de $T$ tokens un número $p_\theta(x_{1:T})$ , no negativo y tal que, sumado sobre todos los textos de esa longitud, da $1$ : una distribución sobre las secuencias de $T$ tokens, para cada $T$ . El subíndice dice de quién es la distribución: de los pesos $\theta$ , no del español. Lo que el modelo cree, no lo que es.

No hace falta guardar un número por texto. Con dos tokens, $p(x_1, x_2) = p(x_1)\,p(x_2 \mid x_1)$ : la probabilidad de que pasen dos cosas es la de la primera por la de la segunda sabida la primera, que es la definición de probabilidad condicionada leída al revés. Aplicada $T - 1$ veces,

p_\theta(x_{1:T}) = \prod_{t=1}^{T} p_\theta(x_t \mid x_{<t}),

con $x_{<1}$ la secuencia vacía, de modo que el primer factor es $p_\theta(x_1)$ a secas. Es la regla de la cadena de la probabilidad (comparte nombre con la de las derivadas, y nada más), y es una identidad: toda distribución sobre textos se escribe así, sea la que sea. Elegir la forma causal no aproxima nada; lo único que hay que aproximar es cada factor, y para eso está la red.

Ver por qué la factorización es exacta, y por qué su recíproco también

Para dos posiciones, la probabilidad condicionada se define como $p(x_2 \mid x_1) = p(x_1, x_2) / p(x_1)$ cuando $p(x_1) > 0$ , así que $p(x_1, x_2) = p(x_1)\,p(x_2 \mid x_1)$ es esa definición con el denominador pasado al otro lado. Para $T$ posiciones, toma como «primera cosa» el prefijo $x_{1:T-1}$ y como «segunda» el token $x_T$ : $p(x_{1:T}) = p(x_{1:T-1})\,p(x_T \mid x_{<T})$ , y el primer factor es el mismo problema con una posición menos. Repetido hasta $p(x_1)$ , sale el producto.

El recíproco es lo que hace que la red sea un modelo de lenguaje. Si cada factor es una distribución sobre $V$ , el producto lo es sobre las secuencias de $T$ tokens: al sumar sobre $x_T$ sólo el último factor depende de él, y suma $1$ ; repite con $x_{T-1}$ , y así hasta que no queda ningún factor y la suma vale $1$ . Con $T$ softmax cualesquiera, el producto es una distribución legítima sobre los textos.

Y ahí entra la red. Entre los tokens y los números está la columna derecha del Transformer tal como la montaste en el proyecto del TransformerDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 9Proyecto: un Transformer desde ceroEl artículo entero, montado y ejecutado: un vocabulario de doce entradas compartido por los dos idiomas, dos bloques por columna, dos cabezas y una frase de cinco tokens que sale por arriba convertida en seis distribuciones. Las seis funciones que hacen el trabajo son los desafíos de las lecciones anteriores sin tocar una letra, y lo que las une es que todo lo de en medio recibe T por d_model y devuelve T por d_model. Nadie ha entrenado estos pesos, así que la traducción que propone no significa nada; lo que sí se puede comprobar con pesos cualesquiera son tres cosas, y la segunda es la que este montaje añade: que ninguna posición del decoder ve lo que todavía no se ha escrito exige la máscara en cada uno de los bloques, no en el primero, y quitar una sola se mide., sin la subcapa que miraba a la otra columna: la tabla, los bloques con su máscara, y la tabla leída al revés. Lo que sale por arriba en la posición $t$ es un vector $\mathbf{z}_t \in \mathbb{R}^{\lvert V \rvert}$ , los logits de esa posición: la preactivación de la capa de salida del curso anterior. Apilados por filas dan $\mathbf{Z} \in \mathbb{R}^{T \times \lvert V \rvert}$ , una fila por posición leída y una columna por entrada. El softmax de la lección sobre las funciones de pérdidaDeep Learning para NLP: del Perceptrón al TransformerBloque 2 · Lección 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. convierte cada fila en la distribución que el producto necesita:

p_\theta(x_{t+1} \mid x_{\le t}) = \text{softmax}(\mathbf{z}_t)_{x_{t+1}} = \frac{e^{z_{t,\,x_{t+1}}}}{\sum_{v \in V} e^{z_{t,\,v}}}.

Fíjate en el desplazamiento: la fila $t$ se calcula con $x_{\le t}$ y apuesta por $x_{t+1}$ , así que el factor de la posición $t$ del producto, $p_\theta(x_t \mid x_{<t})$ , sale de la fila $t - 1$ .

Todas las condicionales en una sola pasada

Cada factor del producto pide, en principio, una pasada por la red con su propio prefijo: $x_{\le 1}$ , luego $x_{\le 2}$ , y así. Serían $T$ pasadas por texto. Lo que las convierte en una es la máscara, y el argumento es el que el proyecto del Transformer dejó demostrado y aquí sólo se cita: con la máscara en cada bloque, la fila $t$ de lo que sale depende únicamente de las filas $1$ a $t$ de lo que entró, y eso sobrevive a apilar. Con lo que el $\mathbf{z}_t$ calculado sobre el texto entero es, número a número, el que saldría de pasar sólo el prefijo:

\mathbf{z}_t(x_{1:T}) = \mathbf{z}_t(x_{\le t}) \quad \text{para todo } t,

donde el argumento indica qué se le dio a la red. Una sola pasada sobre $x_{1:T}$ devuelve las $T$ filas de $\mathbf{Z}$ , con los $T$ factores del producto dentro.

Qué texto se le pasa y contra qué se compara es el desplazamiento de la lección sobre las máscarasDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 7Escribir no es leer: el decoder y su máscaraTodo lo que lleva construido el bloque supone la frase entera delante y las T posiciones calculadas a la vez, y hay media arquitectura para la que eso es falso: un modelo que escribe no tiene el resultado, lo va produciendo. Entrenarlo de una sola pasada pone la respuesta al lado de la posición que tiene que adivinarla, y la solución no es un bucle sino un sumando: menos infinito en la puntuación, antes del softmax, para que la exponencial lo borre del numerador y del denominador a la vez. Eso deja cada fila quedándose con su propio principio y volviéndolo a normalizar, así que la primera posición se lleva la unidad entera y ninguna fila deja de sumar 1. Con eso montado, la segunda subcapa del decoder es la atención del bloque anterior sin un solo cambio: consultas de lo que se escribe, claves y valores de lo que se leyó, mapa rectangular y ninguna máscara. sin ningún cambio: de una ventana de $T + 1$ tokens del corpus, la red lee los $T$ primeros, y la fila $t$ se compara con el token $t + 1$ , que es la misma ventana corrida una posición. Eso era el teacher forcing (el token verdadero en cada posición, no el que el modelo habría escrito), y aquí es lo que hace que cada fila sea la condicional que el producto pide y no otra.

Dos cosas más, dichas en voz alta. El primer factor, $p_\theta(x_1)$ , no lo calcula ninguna fila, porque no hay fila con nada delante. El curso anterior ponía ahí <GO>; el mini-GPT de este bloque prescinde de él: el primer token de cada ventana se da y no se predice, y lo que la red modela de una ventana es $p_\theta(x_{2:T+1} \mid x_1)$ , con $T$ factores y no $T + 1$ . Y sin la máscara pasa lo que la lección sobre BERT y GPTDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 10BERT y GPT: una columna cada unoEl modelo de la lección anterior sabe correr y para aprender pide lo más caro que hay: pares de frases con su traducción, escritos uno a uno a mano. Texto suelto, en cambio, sobra. Las dos familias que salieron del artículo en 2018 contestan a esa escasez quitando una columna, moviendo la máscara y cambiando qué se les pide predecir, y ninguna de las tres cosas es una operación nueva. Por el camino pagan una deuda del bloque 1: la firma de la representación deja de recibir una entrada del vocabulario y pasa a recibir la frase, que es lo único que puede darle a banco dos vectores. La celda lo mide en la misma posición de dos frases, y de los tres números que imprime, dos valen 1 por construcción. usó para descartar un encoder entrenado contra el token siguiente: la fila $t$ contendría ya $x_{t+1}$ , y la manera más barata de bajar la pérdida sería copiar. La máscara no es una restricción que el modelo paga: es lo que hace que la barra vertical diga la verdad.

La pérdida: menos el logaritmo del producto, por token

Entrenar es hacer que el modelo apueste fuerte por los textos del corpus: subir $p_\theta(x_{2:T+1} \mid x_1)$ sobre sus ventanas. Un producto de $T$ números entre $0$ y $1$ es minúsculo e incómodo de derivar; su logaritmo es una suma, y con el signo cambiado, un coste. Repartido entre las $T$ apuestas,

\mathcal{L}(\theta) = -\frac{1}{T}\sum_{t=1}^{T}\log p_\theta(x_{t+1} \mid x_{\le t}) = -\frac{1}{T}\log p_\theta(x_{2:T+1} \mid x_1),

que es la entropía cruzada del curso anterior con la etiqueta puesta en el token que de verdad vino, una por fila, promediada. Cada fila le cobra al modelo $-\log$ de lo que apostó por la verdad: nada si lo apostó todo, $\ln \lvert V \rvert$ si repartió por igual, y sin techo si apostó casi nada. Es el número que el modelo de lenguaje de caracteresDeep Learning para NLP: del Perceptrón al TransformerBloque 3 · Lección 7Proyecto: un modelo de lenguaje a nivel de carácterLa RNN vanilla y la BPTT, juntas en una red que predice el siguiente carácter en cada posición: un texto de T caracteres son T ejemplos apilados, y la etiqueta de cada paso es, gratis, el carácter que viene. Se entrena con recorte del gradiente sobre unos miles de caracteres —pocos pasos, para caber en el navegador— y después escribe, realimentando lo que muestrea. La pérdida cae de ln 32 a alrededor de 2.5 y el texto pasa de ruido a español mal hecho —palabras cortas reales, cuasi-palabras largas, ni una frase con sentido—: es lo que aprende un modelo de caracteres, y decirlo sin adornos es la lección. imprimía en cada vuelta; lo nuevo es saber que $\exp(-T\,\mathcal{L})$ es la probabilidad que el modelo le da a la ventana, y que entrenar es subirla.

La cuenta a mano, con cuatro tokens

Esta lección no lleva celda a propósito: el modelo que cumple todo lo de arriba, el mini-GPT de este bloque, lo cargas y lo entrenas más adelante, en la lección sobre entrenar un mini-GPTMás adelante · Bloque 1 · Lección 3Entrenar un mini-GPT en NumPyEl checkpoint del bloque es el resultado de 2 000 pasos de un bucle que esta lección escribe entero. Cada paso sigue la pérdida media de unas pocas ventanas del corpus sacadas al azar, y la lección deriva por qué eso apunta, de media, adonde apuntaría el corpus entero, y cuánto ruido cuesta ahorrarse el resto. El paso es AdamW, con una tasa de aprendizaje que se calienta y luego decae. Con todo ello el mini-GPT sigue entrenando en el navegador, sobre las últimas páginas de Marianela, que no había visto.. Aquí el modelo es una hoja de papel: los logits me los he inventado yo, elegidos para que $e^{z}$ salga entero. Los tokens son palabras, para que quepan en una hoja; el vocabulario del mini-GPT no está hecho de palabras, y de eso trata la lección siguiente, sobre BPEMás adelante · Bloque 1 · Lección 2BPE de verdad: fusionar, no solo partirEl tokenizador del mini-GPT, escrito desde cero. BPE parte de los 256 bytes con los que se escribe cualquier texto y repite una sola operación: contar los pares de tokens vecinos y fusionar el más frecuente. Esta lección deriva lo que eso garantiza (ningún texto se queda sin tokens, y decodificar devuelve el original byte a byte) y lo que cuesta (cada fusión es una entrada más del vocabulario y ahorra menos tokens que la anterior), y lo comprueba entrenando sobre Marianela las mismas fusiones que usa el modelo..

Toma la ventana la casa es blanca y el vocabulario de sus cuatro palabras, en orden alfabético: $V = \{\textit{blanca}, \textit{casa}, \textit{es}, \textit{la}\}$ . El primer token se da, así que hay tres apuestas, y en cada fila la red ve el prefijo y nada más:

$t$	lo que ve la fila, $x_{\le t}$	lo que viene, $x_{t+1}$	$\mathbf{z}_t$ , en el orden de $V$
$1$	la	casa	$(\ln 2,\; \ln 4,\; 0,\; 0)$
$2$	la casa	es	$(\ln 4,\; 0,\; \ln 2,\; 0)$
$3$	la casa es	blanca	$(\ln 4,\; \ln 2,\; 0,\; 0)$

Haz tres cosas con cada fila, mirando sólo sus números:

Exponencia los cuatro logits y súmalos. En la fila $1$ sale $(2, 4, 1, 1)$ , que suma $8$ ; comprueba que las otras dos también suman $8$ (elección mía, no casualidad).
Divide la casilla del token que de verdad vino entre esa suma: es $p_\theta(x_{t+1} \mid x_{\le t})$ . En la fila $1$ , casa es la segunda casilla: $4/8 = 1/2$ .
Toma $-\ln$ de ese número: $-\ln(1/2) = \ln 2 \approx 0.693$ .

Te tienen que salir $1/2$ , $1/4$ y $1/2$ , que cuestan $\ln 2$ , $2\ln 2$ y $\ln 2$ , y la media es

\mathcal{L} = \frac{\ln 2 + 2\ln 2 + \ln 2}{3} = \frac{4}{3}\ln 2 \approx 0.924,

frente al $\ln 4 \approx 1.386$ de un modelo que repartiera por igual y al $0$ de uno que lo apostara todo a la verdad, siempre. Y ahora por el otro lado: multiplica las tres apuestas. $\frac{1}{2} \cdot \frac{1}{4} \cdot \frac{1}{2} = \frac{1}{16}$ es $p_\theta(\textit{casa}, \textit{es}, \textit{blanca} \mid \textit{la})$ , la probabilidad de la ventana dado su primer token, y $\exp\left(-3 \cdot \frac{4}{3}\ln 2\right) = 2^{-4}$ es el mismo dieciseisavo. La media de los $-\log$ y el producto de las probabilidades son un solo número visto desde dos lados.

Mira la fila $2$ . El modelo apostó más por blanca que por es: la casa blanca es un principio razonable, y su favorita habría fallado. La pérdida no le pregunta eso. Le pregunta cuánto apostó por lo que de verdad vino, y como a es le dio $1/4$ , le cobra $2\ln 2$ : el doble que donde acertó con $1/2$ , y no un salto de «mal» a «bien». Con $1/8$ , el triple. Acertar la favorita no aparece en la fórmula, y por eso un modelo puede mejorar mucho sin cambiar ninguna de sus favoritas. Y la fila $2$ tendría los mismos logits sin blanca al final de la ventana: nunca lo vio. Ésa es la máscara en una frase, y lo que permite escribir tres filas en una tabla en lugar de tres pasadas.

Comprueba tu intuición

Cuatro preguntas sobre la máscara, la fila $t$ , la cadena y la ventana de arriba por el otro lado.

Una columna con la máscara causal en todos sus bloques lee una ventana de $T + 1$ tokens. Marca lo que la máscara compra al entrenar.

Marca todas las opciones correctas. Se corrige todo o nada: no hay puntuación parcial.

Que la fila

t

de los logits sea, número a número, la que saldría de pasar sólo

x_{\le t}

: por eso los

T

factores del producto salen de una única pasada.Que la pérdida se pueda calcular sin conocer la continuación verdadera: la red apuesta y la máscara guarda la respuesta.Que generar texto sea también una sola pasada: las

T

filas salen a la vez, así que los

T

tokens también.Que

p_\theta(x_{t+1} \mid x_{\le t})

signifique lo que dice: sin máscara la fila

t

ya contendría

x_{t+1}

, y bajar la pérdida sería copiar.

La red lee $x_{1:T}$ y devuelve $\mathbf{Z} \in \mathbb{R}^{T \times \lvert V \rvert}$ . ¿Qué hay en su fila $t$ ?

Los logits de una distribución sobre qué entrada de

V

ocupa la posición

t + 1

, calculados a partir de

x_{\le t}

y de nada más.La probabilidad que el modelo le da al token

x_t

, sabido lo que había antes.Los logits de una distribución sobre la posición

t

, calculados a partir de la ventana entera.La fila de la tabla

\mathbf{E}

que corresponde a

x_t

, después de pasar por los bloques.

Escribir $p_\theta(x_{1:T})$ como el producto de las condicionales $p_\theta(x_t \mid x_{<t})$ es una aproximación: la probabilidad exacta de un texto necesitaría, además del producto, un término que recoja lo que las condicionales no capturan.

VerdaderoFalso

El modelo de la tabla de arriba le dio $1/2$ , $1/4$ y $1/2$ a los tres tokens que de verdad venían. ¿Qué probabilidad le da a la ventana entera, $p_\theta(\textit{casa}, \textit{es}, \textit{blanca} \mid \textit{la})$ ? Escríbela como decimal.

Se acepta un margen de ±0.001.

Todo lo de esta lección se ha contado con cuatro palabras como tokens. El vocabulario del mini-GPT que este bloque entrena tiene $512$ entradas y ninguna elegida a mano: las eligió un procedimiento. El curso anterior dijo por qué tenía que ser así, un vocabulario de palabras no es total, y las subpalabras lo arreglan partiendo lo que no conocen en trozos que sí. Lo que aquel curso no hizo, y lo dijo, fue construir uno: su explorable mostraba el resultado de BPE, y de dónde salía cada corte quedó fuera.

Ese procedimiento es la lección siguiente, sobre BPE de verdad: no partir una palabra en trozos que ya existen, sino fusionar, sobre un corpus en español, los pares más frecuentes hasta el tamaño que se quiera, y ver qué le hace eso a la ñ, a qu y a ción. Con el vocabulario en la mano, lo que queda del bloque es cargar el modelo, seguir entrenándolo, muestrear de él y medirlo, y todo eso es aritmética sobre la fórmula de hoy.

¿Te ha sido útil?

Para profundizar2 fuentes · 2 papers

De dónde sale lo de esta lección, y dónde seguir si quieres más. Nada de aquí hace falta para continuar el curso.

A Neural Probabilistic Language Model
paperBengio, Ducharme, Vincent y Jauvin, 2003Journal of Machine Learning Research 3EN
La primera red entrenada contra la regla de la cadena: su introducción abre con el producto de esta lección y explica por qué una red y no una tabla de recuentos. Con un MLP de ventana fija donde aquí hay un Transformer.
Prediction and Entropy of Printed English
paperClaude E. Shannon, 1951Bell System Technical Journal 30(1)EN
El juego de tapar con la mano, jugado por personas sobre inglés en 1951, y lo que sale de medirlo: cuánto se puede apostar por la letra siguiente. La idea de esta lección, décadas antes de la primera red que la usó.