Predecir la siguiente palabra

Unos 23 minutos de lectura, con 8 ejemplos en 10 secciones.

Edición 2026.11.16 Ejemplos verificados el 19 de nov de 2026 86 de 86 ejemplos pasan Qué ha cambiado

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

Al final de este capítulo podrás construir un modelo de lenguaje completo a partir de los nombres de productos de una tienda, contando palabras; usarlo para sugerir la siguiente palabra mientras un comprador escribe; generar texto con él; y medir con un solo número qué tan bien predice texto que nunca ha visto. Cada capítulo posterior reemplaza una parte de este modelo por una mejor, y a partir del capítulo 3 mide cada cambio de la misma manera.

A lo largo del libro se repite un caso de estudio: una tienda en línea de muebles y artículos para el hogar, a la que llamamos la tienda. Su buscador necesita autocompletado, de modo que un comprador que escribe coffee vea table ofrecido como la siguiente palabra, y sus descripciones breves de producto necesitan redacción y revisión. Ambos son problemas de predecir la siguiente palabra, y la tienda tiene el texto del que puede aprenderlos: los nombres y las descripciones de cada producto de su catálogo.

Un modelo de lenguaje es un programa que asigna una probabilidad a cada palabra que podría venir a continuación, dadas las palabras anteriores. Esa única capacidad abarca mucho. Sugerir cómo completar una búsqueda equivale a elegir una palabra siguiente probable. Escribir una oración equivale a elegir una palabra siguiente, añadirla y volver a elegir. Un modelo que predice bien ha aprendido algo sobre el texto con el que fue entrenado, por eso qué tan bien predice es como lo mides. Los grandes modelos de lenguaje detrás de los asistentes de chat hacen lo mismo a una escala mucho mayor: dado el texto anterior, asignan una probabilidad a cada posible siguiente fragmento de texto. Este libro construye esa maquinaria una parte a la vez, lo bastante pequeña para ejecutarse en una laptop, para que puedas ver qué hace cada parte.

En este capítulo contarás qué palabra sigue a cuál en los nombres de productos, convertirás los conteos en probabilidades y las pondrás a trabajar. El modelo que construyas aquí tiene un defecto serio, y el capítulo termina midiéndolo.

Cargar el texto de la tienda

Último cambio en la edición 2026.11.11

Antes de que un modelo pueda aprender qué palabras siguen a cuáles, necesita texto del que aprender y una forma de saber si lo que aprendió se sostiene en texto que no ha visto. La segunda necesidad importa tanto como la primera. Un modelo puede predecir a la perfección el texto del que aprendió memorizándolo, lo cual no dice nada sobre cómo le irá con el siguiente producto que añada la tienda. Por eso el texto se divide una sola vez, antes de que nada aprenda de él, en tres partes: un conjunto de entrenamiento, del que aprenden los modelos; un conjunto de validación, para comparar modelos mientras los construyes, y un conjunto de prueba, que se reserva para los informes finales. Cada producto pertenece a exactamente un conjunto, de modo que ningún nombre ni descripción con los que se evalúa un modelo aparece en aquello de lo que aprendió.

El texto de la tienda, del que aprende cada ejemplo de este libro, es real. Procede de WANDS, un conjunto de datos público de búsqueda de productos que Wayfair publicó con un artículo en ECIR 2022 (Chen et al., 2022), bajo la licencia MIT (licencia). El script prep/wands_text.py lo prepara, y su ficha de datos, examples/data/wands-text/README.md, explica cómo: el texto ya está en minúsculas, con espacios alrededor de los signos de puntuación, y las descripciones se cortan al final de una oración para que el archivo ocupe menos. Se excluyen los productos cuyo texto menciona a la propia tienda, de modo que ningún modelo de este libro aprende a escribir el nombre de la tienda. Los ejemplos leen el texto a través de lib.store, uno de los módulos compartidos del libro: archivos breves en examples/lib/ que contienen código de preparación que muchos ejemplos necesitan, y que puedes abrir y leer.

Antes de contar nada, observa el texto: el tamaño de cada conjunto y algunos nombres:

store-text.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Counts the store's products in each split and the words in its training names, then prints one ordinary training namefor each of four kinds of product. The line "different words in training names" is the one the prose's point rests on,since the rare product-line names are among the words it counts."""from lib.store import load_products, ordinary_words, wordsproducts = load_products()                            # no split given: every product, in all three splitsprint("products:", f"{len(products):,}")for split in ["train", "validation", "test"]:    print(f"{split} products:", f"{(products['split'] == split).sum():,}")train = products[products["split"] == "train"]        # only the training names count toward the word totalsprint("words in training names:", f"{sum(len(words(name)) for name in train['name']):,}")print("different words in training names:", f"{len({w for name in train['name'] for w in words(name)}):,}")print()common = ordinary_words(300)                          # words in 300 descriptions or more: a stricter bar than the book's 30for kind in ["coffee table", "bar stool", "area rug", "bathroom vanity"]:      # one name of each kind, as examples    print(next(name for name in train["name"] if kind in name and all(w in common or not w.isalpha() for w in words(name))))   # the first name whose words are all common; numbers and punctuation pass
Salidapython store-text.py
products: 42,815
train products: 34,252
validation products: 4,282
test products: 4,281
words in training names: 231,048
different words in training names: 25,907

solid wood coffee table
25 '' bar stool
hand-knotted wool/silk teal/plum area rug
36 '' single bathroom vanity

Los nombres de producto son lo bastante cortos y repetitivos para que el conteo funcione, así que este capítulo aprende solo a partir de ellos. El texto de la tienda abarca 42,815 productos, de los cuales 34,252 están en el conjunto de entrenamiento. Los nombres de entrenamiento contienen 231,048 palabras, de 25,907 tipos distintos. Ese segundo recuento es grande para un catálogo de muebles, porque muchos nombres empiezan con el nombre de una línea de productos, una palabra que aparece en unos pocos productos y en ningún otro. Este libro no muestra esos nombres. Cuando la salida de un ejemplo los mostraría, imprime [name] en su lugar, para cualquier palabra que aparezca en menos de 30 de las descripciones de entrenamiento, casi siempre el nombre de una línea de productos. Esas palabras poco frecuentes cobrarán importancia hacia el final del capítulo.

Regla práctica: Divide tu texto en partes de entrenamiento, validación y prueba antes de que ningún modelo lo vea, y divídelo por documento (aquí, por producto), de modo que los casi duplicados de un mismo elemento nunca queden repartidos entre dos partes. Compara modelos con el texto de validación mientras trabajas, y usa el texto de prueba solo para el informe final. Aprende primero del texto más corto y regular que tengas; este capítulo empieza con nombres, y las descripciones llegan más adelante en el libro.

Contar qué palabra sigue a cuál

Último cambio en la edición 2026.11.11

Con los nombres de entrenamiento cargados, un modelo sencillo de lo que viene a continuación es una tabla de cuántas veces cada palabra siguió a cada otra palabra. Un bigrama es un par de palabras contiguas, como coffee table. Cuenta cada bigrama de los nombres de entrenamiento y sabrás, para cualquier palabra, qué palabras le siguieron y con qué frecuencia. Claude Shannon usó exactamente esta idea en el artículo que fundó la teoría de la información, aproximando el inglés al elegir cada palabra según la frecuencia con la que sigue a la anterior (Shannon, 1948).

Dos detalles hacen que los conteos sean completos. La primera palabra de un nombre no sigue a ninguna, y la última no es seguida por ninguna, pero ambas merecen predicción: la primera palabra decide qué tipo de producto está escribiendo una persona compradora, y saber dónde termina un nombre permite que un modelo se detenga. Por eso cada nombre se rellena con dos marcadores, <s> al principio y </s> al final, que cuentan como palabras. El par <s> coffee registra entonces que un nombre empezó con coffee, y table </s> registra que un nombre terminó con table.

Empieza con una palabra cuya sucesora importa para el cuadro de búsqueda, coffee. El ejemplo cuenta cada par de los nombres de entrenamiento y luego enumera lo que le siguió:

count-next-words.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Counts every word pair in the training names, padded with start and end markers, and lists the words that most oftenfollow coffee. The four lines under "words after coffee" are what the prose's point rests on."""from collections import Counterfrom lib.store import load_products, wordsnames = load_products("train")["name"]                # training split only, so validation and test names never add countspairs = Counter()for name in names:    tokens = ["<s>"] + words(name) + ["</s>"]       # the markers record how a name starts and where it stops    pairs.update(zip(tokens, tokens[1:]))            # tokens[1:] is the same list one word on, so each word pairs with the nextprint("word pairs:", f"{sum(pairs.values()):,}")print("different pairs:", f"{len(pairs):,}")after_coffee = {following: n for (word, following), n in pairs.items() if word == "coffee"}   # pairs that start with coffee, by the word afterprint("words after coffee:", f"{sum(after_coffee.values()):,}")for following, n in sorted(after_coffee.items(), key=lambda item: -item[1])[:4]:   # the key negates the count, so largest first    print(f"  coffee {following:<6} {n:>6,}")
Salidapython count-next-words.py
word pairs: 265,300
different pairs: 84,529
words after coffee: 1,260
  coffee table   1,129
  coffee mug        45
  coffee ,          28
  coffee jar        13

Una palabra domina. Casi todo coffee en los nombres de la tienda es parte de un coffee table, y de las 1,260 palabras que siguen a coffee en los nombres de entrenamiento, casi todas son table. Una coma ocupa el tercer lugar, porque el texto de la tienda trata la puntuación como palabras propias. Esa es una decisión sobre los tokens, las unidades que cuenta un modelo, y el capítulo 2 muestra cuánto importa.

