BERT y GPT: una columna cada uno

20 min read

El Transformer de la lección anterior —el proyecto, montado y ejecutado de principio a fin— sabe hacer una cosa y ninguna más: correr. Sus pesos siguen siendo los que devolvió el generador de números aleatorios, y corregirlos pide un conjunto de entrenamiento. El que esa arquitectura pide es de los caros: pares de frases, cada una con su traducción, escritos uno a uno por alguien que sabe los dos idiomas. Texto suelto, en cambio, sobra —hay muchísimo más del que nadie va a leer nunca—. La pregunta de hoy es qué se le puede enseñar a un modelo con un texto y nada más.

Hay una segunda deuda que vence hoy, y es mucho más vieja. El bloque 1 se despidió —su última lección, sobre GloVe y los límites de los embeddings estáticosBlock 1 · Lesson 8GloVe y los límites de los embeddings estáticosLas coocurrencias ya estaban contadas antes de entrenar nada, y sus razones son lo que separa una entrada de otra. Exigirle a las diferencias de vectores que reproduzcan esas razones da la ecuación de GloVe; y las dos técnicas del bloque terminan compartiendo el mismo techo: una fila por entrada del vocabulario, diga lo que diga la frase.— con una entrada del vocabulario que no cabía en su propia maquinaria: banco tiene una fila de $\mathbf{E}$ y tiene una sola, de modo que el banco cerró a las dos y el banco estaba mojado se llevan el mismo vector y ninguna de las dos frases tiene manera de pedir otro. Las dos deudas resultan ser la misma, y ésa es la tesis de hoy: lo que hace falta para aprender de texto suelto es exactamente lo que le da a banco dos vectores.

Pregúntate de qué depende el vector que un modelo le asigna a la posición de banco. En el bloque 1 la respuesta cabía en una palabra: de banco. La tabla se consulta con la entrada y devuelve su fila, y la frase alrededor podría no existir. Un Transformer contesta distinto, porque su auto-atención mezcla filas: lo que sale en una posición depende de las posiciones que esa posición pudo mirar.

Y cuáles pudo mirar lo decide una sola cosa, la máscara de la lección sobre el encoder, el decoder y las máscarasBlock 5 · Lesson 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.. Con ella puesta, la posición de banco ve el banco y se acaba ahí; sin ella ve la frase entera, cerró a las dos incluido. No es un detalle interno del decoder: es el interruptor que decide cuánto del texto llega a cada posición, y las dos posiciones de ese interruptor son los dos modelos de esta lección.

De qué depende el vector de una posición

La lección sobre el problema de representar el lenguaje escribió la representación como una función:

r : V \to \mathbb{R}^{d_{\text{model}}},

una entrada del vocabulario dentro, un vector fuera. Lo que esa firma no admite es la frase, y sin la frase nada distingue las dos apariciones de banco. Cambiar los números de $\mathbf{E}$ no toca el problema; hay que cambiar el argumento.

Un modelo causal lo cambia por lo escrito hasta esa posición. Llamando $V^{*}$ a las secuencias finitas de tokens —la estrella de la lección sobre la tokenización—:

r : V^{*} \to \mathbb{R}^{d_{\text{model}}},

y el vector de la posición $t$ es $r(w_{1:t})$ . Fíjate en que no hace falta pasarle $t$ aparte: la posición es el último índice del prefijo. Un modelo bidireccional lo cambia por la frase entera, y entonces sí hace falta decir de qué posición se habla:

r : V^{*} \times \mathbb{N} \to \mathbb{R}^{d_{\text{model}}},

con el vector de la posición $t$ igual a $r(w_{1:T},\, t)$ . Las dos últimas firmas son las de una representación contextual: el mismo vocabulario, la misma tabla debajo, y un argumento que ya no es una entrada.

Las tres salen de la misma aritmética y lo único que las separa es la máscara. La segunda tiene además una consecuencia que conviene ver antes de las cuentas: $r(w_{1:t})$ depende del prefijo y de nada más, así que dos frases que empiezan igual reciben el mismo vector en esa posición. el banco cerró a las dos y el banco estaba mojado comparten el banco, de modo que un modelo causal le da a banco un vector por prefijo, no uno por frase. La deuda del bloque 1, en esa posición, la paga la tercera firma y sólo ella.

Dos maneras de quitar una columna

GPT (Generative Pre-trained Transformer) se queda con la columna derecha. Le sobra una subcapa —la atención encoder-decoder no tiene a quién mirar cuando no hay encoder—, así que sus bloques llevan dos, igual que los del encoder, con la diferencia de que la auto-atención lleva máscara en todos ellos, que es lo que la lección anterior midió. Lo que se le pide predecir es el token siguiente, y la fórmula no es nueva: es la del modelo de lenguaje de caracteres de la lección sobre el modelo de lenguaje a nivel de carácterBlock 3 · Lesson 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., con tokens donde había caracteres y el Transformer donde estaba la RNN (recurrent neural network),

