Escolhendo o próximo token

Cerca de 23 minutos min de leitura, com 7 exemplos em 9 seções.

Edição 2026.11.16 Exemplos aprovados em 19 de nov de 2026 86 de 86 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.16. Leia o original

Ao final deste capítulo, você será capaz de transformar as probabilidades de um modelo de linguagem em texto e de escolher como fazê-lo: sempre o token mais provável, o texto inteiro mais provável por busca em feixe, ou uma amostra moldada por uma temperatura, um corte top-k ou top-p, uma penalidade de repetição e um comprimento mínimo. Você medirá o que cada escolha faz ao texto e aprenderá quais falhas nenhuma configuração consegue corrigir.

Um modelo de linguagem fornece uma probabilidade para cada possível próximo token; ele não escreve. Para escrever, é preciso que algo escolha um token, o acrescente, peça as próximas probabilidades e repita o processo até que o modelo preveja o marcador de fim, </s>. Transformar as probabilidades de um modelo em texto, um token escolhido por vez, chama-se decodificação, e ela define grande parte da aparência do texto, mesmo com o modelo inalterado.

A loja tem um motivo para escrever: entre os móveis e artigos para casa de seu conjunto de validação, 597 de 4,282 produtos não têm descrição, e o mesmo ocorre com 14% dos produtos de treinamento. O modelo da loja, o transformer que o capítulo 8 treinou e mediu, aprendeu descrições a partir do próprio texto da loja, então ele pode redigir uma descrição a partir do nome de um produto: comece o texto com o nome e <sep>, como todos os textos de treinamento estavam organizados, e deixe o modelo continuar. Este capítulo faz isso com decodificação gananciosa, busca em feixe e amostragem, usando o módulo compartilhado do livro, lib.decoding, construído em NumPy sobre lib.transformer. Em seguida, mede o que cada método escreve em comparação com as descrições reais da loja, e corrige duas falhas que as medições revelam: a repetição e descrições que saem vazias.

Escolha o token mais provável

Última alteração na edição 2026.11.11

O decodificador mais simples é o guloso: a cada passo, escolhe o único token mais provável. Ele não precisa de aleatoriedade, então sempre escreve o mesmo texto para o mesmo início, e cada passo custa uma passagem direta pelo modelo. O texto que ele escreve, token por token, é a melhor suposição do modelo.

Um produto sem descrição é a necessidade da loja, então comece por um: front porch welcome sign wall décor, decodificado de forma gulosa por até 60 tokens. Depois, pegue um segundo produto, 5 light light bulb, e imprima a probabilidade de que a descrição dele esteja vazia:

greedy-description.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Greedy decoding writes one description of a product that has none, and shows how it repeats itself, and how likelythe model is to leave a bulb's description empty. The prose quotes the greedy description, its repeated phrases, andthe line with the bulb's probability of an empty description."""from collections import Counterfrom lib import decoding, transformerfrom lib.store import load_productsvalidation, training = load_products("validation"), load_products("train")empty = lambda rows: rows["description"].fillna("").str.strip() == ""print("validation products:", f"{len(validation):,}")print("validation products with no description:", f"{empty(validation).sum():,}")print("training products with no description:", f"{empty(training).mean():.0%}")bulbs = training[training["name"].str.contains(r"\bbulbs?\b")]print("training products named as bulbs with no description:", f"{empty(bulbs).mean():.0%}")longest = 60print("longest description, in tokens:", longest)ids = decoding.generate(decoding.prompt("front porch welcome sign wall décor"), longest=longest)   # no rng: each step takes the likeliest tokenprint("greedy description:", decoding.text(ids))fourgrams = 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 timeprint("4-token phrases it uses twice or more:", " | ".join(decoding.text(list(g)) for g, n in fourgrams.items() if n > 1))end = transformer.load()[1].index(transformer.END)                     # the index of </s> in the vocabularyprobabilities = transformer.softmax(decoding.next_logits(decoding.prompt("5 light light bulb")))   # the first token after <sep>print("P(the description is empty), 5 light light bulb:", f"{probabilities[end]:.2f}")
Saídapython greedy-description.py
validation 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

A descrição gulosa soa como o próprio texto da loja e depois entra em loop. Ela soa assim porque é o texto da loja, recombinado, como em this welcome sign is a great way to add a touch of rustic charm to your home. Ela escreve features a distressed finish with a distressed finish, e depois has a distressed finish de novo, e usa duas frases de quatro tokens duas vezes, this welcome sign is e to your home ., que o exemplo lista. A decodificação gulosa entra em loop porque a mesma continuação mais provável vence sempre que o texto chega a um ponto parecido: distressed é o acabamento favorito do modelo para uma placa, então volta sempre que um acabamento é necessário. Holtzman e colaboradores encontraram o mesmo em modelos grandes: a decodificação que sempre maximiza a probabilidade leva a textos que são "monótonos, incoerentes ou presos em loops repetitivos" (Holtzman et al., 2020).

A descrição gulosa também afirma que a placa é made of natural wood, o que nada no nome do produto indica. A lâmpada mostra outra falha: para 5 light light bulb, o modelo dá o fim imediato, uma descrição vazia, com probabilidade de 0.28. O modelo aprendeu o catálogo como ele é, com as lacunas. Dos produtos de treinamento nomeados como lâmpadas, 24% não têm descrição, contra 14% de todos os produtos. Uma seção posterior trata da descrição vazia.

Regra prática: use a decodificação gulosa quando quiser a mesma saída sempre e textos curtos, como uma sugestão de caixa de busca, em que a próxima palavra mais provável é o ponto. Para qualquer coisa mais longa que uma frase, espere que ela se repita, e escolha um dos métodos das seções seguintes.

Busca do texto mais provável

Última alteração na edição 2026.11.16

Decodificação gulosa escolhe o token mais provável a cada passo, o que não é o mesmo que o texto mais provável: uma primeira palavra um pouco menos provável pode levar a palavras seguintes muito mais prováveis. A busca em feixe olha mais adiante, mantendo os k textos parciais mais prováveis, o feixe, pontuados pela sua log-probabilidade total, a soma dos logaritmos das probabilidades dos tokens de um texto, em que valores maiores significam mais provável. A cada passo, ela estende cada texto do feixe com seus k próximos tokens mais prováveis e mantém os k melhores resultados. Um texto que chega ao marcador de fim está concluído e permanece na disputa. O núcleo de lib.decoding.beam é a linha que pontua cada extensão:

            candidates += [(score + log_p[token], written + [int(token)]) for token in np.argsort(-log_p, kind="stable")[:width]]

Qual descrição você espera que a busca em feixe classifique como a mais provável para a placa de boas-vindas? Execute o código duas vezes, com um feixe de 4. A primeira execução completa a consulta de busca outdoor bar com até 4 tokens, incluindo o fim do nome, como uma caixa de busca poderia oferecer frases inteiras; a segunda escreve a descrição da placa de boas-vindas e imprime o texto mais provável no geral e por token, sua log-probabilidade total dividida pelo seu comprimento.

Na consulta, a busca em feixe entrega o que uma caixa de busca deve entregar: frases curtas e prováveis, com stool primeiro e depois stool cushion. Isso usa apenas o transformer; a mistura que o capítulo 8 escolheu para o autocompletar exigiria a probabilidade do 4-grama para cada candidato a cada passo, o que lib.decoding não calcula.

A descrição mais provável no geral está vazia. Terminar imediatamente tem probabilidade de 0.15, e cada texto mais longo multiplica muitas probabilidades menores que um, então nenhum se aproxima. Stahlberg e Byrne encontraram o mesmo em modelos de tradução: para a maioria das frases, a tradução mais provável era vazia, e a busca em feixe só funcionava porque buscava mal (Stahlberg e Byrne, 2019). Ordenar pela probabilidade por token elimina esse viés e dá uma descrição sensata. Ainda assim, ela inventa um material: desta vez a placa é crafted of iron.

Regra prática: use a busca em feixe para completar textos curtos em que a frase mais provável é o objetivo, como consultas de busca, ordenadas pela probabilidade total. Para textos mais longos, ordene os textos concluídos pela probabilidade por token, já que a probabilidade total favorece os mais curtos, e mesmo assim prefira os métodos de amostragem das próximas seções, que escrevem textos mais próximos do que as pessoas escrevem.

Amostragem, com uma temperatura

Última alteração na edição 2026.11.16

A decodificação gulosa e a busca em feixe usam apenas o topo da distribuição. A amostragem, que o capítulo 1 usou para gerar nomes, usa a distribuição inteira: sorteia-se o próximo token ao acaso, em proporção à sua probabilidade, de modo que um token com probabilidade 0.2 seja escolhido uma vez em cada cinco. Antes de amostrar, a distribuição pode ser tornada mais aguda ou mais achatada com uma temperatura, T: divida cada logit por T antes do softmax. Em símbolos, com zᵢ o logit do token i, como no capítulo 5:

P(token i) = exp(zᵢ / T) / Σⱼ exp(zⱼ / T)

Uma temperatura abaixo de 1 torna a distribuição mais aguda, dando mais probabilidade aos tokens mais prováveis; acima de 1, ela a achata, dando mais aos improváveis. Uma temperatura próxima de 0 se aproxima da decodificação gulosa, e uma temperatura de 1 mantém as probabilidades do modelo como estão. Dividir por T preserva a ordem dos tokens; apenas altera o quão distantes ficam suas probabilidades.

Para ver o que a temperatura faz em uma escolha real, interrompa a descrição gulosa antes do fim e leia a distribuição do próximo token em três temperaturas. Para cada uma, o exemplo imprime os três tokens mais prováveis, quantos tokens são necessários para cobrir 90% da probabilidade e quanto da probabilidade fica fora da cobertura de 90% da temperatura 1.

temperature-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""The next token's distribution after the first nine tokens of the greedy description, at three temperatures, and howmany tokens each needs to cover 90% of the probability. The prose quotes the three counts, and the share at 1.5 thatfalls outside temperature 1's 90% cover."""import numpy as npfrom lib import decoding, transformer_, vocabulary, _ = transformer.load()start = decoding.prompt("front porch welcome sign wall décor")so_far = decoding.generate(start, longest=9)                   # the greedy description's first 9 tokenslogits = decoding.next_logits(start + so_far)print("text so far:", decoding.text(so_far))print("tokens in the vocabulary:", f"{len(vocabulary):,}")cover = np.argsort(-transformer.softmax(logits), kind="stable")    # at temperature 1, the likeliest firstcover = cover[:int(np.searchsorted(np.cumsum(transformer.softmax(logits)[cover]), 0.9)) + 1]   # temperature 1's 90% cover, its last token includedfor temperature in [0.5, 1.0, 1.5]:    probabilities = transformer.softmax(logits / temperature)     # divide the logits, then softmax    top = np.argsort(-probabilities, kind="stable")    covering = int(np.searchsorted(np.cumsum(probabilities[top]), 0.9)) + 1   # +1: the token that reaches 90% counts    print(f"temperature {temperature}, top 3:", ", ".join(f'"{vocabulary[i].replace("</w>", "")}" {probabilities[i]:.2f}' for i in top[:3]))    print(f"temperature {temperature}, tokens needed to cover 90% of the probability:", covering)    print(f"temperature {temperature}, probability outside temperature 1.0's 90% cover:",          f"{1 - probabilities[cover].sum():.0%}")
Saídapython temperature-by-hand.py
text 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%

