Elegir el siguiente token
Unos 20 minutos de lectura, con 7 ejemplos en 9 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
Al final de este capítulo podrás convertir las probabilidades de un modelo de lenguaje en texto, y decidir cómo hacerlo: siempre el token más probable, el texto completo más probable mediante búsqueda por haz, o una muestra modelada por una temperatura, un recorte top-k o top-p, una penalización por repetición y una longitud mínima. Medirás lo que cada elección hace al texto, y aprenderás qué fallos ningún ajuste puede corregir.
Un modelo de lenguaje da una probabilidad para cada posible token siguiente; no escribe. Para escribir, algo tiene que elegir un token, añadirlo, pedir las siguientes probabilidades y repetir hasta que el modelo prediga la marca de fin, </s>. Convertir las probabilidades de un modelo en texto, un token elegido a la vez, se llama decodificación, y decide buena parte de cómo se lee el texto, sin que el modelo cambie.
La tienda tiene una razón para escribir: de los muebles y artículos para el hogar de su conjunto de validación, 597 de 4,282 productos no tienen descripción, y tampoco la tienen 14% de sus productos de entrenamiento. El modelo de la tienda, el transformador que entrenó y midió el capítulo 8, aprendió descripciones a partir del texto propio de la tienda, así que puede redactar una a partir del nombre de un producto: comienza el texto con el nombre y <sep>, tal como estaba organizado cada texto de entrenamiento, y deja que el modelo continúe. Este capítulo lo hace con decodificación voraz, búsqueda por haz y muestreo, usando el módulo compartido del libro lib.decoding, construido en NumPy sobre lib.transformer. Después mide lo que escribe cada método frente a las descripciones reales de la tienda, y corrige dos fallos que las mediciones dejan al descubierto: la repetición y las descripciones que salen vacías.
Elige el token más probable
El decodificador más sencillo es el voraz (greedy): en cada paso, toma el token más probable. No necesita aleatoriedad, así que siempre escribe el mismo texto para el mismo inicio, y cada paso cuesta un pase hacia adelante del modelo. El texto que escribe es, token a token, la mejor suposición del modelo.
Un producto sin descripción es lo que la tienda necesita resolver, así que empieza con uno: front porch welcome sign wall décor, decodificado de forma voraz hasta 60 tokens. Luego toma un segundo producto, 5 light light bulb, e imprime la probabilidad de que su descripción esté vacía:
1"""Greedy decoding writes one description of a product that has none, and shows how it repeats itself, and how likely2the model is to leave a bulb's description empty. The prose quotes the greedy description, its repeated phrases, and3the line with the bulb's probability of an empty description."""4from collections import Counter56from lib import decoding, transformer7from lib.store import load_products89validation, training = load_products("validation"), load_products("train")10empty = lambda rows: rows["description"].fillna("").str.strip() == ""11print("validation products:", f"{len(validation):,}")12print("validation products with no description:", f"{empty(validation).sum():,}")13print("training products with no description:", f"{empty(training).mean():.0%}")14bulbs = training[training["name"].str.contains(r"\bbulbs?\b")]15print("training products named as bulbs with no description:", f"{empty(bulbs).mean():.0%}")1617longest = 6018print("longest description, in tokens:", longest)19ids = decoding.generate(decoding.prompt("front porch welcome sign wall décor"), longest=longest) # no rng: each step takes the likeliest token20print("greedy description:", decoding.text(ids))21fourgrams = Counter(tuple(ids[i:i + 4]) for i in range(len(ids) - 3)) # the four tokens from i: a window that slides one token at a time22print("4-token phrases it uses twice or more:", " | ".join(decoding.text(list(g)) for g, n in fourgrams.items() if n > 1))2324end = transformer.load()[1].index(transformer.END) # the index of </s> in the vocabulary25probabilities = transformer.softmax(decoding.next_logits(decoding.prompt("5 light light bulb"))) # the first token after <sep>26print("P(the description is empty), 5 light light bulb:", f"{probabilities[end]:.2f}")
python greedy-description.pyvalidation products: 4,282
validation products with no description: 597
training products with no description: 14%
training products named as bulbs with no description: 24%
longest description, in tokens: 60
greedy description: this welcome sign is a great way to add a touch of rustic charm to your home . it is made of natural wood and features a distressed finish with a distressed finish . this welcome sign is made of wood and has a distressed finish that adds a rustic touch to your home . this sign is made from
4-token phrases it uses twice or more: this welcome sign is | to your home .
P(the description is empty), 5 light light bulb: 0.28
La descripción voraz se lee como el propio texto de la tienda, y luego se repite. Se lee así porque es el texto de la tienda, recombinado, como en this welcome sign is a great way to add a touch of rustic charm to your home. Escribe features a distressed finish with a distressed finish, y más tarde has a distressed finish de nuevo, y usa dos frases de cuatro tokens dos veces, this welcome sign is y to your home ., que lista el ejemplo. La decodificación voraz entra en bucle porque la misma continuación más probable gana cada vez que el texto llega a un punto parecido: distressed es el remate favorito del modelo para un letrero, así que vuelve cada vez que toca un remate. Holtzman y colegas encontraron lo mismo en modelos grandes: la decodificación que siempre maximiza la probabilidad produce texto que es "soso, incoherente, o se queda atascado en bucles repetitivos" (Holtzman et al., 2020).
La descripción voraz también dice que el letrero es made of natural wood, algo que nada en el nombre del producto dice. La bombilla muestra otro fallo: para 5 light light bulb, el modelo da el final inmediato, una descripción vacía, con una probabilidad de 0.28. El modelo aprendió el catálogo tal como es, con sus huecos incluidos. De los productos de entrenamiento nombrados como bombillas, 24% no tienen descripción, frente a 14% de todos los productos. Una sección posterior trata la descripción vacía.
Regla práctica: Usa la decodificación voraz cuando quieras la misma salida cada vez y textos cortos, como una sugerencia en un cuadro de búsqueda, donde la siguiente palabra más probable es el objetivo. Para cualquier cosa más larga que una frase, espera que se repita, y elige uno de los métodos de las secciones que siguen.
Búsqueda del texto más probable
La decodificación voraz elige el token más probable en cada paso, lo cual no es lo mismo que el texto más probable: una primera palabra algo menos probable puede llevar a palabras posteriores mucho más probables. La búsqueda en haz mira más lejos: conserva los k textos parciales más probables, el haz, puntuados por su log-probabilidad total, la suma de los logaritmos de las probabilidades de los tokens de un texto, donde un valor más alto significa más probable. En cada paso extiende cada texto del haz con sus k tokens siguientes más probables, y conserva los k mejores resultados. Un texto que alcanza el marcador de fin queda terminado y sigue en la competencia. El núcleo de lib.decoding.beam es la línea que puntúa cada extensión:
candidates += [(score + log_p[token], written + [int(token)]) for token in np.argsort(-log_p, kind="stable")[:width]]
¿Qué descripción crees que la búsqueda en haz clasificará como la más probable para el letrero de bienvenida? Ejecútala dos veces, con un haz de 4. La primera ejecución completa la consulta de búsqueda outdoor bar con hasta 4 tokens, incluido el final del nombre, como lo haría un cuadro de búsqueda que ofrece frases completas; la segunda escribe la descripción del letrero de bienvenida e imprime el texto más probable en total y por token, es decir, su log-probabilidad total dividida entre su longitud.
1"""Beam search with a beam of four, on a search query and on a product's description. The prose quotes the two2completions of outdoor bar, then the likeliest description, its probability and the likeliest per token."""3import numpy as np45from lib import decoding, transformer67_, vocabulary, _ = transformer.load()8width, longest = 4, 49print("beam width:", width)10print("longest completion, in tokens, its end included:", longest)11start = decoding.prompt("outdoor bar")[:-1] # a search query: <s> and the words typed so far12for score, written in decoding.beam(start, width=width, longest=longest, stops=(transformer.SEP,))[:2]: # stop at <sep>, where a name ends; keep the two likeliest13 print("completion of outdoor bar:", decoding.text([t for t in written if vocabulary[t] != transformer.SEP]),14 f"(probability {np.exp(score):.3f})")1516kept = decoding.beam(decoding.prompt("front porch welcome sign wall décor"), width=width) # longest and stops take their defaults: 60 tokens, </s>17score, written = kept[0] # the likeliest text overall18print("likeliest description:", decoding.text(written) or "(empty)")19print("its probability:", f"{np.exp(score):.2f}")20score, written = max(kept, key=lambda candidate: candidate[0] / len(candidate[1])) # the likeliest per token21print("likeliest description per token:", decoding.text(written))
python beam-search.pybeam width: 4
longest completion, in tokens, its end included: 4
completion of outdoor bar: stool (probability 0.365)
completion of outdoor bar: stool cushion (probability 0.089)
likeliest description: (empty)
its probability: 0.15
likeliest description per token: welcome guests to your home with this welcome sign . crafted of iron , this welcome sign is a great way to add a rustic touch to your home .
En la consulta, la búsqueda en haz da lo que debe dar un cuadro de búsqueda: frases cortas y probables, con stool primero y luego stool cushion. Esto usa solo el transformador; la mezcla que eligió el capítulo 8 para el autocompletado necesitaría la probabilidad del 4-grama para cada candidato en cada paso, algo que lib.decoding no calcula.
La descripción más probable en total está vacía. Terminar de inmediato tiene una probabilidad de 0.15, y cada texto más largo multiplica muchas probabilidades menores que uno, así que ninguno se acerca. Stahlberg y Byrne encontraron lo mismo en modelos de traducción: para la mayoría de las oraciones, la traducción más probable era vacía, y la búsqueda en haz funcionaba solo porque buscaba mal (Stahlberg y Byrne, 2019). Clasificar por probabilidad por token elimina ese sesgo y da una descripción sensata. Aun así, inventa un material: esta vez el letrero está crafted of iron.
Regla práctica: Usa la búsqueda en haz para completados cortos en los que la frase más probable es el objetivo, como las consultas de búsqueda, clasificadas por probabilidad total. Para textos más largos, clasifica los textos terminados por probabilidad por token, ya que la probabilidad total favorece a los más cortos, y aun así prefiere los métodos de muestreo de las próximas secciones, que escriben texto más parecido al que escriben las personas.
Muestreo, con una temperatura
La decodificación voraz y la búsqueda en haz usan solo la parte superior de la distribución. El muestreo, que el capítulo 1 usó para generar nombres, usa toda la distribución: se elige el siguiente token al azar, en proporción a su probabilidad, de modo que un token con probabilidad 0.2 se elige una de cada cinco veces. Antes del muestreo, la distribución puede hacerse más aguda o más plana con una temperatura, T: se divide cada logit entre T antes del softmax. En símbolos, con zᵢ el logit del token i, como en el capítulo 5:
P(token i) = exp(zᵢ / T) / Σⱼ exp(zⱼ / T)
Una temperatura inferior a 1 agudiza la distribución, dando más probabilidad a los tokens más probables; por encima de 1, la aplana, dando más a los improbables. Una temperatura cercana a 0 se aproxima a la decodificación voraz, y una temperatura de 1 deja las probabilidades del modelo tal como están. Dividir entre T conserva el orden de los tokens; solo cambia qué tan separadas están sus probabilidades.
Para ver qué hace la temperatura con una elección real, detén la descripción voraz antes de tiempo y lee la distribución del siguiente token a tres temperaturas. Para cada una, el ejemplo imprime los tres tokens más probables, cuántos cubren el 90% de la probabilidad y cuánta queda fuera de la cobertura del 90% a temperatura 1.
1"""The next token's distribution after the first nine tokens of the greedy description, at three temperatures, and how2many tokens each needs to cover 90% of the probability. The prose quotes the three counts, and the share at 1.5 that3falls outside temperature 1's 90% cover."""4import numpy as np56from lib import decoding, transformer78_, vocabulary, _ = transformer.load()9start = decoding.prompt("front porch welcome sign wall décor")10so_far = decoding.generate(start, longest=9) # the greedy description's first 9 tokens11logits = decoding.next_logits(start + so_far)12print("text so far:", decoding.text(so_far))13print("tokens in the vocabulary:", f"{len(vocabulary):,}")14cover = np.argsort(-transformer.softmax(logits), kind="stable") # at temperature 1, the likeliest first15cover = cover[:int(np.searchsorted(np.cumsum(transformer.softmax(logits)[cover]), 0.9)) + 1] # temperature 1's 90% cover, its last token included16for temperature in [0.5, 1.0, 1.5]:17 probabilities = transformer.softmax(logits / temperature) # divide the logits, then softmax18 top = np.argsort(-probabilities, kind="stable")19 covering = int(np.searchsorted(np.cumsum(probabilities[top]), 0.9)) + 1 # +1: the token that reaches 90% counts20 print(f"temperature {temperature}, top 3:", ", ".join(f'"{vocabulary[i].replace("</w>", "")}" {probabilities[i]:.2f}' for i in top[:3]))21 print(f"temperature {temperature}, tokens needed to cover 90% of the probability:", covering)22 print(f"temperature {temperature}, probability outside temperature 1.0's 90% cover:",23 f"{1 - probabilities[cover].sum():.0%}")
python temperature-by-hand.pytext so far: this welcome sign is a great way to add
tokens in the vocabulary: 4,142
temperature 0.5, top 3: "a" 0.61, "style" 0.20, "some" 0.11
temperature 0.5, tokens needed to cover 90% of the probability: 3
temperature 0.5, probability outside temperature 1.0's 90% cover: 0%
temperature 1.0, top 3: "a" 0.26, "style" 0.15, "some" 0.11
temperature 1.0, tokens needed to cover 90% of the probability: 78
temperature 1.0, probability outside temperature 1.0's 90% cover: 10%
temperature 1.5, top 3: "a" 0.09, "style" 0.06, "some" 0.05
temperature 1.5, tokens needed to cover 90% of the probability: 640
temperature 1.5, probability outside temperature 1.0's 90% cover: 42%
La temperatura fija qué tan repartida queda la probabilidad. Después de this welcome sign is a great way to add, a temperatura 1 el modelo necesita 78 tokens para cubrir el 90%, y el resto es una cola larga, con cada token de ella poco probable. A 0.5, 3 tokens cubren el 90%. A 1.5, se necesitan 640 tokens, y 42% de la probabilidad cae fuera de la cobertura del 90% a temperatura 1.
| Temperatura | Tres tokens más probables | Tokens para cubrir el 90% | Fuera de la cobertura del 90% con T = 1 |
|---|---|---|---|
| 0.5 | "a" 0.61, "style" 0.20, "some" 0.11 | 3 | 0% |
| 1 | "a" 0.26, "style" 0.15, "some" 0.11 | 78 | 10% |
| 1.5 | "a" 0.09, "style" 0.06, "some" 0.05 | 640 | 42% |
Esa cola es el riesgo del muestreo. La mayoría de los tokens que contiene son incorrectos aquí, y a temperatura 1 un muestreador extrae de ella aproximadamente una vez cada diez tokens, y con más frecuencia a medida que sube la temperatura.
Regla práctica: Trata la temperatura como el control entre un texto predecible y uno variado. Mantenla en 1 o un poco por debajo para textos que deban mantenerse cerca de lo que suele decir el texto de entrenamiento, como las descripciones de productos. Una temperatura más baja hace el texto más predecible, no más preciso.
Muestrear y recortar la cola
Bajar la temperatura reduce la cola pero nunca la elimina. Dos métodos la eliminan directamente, antes de muestrear. Top-k conserva solo los k tokens más probables y renormaliza sus probabilidades para que sumen uno (Fan et al., 2018). Top-p, también llamado muestreo de núcleo, conserva el conjunto más pequeño de tokens más probables cuyas probabilidades alcanzan al menos p (Holtzman et al., 2020, ecuación 2). Ambos son opciones de lib.decoding.truncate, cuyo núcleo tiene tres pasos: ordenar los tokens, sumar sus probabilidades en ese orden y encontrar dónde la suma alcanza p:
order = np.argsort(-probabilities, kind="stable")
...
keep = int(np.searchsorted(np.cumsum(probabilities[order]), top_p)) + 1
Top-p se adapta a la confianza del modelo, mientras que top-k no. En el punto del ejemplo de la sección anterior donde el modelo no estaba seguro de la siguiente palabra, hicieron falta 78 tokens para cubrir el 90% de la probabilidad, así que top-p 0.9 conservaría esa cantidad, mientras que top-k 20 conservaría solo 20. Después de una palabra que el modelo predice con certeza casi total, top-p conserva uno o dos tokens y top-k sigue conservando 20, la mayoría de ellos incorrectos. Holtzman y sus colegas defendieron top-p precisamente por esta razón: un k fijo es "subóptimo en contextos variados".
Cuatro muestreadores, cada uno con la misma semilla aleatoria, escriben la descripción del letrero de bienvenida hasta 40 tokens: muestreo a temperatura 1, muestreo a 0.7, top-k con k = 20 y top-p con p = 0.9. Luego el ejemplo reproduce la muestra a temperatura 1, enumerando los tokens extraídos fuera del núcleo del 90% de cada paso, que top-p 0.9 habría recortado.
1"""Four samplers write the same description from one seed, and the temperature-1 draws are then replayed to mark the2tokens outside each step's 90% nucleus. The last two lines are the ones the prose quotes: how many draws came from3the tail, and which tokens they were."""4import numpy as np56from lib import decoding, transformer78_, vocabulary, _ = transformer.load()9start, longest, seed = decoding.prompt("front porch welcome sign wall décor"), 40, 202610print("longest description, in tokens:", longest)11print("random seed:", seed)12for label, settings in [("sampling, temperature 1.0", {}), ("sampling, temperature 0.7", {"temperature": 0.7}),13 ("top-k 20", {"top_k": 20}), ("top-p 0.9", {"top_p": 0.9})]:14 ids = decoding.generate(start, rng=np.random.default_rng(seed), longest=longest, **settings)15 print(f"{label}:", decoding.text(ids))1617rng, written, tail = np.random.default_rng(seed), [], [] # replay temperature 1.0's draws, step by step18for _ in range(longest):19 probabilities = transformer.softmax(decoding.next_logits(start + written))20 token = int(rng.choice(len(probabilities), p=decoding.truncate(probabilities))) # no cut: draw from all of it21 order = np.argsort(-probabilities, kind="stable")22 before = probabilities[order[:int(np.where(order == token)[0][0])]].sum() # the probability ranked above it23 if before >= 0.9: # top-p 0.9 would have cut this token24 tail.append(vocabulary[token].replace("</w>", ""))25 written.append(token)26 if vocabulary[token] == transformer.END:27 break28print("temperature 1.0, tokens drawn from outside the 90% nucleus:", f"{len(tail)} of {len(written)}")29print("temperature 1.0, those tokens:", ", ".join(tail))
python sample-descriptions.pylongest description, in tokens: 40
random seed: 2026
sampling, temperature 1.0: enhance your home even glywheel design with this welcome welcome sign sign . this piece is ideal for both indoor and inviting . made in the usa , mini spirits decorate .
sampling, temperature 0.7: the sign is a great way to add some extra whimsy to your home and get colorful ! made of high-quality metal , this sign comes with a hanging dustroke hanger to help you gli
top-k 20: if you have a new product with a personalized sign wall décor that will help you entertain . look no further like a home decor , this sign is constructed to make life more wonderful . this welcome sign
top-p 0.9: express your guests with this cast iron sign from the nature of the world . it features a meditating podishade design . the hose and symbol in this metal piece will be
temperature 1.0, tokens drawn from outside the 90% nucleus: 5 of 36
temperature 1.0, those tokens: inviting, in, mini, spir, decorate
Recortar la cola elimina los errores más raros, pero no todos. El muestreo a temperatura 1 divaga: escribe welcome welcome sign sign, inventa una palabra, glywheel, y afirma que el letrero es made in the usa. Solo una parte de eso proviene de la cola: 5 of 36 tokens la produjeron, inviting, in, mini, spir, decorate. Las palabras duplicadas y la palabra inventada se construyeron con tokens dentro del núcleo, que top-p habría conservado. A 0.7 el texto se sostiene mejor, aunque ahora dice que el letrero es made of high-quality metal, donde la decodificación voraz decía madera. Top-k y top-p se parecen más al catálogo que el muestreo simple, y aun así inventan: el letrero de top-p es cast iron, con un diseño podishade.
A lo largo de este capítulo, al letrero de bienvenida se le ha dado un material seis veces: mediante la decodificación voraz, la búsqueda en haz, tres de estas muestras y el texto voraz penalizado que aparece más abajo, y nada en su nombre indica de qué está hecho. El modelo escribe lo que suelen decir las descripciones de letreros de bienvenida, y suelen indicar un material. Un método de decodificación cambia qué material plausible elige el modelo; ninguno puede lograr que elija el verdadero.
Regla práctica: Para un texto variado, recorta la cola con top-p alrededor de 0.9 o top-k alrededor de 20, con una temperatura de 1 o un poco menos, y fija la semilla aleatoria cuando necesites reproducir un resultado. No esperes que ningún ajuste haga el texto verdadero: la decodificación elige entre lo que el modelo considera plausible, y comprobar los hechos es una tarea aparte.
Mide lo que escribe cada ajuste
Las muestras sueltas muestran el estilo de cada método; las mediciones muestran las compensaciones. Varias propiedades pueden medirse sin que una persona lea el texto:
- repetición: la proporción de frases de cuatro tokens que repiten una anterior en la misma descripción
- la perplejidad propia del modelo sobre el texto: cuánto le sorprende al modelo lo que escribió, promediada sobre todos los tokens, donde un valor bajo significa predecible
- si la descripción termina dentro del límite, como lo hacen las reales
- si usa una palabra completa del nombre del producto, como debería hacerlo la descripción de ese producto
- su longitud media en tokens
¿Qué tan cerca está cada ajuste del texto real? Extrae al azar 20 productos de validación entre los que tienen descripción, escribe una descripción para cada uno con cada método y compáralas con las reales, recortadas al mismo límite de 60 tokens:
1"""Seven ways of choosing the next token, measured on the same 20 product descriptions: how often each repeats2itself, how likely the model finds its own text, whether it ends, and whether it stays on the product. The real3descriptions come first, as the bar the others are read against. The prose quotes these lines for each setting."""4import numpy as np56from lib import decoding # the store's model, and the decoding methods this chapter builds7from lib.products import product_texts89longest, sample, seed = 60, 20, 202610# Validation products, which the model never trained on, that have at least one token of description after <sep>11described = [(ids, sep) for ids, sep in product_texts("validation") if sep < len(ids) - 2]12products = [described[i] for i in np.random.default_rng(seed).choice(len(described), sample, replace=False)]13print("products, drawn at random from the validation products with a description:", sample)14print("longest description, in tokens:", longest)151617settings = [("real descriptions", None), ("greedy", {}), ("greedy, repetition penalty 1.3", {"penalty": 1.3}),18 ("sampling, temperature 1.0", {"sample": True}), ("sampling, temperature 0.7", {"sample": True, "temperature": 0.7}),19 ("top-k 20", {"sample": True, "top_k": 20}), ("top-p 0.9", {"sample": True, "top_p": 0.9})]20for label, chosen in settings:21 rows = []22 for number, (ids, sep) in enumerate(products):23 start = ids[:sep + 1] # the start marker, the name and <sep>: the model writes on from here24 if chosen is None:25 written = ids[sep + 1:][:longest] # the description as sold, cut where generating would stop26 else:27 options = {option: value for option, value in chosen.items() if option != "sample"}28 # generate samples when it's given a generator, and is greedy without one. Each product gets its own29 # seed, the same for every sampling setting, so the settings differ only in how they choose.30 rng = np.random.default_rng(seed + number) if chosen.get("sample") else None31 written = decoding.generate(start, rng=rng, longest=longest, **options)32 rows.append(decoding.measures(start, written)) # repetition, each token's log-probability, ended, uses the name, length33 repeated, log_p, ended, uses_name, length = zip(*rows)34 print(f"{label}, repeated 4-token phrases:", f"{np.mean(repeated):.0%}")35 print(f"{label}, the model's perplexity of the text:", f"{np.exp(-np.concatenate(log_p).mean()):.1f}") # over all 20 texts' tokens at once36 print(f"{label}, ended within {longest} tokens:", f"{np.mean(ended):.0%}")37 print(f"{label}, uses a whole word of the name:", f"{np.mean(uses_name):.0%}")38 print(f"{label}, average length in tokens:", f"{np.mean(length):.0f}")
python measure-decoding.pyproducts, drawn at random from the validation products with a description: 20
longest description, in tokens: 60
real descriptions, repeated 4-token phrases: 0%
real descriptions, the model's perplexity of the text: 30.5
real descriptions, ended within 60 tokens: 35%
real descriptions, uses a whole word of the name: 95%
real descriptions, average length in tokens: 53
greedy, repeated 4-token phrases: 11%
greedy, the model's perplexity of the text: 2.7
greedy, ended within 60 tokens: 25%
greedy, uses a whole word of the name: 80%
greedy, average length in tokens: 52
greedy, repetition penalty 1.3, repeated 4-token phrases: 0%
greedy, repetition penalty 1.3, the model's perplexity of the text: 3.9
greedy, repetition penalty 1.3, ended within 60 tokens: 70%
greedy, repetition penalty 1.3, uses a whole word of the name: 80%
greedy, repetition penalty 1.3, average length in tokens: 41
sampling, temperature 1.0, repeated 4-token phrases: 0%
sampling, temperature 1.0, the model's perplexity of the text: 22.6
sampling, temperature 1.0, ended within 60 tokens: 50%
sampling, temperature 1.0, uses a whole word of the name: 50%
sampling, temperature 1.0, average length in tokens: 45
sampling, temperature 0.7, repeated 4-token phrases: 0%
sampling, temperature 0.7, the model's perplexity of the text: 7.2
sampling, temperature 0.7, ended within 60 tokens: 45%
sampling, temperature 0.7, uses a whole word of the name: 65%
sampling, temperature 0.7, average length in tokens: 45
top-k 20, repeated 4-token phrases: 0%
top-k 20, the model's perplexity of the text: 7.6
top-k 20, ended within 60 tokens: 50%
top-k 20, uses a whole word of the name: 80%
top-k 20, average length in tokens: 40
top-p 0.9, repeated 4-token phrases: 0%
top-p 0.9, the model's perplexity of the text: 10.7
top-p 0.9, ended within 60 tokens: 30%
top-p 0.9, uses a whole word of the name: 60%
top-p 0.9, average length in tokens: 47
El texto codicioso es mucho más predecible que cualquier cosa que haya escrito una persona, con una perplejidad de 2.7, y 11% de sus frases de cuatro tokens se repiten. Las descripciones reales no repiten nada (0% de sus frases de cuatro tokens), y el modelo las encuentra bastante sorprendentes, con una perplejidad de 30.5. Esa cifra es mayor que la del capítulo 8 para descripciones, porque se trata de una muestra distinta y solo de sus primeros 60 tokens. Holtzman y colaboradores hicieron la misma observación a gran escala: el texto humano no es el texto que el modelo considera más probable.
Ningún ajuste iguala a las descripciones reales en todas las medidas. El muestreo con temperatura 1 es el que más se acerca en perplejidad, con 22.6, pero solo 50% de sus descripciones usan una palabra del nombre del producto, frente a 95% de las reales, así que se aleja del producto. El top-p 0.9 termina casi tan a menudo como el texto real, 30% frente a 35%, pero solo se mantiene en el producto en 60%. El top-k 20 es el que más se mantiene en el producto entre los muestreadores, con 80%, sin repetición y con descripciones de 40 tokens en promedio. Veinte productos es una muestra pequeña, así que interpreta estas cifras como tendencias, no como tasas exactas.
Lo que estas medidas no pueden decir es si una descripción es verdadera. Una descripción puede ser fluida, variada, pertinente y equivocada, como lo fueron las de la sección anterior sobre el material del letrero.
Regla práctica: Compara los ajustes de decodificación con medidas como estas, frente a texto real del mismo tipo, antes de leer las muestras. Decide qué medida importa más para la tarea: en las descripciones de productos, mantenerse en el producto y no repetir van primero. Luego lee aun así una muestra de los resultados, para lo que ninguna medida detecta, y verifica cada afirmación fáctica con los datos del producto.
Penalizar la repetición
Los bucles de la decodificación codiciosa también pueden corregirse sin muestreo. Keskar y sus colegas propusieron una penalización por repetición: dividir el logit de cada token ya generado entre un factor θ mayor que 1, de modo que sea menos probable (Keskar et al., 2019, sección 4.1). Dividir un logit negativo lo haría subir, así que las implementaciones multiplican los logits negativos por θ, como hace lib.decoding.penalize, de modo que el token sea menos probable en ambos casos. Keskar y sus colegas encontraron que un factor de alrededor de 1.2 equilibra evitar la repetición con escribir de forma coherente.
Vuelve al punto en que la descripción codiciosa estaba a punto de escribir distressed por segunda vez. Aplica la penalización a mano sobre los logits del siguiente token, compara el resultado con lib.decoding.penalize y compara las probabilidades antes y después. Después, escríbelo de forma codiciosa con la penalización, para ver si el bucle desaparece:
1"""The repetition penalty applied by hand to the next token's logits, checked against lib.decoding.penalize, and then2used for a whole greedy description. The two P(distressed) lines are the ones the prose quotes, and the3assert against lib.decoding.penalize is the match it states as fact."""4import numpy as np56from lib import decoding, transformer78_, vocabulary, _ = transformer.load()9start, factor = decoding.prompt("front porch welcome sign wall décor"), 1.310written = decoding.generate(start) # greedy, as in greedy-description11distressed = vocabulary.index("distressed</w>")12position = [i for i, token in enumerate(written) if token == distressed][1] # where greedy writes it a second time13before = written[:position]14print("text so far:", decoding.text(before))15print("penalty factor:", factor)1617logits = decoding.next_logits(start + before)18seen = np.unique(before) # every token the description has used19penalized = logits.copy()20penalized[seen] = np.where(logits[seen] > 0, logits[seen] / factor, logits[seen] * factor) # less likely either way21assert np.allclose(penalized, decoding.penalize(logits, before, factor)) # the hand calculation is the library's22for label, adjusted in [("without a penalty", logits), ("with the penalty", penalized)]:23 probabilities = transformer.softmax(adjusted)24 top = np.argsort(-probabilities, kind="stable")[:3]25 print(f"next token, {label}:", ", ".join(f"{vocabulary[i].replace('</w>', '')} {probabilities[i]:.2f}" for i in top))26 print(f"P(distressed), {label}:", f"{probabilities[distressed]:.2f}")27print("greedy with the penalty:", decoding.text(decoding.generate(start, penalty=factor)))
python repetition-penalty-by-hand.pytext so far: this welcome sign is a great way to add a touch of rustic charm to your home . it is made of natural wood and features a distressed finish with a
penalty factor: 1.3
next token, without a penalty: distressed 0.20, black 0.03, weathered 0.03
P(distressed), without a penalty: 0.20
next token, with the penalty: black 0.04, weathered 0.03, distressed 0.03
P(distressed), with the penalty: 0.03
greedy with the penalty: this welcome sign is a great way to add style and functionality to any room . the worn look of these beautiful signs are made from natural coir , so it can be used indoors or outdoors .
Con un factor de 1.3, distressed baja de una probabilidad de 0.20 a 0.03, y otro token gana en su lugar. El cálculo a mano coincide con el de la biblioteca, y la descripción codiciosa penalizada ya no entra en bucle. Sigue inventando, eso sí: esta vez la señal está hecha de natural coir, una fibra de la cáscara del coco.
La penalización tiene un efecto secundario que muestran las mediciones: las descripciones terminan antes. Penaliza todo token ya usado, incluidas palabras comunes como the y and que una descripción necesita muchas veces, pero nunca el marcador de fin, que aún no se ha usado. Así, el final se vuelve relativamente más probable: 70% de las descripciones codiciosas penalizadas terminaron dentro del límite, frente a 25% sin penalización, con una longitud media de 41 tokens frente a 52. Su repetición bajó de 11% a 0%.
Regla práctica: añade una penalización por repetición de alrededor de 1.2 a 1.3 cuando decodifiques de forma codiciosa o con una temperatura baja, y comprueba su efecto sobre la longitud, ya que acorta el texto. Si las descripciones salen cortadas, deja fuera de la penalización las palabras funcionales comunes y los signos de puntuación.
Prohibir una descripción vacía
El ejemplo greedy mostró que el modelo estaba dispuesto a no escribir nada para una bombilla, y la búsqueda por haz encontró que nada era la descripción más probable para un letrero. Ambos casos vienen del catálogo: muchos productos no tienen descripción, así que el modelo aprendió que terminar de inmediato es común. Para rellenar justo esos huecos, hay que impedir que el modelo los reproduzca. La solución sencilla es una longitud mínima: prohibir la marca de fin, fijando su logit en menos infinito, hasta que la descripción tenga cierto número de tokens. lib.decoding.generate la recibe como shortest.
La bombilla que la decodificación greedy dejó vacía es el caso de prueba. Decodifícala dos veces, sin mínimo y luego con un mínimo de 10 tokens; la salida muestra primero la probabilidad de que su descripción termine de inmediato:
1"""Greedy decoding of the bulb's description, without a minimum length and with one that forbids the end marker until2it has that many tokens. The prose quotes the printed probability of an empty description, and3the description the minimum produces."""4from lib import decoding, transformer56end = transformer.load()[1].index(transformer.END) # the index of </s>, to read its probability7start, shortest = decoding.prompt("5 light light bulb"), 108print("P(the description is empty):", f"{transformer.softmax(decoding.next_logits(start))[end]:.2f}") # the first token is </s>: an empty description9print("greedy description:", decoding.text(decoding.generate(start)) or "(empty)")10print("minimum length, in tokens:", shortest)11print("greedy description, with the minimum:", decoding.text(decoding.generate(start, shortest=shortest))) # shortest: </s> stays forbidden until then
python minimum-length.pyP(the description is empty): 0.28
greedy description: (empty)
minimum length, in tokens: 10
greedy description, with the minimum: this light is a great light for a light , a light , and more light . it is made of metal and has a long , high gloss finish that will make it a perfect accent piece for your home . this light is dimmable , compatible with most standard bulbs , which are not included .
El mínimo llena el hueco, pero no puede aportar los datos. Sin él, la decodificación greedy toma la descripción vacía, con una probabilidad de 0.28. Con el mínimo, escribe una, y aparecen en ella dos fallos vistos antes en este capítulo. Se repite, a light , a light , and more light, y afirma cosas que el nombre no dice: que la bombilla es made of metal, dimmable y compatible with most standard bulbs.
Regla práctica: Establece una longitud mínima siempre que el texto de entrenamiento incluya ejemplos vacíos o muy cortos de lo que estás generando. Combínala con los demás ajustes de este capítulo, no en lugar de ellos, y espera que el texto que fuerce necesite la misma revisión que cualquier otro.
Qué sale mal en producción
La mayoría de los fallos de la decodificación son silenciosos:
- El texto fluido afirma hechos inventados. Seis descripciones de este capítulo le atribuyeron un material a la señal de bienvenida, y no coincidían entre sí. Nunca publiques texto de producto generado sin comprobar cada afirmación factual contra los datos del producto; el capítulo 11 mide con qué frecuencia un modelo inventa.
- Los huecos del texto de entrenamiento se convierten en resultados. El modelo predice una descripción vacía para una bombilla, porque el catálogo tiene muchas, y la búsqueda por haces encuentra que la descripción vacía es la más probable de todas. Prohíbe el marcador de fin hasta una longitud mínima, o el modelo reproducirá los mismos huecos que intentas rellenar.
- El texto con decodificación voraz entra en bucles. Usa muestreo con cola recortada, o una penalización por repetición, para cualquier texto más largo que una frase, y mide la repetición en una muestra de los resultados.
- El texto muestreado no es reproducible por defecto. Fija y registra la semilla aleatoria con cada texto generado, para que una queja sobre una descripción pueda rastrearse y repetirse.
- Los ajustes se desvían con el modelo. Un modelo reentrenado tiene una distribución distinta, así que una temperatura o un top-k ajustados para el modelo anterior pueden escribir de otra manera con el siguiente. Repite las mediciones de este capítulo después de cada reentrenamiento, antes de que el nuevo modelo escriba nada que vea un comprador.
- Cada token cuesta un paso hacia delante.
lib.decodingvuelve a ejecutar el modelo sobre todo el texto por cada nuevo token, lo que es sencillo y suficiente para 60 tokens. Los sistemas de servicio conservan las claves y los valores de cada capa de las posiciones anteriores, de modo que las multiplicaciones de matrices de cada nuevo token cubren una sola posición, aunque la atención sigue leyendo las claves y los valores en caché de todas las posiciones anteriores (Pope et al., 2022).
Lo que decidió este capítulo
- El autocompletado usa los tokens más probables. Las sugerencias del cuadro de búsqueda muestran los primeros tokens de la mezcla elegida en el capítulo 8, y la búsqueda por haz, ordenada por probabilidad total, puede extenderlas a frases cortas.
- Las descripciones usan muestreo top-k 20, el ajuste que se mantuvo más veces en el producto sin repetirse, según las medidas anteriores, con una semilla fija y registrada y una longitud mínima para que no salgan vacías. Como solo hay veinte productos detrás, la elección se vuelve a comprobar con una muestra más grande antes de que llegue cualquier descripción a un comprador.
- La búsqueda por haz ordena los textos más largos por token, porque la probabilidad total favorece el texto vacío. Las completaciones cortas de las consultas de búsqueda se ordenan por probabilidad total, donde la frase más probable es la que busca el comprador.
- Los ajustes de decodificación se eligen por medición con texto real: repetición, la perplejidad propia del modelo, si las descripciones terminan, si usan el nombre y su longitud, sobre un conjunto aleatorio de productos, antes de leer las muestras, y de nuevo después de cada reentrenamiento.
- Las descripciones generadas son borradores, nunca una fuente de datos del producto. Una persona o un paso de verificación corrige cada afirmación que el nombre y el catálogo no pueden sostener: todos los métodos aquí inventaron un material para un producto cuyo nombre no lo indica.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 7 de 7 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.