La tabla de conteos es todo el modelo. No tiene reglas de gramática ni conocimiento de muebles; ha visto coffee table muchas veces y coffee lamp nunca, y eso es todo lo que sabe. El módulo compartido lib.bigrams contiene este mismo código de conteo, como la clase Bigrams, para que los ejemplos posteriores puedan construir el modelo en una sola línea.

Regla práctica: Cuenta los pares solo en la partición de entrenamiento, y rellena cada texto con marcadores de inicio y de fin para que el modelo aprenda cómo empiezan y terminan los textos. Conserva los conteos brutos, no solo las probabilidades que derivarás de ellos: los conteos indican cuánta evidencia respalda cada probabilidad, y las siguientes secciones los necesitan.

Convertir recuentos en probabilidades

Último cambio en la edición 2026.11.16

Los recuentos indican lo que ha ocurrido, pero un modelo de lenguaje necesita probabilidades: qué tan probable es cada palabra siguiente. El paso de uno a otro es una división. La probabilidad de una palabra dada la palabra anterior es el número de veces que apareció el par, dividido entre el número de veces que la primera palabra apareció seguida de cualquier otra. En símbolos, escribiendo w para la palabra anterior y v para la siguiente:

P(v | w) = count(w v) / count(w)

Léelo como «la probabilidad de v, dado w». Estimar probabilidades a partir de la fracción de veces que algo ocurrió se llama estimación de máxima verosimilitud: de todas las tablas de probabilidad que podrías elegir, es la que hace más probable el texto de entrenamiento (Jurafsky y Martin, capítulo 3).

Aplica la fórmula a coffee y a cuatro palabras que podrían seguirle, mostrando cada probabilidad junto a los recuentos que la respaldan, y después la suma sobre todas las palabras que siguieron a coffee:

next-word-probabilities.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Divides how often each of four words followed coffee by how often coffee was followed by anything, then prints the sum of theprobabilities of every word after coffee. The line for lamp, which prints 0.000, is the one the prose's point rests on:the bigram model gives a pair it never counted no probability at all."""from lib.bigrams import Bigramsfrom lib.store import load_productsmodel = Bigrams(load_products("train")["name"])after_coffee, total = model.counts["coffee"], model.totals["coffee"]   # counts[word] is a Counter of the words after word; totals[word] is their sumfor following in ["table", "mug", "jar", "lamp"]:    print(f"P({following} | coffee): {after_coffee[following] / total:.3f}  ({after_coffee[following]} of {total})")   # a Counter returns 0 for a word never seen after coffee, not an errorprint("sum over every word after coffee:", round(sum(n / total for n in after_coffee.values()), 6))   # rounded, so float error doesn't show in the sum
Salidapython next-word-probabilities.py
P(table | coffee): 0.896  (1129 of 1260)
P(mug | coffee): 0.036  (45 of 1260)
P(jar | coffee): 0.010  (13 of 1260)
P(lamp | coffee): 0.000  (0 of 1260)
sum over every word after coffee: 1.0

Las probabilidades de todas las palabras que siguieron a coffee suman 1.0, como debe ser en una distribución, porque lo que venga después es una de esas palabras. table concentra la mayor parte de esa probabilidad, 0.896 (1129 of 1260), y mug mucha menos, 0.036 (45 of 1260).

La cuarta línea es la que hay que recordar. coffee lamp nunca aparece en los nombres de entrenamiento, así que su probabilidad es 0.000 (0 of 1260). El modelo no dice que una lámpara de café sea poco probable; dice que una lámpara de café es imposible. Para una tienda de muebles es una apuesta razonable, pero el mismo cero se aplica a todo par que el modelo no ha visto, incluidos pares perfectamente corrientes. Ese es el defecto con el que termina este capítulo.

Regla práctica: deriva probabilidades a partir de recuentos mediante división, y comprueba que las probabilidades de cada palabra sumen uno; una suma que no lo haga es un error en el conteo. Considera que una probabilidad vale tanto como el recuento en que se apoya: 0.9 a partir de 1,000 pares es evidencia, mientras que 1.0 a partir de un único par es una anécdota.

Sugerir la siguiente palabra mientras el cliente escribe

Último cambio en la edición 2026.11.11

El autocompletado, la primera necesidad de la tienda, quiere las palabras siguientes más probables, y una tabla de probabilidades las ordena. Un cliente que ha escrito coffee ve primero table. Con el modelo de bigramas, las sugerencias para cualquier texto escrito son las palabras con mayor probabilidad después de su última palabra. La clase del modelo de bigramas, Bigrams, a partir de contar qué palabra sigue a cuál, tiene un método, next_words, que las devuelve, de la más probable a la menos probable.