A temperatura define o quanto a probabilidade se espalha. Depois de this welcome sign is a great way to add, na temperatura 1 o modelo precisa de 78 tokens para cobrir 90%, e o restante é uma longa cauda, com cada token nela improvável. Em 0.5, 3 tokens cobrem 90%. Em 1.5, são necessários 640 tokens, e 42% da probabilidade fica fora da cobertura de 90% da temperatura 1.

Temperatura Três tokens mais prováveis Tokens para cobrir 90% Fora da cobertura de 90% de 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%

Essa cauda é o risco da amostragem. A maioria dos tokens nela está errada aqui, e na temperatura 1 um amostrador sorteia dela cerca de uma vez a cada dez tokens, com mais frequência à medida que a temperatura sobe.

Regra prática: Trate a temperatura como o controle entre texto previsível e texto variado. Mantenha-a em 1 ou um pouco abaixo para textos que devem permanecer próximos do que o texto de treinamento costuma dizer, como descrições de produtos. Uma temperatura menor torna o texto mais previsível, não mais preciso.

Amostre e corte a cauda

Última alteração na edição 2026.11.11

Reduzir a temperatura encolhe a cauda, mas nunca a elimina. Dois métodos a removem diretamente, antes da amostragem. Top-k mantém apenas os k tokens mais prováveis e renormaliza suas probabilidades para que somem um (Fan et al., 2018). Top-p, também chamado de amostragem por núcleo, mantém o menor conjunto de tokens mais prováveis cujas probabilidades alcançam pelo menos p (Holtzman et al., 2020, equação 2). Ambos são opções de lib.decoding.truncate, cujo núcleo tem três passos: ordenar os tokens, somar as probabilidades nessa ordem e encontrar onde a soma alcança p:

    order = np.argsort(-probabilities, kind="stable")
    ...
        keep = int(np.searchsorted(np.cumsum(probabilities[order]), top_p)) + 1