\ell = \frac{1}{T}\sum_{t=1}^{T} -\log P\left(w_t \mid w_{<t}\right).

Eso es lo que contesta a la pregunta de arriba: cualquier texto sirve de conjunto de entrenamiento, y uno de $T$ tokens trae $T$ ejemplos ya hechos, con su etiqueta puesta por el propio texto. Nadie tiene que escribir nada más.

BERT (Bidirectional Encoder Representations from Transformers) se queda con la izquierda y le quita la máscara, y ahí esa fórmula deja de servir. Desarrollémoslo, porque es la única cuenta de la lección. La lección anterior demostró que respetar el pasado se conserva al componer subcapas, y que por eso la barra vertical de $P\left(w_t \mid w_{<t}\right)$ dice la verdad. Quita la máscara y el argumento se cae por donde entró: la auto-atención de la primera subcapa ya mezcla en su fila $t$ la fila $t+1$ , así que lo que sale en la posición $t$ contiene $w_{t+1}$ . Pedirle que prediga $w_{t+1}$ es pedirle que copie. La pérdida se va al suelo, la barra vertical condiciona sobre su propia respuesta y de la frase no ha aprendido nada.

De ahí sale el modelado de lenguaje enmascarado (masked language modelling, MLM): tapa una parte de las posiciones con [MASK] —la marca que tapa una posición— y pide justo las tapadas. Con $\tilde{w}_{1:T}$ la frase ya tapada, cada posición escondida aporta

-\log P\left(w_t \mid \tilde{w}_{1:T}\right),

y $\ell$ es la media de ese número sobre las tapadas. La respuesta ya no está en la entrada porque se ha borrado de la entrada, que es la diferencia entera. Y trae su precio: BERT cobra la fórmula de GPT sólo en las posiciones que tapó —un 15 % de ellas, en el artículo original—, mientras que GPT la cobra en las $T$ .

Lo que las dos familias comparten viene después, y es lo que las hizo importar. Primero el preentrenamiento: muchas vueltas contra texto crudo, sin tarea ninguna a la vista, hasta que la representación contextual valga algo. Después, la tarea de quien lo use. Lo que vino luego —modelos mucho mayores, otras maneras de codificar la posición, atenciones más baratas para textos largos— cambió los detalles de las quince cajas y no la aritmética que escribiste en la lección anterior.

Banco, en dos frases

La celda pone las dos frases una al lado de otra, con banco en la misma posición en las dos, y las mete por una llamada de auto-atención con un interruptor para la máscara. Compara los dos vectores de esa posición con la similitud coseno de la lección sobre la bolsa de palabras. Son tres números, y dos de ellos valen $1$ por construcción, no por suerte.

import numpy as np

f1 = "el banco cerró a las dos".split()
f2 = "el banco estaba mojado".split()
V = sorted(set(f1 + f2))
ix = {w: i for i, w in enumerate(V)}
d, t = 32, 1                                    # <banco> ocupa la posicion 1 en las dos

rng = np.random.default_rng(0)
E = rng.normal(size=(len(V), d)) / np.sqrt(d)
Wq, Wk, Wv = [rng.normal(size=(d, d)) / np.sqrt(d) for _ in range(3)]