Cinco prefijos escritos, de una palabra a dos, muestran dónde ayudan las sugerencias y dónde fallan. Se devuelven tres sugerencias para cada uno:

autocomplete.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Asks the bigram model for its three likeliest next words after five typed prefixes, then counts the training names thatcontain outdoor door. The patio bar line, which gets the same suggestions as bar, is the one the prose's point rests on."""from lib.bigrams import Bigramsfrom lib.store import load_productsmodel = Bigrams(load_products("train")["name"])for typed in ["coffee", "bar", "kitchen", "outdoor", "patio bar"]:    last_word = typed.split()[-1]                    # the model reads only this word, so patio never reaches it    suggestions = model.next_words(last_word, k=3)   # (word, probability) pairs, likeliest first    print(f"{typed:<10} -> " + ", ".join(f"'{word}' {p:.2f}" for word, p in suggestions))names = load_products("train")["name"]               # the training names as plain strings, for the substring countsprint("training names containing 'outdoor door':", sum("outdoor door" in n for n in names))   # a substring test, so `outdoor doors` counts tooprint("of them, followed by 'mat':", sum("outdoor door mat" in n for n in names))   # the same test, with mat after them
Salidapython autocomplete.py
coffee     -> 'table' 0.90, 'mug' 0.04, ',' 0.02
bar        -> 'stool' 0.32, 'pull' 0.18, '&' 0.15
kitchen    -> 'sink' 0.17, 'island' 0.16, 'canister' 0.12
outdoor    -> 'door' 0.22, 'patio' 0.07, 'area' 0.06
patio bar  -> 'stool' 0.32, 'pull' 0.18, '&' 0.15
training names containing 'outdoor door': 215
of them, followed by 'mat': 214

Después de coffee, bar y kitchen, las sugerencias principales son lo que querría un cliente: mesas, taburetes, fregaderos e islas. Después de outdoor son más débiles. La sugerencia principal, door, inicia un tipo de producto real: 214 de los 215 nombres de entrenamiento que contienen outdoor door continúan con mat. Pero una sugerencia de una sola palabra no puede ofrecer un tipo de producto de dos palabras, y después de door las proporciones son pequeñas, porque outdoor va seguida de muchas palabras distintas. Una coma y un ampersand también aparecen como sugerencias, algo que ningún cuadro de búsqueda debería ofrecer. Filtrar la puntuación de las sugerencias es un parche razonable, y el capítulo 2 trata la causa.

La última línea muestra el límite real del modelo. Un cliente que escribe patio bar recibe exactamente las sugerencias de bar, porque un modelo de bigramas mira una sola palabra de contexto y nada de lo anterior. patio se pierde, así que el modelo ofrece pull y &, que pertenecen a herrajes de armarios y a nombres como bar & counter stools. Usar más contexto es el tema del capítulo 3, y un modelo que pondera cada palabra anterior es hacia donde se dirige el libro.

Regla práctica: Para el autocompletado, ofrece unas pocas palabras siguientes con mayor probabilidad, y descarta los tokens que no son palabras, como la puntuación. Espera que las sugerencias de un modelo de bigramas sean buenas después de palabras que casi siempre van seguidas de lo mismo, como coffee, y malas después de palabras con muchas continuaciones posibles, como outdoor. Cuando importan las palabras anteriores, como ocurre en patio bar, un modelo de bigramas no puede ayudar, por mucho texto del que aprenda.

Generar nombres una palabra a la vez

Último cambio en la edición 2026.11.16

La misma tabla de probabilidades puede también escribir texto, no solo completarlo. Para generar, empieza en <s>, elige la siguiente palabra al azar en proporción a su probabilidad, añádela y repite desde la palabra elegida, hasta que el modelo elija </s>. Elegir al azar, en lugar de tomar siempre la palabra más probable, es lo que permite al modelo producir nombres variados en lugar del mismo nombre cada vez. Los modelos de lenguaje grandes hacia los que apunta este libro escriben texto de la misma manera: un token a la vez, cada uno elegido a partir de probabilidades calculadas con el texto anterior.

Seis nombres, extraídos de esas probabilidades mediante un generador aleatorio con semilla, salen iguales en cada ejecución, de modo que los nombres de este libro coinciden con lo que produce el código:

generate-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Draws six product names from the bigram model, one word at a time, with a fixed seed so the same six come out on everyrun. The count of generated words never seen in training is the line the prose's point rests on."""import numpy as npfrom lib.bigrams import END, START, Bigramsfrom lib.store import load_products, maskedmodel = Bigrams(load_products("train")["name"])rng = np.random.default_rng(2026)                    # fixed seed: any seed gives six names, this one gives the book'sdef generate(longest=12):                            # twelve words at most, if the end marker hasn't come first    word, name = START, []    while len(name) < longest:        candidates = list(model.counts[word])        # the words seen after word: the only ones the model can draw        chances = [model.probability(word, c) for c in candidates]        word = candidates[rng.choice(len(candidates), p=chances)]   # choice returns an index into candidates, drawn with these chances        if word == END:            break        name.append(word)    return " ".join(name)generated = [generate() for _ in range(6)]print("\n".join(masked(name) for name in generated))   # masked shows each rare word, used in fewer than 30 training descriptions, as [name]; most are product lines' namesprint("generated words never seen in training:", sum(w not in model.counts for name in generated for w in name.split()))   # every training word is a key, since each is followed by something
Salidapython generate-names.py
waterproof table
long bistro set , dimmable led , smart dryer
[name] 3 '' wide genuine leather lounge chair
[name] kitchen cart
[name] pressure balanced tub door , french [name] panel post cap
[name] 68.75 '' wide armchair
generated words never seen in training: 0

Cada par de palabras contiguas es plausible, porque cada par aparece en un nombre real: genuine leather, kitchen cart, lounge chair. Los nombres en conjunto a menudo no lo son, porque nada obliga a un nombre a referirse a un solo producto. Un nombre va de un juego de bistró a una luz regulable y de ahí a una secadora inteligente, unidos por comas, ya que después de una coma casi cualquier cosa puede seguir. El modelo no tiene memoria más allá de la última palabra, así que no puede saber que estaba describiendo un juego de bistró. Otros unen el nombre de una línea de productos, escrito como [name], a un producto de otro tipo, como un sillón de cuero (lounge chair), porque los nombres que empiezan con una línea de productos son frecuentes en el texto de entrenamiento. Nada se inventa: un modelo de bigramas solo puede escribir palabras que contó, y la salida lo confirma, con 0 palabras generadas que no aparecen en los nombres de entrenamiento.

Los nombres generados hacen visibles los límites de un modelo de una manera que un número no logra, y por eso vale la pena leerlos. Sin embargo, no miden nada: seis nombres son muy pocos para comparar dos modelos, y la noción de "plausible" de un lector cambia de un día para otro. La siguiente sección ofrece el número.

Regla práctica: Genera muestras cada vez que cambies un modelo, y léelas, porque muestran fallos que una puntuación oculta, como un texto que se desplaza de un producto a otro. Usa una semilla fija para que las muestras sean reproducibles. Nunca compares modelos por sus muestras; compáralos por perplejidad sobre texto de validación.

Evalúa un modelo con la perplejidad

Último cambio en la edición 2026.11.16

Un modelo de lenguaje es bueno cuando asigna alta probabilidad al texto que realmente aparece. Eso sugiere una puntuación: ejecuta el modelo sobre texto real y observa cuánta probabilidad dio a cada palabra que vino después. La forma estándar de resumir esto es la perplejidad, y este libro la usa para comparar cada modelo que construye.

Partamos de un solo par. Si el modelo dio a la palabra siguiente real la probabilidad p, su sorpresa ante esa palabra es −log p: cero cuando estaba seguro (p = 1) y mayor cuanto menos la esperaba. La entropía cruzada de un texto es la sorpresa promedio sobre cada palabra del mismo, escrita con N como el número de palabras predichas:

entropía cruzada = −(1/N) Σ log P(palabra siguiente | palabra anterior)

La perplejidad es la entropía cruzada convertida de nuevo en un recuento: perplejidad = exp(entropía cruzada) (Jurafsky y Martin, capítulo 3). Se interpreta como el número de palabras igualmente probables entre las que el modelo elegía, en promedio, en cada paso. Una perplejidad de 10 significa que el modelo tenía, en promedio, tanta incertidumbre como si tuviera que escoger entre 10 palabras igualmente probables. Cuanto menor, mejor, y un modelo que supiera cada palabra siguiente obtendría 1. Este libro usa logaritmos naturales en todo momento, lo que cambia las unidades de la entropía cruzada pero no la perplejidad.

Puntúa un nombre de entrenamiento, sled coffee table, par por par para ver dónde se concentra su sorpresa, y luego todos los nombres de entrenamiento a la vez:

perplexity-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Scores the training name sled coffee table pair by pair, to show where its surprise sits, then scores every training nameat once. The printed line for P(sled | <s>), the largest surprise in the name, is the one the prose's point rests on."""import mathfrom lib.bigrams import Bigrams, padded, perplexityfrom lib.store import load_productstrain = load_products("train")["name"]model = Bigrams(train)name = "sled coffee table"                  # a training name, so every pair in it has a counttokens = padded(name)                       # the name with <s> and </s> around it, as in trainingsurprise = 0.0for word, following in zip(tokens, tokens[1:]):   # tokens[1:] shifts the list one word on, so each pair is a word and the next    p = model.probability(word, following)    surprise += -math.log(p)                # natural log, so surprise is in nats, the units that exp() undoes    print(f"P({following} | {word}) = {p:.4f}   -log P = {-math.log(p):.2f}")print("average -log P:", round(surprise / (len(tokens) - 1), 3))   # pairs: one fewer than the tokens, one per word predicted, </s> includedprint("perplexity of the name:", round(math.exp(surprise / (len(tokens) - 1)), 1))   # perplexity is exp of the average surpriseprint("perplexity of every training name:", round(perplexity(model, train), 1))   # pooled over every pair in every name, not averaged name by name
Salidapython perplexity-by-hand.py
P(sled | <s>) = 0.0001   -log P = 8.83
P(coffee | sled) = 0.7846   -log P = 0.24
P(table | coffee) = 0.8960   -log P = 0.11
P(</s> | table) = 0.6903   -log P = 0.37
average -log P: 2.389
perplexity of the name: 10.9
perplexity of every training name: 16.9

Casi toda la sorpresa cae en el primer par. Pocos nombres empiezan por sled, así que el modelo se sorprendió con eso, y después cada palabra estuvo cerca de lo esperado: coffee sigue a sled en la mayoría de los nombres de entrenamiento que contienen sled, y table sigue a coffee. La sorpresa promedio del nombre es 2.389, y su perplejidad 10.9. Sobre todos los nombres de entrenamiento, la perplejidad del modelo es 16.9: sobre el texto del que aprendió, elegía entre aproximadamente esa cantidad de palabras probables en cada paso.

Ese número favorece al modelo, porque se mide sobre el texto del que salieron los recuentos. Cada par de los nombres de entrenamiento tiene un recuento, así que ningún par sorprende infinitamente al modelo. La prueba real es un texto que no ha visto.

Regla práctica: Puntúa cada modelo de lenguaje por su perplejidad sobre texto de validación, calculada exactamente como se indicó arriba, con logaritmos naturales y contando cada palabra predicha, incluido el marcador de fin. Compara perplejidades solo entre modelos que usen los mismos tokens y el mismo texto de validación, ya que dividir el texto de otra manera cambia N y lo que cuenta como palabra. Informa la perplejidad de entrenamiento solo junto a la perplejidad de validación, para mostrar cuánto memorizó el modelo.

Los pares de palabras no vistos hacen fallar al modelo

Último cambio en la edición 2026.11.16

Un modelo entrenado por conteo solo conoce los pares que ha contado, y los nombres de validación se separaron de los nombres de entrenamiento precisamente por esta razón: muestran qué ocurre cuando el modelo se enfrenta a un texto que nunca vio. El modelo obtuvo 16.9 en los nombres de entrenamiento, en evalúa un modelo con la perplejidad. Antes de ejecutar el siguiente ejemplo, adivina cuál será su perplejidad en los 4,282 nombres de validación.

perplexity-on-new-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Scores the bigram model on the validation names, which it never learned from, then counts the pairs in them that neveroccurred in training. The printed validation perplexity, which is infinite, is the line the prose's point rests on."""from lib.bigrams import Bigrams, padded, perplexityfrom lib.store import load_products, maskedmodel = Bigrams(load_products("train")["name"])validation = load_products("validation")["name"]   # products the model never learned fromprint("validation perplexity:", perplexity(model, validation))   # inf as soon as one pair has probability zero, rather than an errorpairs = [(w, f) for name in validation for w, f in zip(padded(name), padded(name)[1:])]   # each neighbouring pair in a padded nameunseen = [pair for pair in pairs if model.probability(*pair) == 0]   # probability is 0 for a pair the training names never containprint("validation word pairs:", f"{len(pairs):,}")print("pairs never seen in training:", f"{len(unseen):,}")print("share never seen in training:", f"{len(unseen) / len(pairs):.0%}")names_hit = sum(any(model.probability(*p) == 0 for p in zip(padded(n), padded(n)[1:])) for n in validation)   # a name counts once, if any of its pairs is unseenprint("names with an unseen pair:", f"{names_hit:,}")print("validation names:", f"{len(validation):,}")print("first unseen pairs:", ", ".join(masked(f"{w} {f}") for w, f in unseen[:3]))   # the first three in validation order, not the most common
Salidapython perplexity-on-new-names.py
validation perplexity: inf
validation word pairs: 33,336
pairs never seen in training: 8,278
share never seen in training: 25%
names with an unseen pair: 3,724
validation names: 4,282
first unseen pairs: [name] [name], [name] 4, wood half-circle