Top-p se adapta à confiança do modelo, enquanto top-k não. No ponto do exemplo da seção anterior em que o modelo estava incerto sobre a próxima palavra, foram necessários 78 tokens para cobrir 90% da probabilidade; assim, top-p 0.9 manteria essa quantidade, enquanto top-k 20 manteria apenas 20. Depois de uma palavra que o modelo prevê com quase certeza, top-p mantém um ou dois tokens, e top-k ainda mantém 20, a maioria deles errada. Holtzman e colegas defenderam top-p exatamente com base nisso: um k fixo é "subótimo em contextos variados".

Quatro amostradores, cada um a partir da mesma semente aleatória, escrevem a descrição da placa de boas-vindas em até 40 tokens: amostragem com temperatura 1, amostragem com 0.7, top-k com k = 20 e top-p com p = 0.9. Em seguida, o exemplo reproduz a amostra com temperatura 1, listando os tokens sorteados de fora do núcleo de 90% de cada passo, que top-p 0.9 teria cortado.

sample-descriptions.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Four samplers write the same description from one seed, and the temperature-1 draws are then replayed to mark thetokens outside each step's 90% nucleus. The last two lines are the ones the prose quotes: how many draws came fromthe tail, and which tokens they were."""import numpy as npfrom lib import decoding, transformer_, vocabulary, _ = transformer.load()start, longest, seed = decoding.prompt("front porch welcome sign wall décor"), 40, 2026print("longest description, in tokens:", longest)print("random seed:", seed)for label, settings in [("sampling, temperature 1.0", {}), ("sampling, temperature 0.7", {"temperature": 0.7}),                        ("top-k 20", {"top_k": 20}), ("top-p 0.9", {"top_p": 0.9})]:    ids = decoding.generate(start, rng=np.random.default_rng(seed), longest=longest, **settings)    print(f"{label}:", decoding.text(ids))rng, written, tail = np.random.default_rng(seed), [], []    # replay temperature 1.0's draws, step by stepfor _ in range(longest):    probabilities = transformer.softmax(decoding.next_logits(start + written))    token = int(rng.choice(len(probabilities), p=decoding.truncate(probabilities)))   # no cut: draw from all of it    order = np.argsort(-probabilities, kind="stable")    before = probabilities[order[:int(np.where(order == token)[0][0])]].sum()   # the probability ranked above it    if before >= 0.9:                                        # top-p 0.9 would have cut this token        tail.append(vocabulary[token].replace("</w>", ""))    written.append(token)    if vocabulary[token] == transformer.END:        breakprint("temperature 1.0, tokens drawn from outside the 90% nucleus:", f"{len(tail)} of {len(written)}")print("temperature 1.0, those tokens:", ", ".join(tail))
Saídapython sample-descriptions.py
longest 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

