Predecir la siguiente palabra

El objetivo: predecir la siguiente pieza

Por la regla de la cadena, la probabilidad de un texto $x_1,\dots,x_n$ se descompone en predicciones de la siguiente pieza:

Un modelo de lenguaje es cualquier modelo de $P(x_t\mid x_{<t})$. GPT-1 se entrena maximizando $\sum_t \ln P_\theta(x_t\mid x_{t-k},\dots,x_{t-1})$ sobre un corpus, el «objetivo estándar de modelado de lenguaje» (ecuación 1 del artículo), donde $k$ es el tamaño de la ventana de contexto. Equivale a minimizar la entropía cruzada $L=-\tfrac1n\sum_t \ln p_\theta(x_t\mid x_{<t})$. Generar es el camino inverso: $x_t\sim P(\cdot\mid x_{<t})$, una pieza a la vez (autorregresión).

Contar: el modelo de n-gramas

Con una ventana de $n-1$ piezas, la estimación de máxima verosimilitud es la frecuencia relativa:

donde $N(c,w)$ cuenta cuántas veces $w$ siguió al contexto $c$. En la lección ($n=2$, bigramas), «es» aparece $N=8$ veces y $N(\text{es},\text{azul})=4$, así que $P=4/8=0.5$. Shannon (1948) ya generaba texto así: su «aproximación de segundo orden por palabras» elige cada palabra según las frecuencias de transición desde la anterior. El límite es la dispersión: con un vocabulario de tamaño $V$ hay hasta $V^{\,n-1}$ contextos, casi todos raros o nunca vistos, y la tabla no generaliza. Bengio et al. (2003) propusieron cambiarla por una red que aprende un vector por palabra: si «perro» y «gato» tienen vectores parecidos, lo aprendido de una frase se extiende a la otra.

Softmax y temperatura

Una red produce un puntaje $z_i$ (en inglés, logit) por cada pieza $i$ del vocabulario. La probabilidad es

Con $T=1$ es el softmax de siempre. Sumar la misma constante a todos los puntajes no cambia nada; por eso los puntajes de la lección, $z_i=\ln c_i-\ln 2$ (cuentas $4,2,1,1$; en pantalla, redondeados: $0.7,\,0,\,-0.7,\,-0.7$), dan exactamente cuenta ÷ total. En general, con $z_i=\ln c_i$ queda $p_i=c_i^{1/T}/\sum_j c_j^{1/T}$: con $T=0.5$, azul vale $16/22\approx0.727$; con $T=2$, $2/(2+\sqrt2+1+1)\approx0.369$; con $T=0.25$, $256/274\approx0.934$. Si $T\to0$ toda la masa va a la pieza de mayor puntaje (voraz); si $T\to\infty$ la distribución tiende a la uniforme. El nombre viene de la física estadística: la distribución de Boltzmann tiene esta misma forma, con la temperatura dividiendo. Con este papel aparece, por ejemplo, en la destilación de conocimiento (Hinton et al., 2015).

Top-k y top-p

Tras el softmax se puede recortar. Top-k (Fan et al., 2018, que muestrean entre las $k=10$ más probables) conserva las $k$ piezas más probables. Top-p, o muestreo de núcleo (Holtzman et al., 2020), conserva el conjunto más pequeño $V^{(p)}$ cuya probabilidad suma al menos $p$:

Luego se reparte de nuevo, $q_i=p_i/\sum_{j\in V^{(p)}}p_j$, y se sortea con $q$. Holtzman et al. observaron que los métodos que maximizan la probabilidad al generar producen texto «soso, incoherente o atrapado en ciclos repetitivos» (el ciclo voraz de la lección), y que recortar la cola poco fiable, sin llegar a lo voraz, da texto más parecido al humano.

En código

El modelo de la lección: contar pares, softmax con temperatura, top-p y escritura voraz, con la salida que imprime:

import math
from collections import Counter, defaultdict

texto = ("el cielo es azul . el mar es azul . el cielo es gris . el sol es grande . "
         "de noche el cielo es oscuro . el cielo es azul y el sol brilla . "
         "el mar es gris . hoy el cielo es azul .")
piezas = texto.split()

# 1. Contar qué pieza sigue a cada pieza (un modelo de bigramas)
tabla = defaultdict(Counter)
for a, b in zip(piezas, piezas[1:]):
    tabla[a][b] += 1

def softmax(puntajes, T=1.0):
    z = [s / T for s in puntajes]
    m = max(z)
    e = [math.exp(v - m) for v in z]    # restar el máximo no cambia el resultado
    return [v / sum(e) for v in e]

def distribucion(contexto, T=1.0, top_p=1.0):
    palabras = [w for w, _ in tabla[contexto].most_common()]
    puntajes = [math.log(c) for _, c in tabla[contexto].most_common()]   # puntaje = ln(cuenta)
    p = softmax(puntajes, T)
    nucleo, acum = [], 0.0               # top-p: las más probables hasta juntar top_p
    for w, q in zip(palabras, p):
        nucleo.append((w, q)); acum += q
        if acum >= top_p - 1e-9: break
    total = sum(q for _, q in nucleo)
    return [(w, round(q / total, 3)) for w, q in nucleo]   # repartir de nuevo

print(dict(tabla["es"]))
for T in (1.0, 0.5, 2.0):
    print(T, distribucion("es", T))
print(distribucion("es", top_p=0.7))

# 2. Escribir: tomar siempre la más probable (voraz) y repetir
escrito = ["el", "cielo", "es"]
for _ in range(9):
    escrito.append(tabla[escrito[-1]].most_common(1)[0][0])
print(" ".join(escrito))
# {'azul': 4, 'gris': 2, 'grande': 1, 'oscuro': 1}
# 1.0 [('azul', 0.5), ('gris', 0.25), ('grande', 0.125), ('oscuro', 0.125)]
# 0.5 [('azul', 0.727), ('gris', 0.182), ('grande', 0.045), ('oscuro', 0.045)]
# 2.0 [('azul', 0.369), ('gris', 0.261), ('grande', 0.185), ('oscuro', 0.185)]
# [('azul', 0.667), ('gris', 0.333)]
# el cielo es azul . el cielo es azul . el cielo

El texto es propio de la lección y sus versiones en español e inglés son paralelas palabra por palabra, así que las cuentas coinciden en los dos idiomas. La escena usa este mismo modelo (lm.ts) y lo comprueba verify-data.ts, ambos en la carpeta de la lección.

Escala: GPT-1, GPT-2 y GPT-3

Los tres son transformers de solo decodificador entrenados con el objetivo de arriba. GPT-1 (2018) leyó BooksCorpus, más de 7 000 libros inéditos; su tamaño, 117 millones de parámetros, figura en la tabla 2 del artículo de GPT-2 («el modelo más pequeño equivale al GPT original»). GPT-2 (2019) llegó a 1 542 millones y leyó WebText, algo más de 8 millones de documentos (40 GB de texto). GPT-3 (2020) tiene 175 000 millones. Un dato curioso: el artículo de GPT-3 cuenta 125 millones para un modelo con la misma forma que GPT-1 (12 capas de 768). La diferencia cuadra con la tabla de embeddings, que crece con el vocabulario: GPT-1 usó 40 000 fusiones de BPE y GPT-2 amplió el vocabulario a 50 257 piezas.

Lo que viene

Dijimos «palabras», pero el modelo trabaja con piezas: los tokens (lección 20). La probabilidad la calcula una red que mira todo el contexto con atención (lecciones 21 y 22), y qué significa entrenarla con casi todo internet se ve en la lección 23.