La perplejidad de validación es infinita: el ejemplo imprime inf. Basta con un solo par al que el modelo le asignó probabilidad cero, porque su sorpresa, −log 0, es infinita, y también lo es cualquier promedio que lo incluya. Y no es uno solo. El 25% de los pares de palabras de validación nunca aparece en los nombres de entrenamiento, y el 3,724 de los nombres de validación contiene al menos uno. Los primeros pares no vistos lo muestran: un nombre de validación que empieza con una línea de producto que los nombres de entrenamiento nunca mencionan, escrita como [name], hace que tanto su primer par como el segundo sean pares no vistos.

Este es el defecto que advertía la sección de probabilidades. La máxima verosimilitud asigna probabilidad cero a todo par no visto, y en el texto real la mayoría de los documentos nuevos contienen algo no visto: una nueva línea de producto, un tamaño inusual, una palabra familiar en un lugar desconocido, como half-circle después de wood. Más texto de entrenamiento ayuda un poco, pero no resuelve el problema. El lenguaje sigue produciendo combinaciones nuevas, así que un modelo que considera imposible toda combinación no vista siempre fallará con texto nuevo.

La solución es el suavizado, que asigna algo de probabilidad a los pares no vistos quitando un poco de probabilidad a los pares que el modelo sí ha visto.

Regla práctica: Nunca confíes en un modelo de lenguaje que asigne probabilidad cero a cualquier cosa; comprueba si hay perplejidad infinita o indefinida en el texto de validación antes de comparar modelos. Cuando veas una, cuenta los pares no vistos, como se explicó antes, para saber qué parte del texto no puede manejar el modelo.

Asigna una pequeña probabilidad a los pares no vistos

Último cambio en la edición 2026.11.16

El modelo de los pares de palabras no vistos rompen el modelo falla porque asigna probabilidad cero a los pares no vistos, y el suavizado les da algo de probabilidad. El método de suavizado más simple, el suavizado de sumar uno, supone que cada par posible ocurrió una vez más de lo que ocurrió. Cada cuenta aumenta en uno, incluidas las cuentas en cero, y los totales crecen en consecuencia:

P(v | w) = (cuenta(w v) + 1) / (cuenta(w) + V)

donde V es el tamaño del vocabulario, es decir, todas las palabras que el modelo puede predecir. Una palabra que el texto de entrenamiento no contiene en absoluto se cuenta como una entrada más del vocabulario, <unk>, de «unknown» (desconocida), de modo que las probabilidades siguen sumando uno. Ningún par tiene ya probabilidad cero, así que la perplejidad sobre texto nuevo es finita. La pregunta es cuánto cuesta.

Dos números muestran el costo, la probabilidad de table después de coffee y la perplejidad, con cada modelo:

add-one-smoothing.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Superado
"""Compares the counted and add-one bigram models on one probability and on perplexity, to show what add-one smoothingcosts. The printed validation perplexity, add-one, is the line the prose's point rests on: it is finite, where thecounted model's is infinite."""from lib.bigrams import Bigrams, perplexityfrom lib.store import load_productsmodel = Bigrams(load_products("train")["name"])train, validation = load_products("train")["name"], load_products("validation")["name"]   # the counts come from the training names; validation tests themprint("vocabulary:", f"{len(model.vocabulary):,}")   # every word the model can predict: training words, </s> and <unk>, but not <s>, which is never predictedprint("P(table | coffee) counted:", round(model.probability("coffee", "table"), 3))print("P(table | coffee) add-one:", round(model.probability("coffee", "table", add_one=True), 3))   # add_one adds one to every count, and the vocabulary's size to every totalprint("training perplexity, counted:", round(perplexity(model, train), 1))   # on the names the counts came from, so every pair has a countprint("training perplexity, add-one:", f"{perplexity(model, train, add_one=True):,.1f}")print("validation perplexity, add-one:", f"{perplexity(model, validation, add_one=True):,.1f}")   # add-one gives no pair probability zero, so this is finite
Salidapython add-one-smoothing.py
vocabulary: 25,909
P(table | coffee) counted: 0.896
P(table | coffee) add-one: 0.042
training perplexity, counted: 16.9
training perplexity, add-one: 1,232.8
validation perplexity, add-one: 1,575.1

El vocabulario contiene 25,909 palabras, incluidos el marcador de fin y <unk>, y ahí está el problema. El suavizado de sumar uno añade una ocurrencia imaginaria por cada una de ellas después de cada palabra, así que después de coffee imagina decenas de miles de pares extra frente a unos mil reales.

La probabilidad de table después de coffee baja de 0.896 a 0.042. El modelo ahora confía mucho menos en lo que ha visto, y las perplejidades lo muestran: en los nombres de entrenamiento, la perplejidad sube de 16.9 a 1,232.8.

La perplejidad de validación es finita, 1,575.1, lo cual es un avance, pero el modelo da tanta probabilidad a pares de palabras que nunca ocurren que sus predicciones son casi inútiles.