Cortar a cauda remove os erros mais raros, não todos. A amostragem com temperatura 1 divaga: escreve welcome welcome sign sign, inventa uma palavra, glywheel, e afirma que a placa é de made in the usa. Só parte disso vem da cauda: 5 of 36 tokens vieram de lá, inviting, in, mini, spir, decorate. As palavras duplicadas e a palavra inventada foram construídas com tokens dentro do núcleo, que top-p teria mantido. Com 0.7, o texto se sustenta melhor, embora agora diga que a placa é de made of high-quality metal, onde a decodificação gulosa dizia madeira. Top-k e top-p soam mais como o catálogo do que a amostragem simples, e ainda inventam: a placa de top-p é de cast iron, com um desenho podishade.

Ao longo deste capítulo, a placa de boas-vindas recebeu um material seis vezes, pela decodificação gulosa, pela busca em feixe, por três dessas amostras e pelo texto de decodificação gulosa penalizada abaixo, e nada no nome dela diz do que é feita. O modelo escreve o que descrições de placas de boas-vindas costumam dizer, e elas costumam informar um material. Um método de decodificação muda qual material plausível o modelo escolhe; nenhum deles consegue fazer o modelo escolher o material verdadeiro.

Regra prática: Para texto variado, corte a cauda com top-p em torno de 0.9 ou top-k em torno de 20, com temperatura igual a 1 ou um pouco abaixo, e fixe a semente aleatória quando precisar reproduzir um resultado. Não espere que nenhuma configuração torne o texto verdadeiro: a decodificação escolhe entre o que o modelo considera plausível, e verificar fatos é uma tarefa separada.

Meça o que cada configuração escreve

Última alteração na edição 2026.11.12

Amostras isoladas mostram o sabor de cada método; as medições mostram as compensações (trade-offs). Várias propriedades podem ser medidas sem que uma pessoa leia o texto:

  • repetição: a parcela de frases de quatro tokens que repetem uma anterior na mesma descrição
  • a própria perplexidade do modelo sobre o texto: o quanto o modelo considera surpreendente o que escreveu, somada sobre todos os tokens, em que valor baixo significa previsível
  • se a descrição termina dentro do limite, como as reais fazem
  • se usa uma palavra inteira do nome do produto, como a descrição desse produto deve fazer
  • seu comprimento médio em tokens

Quão perto cada configuração chega do texto real? Sorteie 20 produtos de validação, entre os que têm descrição, escreva uma descrição para cada um com cada método e compare-as com as reais, cortadas no mesmo limite de 60 tokens:

measure-decoding.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Seven ways of choosing the next token, measured on the same 20 product descriptions: how often each repeatsitself, how likely the model finds its own text, whether it ends, and whether it stays on the product. The realdescriptions come first, as the bar the others are read against. The prose quotes these lines for each setting."""import numpy as npfrom lib import decoding                    # the store's model, and the decoding methods this chapter buildsfrom lib.products import product_textslongest, sample, seed = 60, 20, 2026# Validation products, which the model never trained on, that have at least one token of description after <sep>described = [(ids, sep) for ids, sep in product_texts("validation") if sep < len(ids) - 2]products = [described[i] for i in np.random.default_rng(seed).choice(len(described), sample, replace=False)]print("products, drawn at random from the validation products with a description:", sample)print("longest description, in tokens:", longest)settings = [("real descriptions", None), ("greedy", {}), ("greedy, repetition penalty 1.3", {"penalty": 1.3}),            ("sampling, temperature 1.0", {"sample": True}), ("sampling, temperature 0.7", {"sample": True, "temperature": 0.7}),            ("top-k 20", {"sample": True, "top_k": 20}), ("top-p 0.9", {"sample": True, "top_p": 0.9})]for label, chosen in settings:    rows = []    for number, (ids, sep) in enumerate(products):        start = ids[:sep + 1]                                 # the start marker, the name and <sep>: the model writes on from here        if chosen is None:            written = ids[sep + 1:][:longest]                 # the description as sold, cut where generating would stop        else:            options = {option: value for option, value in chosen.items() if option != "sample"}            # generate samples when it's given a generator, and is greedy without one. Each product gets its own            # seed, the same for every sampling setting, so the settings differ only in how they choose.            rng = np.random.default_rng(seed + number) if chosen.get("sample") else None            written = decoding.generate(start, rng=rng, longest=longest, **options)        rows.append(decoding.measures(start, written))        # repetition, each token's log-probability, ended, uses the name, length    repeated, log_p, ended, uses_name, length = zip(*rows)    print(f"{label}, repeated 4-token phrases:", f"{np.mean(repeated):.0%}")    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 once    print(f"{label}, ended within {longest} tokens:", f"{np.mean(ended):.0%}")    print(f"{label}, uses a whole word of the name:", f"{np.mean(uses_name):.0%}")    print(f"{label}, average length in tokens:", f"{np.mean(length):.0f}")
Saídapython measure-decoding.py
products, 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

O texto guloso é muito mais previsível do que qualquer coisa que uma pessoa escreveu, com perplexidade de 2.7, e 11% de suas frases de quatro tokens se repetem. As descrições reais não repetem nada (0% de suas frases de quatro tokens), e o modelo as considera bastante surpreendentes, com perplexidade de 30.5. Esse valor é maior que o do capítulo 8 para descrições, porque estas são outra amostra e foram cortadas nos primeiros 60 tokens. Holtzman e colaboradores fizeram a mesma observação em larga escala: o texto humano não é o texto que o modelo considera mais provável.

Nenhuma configuração iguala as descrições reais em todas as medidas. A amostragem com temperatura 1 chega mais perto na perplexidade, com 22.6, mas apenas 50% de suas descrições usam uma palavra do nome do produto, contra 95% das reais, então ela se afasta do produto. Top-p 0.9 termina quase tantas vezes quanto o texto real, 30% contra 35%, mas permanece no produto em apenas 60%. Top-k 20 permanece no produto mais que os demais métodos de amostragem, com 80%, sem repetição e com descrições de 40 tokens em média. Vinte produtos são uma amostra pequena, então leia estes números como indicações de tendência, não como taxas exatas.

O que as medidas não dizem é se uma descrição é verdadeira. Uma descrição pode ser fluente, variada, no assunto e errada, como as da seção anterior estavam erradas quanto ao material da placa.

Regra prática: Compare configurações de decodificação com medidas como estas, contra texto real do mesmo tipo, antes de ler amostras. Decida qual medida importa mais para a tarefa: para descrições de produtos, permanecer no produto e não repetir vêm em primeiro lugar. Depois, leia ainda assim uma amostra das saídas, para o que nenhuma medida captura, e confira cada afirmação factual com os dados do produto.

Penalizar a repetição

Última alteração na edição 2026.11.11

Os loops da decodificação gulosa também podem ser corrigidos sem amostragem. Keskar e colaboradores propuseram uma penalização por repetição: dividir o logit de cada token já gerado por um fator θ acima de 1, de modo que ele fique menos provável (Keskar et al., 2019, seção 4.1). Dividir um logit negativo o tornaria maior, então as implementações multiplicam logits negativos por θ, como lib.decoding.penalize faz, de modo que o token fique menos provável nos dois casos. Keskar e colaboradores descobriram que um fator em torno de 1.2 equilibra evitar repetições e escrever com sensatez.

Volte ao ponto em que a descrição gulosa estava prestes a escrever distressed pela segunda vez. Aplique a penalização à mão aos logits do próximo token, confira o resultado com lib.decoding.penalize e compare as probabilidades antes e depois. Em seguida, escreva de forma gulosa com a penalização, para ver se o loop acontece:

repetition-penalty-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""The repetition penalty applied by hand to the next token's logits, checked against lib.decoding.penalize, and thenused for a whole greedy description. The two P(distressed) lines are the ones the prose quotes, and theassert against lib.decoding.penalize is the match it states as fact."""import numpy as npfrom lib import decoding, transformer_, vocabulary, _ = transformer.load()start, factor = decoding.prompt("front porch welcome sign wall décor"), 1.3written = decoding.generate(start)                                    # greedy, as in greedy-descriptiondistressed = vocabulary.index("distressed</w>")position = [i for i, token in enumerate(written) if token == distressed][1]   # where greedy writes it a second timebefore = written[:position]print("text so far:", decoding.text(before))print("penalty factor:", factor)logits = decoding.next_logits(start + before)seen = np.unique(before)                                              # every token the description has usedpenalized = logits.copy()penalized[seen] = np.where(logits[seen] > 0, logits[seen] / factor, logits[seen] * factor)   # less likely either wayassert np.allclose(penalized, decoding.penalize(logits, before, factor))   # the hand calculation is the library'sfor label, adjusted in [("without a penalty", logits), ("with the penalty", penalized)]:    probabilities = transformer.softmax(adjusted)    top = np.argsort(-probabilities, kind="stable")[:3]    print(f"next token, {label}:", ", ".join(f"{vocabulary[i].replace('</w>', '')} {probabilities[i]:.2f}" for i in top))    print(f"P(distressed), {label}:", f"{probabilities[distressed]:.2f}")print("greedy with the penalty:", decoding.text(decoding.generate(start, penalty=factor)))
Saídapython repetition-penalty-by-hand.py
text 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 .