def entrada(frase):                             # la tabla mas la codificacion posicional
  i = np.arange(d // 2)
  pos = np.arange(len(frase))[:, None]
  PE = np.zeros((len(frase), d))
  PE[:, 0::2] = np.sin(pos / 10000 ** (2 * i / d))
  PE[:, 1::2] = np.cos(pos / 10000 ** (2 * i / d))
  return np.sqrt(d) * E[[ix[w] for w in frase]] + PE


def auto_atencion(X, causal):
  S = (X @ Wq) @ (X @ Wk).T / np.sqrt(d)
  if causal:
      S = np.where(np.triu(np.ones(S.shape, dtype=bool), k=1), -np.inf, S)
  A = np.exp(S - S.max(axis=1, keepdims=True))
  A = A / A.sum(axis=1, keepdims=True)
  return A @ (X @ Wv)


def cos(u, v):
  return float(u @ v / (np.linalg.norm(u) * np.linalg.norm(v)))


X1, X2 = entrada(f1), entrada(f2)
print("el mismo array a la entrada:", bool(np.allclose(X1[t], X2[t])))
print("coseno a la entrada : %.6f" % cos(X1[t], X2[t]))
print("coseno con mascara  : %.6f" % cos(auto_atencion(X1, True)[t], auto_atencion(X2, True)[t]))
print("coseno sin mascara  : %.6f" % cos(auto_atencion(X1, False)[t], auto_atencion(X2, False)[t]))

numpy

La primera ejecución descarga el intérprete de Python (~15 MB). Después queda en la caché del navegador.

Los dos primeros salen $1$ y salen exactos, cada uno por su motivo. A la entrada las dos filas son el mismo array: la misma fila de $\mathbf{E}$ , la misma posición y por tanto la misma fila de $\text{PE}$ sumada encima. Con máscara, la fila $1$ de los pesos de atención sólo tiene peso en las columnas $0$ y $1$ , y esas dos filas de $\mathbf{X}$ son idénticas en las dos frases, así que las puntuaciones son idénticas y lo que sale también. El tercero baja a $0.550005$ , y ése es el que hacía falta: quitada la máscara, cerró a las dos y estaba mojado entran en la mezcla y el vector de banco deja de ser el mismo.

Con pesos que nadie ha entrenado, cuánto se separan esos dos vectores no significa nada —lo decidió el generador—. Lo que es de la arquitectura y no del generador es que puedan separarse: la firma admite la frase, así que la frase alcanza al resultado. Que los separe bien —el banco del dinero lejos del banco del parque— es lo que el preentrenamiento tiene que conseguir, y no hay número en esta celda que lo demuestre.

Comprueba tu intuición

Cuatro preguntas: qué cambiaron los dos respecto de la figura del artículo, por qué un encoder sin máscara no puede entrenarse contra el token siguiente, cuál de las tres firmas le da a banco dos vectores, y qué se puede preentrenar con un texto suelto.

BERT y GPT salen los dos de la figura 1 de Attention is All You Need. Marca lo que cada uno cambió respecto de ella.

Select every correct option. This is graded all-or-nothing: there is no partial credit.

Cuál de las dos columnas se queda, y con ella cuántas subcapas tiene un bloque: sin encoder no hay atención encoder-decoder que poner.Dónde va la máscara: en todas las auto-atenciones del modelo o en ninguna.Qué se le pide predecir, y con ello qué texto sirve de conjunto de entrenamiento.La fórmula de la atención: uno de los dos cambió el divisor

\sqrt{d_k}

para poder mirar en las dos direcciones.

Un encoder sin máscara entrenado con la pérdida $-\log P\left(w_t \mid w_{<t}\right)$ aprendería un modelo de lenguaje que además mira a la derecha: lo mejor de los dos mundos.

TrueFalse

el banco cerró a las dos y el banco estaba mojado. ¿Cuál de las tres firmas le da a banco dos vectores distintos en la posición que ocupa?

Sólo

r(w_{1:T},\, t)

. A las otras dos les llega lo mismo en las dos frases: a la tabla porque la frase no le entra, y a la causal porque las dos frases comparten el prefijo el banco.Las dos contextuales,

r(w_{1:t})

r(w_{1:T},\, t)

: en cuanto la frase es argumento, dos frases distintas dan dos vectores distintos.Las tres, en cuanto los pesos estén entrenados: con

\mathbf{E}

bien ajustada, banco acaba teniendo una fila por sentido.Ninguna en esa posición, porque la codificación posicional es la misma en las dos frases y domina la suma.

Tienes un archivo de novelas en español y nada más: ni traducciones, ni etiquetas, ni preguntas. Marca lo que puedes preentrenar con él.

Select every correct option. This is graded all-or-nothing: there is no partial credit.

Un GPT, prediciendo cada token a partir de lo anterior: cada novela trae tantos ejemplos como tokens tiene, y ya están escritos.Un BERT, tapando posiciones y pidiendo las tapadas: la respuesta está en el propio texto, borrada de la entrada.El Transformer de dos columnas de la lección anterior, dándole las novelas por las dos entradas: aprendería a llevar el español al español, que es un caso particular de traducir.Un clasificador de reseñas, pidiéndole la etiqueta de cada novela.

Ninguno de los dos sirve, recién preentrenado, para lo que tú quieras. Lo que sale de esa primera fase es una representación contextual buena y ninguna tarea: BERT no clasifica reseñas y GPT no contesta preguntas, porque nadie les ha dicho todavía qué es una reseña ni qué es una pregunta. Lo que falta es la segunda mitad de la receta, y es la mitad corta —unas pocas vueltas sobre unos pocos miles de ejemplos etiquetados, partiendo de los pesos del preentrenamiento en lugar del generador de números aleatorios.

Eso es el fine-tuning, y es la lección siguiente, la última: hacerlo de verdad, sobre un modelo preentrenado de verdad. No corre en el navegador, y la lección empieza diciendo por qué —los pesos que hay que mover no caben donde han cabido las celdas de este curso—. Se hace en un cuaderno de Colab, con la máquina que hace falta al otro lado.