El suavizado de sumar uno arregla el infinito y rompe casi todo lo demás, porque añade un par imaginario por cada palabra del vocabulario, sin importar cuánta evidencia contengan los conteos reales, y los reparte por igual. Los mejores métodos de suavizado quitan mucha menos probabilidad a los pares vistos y se la dan a los pares no vistos en proporción a con qué frecuencia aparecen sus palabras en otros lugares. El capítulo 3 cubre esos métodos. Allí, el modelo de conteo de este capítulo, que mira más atrás y usa un mejor método de suavizado, se convierte en la línea base con la que se miden todos los modelos posteriores del libro.

Regla práctica: Nunca publiques un modelo de conteo sin suavizado, y nunca uno con suavizado de sumar uno: mide la perplejidad de validación y espera que el de sumar uno pierda frente a todos los métodos del capítulo 3, que los compara sobre los mismos tokens. Usa el de sumar uno solo como lo hace este capítulo, para mostrar que las probabilidades cero se pueden corregir y que la corrección requiere cuidado.

Qué sale mal en producción

El autocompletado con bigramas es barato y rápido, y sigue siendo una base razonable para un cuadro de búsqueda. Estos son los problemas que lo acompañan:

  • El catálogo cambia. Un modelo cuyos conteos se calcularon a partir de los nombres del mes pasado no conoce las líneas de productos de este mes. Un comprador que escribe una línea de productos nueva no recibe ninguna sugerencia, porque el modelo no tiene conteos posteriores a ella, hasta que los conteos se reconstruyan; por eso, reconstrúyelos de forma programada y cada vez que cambie el catálogo.
  • Las sugerencias pueden resultar embarazosas. El modelo sugiere lo que siguió a una palabra en su texto de entrenamiento, incluidos los signos de puntuación. Filtra las sugerencias con una lista de tokens permitidos y revisa a mano las sugerencias más frecuentes antes de publicarlas.
  • Los productos populares desplazan al resto. Una palabra seguida la mayor parte del tiempo por un mismo tipo de producto, como coffee, sugerirá siempre ese tipo. Los compradores que buscan una taza de café tienen que escribir más. Ofrece varias sugerencias, no una sola.
  • Una palabra de contexto es muy poco. Como mostró patio bar, el modelo ignora todo excepto la última palabra. Si los compradores escriben consultas largas, mide con qué frecuencia cambian las sugerencias cuando condicionas el modelo a más palabras, algo que hace el capítulo 3.
  • La tabla crece con el texto. Una tabla de bigramas tiene una entrada por cada par que se ha visto alguna vez; con contextos más largos, el número de entradas se dispara. Cuenta solo lo que necesitas y elimina los pares vistos una única vez si la memoria es escasa.

Lo que decidió este capítulo

Último cambio en la edición 2026.11.11
  • El texto de la tienda se divide una sola vez, por producto, en particiones de entrenamiento, validación y prueba, y los modelos aprenden solo de la partición de entrenamiento. Una puntuación sobre texto que un modelo aprendió mide la memoria, no la predicción, y dividir por producto evita que nombres casi idénticos de un mismo producto caigan en ambos lados.
  • Cada texto se rellena con <s> y </s>. Así los modelos aprenden cómo empiezan y terminan los textos, algo que el autocompletado necesita para la primera palabra de una persona compradora y que la generación necesita para detenerse.
  • Los modelos se comparan por perplejidad sobre el texto de validación, con logaritmos naturales y contando cada palabra predicha, incluido el marcador de fin. Las muestras generadas se leen por lo que muestran, pero nunca se usan para elegir entre modelos.
  • El modelo de bigramas de los nombres de productos de la tienda, construido a partir de conteos, es el primer modelo del libro. Sugiere buenas palabras siguientes tras palabras con una única continuación frecuente, como coffee, y malas tras palabras con muchas, como outdoor. Solo ve una palabra de contexto, por lo que patio bar y bar reciben las mismas sugerencias.
  • Sin suavizado, la perplejidad de validación del modelo es infinita, y con suavizado de suma uno es finita pero mala. El capítulo 3 le aplica un método de suavizado mejor, lo convierte en la línea base y mantiene las mismas particiones y la misma medida, para que cada modelo posterior se compare con él en igualdad de condiciones.

Este capítulo, en esta edición

Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 8 de 8 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.16.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 1 de 11: Predecir la siguiente palabra

  1. Cargar el texto de la tienda
  2. Contar qué palabra sigue a cuál
  3. Convertir recuentos en probabilidades
  4. Sugerir la siguiente palabra mientras el cliente escribe
  5. Generar nombres una palabra a la vez
  6. Evalúa un modelo con la perplejidad
  7. Los pares de palabras no vistos hacen fallar al modelo
  8. Asigna una pequeña probabilidad a los pares no vistos
  9. Qué sale mal en producción
  10. Lo que decidió este capítulo

Volver arribaTodos los capítulos