Un modelo neuronal de lenguaje
Unos 22 minutos de lectura, con 10 ejemplos en 11 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.16. Lee el original
En esta página
- Predecir a partir de una ventana de embeddings
- Calcular gradientes por retropropagación
- Da pasos de descenso de gradiente
- Entrenar con PyTorch
- Detén el entrenamiento cuando la pérdida de validación empieza a subir
- Compara con la línea base
- Mezcla la red con los conteos
- Más texto ayuda solo si es del mismo tipo
- Sugerir a partir de contextos similares
- Qué sale mal en producción
- Lo que decidió este capítulo
Al final de este capítulo podrás construir un modelo neuronal de lenguaje que predice el siguiente token a partir de una ventana de tokens anteriores, calcular sus gradientes a mano y comprobarlos, entrenarlo con PyTorch y medirlo de forma justa frente al modelo basado en conteos. También verás que un modelo aprendido no gana por el hecho de ser aprendido: este pierde frente al conteo por sí solo, y ayuda cuando se combinan los dos.
El capítulo 3 construyó la referencia del libro, un modelo Kneser-Ney de 4 gramos que predice cada token de los nombres de productos de la tienda a partir de los tres tokens anteriores, mediante conteos. Su límite era que no puede relacionar un contexto con otro: entre los nombres de una tienda que vende muebles y artículos para el hogar, tiene conteos para patio bar y ninguno para outdoor bar, y nada vincula los dos. El capítulo 4 mostró que los vectores pueden relacionar tokens, ya que patio y outdoor obtienen vectores cercanos cuando se aprenden a partir del texto de la tienda. Este capítulo coloca vectores dentro de un modelo. Un modelo neuronal de lenguaje lee los tokens anteriores como vectores, los combina con una aritmética aprendida y produce una probabilidad para cada token del vocabulario. Aprende sus vectores y su aritmética a la vez, entrenándose para predecir el siguiente token. El diseño es el que introdujeron Bengio y sus colaboradores (Bengio et al., 2003).
La tienda aporta el texto, y la prueba es la que enfrenta todo modelo desde el capítulo 3: la perplejidad por token sobre los nombres de validación, usando el tokenizador de la tienda. Cuanto menor, mejor, y la referencia obtiene 23.1.
Predecir a partir de una ventana de embeddings
El modelo de este capítulo observa una ventana fija de los tokens anteriores, cuatro en este caso, el mismo contexto que cuenta un 5-grama. Cada token se busca en una tabla de embeddings, una matriz con una fila de números por cada token del vocabulario, como en el capítulo 4, salvo que esta tabla se aprende para predecir el siguiente token en lugar de calcularse a partir de conteos. Las cuatro filas se unen una junto a otra formando un único vector largo, x. Una capa oculta calcula h = tanh(xW + b) a partir de su entrada x: multiplica x por una matriz de pesos W, suma un vector de sesgos b y pasa cada resultado por tanh, una función que comprime cualquier número al rango entre −1 y 1, de modo que la capa puede combinar sus entradas de maneras que las simples sumas no permiten. Después, una capa de salida calcula z = hU + c a partir de la salida h de la capa oculta, una puntuación por cada token del vocabulario, llamadas en conjunto los logits.
El último paso convierte las puntuaciones en probabilidades. Softmax exponencia cada logit y divide entre la suma, de modo que los resultados son positivos y suman uno, y una puntuación más alta significa una probabilidad más alta:
P(token i) = exp(zᵢ) / Σⱼ exp(zⱼ)
Trabajado con los pesos entrenados, una predicción muestra cómo el modelo convierte cuatro tokens en probabilidades: el siguiente token después de un nombre que empieza con patio bar. Cada línea del ejemplo es una de las fórmulas anteriores, y sus formas impresas muestran lo que hace cada paso:
1"""One prediction of the trained window model, computed by hand from its saved weights: the embeddings, the tanh layer,2the output scores and the softmax. The prose's point rests on the shapes, the parameter counts and the three likeliest3tokens after `patio bar`."""4import numpy as np56from lib import bpe, neural7from lib.ngrams import START89weights, vocabulary, manifest = neural.load()10index, width = {t: i for i, t in enumerate(vocabulary)}, manifest["settings"]["context"] # token -> row; the window's width, from the saved settings11context = ([START] * width + bpe.store_tokenizer().encode("patio bar"))[-width:] # pad with start markers, keep the last width tokens12ids = np.array([[index[t] for t in context]])1314vectors = weights["embedding"][ids] # one 64-number vector per token15joined = vectors.reshape(1, -1) # -1 lets numpy work out the length: 4 vectors of 64 make 25616hidden = np.tanh(joined @ weights["hidden_w"] + weights["hidden_b"]) # one layer, squashed into -1 to 117logits = hidden @ weights["output_w"] + weights["output_b"] # one score for every token18probabilities = np.exp(logits - logits.max()) # subtract the largest score first: same probabilities, and exp can't overflow19probabilities /= probabilities.sum() # softmax: scores into probabilities2021print("context:", " ".join(context))22for name, array in [("embeddings", vectors), ("joined", joined), ("hidden", hidden), ("logits", logits)]:23 print(f"{name} shape:", array.shape)24print("vocabulary size:", f"{len(vocabulary):,}")25print("parameters:", f"{sum(w.size for w in weights.values()):,}")26for part in ["embedding", "hidden_w", "output_w"]:27 print(f"parameters in {part}:", f"{weights[part].size:,}")28for i in np.argsort(-probabilities[0], kind="stable")[:3]: # the three likeliest; a stable sort keeps ties in vocabulary order29 print(f"P({vocabulary[i]} | patio bar): {probabilities[0, i]:.2f}")
python window-model-by-hand.pycontext: <s> <s> patio</w> bar</w>
embeddings shape: (1, 4, 64)
joined shape: (1, 256)
hidden shape: (1, 256)
logits shape: (1, 4140)
vocabulary size: 4,140
parameters: 1,394,732
parameters in embedding: 264,960
parameters in hidden_w: 65,536
parameters in output_w: 1,059,840
P(stool</w> | patio bar): 0.63
P(with</w> | patio bar): 0.23
P(&</w> | patio bar): 0.05
La ventana se rellena con marcadores de inicio, porque el nombre solo tiene dos tokens hasta el momento. Cada uno de los cuatro tokens se convierte en un vector de 64 números; unidos, forman un vector de 256; la capa oculta lo transforma en otros 256; y la capa de salida da una puntuación para cada uno de los 4,140 tokens que conoce el modelo, el vocabulario del tokenizador de tiendas más los marcadores de inicio y fin. El modelo de ventana tiene 1,394,732 parámetros, los números que aprende. Alrededor de tres cuartas partes de ellos están en los pesos de la capa de salida, 1,059,840, porque necesita una columna para cada token, y la mayoría del resto está en la tabla de embeddings. Su predicción es razonable: stool con probabilidad 0.63, y después with y &, que continúan nombres como patio bar with stools.
Regla práctica: Construye a mano el paso hacia adelante de cualquier modelo que entrenes, al menos una vez, e imprime la forma de cada arreglo intermedio, como hace este ejemplo: un error de forma es un fallo común en el código de redes neuronales, y las formas indican exactamente lo que calcula el modelo. Espera que la capa de salida concentre la mayoría de los parámetros siempre que el vocabulario sea grande.
Calcular gradientes por retropropagación
Un modelo con pesos aleatorios predice mal; el entrenamiento ajusta los pesos para predecir bien. Para medir qué tan mal predice un modelo, usa la pérdida: L = −log P(siguiente token), el logaritmo negativo de la probabilidad que el modelo asignó al token que realmente vino después, la misma sorpresa que el capítulo 1 promedia en la perplejidad. El entrenamiento reduce la pérdida promedio, y una pérdida menor significa una perplejidad menor. Para reducir la pérdida, cada peso necesita un gradiente: cuánto cambiaría la pérdida si ese peso cambiara un poco, escrito ∂L/∂w.
La retropropagación calcula todos los gradientes de una sola vez, aplicando la regla de la cadena del cálculo hacia atrás a través del pase hacia adelante: desde la pérdida hasta los logits, desde los logits a través de la capa de salida hasta la capa oculta, a través de tanh, y de vuelta a los embeddings que se usaron (Rumelhart et al., 1986). Vale la pena aprenderse de memoria dos de sus pasos. El gradiente de la pérdida respecto a los logits son las probabilidades de softmax menos 1 en el token verdadero. Y el gradiente a través de tanh se multiplica por 1 − h², que es pequeño donde h está cerca de ±1. El módulo compartido del libro lib.tinynet lo escribe completo, línea por línea, para una versión pequeña del modelo de la tienda, con 5 tokens, embeddings de 2 números, una ventana de 2 y 3 unidades ocultas.
El código de retropropagación suele fallar de forma sutil, así que compruébalo contra un método más lento que no puede fallar: desplaza un peso un poco hacia arriba y hacia abajo, en una cantidad mínima, mide cómo cambia la pérdida y compara. El modelo de la tienda requeriría más de un millón de modificaciones, así que verifica cada parámetro del modelo pequeño:
1"""Backpropagation's gradients for the tiny model, checked against nudging every one of its parameters up and down.2The assert is the check the prose relies on: the two agree to six decimal places, for every parameter."""3import numpy as np45from lib.tinynet import backprop, forward, parameters67p = parameters() # the tiny model: 5 tokens, a window of 2, 3 hidden units; seeded, so the same every run8context, target = np.array([1, 3]), 4 # the window: token ids 1 and 3; the token that came next is id 4910worst, step = 0.0, 1e-6 # the nudge: small enough that the loss is nearly a straight line over it11gradients = backprop(p, context, target)12for name, value in p.items(): # nudge each parameter both ways, and see how the loss moves13 for i in np.ndindex(value.shape):14 value[i] += step15 up = forward(p, context, target)[3] # forward returns (joined, hidden, logits, loss): index 3 is the loss16 value[i] -= 2 * step # from up to down is two steps, so the estimate is centred on the value17 down = forward(p, context, target)[3]18 value[i] += step # back where it started19 worst = max(worst, abs((up - down) / (2 * step) - gradients[name][i]))20agrees = worst < 1e-6 # the largest disagreement over all parameters, against six decimal places21assert agrees22print("loss:", round(float(forward(p, context, target)[3]), 4))23print("parameters checked:", sum(v.size for v in p.values()))24print("backprop agrees with nudging to 6 decimal places:", "yes" if agrees else "no")
python gradients-by-hand.pyloss: 1.5293
parameters checked: 45
backprop agrees with nudging to 6 decimal places: yes
Todos los 45 gradientes de la retropropagación coinciden con las estimaciones por modificación hasta seis decimales, lo que el ejemplo comprueba con una aserción. El método de modificación cuesta dos pases hacia adelante por parámetro, por eso nadie entrena con él, pero en un modelo pequeño es la referencia que te dice que la retropropagación es correcta.
Regla práctica: Compara los gradientes escritos a mano con las estimaciones por modificación en un modelo pequeño antes de confiar en ellos. Cuando uses una biblioteca que calcula los gradientes por ti, como lo hace la sección de PyTorch, compara en cambio el pase hacia adelante de la biblioteca con el tuyo.
Da pasos de descenso de gradiente
Con los gradientes en mano, el entrenamiento es un bucle. El descenso de gradiente mueve cada peso un pequeño paso en contra de su gradiente, w ← w − η · ∂L/∂w, donde η, el tamaño del paso, también llamado tasa de aprendizaje, determina cuánto avanza cada paso. Cada paso hace que la pérdida sea un poco menor para los ejemplos con los que se calculó, y repetido a lo largo de muchos ejemplos, los pesos se estabilizan donde el modelo predice bien.
Veinte pasos de descenso de gradiente con un tamaño de paso de 0.5, usando los gradientes de lib.tinynet, sobre tres ejemplos del pequeño modelo de la tienda de la sección anterior, muestran cómo la pérdida va disminuyendo:
1"""Twenty steps of gradient descent on three examples of the tiny model, printing the average loss before training and2after one, five and twenty steps. The prose's point rests on the average loss at those four points."""3import numpy as np45from lib.tinynet import backprop, forward, parameters67p = parameters() # seeded, so every run starts from the same weights8examples = [(np.array([1, 3]), 4), (np.array([0, 1]), 3), (np.array([3, 4]), 2)] # three (window, next token) pairs: each window is two token ids, then the id of the token after it9rate = 0.5 # the step size101112def average_loss():13 return np.mean([forward(p, c, t)[3] for c, t in examples])141516print("average loss before:", f"{average_loss():.3f}")17for step in range(1, 21): # twenty steps, each one a pass over all three examples18 for c, t in examples:19 for name, gradient in backprop(p, c, t).items():20 p[name] -= rate * gradient / len(examples) # w <- w - rate * dL/dw, with each gradient averaged over the examples21 if step in (1, 5, 20):22 print(f"average loss after {step} steps:", f"{average_loss():.3f}")
python gradient-descent-by-hand.pyaverage loss before: 1.568
average loss after 1 steps: 1.346
average loss after 5 steps: 0.646
average loss after 20 steps: 0.109
La pérdida media disminuye en cada paso que imprime el ejemplo, desde 1.568 antes del entrenamiento hasta 0.109 después de veinte. Con solo tres ejemplos de los que aprender, el pequeño modelo puede llevar su pérdida cerca de cero, lo que equivale a memorizar; el modelo de la tienda aprende de cientos de miles de ejemplos, donde el mismo bucle tiene que encontrar patrones que se cumplan en todos ellos.
El entrenamiento real cambia dos cosas de este bucle. Cada paso del entrenamiento real se calcula sobre un lote de ejemplos, unos cientos a la vez, en lugar de todos ellos, de modo que cada paso es barato y los pasos varían un poco. Y utiliza una actualización refinada en lugar de un tamaño de paso fijo, como describe la siguiente sección.
Regla práctica: Empieza cualquier modelo nuevo ejecutando unos pocos pasos sobre un puñado de ejemplos y comprueba que la pérdida disminuye: una pérdida que no baja con tres ejemplos indica un error, no un problema difícil. Elige el tamaño del paso probando algunos: si es demasiado pequeño, la pérdida avanza muy despacio; si es demasiado grande, salta de un lado a otro o crece.
Entrenar con PyTorch
Escribir la retropropagación a mano para cada modelo sería lento y propenso a errores. PyTorch, una biblioteca muy utilizada para entrenar redes neuronales, calcula los gradientes automáticamente a partir del paso hacia adelante, y ejecuta la aritmética con rapidez. El libro entrena su modelo con ella, en recordings/neural_lm.py, que construye el mismo modelo de ventana de la primera sección: una tabla de embeddings, una capa tanh y una capa de salida, entrenadas con los nombres del conjunto de entrenamiento de la tienda. El corazón del script es el bucle de la sección anterior, sobre lotes de 512 predicciones:
loss = loss_of(model(train_x[pick]), train_y[pick]) # forward pass and average loss on one batch
optimizer.zero_grad() # clear the previous batch's gradients
loss.backward() # backpropagation: a gradient for every weight
optimizer.step() # move every weight against its gradient
El optimizador del script de entrenamiento es Adam, un refinamiento del descenso de gradiente (Kingma y Ba, 2015). Mantiene, para cada peso, un promedio móvil de sus gradientes y un promedio móvil de sus cuadrados, y avanza dividiendo el primero entre la raíz cuadrada del segundo. Un peso cuyos gradientes son consistentemente grandes recibe pasos de un tamaño similar al de uno cuyos gradientes son pequeños, de modo que un solo tamaño de paso sirve para todos ellos.
El entrenamiento depende de la aritmética de punto flotante de la máquina, que el capítulo 4 explica, así que se ejecuta una vez y los ejemplos del libro leen los pesos que guardó, como leen cualquier otro resultado de este tipo. Los ejemplos nunca importan PyTorch: lib.neural recalcula el paso hacia adelante del modelo en NumPy, a partir de esos pesos. Eso solo funciona si la versión de NumPy calcula lo que calculó PyTorch, así que el script de entrenamiento guardó los logits propios de PyTorch para 64 contextos de validación, y el siguiente ejemplo los compara:
1"""The trained model's logits, recomputed in NumPy from its saved weights and compared with the logits PyTorch computed2for the same saved validation contexts. The prose's point rests on the agreement, which the last line prints."""3import numpy as np45from lib import neural67weights, _, manifest = neural.load()8check = np.load("data/recorded/neural-lm/check.npz") # saved by the training script, so this runs without PyTorch: contexts, and PyTorch's logits for them910ours = neural.forward(weights, check["contexts"])11print("PyTorch version:", manifest["torch"])12print("contexts compared:", len(check["contexts"]))13print("logits compared:", f"{ours.size:,}") # every logit: one per context and per token in the vocabulary14print("same as PyTorch to 4 decimal places:", bool(np.abs(ours - check["logits"]).max() < 1e-4)) # 1e-4: four decimal places
python same-as-pytorch.pyPyTorch version: 2.14.1+cpu
contexts compared: 64
logits compared: 264,960
same as PyTorch to 4 decimal places: True
El paso hacia adelante en NumPy reproduce todos los 264,960 logits de PyTorch con cuatro decimales, para el modelo entrenado con PyTorch 2.14.1+cpu. Todos los números que este capítulo presenta sobre el modelo entrenado provienen de ese código de NumPy, excepto la curva de entrenamiento, que el script registró mientras entrenaba.
Regla práctica: Entrena con una biblioteca que calcule los gradientes por ti, y mantén un paso hacia adelante propio, corto e independiente para verificar sus salidas, como hace aquí lib.neural. Registra las salidas de la biblioteca para algunas entradas cada vez que guardes pesos, de modo que la verificación pueda ejecutarse en cualquier lugar, mucho después del entrenamiento.
Detén el entrenamiento cuando la pérdida de validación empieza a subir
Un modelo con 1.4 millones de parámetros, entrenado con unos cientos de miles de tokens, puede memorizar su texto de entrenamiento, como lo hizo el 5-grama del capítulo 3. La perplejidad de entrenamiento sigue bajando mientras tanto. La perplejidad de validación baja al principio, mientras el modelo aprende patrones que valen para nombres nuevos, y luego sube, cuando empieza a ajustarse a particularidades de los nombres de entrenamiento. Una perplejidad de validación que sube mientras la perplejidad de entrenamiento sigue bajando es sobreajuste, y la defensa más sencilla es la parada temprana: medir la pérdida de validación después de cada época, es decir, una pasada completa por el texto de entrenamiento, y quedarse con los pesos de la mejor época.
El script de entrenamiento registró ambas perplejidades después de cada una de sus doce épocas. Obsérvalas para ver dónde deja de mejorar la validación:
1"""The training script's record of training and validation perplexity after each epoch, and the epoch whose weights were2kept. The prose's point rests on the validation column, and on the two validation figures printed after the table."""3import json4import math56curves = json.load(open("data/recorded/neural-lm/curves.json", encoding="utf-8"))7manifest = json.load(open("data/recorded/neural-lm/manifest.json", encoding="utf-8"))89print(f"{'epoch':>5} {'training perplexity':>19} {'validation perplexity':>21}")10for c in curves: # losses are averages of log probabilities: exp turns them into perplexities11 print(f"{c['epoch']:>5} {math.exp(c['train_loss']):>19.1f} {math.exp(c['validation_loss']):>21.1f}")12best = min(curves, key=lambda c: c["validation_loss"]) # the epoch with the lowest validation loss, which the kept epoch should match13print("epoch kept:", manifest["kept_epoch"])14print("validation perplexity at the kept epoch:", f"{math.exp(best['validation_loss']):.1f}")15print("validation perplexity at the last epoch:", f"{math.exp(curves[-1]['validation_loss']):.1f}") # curves[-1]: the final epoch's record, whatever was kept
python training-curve.pyepoch training perplexity validation perplexity
1 109.3 51.4
2 37.6 39.9
3 27.3 37.3
4 22.4 36.6
5 19.3 36.4
6 17.2 36.9
7 15.6 37.8
8 14.4 38.6
9 13.5 39.7
10 12.7 40.9
11 12.0 42.1
12 11.5 43.7
epoch kept: 5
validation perplexity at the kept epoch: 36.4
validation perplexity at the last epoch: 43.7
En la época 1, la perplejidad de entrenamiento es mayor que la de validación, porque la cifra de entrenamiento promedia toda la época, incluidos sus primeros lotes, cuando el modelo todavía no estaba entrenado, mientras que la validación se mide al final de la época. La perplejidad de validación toca fondo en 36.4 en la época 5 y de ahí en adelante sube, hasta 43.7 en la última época, mientras que la perplejidad de entrenamiento baja en cada época después de la primera. El script de entrenamiento conservó los pesos de la mejor época, y todos los resultados del resto de este capítulo los usan.
La separación entre las dos curvas es la memorización del modelo. Crece en cada época, porque los nombres de entrenamiento repiten sus líneas de producto y su redacción, y este modelo no tiene regularización, es decir, nada en el entrenamiento que desaliente la memorización, así que la parada temprana es su única defensa.
Regla práctica: Registra siempre la pérdida de validación por época y conserva los pesos de la mejor época, nunca los de la última. Cuando las curvas se separan pronto, como ocurre aquí tras unas pocas épocas, el modelo tiene más capacidad de la que su texto de entrenamiento sostiene: regularízalo, usa un modelo más pequeño o consigue más texto del mismo tipo.
Compara con la línea base
La prueba real es la que toma cada modelo de este libro: la perplejidad por token en los nombres de validación, frente al modelo de 4-gramas como línea base. ¿Qué importa más con estos nombres: relacionar contextos similares o los conteos exactos? El modelo neuronal puede relacionar contextos similares, algo que el 4-grama no puede hacer; el 4-grama tiene conteos exactos para cada contexto que ha visto.
1"""The window model and the 4-gram baseline, each scored by perplexity per token on the same validation names. The2prose's point rests on the two printed perplexities."""3from lib import neural4from lib.names import name_tokens5from lib.ngrams import KneserNey, perplexity67train, validation = name_tokens("train"), name_tokens("validation") # both models are scored on the same tokens of the same names8print("window model validation perplexity:", f"{neural.perplexity(validation):.1f}") # the window model, from its saved weights9print("4-gram baseline validation perplexity:", f"{perplexity(KneserNey(train, 4), validation):.1f}") # a 4-gram: each token is predicted from the three before it
python neural-vs-baseline.pywindow model validation perplexity: 36.4
4-gram baseline validation perplexity: 23.1
El modelo basado en conteos gana, por un margen amplio: la perplejidad de validación del modelo de ventana es 36.4, frente a los 23.1 de la línea base.
Para ver dónde, divide los tokens de validación según si su contexto de tres tokens aparece en los nombres de entrenamiento, y evalúa ambos modelos en cada parte:
1"""Splits the validation tokens by whether their three-token context occurs in the training names, and scores both models2on each part. The prose's point rests on the four perplexities printed for the two parts."""3import math45import numpy as np67from lib import neural8from lib.names import name_tokens9from lib.ngrams import KneserNey, ngrams, padded1011train, validation = name_tokens("train"), name_tokens("validation")12counted = KneserNey(train, 4)13pairs = [(c, t) for text in validation for c, t in ngrams(padded(text, 4), 4)] # padding gives each name's first tokens a context14seen = np.array([c in counted.totals[4] for c, _ in pairs]) # was this 3-token context in the training names?15from_counts = np.array([counted.probability(c, t) for c, t in pairs])16from_network = neural.token_probabilities(validation) # in the same order as pairs, so each entry is for the same token1718print("validation tokens with a context seen in training:", f"{seen.mean():.0%}")19for part, where in [("seen", seen), ("unseen", ~seen)]: # ~seen: the complement, the contexts the training names lack20 for model, p in [("4-gram", from_counts), ("network", from_network)]:21 print(f"{model} perplexity, {part} contexts: {math.exp(-np.log(p[where]).mean()):.1f}") # exp of the average surprise, over this part
python seen-and-unseen-contexts.pyvalidation tokens with a context seen in training: 70%
4-gram perplexity, seen contexts: 17.9
network perplexity, seen contexts: 26.1
4-gram perplexity, unseen contexts: 41.2
network perplexity, unseen contexts: 78.5
La red es peor en ambas partes, y por más diferencia en los contextos no vistos, donde su capacidad para relacionar contextos debería ayudar más. Allí el 4-grama obtiene 41.2 y la red 78.5. En los contextos vistos, que constituyen 70% de los tokens de validación, el 4-grama obtiene 17.9 y la red 26.1.
Así, esta red no pierde solo donde los conteos son exactos; tampoco ha aprendido a generalizar bien. Dos rasgos de este modelo y de este texto son las razones más probables. La red no tiene regularización y sobreajusta tras unas pocas épocas, como mostró la curva de entrenamiento. Y los nombres de la tienda son cortos y formulaicos: tres tokens de contexto cubren la mayor parte de lo que contiene un nombre, que es el escenario donde los conteos de Kneser-Ney son más sólidos. Bengio y sus colegas encontraron lo contrario en textos más grandes y variados: en el corpus Brown, de unas 800,000 palabras de entrenamiento, su mejor red por sí sola tuvo una perplejidad de prueba de 268, y mezclada con un modelo de trigramas, 252, frente al 312 del mejor modelo de n-gramas (Bengio et al., 2003, sección 4.2 y tabla 1). Un modelo aprendido no es mejor por ser aprendido; hay que medirlo.
Regla práctica: Compara siempre un modelo aprendido con una línea base sólida basada en conteos, sobre el mismo texto y los mismos tokens, antes de afirmar que ayuda, y divide la comparación entre contextos vistos y no vistos para ver dónde gana cada modelo. No concluyas, a partir de un conjunto de datos pequeño, que los modelos neuronales no funcionan, ni que siempre funcionan.
Mezcla la red con los conteos
Un modelo que es peor en promedio puede seguir siendo útil, si sus errores difieren de los del modelo mejor. Cuando dos modelos cometen errores distintos, mezclar sus probabilidades puede superar a ambos, que es lo que hicieron Bengio y sus colegas con su red y un modelo de trigramas suavizado (Bengio et al., 2003, sección 4). La mezcla es un promedio ponderado de las probabilidades que dan los dos modelos a cada token, como en la interpolación del capítulo 3.
¿Supera una mezcla a ambos extremos? Evalúa los nombres de validación con la proporción de la red en la mezcla en 0, 0.2, 0.3, 0.5 y 1, donde 0 es solo el modelo de conteos y 1 es solo la red:
1"""Mixes the network's and the 4-gram's probability of every validation token, at five shares for the network, and prints2the validation perplexity of each mix. The prose's point rests on the printed perplexity at share 0.2, and at the two ends."""3import math45import numpy as np67from lib import neural8from lib.names import name_tokens9from lib.ngrams import KneserNey, ngrams, padded1011train, validation = name_tokens("train"), name_tokens("validation")12from_network = neural.token_probabilities(validation) # the network's probability of each actual next token, in order13counted = KneserNey(train, 4)14# the 4-gram's probability for the same tokens, in the same order: each name padded with three start markers first15from_counts = np.array([counted.probability(c, t) for text in validation for c, t in ngrams(padded(text, 4), 4)])1617for share in [0.0, 0.2, 0.3, 0.5, 1.0]: # the network's share of the mix; the counts get the rest18 mixed = share * from_network + (1 - share) * from_counts19 print(f"validation perplexity, network share {share:.1f}: {math.exp(-np.log(mixed).mean()):.1f}")
python mix-neural-and-counts.pyvalidation perplexity, network share 0.0: 23.1
validation perplexity, network share 0.2: 21.9
validation perplexity, network share 0.3: 22.1
validation perplexity, network share 0.5: 22.9
validation perplexity, network share 1.0: 36.4
La mezcla supera a ambos modelos. Con una proporción de red de 0.2, la perplejidad de validación es 21.9, mejor que la de referencia, 23.1, y mucho mejor que la de la red sola, 36.4. La red es peor en promedio, pero allí donde los conteos asignan muy poca probabilidad a un token, la proporción de la red evita que sea diminuta, y eso reduce la sorpresa media.
Tanto la época elegida como la proporción se escogieron mirando los nombres de validación, así que la mejora es algo optimista; la comparación final del libro, con los nombres de prueba, la comprobará. Además, la mezcla solo ayuda porque los errores de los dos modelos difieren: si cometieran los mismos errores, promediarlos no aportaría nada.
Regla práctica: Cuando un modelo aprendido y uno basado en conteos tienen un rendimiento parecido, prueba a mezclar sus probabilidades antes de elegir uno, y escoge la proporción con texto reservado para validación. Mantén pequeña la proporción cuando un modelo es mucho más fuerte, y confirma la mejora en un conjunto de prueba separado antes de confiar en ella.
Más texto ayuda solo si es del mismo tipo
Si la red sobreajusta porque aprendió de muy poco texto, la solución obvia es más texto. La tienda tiene bastante: sus descripciones de productos. El script de entrenamiento puede entrenar el mismo modelo con nombres y descripciones juntos, y el libro registró también esa versión, evaluada con los mismos nombres de validación.
Compara los dos modelos registrados con los nombres de validación, uno entrenado con nombres y otro con nombres y descripciones:
1"""Scores the window model trained on names alone against the one trained on names and descriptions, counts the training2tokens of each kind of text, and prints the second model's validation perplexity after each of its epochs. The prose's3point rests on the two validation perplexities, and on the training token counts printed beside them."""4import json5import math67from lib import neural8from lib.names import name_tokens910validation = name_tokens("validation")11for name in ["neural-lm", "neural-lm-all-text"]: # the recorded runs: names alone, then names and descriptions12 manifest = json.load(open(f"data/recorded/{name}/manifest.json", encoding="utf-8"))13 print(f"learned from {manifest['settings']['text']}:", f"{neural.perplexity(validation, name):.1f}")1415from lib import bpe16from lib.store import load_products1718tokenizer = bpe.store_tokenizer()19names_tokens = sum(len(t) for t in name_tokens("train")) # counted in the store's tokens, the ones the model reads20description_tokens = sum(len(tokenizer.encode(d)) for d in load_products("train")["description"]) # the training split only, as for names21print("training tokens, names:", f"{names_tokens:,}")22print("training tokens, names and descriptions:", f"{names_tokens + description_tokens:,}")23curve = json.load(open("data/recorded/neural-lm-all-text/curves.json", encoding="utf-8"))24print("all-text model, validation perplexity by epoch:", ", ".join(f"{math.exp(c['validation_loss']):.1f}" for c in curve)) # one per epoch, in order
python more-text-of-another-kind.pylearned from names: 36.4
learned from all: 59.0
training tokens, names: 337,071
training tokens, names and descriptions: 2,744,320
all-text model, validation perplexity by epoch: 73.6, 64.0, 60.8, 59.0
Añadir las descripciones empeora el modelo con nombres. Los nombres de entrenamiento contienen 337,071 tokens, y los nombres y descripciones juntos 2,744,320, unas ocho veces más. El modelo que aprendió solo de nombres obtiene 36.4, y el que aprendió de nombres y descripciones obtiene 59.0. Este segundo modelo entrenó durante cuatro épocas, y su perplejidad de validación seguía bajando cuando se detuvo, en pasos cada vez más pequeños: 73.6, 64.0, 60.8, 59.0. Nuestro criterio es que más épocas no lo acercarían al modelo de nombres.
Las descripciones son un tipo de texto distinto. Están escritas en oraciones completas, con palabras como your, this y perfect que los nombres rara vez contienen, y un modelo que aprende sobre todo de ellas predice nombres como si fueran descripciones. El texto añadido enseñó al modelo una distribución equivocada para la tarea. Un modelo aprende el texto que se le da, y su perplejidad mide qué tan bien predice texto de ese tipo: datos de otro tipo pueden empeorarlo, y deben ponderarse o mantenerse separados.
Regla práctica: Antes de añadir texto de entrenamiento, comprueba que se parece al texto que vas a predecir; entrena con ambos y mide sobre el texto objetivo, en lugar de suponer que más siempre es mejor. Cuando el texto extra difiere mucho, entrena solo con el texto objetivo, o organiza cada texto de forma que el modelo pueda distinguir sus tipos, como hace el capítulo 8 con un separador entre el nombre de un producto y su descripción.
Sugerir a partir de contextos similares
La red perdió, en promedio, incluso en los contextos de los que carecen los nombres de entrenamiento, pero los promedios ocultan casos individuales. El autocompletado del capítulo 3 mostró el peor caso del 4-grama, outdoor bar, un contexto que ningún nombre de entrenamiento contiene, donde recurrió a continuaciones genéricas.
A continuación, los tres tokens más probables de la red tras cinco prefijos de nombre, y algunos embeddings, indican si outdoor bar obtiene la sugerencia stool que sí obtiene patio bar:
1"""The network's three likeliest next tokens after five typed prefixes, its probability of `stool` after `outdoor bar`,2and the cosine similarity of `patio` with three other tokens in its embedding table. The prose's point rests on the3suggestions after each prefix, and on the three cosines printed last."""4import numpy as np56from lib import bpe, neural7from lib.ngrams import START89weights, vocabulary, manifest = neural.load()10index, width = {t: i for i, t in enumerate(vocabulary)}, manifest["settings"]["context"]11tokenizer = bpe.store_tokenizer()1213for typed in ["bar", "patio bar", "outdoor bar", "kitchen bar", "wine bar"]: # each typed prefix is read as the start of a name14 context = ([START] * width + tokenizer.encode(typed))[-width:] # pad with start markers, keep the last width tokens15 logits = neural.forward(weights, np.array([[index[t] for t in context]]))[0] # forward takes a batch: one row, so take row 016 probabilities = np.exp(neural.log_softmax(logits[None])[0]) # log_softmax wants a batch too: add an axis, then take it off17 best = np.argsort(-probabilities, kind="stable")[:3] # the three likeliest; a stable sort keeps ties in vocabulary order18 # the end-of-word marker </w> is shown as nothing, so the tokens read as the words they came from19 print(f"{typed:<12} -> " + ", ".join(f"{vocabulary[i].replace('</w>', '')} {probabilities[i]:.2f}" for i in best))2021outdoor_bar = ([START] * width + tokenizer.encode("outdoor bar"))[-width:] # the same padding as above22p_stool = np.exp(neural.log_softmax(neural.forward(weights, np.array([[index[t] for t in outdoor_bar]])))[0, index["stool</w>"]])23print("P(stool | outdoor bar):", f"{p_stool:.2f}")24table = weights["embedding"] / np.linalg.norm(weights["embedding"], axis=1, keepdims=True) # unit-length rows, so a dot product is a cosine25for a, b in [("patio</w>", "outdoor</w>"), ("patio</w>", "kitchen</w>"), ("patio</w>", "wine</w>")]:26 print(f"cosine({a.replace('</w>', '')}, {b.replace('</w>', '')}) in the model's embeddings:", f"{float(table[index[a]] @ table[index[b]]):.2f}")
python neural-autocomplete.pybar -> with 0.22, cabinet 0.14, cart 0.13
patio bar -> stool 0.63, with 0.23, & 0.05
outdoor bar -> stool 0.40, with 0.13, & 0.12
kitchen bar -> & 0.53, with 0.17, cart 0.09
wine bar -> with 0.23, cabinet 0.16, </s> 0.14
P(stool | outdoor bar): 0.40
cosine(patio, outdoor) in the model's embeddings: 0.16
cosine(patio, kitchen) in the model's embeddings: 0.07
cosine(patio, wine) in the model's embeddings: 0.10
Tras outdoor bar, la red sugiere primero stool, con una probabilidad de 0.40, mientras que el 4-grama colocó & y with por delante de ella. Los prefijos de control muestran que stool no es automático tras bar: tras bar solo, kitchen bar y wine bar, no aparece entre las tres sugerencias de la red. Y en la propia tabla de embeddings de la red, patio está un poco más cerca de outdoor, con una similitud coseno de 0.16, que de kitchen o wine. Eso es coherente con que la red haya trasladado algo de patio bar a outdoor bar, aunque la similitud es débil, y un solo prefijo demuestra poco.
Este es un caso, no un promedio: la división entre contextos vistos y no vistos mostró que la red era peor en contextos no vistos en conjunto. Muestra lo que un modelo aprendido puede hacer y el conteo no, y que este solo lo logra a veces.
Regla práctica: Observa las predicciones de un modelo aprendido sobre contextos que faltan en el texto de entrenamiento, con prefijos de control junto a ellas, pero júzgalo por mediciones sobre muchos contextos, no por ejemplos. Para el autocompletado en producción, usa la mezcla y pruébala también con prefijos poco frecuentes, además de los comunes.
Qué sale mal en producción
Un modelo neuronal de lenguaje trae nuevos modos de fallo junto con sus nuevas fortalezas:
- El sobreajuste es silencioso. La pérdida de entrenamiento siempre se ve bien. Sin una curva de validación, un modelo entrenado durante demasiado tiempo se despliega peor que uno entrenado menos. Conserva la mejor época y vigila la brecha.
- Guarda los pesos que despliegas. Reentrenar en otro procesador da pesos ligeramente distintos, así que conserva el código y la configuración que los produjeron, y las salidas de la biblioteca para unas pocas entradas, como hace aquí el script de entrenamiento.
- La capa de salida domina. Puntuar cada token del vocabulario en cada paso es la mayor parte del cálculo y de los parámetros. Un vocabulario más grande encarece primero esta capa.
- El texto de entrenamiento que no coincide perjudica. Añadir texto distinto del objetivo, como las descripciones lo fueron para los nombres, empeora las predicciones mientras la pérdida de entrenamiento se ve bien. Mide sobre el texto objetivo después de cada cambio en los datos de entrenamiento.
- Los promedios ocultan los contextos raros. Un modelo puede puntuar bien en conjunto y aun así fallar con los prefijos inusuales que escriben los compradores cuando buscan algo nuevo. Evalúa por separado los contextos vistos y no vistos, como hizo este capítulo, y vigila los no vistos.
- Una mezcla necesita ambos modelos al servir. Mezclar una red con conteos duplica lo que hay que cargar y mantener actualizado. Reconstruye los conteos cada vez que reentrenes la red, para que ambos describan el mismo texto.
Lo que decidió este capítulo
- Los modelos neuronales del libro se entrenan en PyTorch, una sola vez, en
recordings/, y los ejemplos los recalculan en NumPy a partir de los pesos guardados. El paso hacia delante en NumPy reproduce los logits de PyTorch con cuatro decimales, así que los ejemplos no necesitan PyTorch. - Los modelos conservan los pesos de su mejor época de validación. La perplejidad de validación del modelo de ventana fue mínima después de la época 5, y subió en cada época posterior, mientras la perplejidad de entrenamiento seguía bajando: el modelo estaba memorizando los nombres de entrenamiento.
- Con los nombres de la tienda, el modelo de ventana pierde frente a la línea base de 4-gramas por sí solo, tanto en contextos vistos como no vistos, y la supera en modo mezclado. Una proporción de red de 0.2 da 21.9, la mejor de los modelos del libro hasta ahora.
- Los modelos aprendidos se comparan con la línea base por separado en contextos vistos y no vistos, no solo en promedio, porque las dos partes pueden contar historias distintas. Aquí la red perdió en ambos, y por más margen en los no vistos.
- El texto de entrenamiento debe parecerse al texto objetivo. Añadir las descripciones empeoró el modelo con los nombres, aunque los nombres y las descripciones juntos contenían unas ocho veces más tokens que solo los nombres, así que el texto de entrenamiento de cada modelo se elige según el texto con el que será evaluado.
- Los nombres son cortos, así que desde el capítulo 8 el libro también mide los modelos con las descripciones de la tienda.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 10 de 10 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.