Com um fator de 1.3, distressed cai de uma probabilidade de 0.20 para 0.03, e outro token vence em seu lugar. O cálculo à mão coincide com o da biblioteca, e a descrição gulosa penalizada não entra em loop. Ela ainda inventa, porém: desta vez, a placa é feita de natural coir, uma fibra das cascas de coco.

A penalização tem um efeito colateral que as medições mostram: as descrições terminam mais cedo. Ela penaliza todo token já usado, incluindo palavras comuns como the e and, que uma descrição precisa muitas vezes, mas nunca o marcador de fim, que ainda não foi usado. Assim, o fim fica relativamente mais provável, e 70% das descrições gulosas penalizadas terminaram dentro do limite, contra 25% sem a penalização, com um comprimento médio de 41 tokens contra 52. Sua repetição caiu de 11% para 0%.

Regra prática: adicione uma penalização por repetição em torno de 1.2 a 1.3 ao decodificar de forma gulosa ou com temperatura baixa, e verifique o efeito sobre o comprimento, já que ela encurta o texto. Como orientação geral, se as descrições saírem cortadas, deixe de fora da penalização as palavras funcionais comuns e a pontuação.

Proíba uma descrição vazia

Última alteração na edição 2026.11.11

O exemplo guloso mostrou o modelo pronto para não escrever nada para uma lâmpada, e a busca em feixe mostrou que nada era a descrição mais provável para uma placa. Ambos vêm do catálogo: muitos produtos não têm descrição, então o modelo aprendeu que terminar de imediato é comum. Para preencher exatamente essas lacunas, é preciso impedir que o modelo as reproduza. A correção simples é um comprimento mínimo: proíba o marcador de fim, definindo o seu logit como menos infinito, até que a descrição tenha um certo número de tokens. lib.decoding.generate recebe isso como shortest.

A lâmpada que a decodificação gulosa deixou vazia é o caso de teste. Decodifique-a duas vezes, sem mínimo e depois com um mínimo de 10 tokens; a saída mostra primeiro a probabilidade de a descrição terminar de imediato:

minimum-length.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Greedy decoding of the bulb's description, without a minimum length and with one that forbids the end marker untilit has that many tokens. The prose quotes the printed probability of an empty description, andthe description the minimum produces."""from lib import decoding, transformerend = transformer.load()[1].index(transformer.END)                    # the index of </s>, to read its probabilitystart, shortest = decoding.prompt("5 light light bulb"), 10print("P(the description is empty):", f"{transformer.softmax(decoding.next_logits(start))[end]:.2f}")   # the first token is </s>: an empty descriptionprint("greedy description:", decoding.text(decoding.generate(start)) or "(empty)")print("minimum length, in tokens:", shortest)print("greedy description, with the minimum:", decoding.text(decoding.generate(start, shortest=shortest)))   # shortest: </s> stays forbidden until then
Saídapython minimum-length.py
P(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 .

O mínimo preenche a lacuna, mas não pode fornecer os fatos. Sem ele, a decodificação gulosa escolhe a descrição vazia, com probabilidade de 0.28. Com o mínimo, ela escreve uma, e duas falhas vistas antes neste capítulo aparecem nela. Ela se repete, a light , a light , and more light, e afirma coisas que o nome não diz: que a lâmpada é made of metal, dimmable e compatible with most standard bulbs.

Regra prática: Defina um comprimento mínimo sempre que o texto de treinamento incluir exemplos vazios ou muito curtos do que você está gerando. Combine-o com as outras configurações deste capítulo, e não no lugar delas, e espere que o texto que ele força a sair precise da mesma verificação que qualquer outro.

O que dá errado em produção

Última alteração na edição 2026.11.11

A maioria das falhas da decodificação é silenciosa:

  • O texto fluente afirma fatos inventados. Seis descrições deste capítulo deram ao letreiro de boas-vindas um material, e elas discordavam entre si. Nunca publique texto de produto gerado sem verificar cada afirmação factual contra os dados do produto; o capítulo 11 mede com que frequência um modelo inventa.
  • Lacunas no texto de treinamento tornam-se saídas. O modelo prevê uma descrição vazia para uma lâmpada, porque o catálogo tem muitas delas, e a busca em feixe encontra a descrição vazia como a mais provável de todas. Proíba o marcador de fim até um comprimento mínimo, caso contrário o modelo reproduzirá as lacunas que você está tentando preencher.
  • Texto guloso entra em laços. Use amostragem com cauda cortada, ou uma penalidade de repetição, para qualquer coisa mais longa que uma frase, e meça a repetição em uma amostra das saídas.
  • Texto amostrado não é reproduzível por padrão. Fixe e registre a semente aleatória com cada texto gerado, para que uma reclamação sobre uma descrição possa ser rastreada e repetida.
  • As configurações divergem conforme o modelo muda. Um modelo retreinado tem outra distribuição, então uma temperatura ou um top-k ajustados no modelo anterior podem escrever de outra forma com o próximo. Reexecute as medições deste capítulo após cada retreinamento, antes que o novo modelo escreva qualquer coisa que um comprador veja.
  • Cada token custa uma passagem direta. lib.decoding executa novamente o modelo sobre o texto inteiro a cada novo token, o que é simples e adequado para 60 tokens. Sistemas de servimento de modelos mantêm as chaves e os valores de cada camada das posições anteriores, de modo que as multiplicações de matrizes de cada novo token cobrem uma única posição, embora a atenção ainda leia as chaves e os valores armazenados de todas as posições anteriores (Pope et al., 2022).

O que este capítulo decidiu

  • A autocompletação usa os tokens mais prováveis. As sugestões da caixa de busca mostram os primeiros tokens da mistura escolhida no capítulo 8, e a busca em feixe (beam search), ordenada pela probabilidade total, pode estendê-las até formar frases curtas.
  • As descrições usam amostragem top-k 20, a configuração que mais vezes permaneceu no produto sem repetir, nas medidas acima, com uma semente fixa e registrada e um comprimento mínimo para que não saiam vazias. Com apenas vinte produtos por trás, a escolha é reverificada em uma amostra maior antes que qualquer descrição chegue a um comprador.
  • A busca em feixe ranqueia textos mais longos por token, porque a probabilidade total favorece o texto vazio. As completações curtas de consultas de busca são ranqueadas pela probabilidade total, em que a frase mais provável é a que o comprador deseja.
  • As configurações de decodificação são escolhidas por medição com textos reais: repetição, a perplexidade do próprio modelo, se as descrições terminam, se usam o nome e o seu comprimento, sobre um conjunto aleatório de produtos, antes que as amostras sejam lidas, e novamente após cada novo treinamento.
  • Descrições geradas são rascunhos, nunca uma fonte de fatos sobre o produto. Uma pessoa ou uma etapa de verificação corrige toda afirmação que o nome e o catálogo não sustentam: todos os métodos aqui apresentados inventaram um material para um produto cujo nome não indica nenhum.

Este capítulo, nesta edição

Edição 2026.11.16Exemplos aprovados em 19 de nov de 20267 de 7 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.16.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 9 de 11: Escolhendo o próximo token

  1. Escolha o token mais provável
  2. Busca do texto mais provável
  3. Amostragem, com uma temperatura
  4. Amostre e corte a cauda
  5. Meça o que cada configuração escreve
  6. Penalizar a repetição
  7. Proíba uma descrição vazia
  8. O que dá errado em produção
  9. O que este capítulo decidiu

Voltar ao topoTodos os capítulos