Prevendo a próxima palavra

Cerca de 27 minutos min de leitura, com 8 exemplos em 10 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ê consegue construir um modelo de linguagem completo a partir dos nomes de produtos de uma loja, apenas por contagem; usá-lo para sugerir a próxima palavra enquanto um cliente digita; gerar texto com ele; e medir, com um único número, quão bem ele prevê um texto que nunca viu. Cada capítulo seguinte substitui uma parte deste modelo por uma melhor e, a partir do capítulo 3, mede cada mudança da mesma forma.

Ao longo do livro, um estudo de caso se repete: uma loja online de móveis e artigos para casa, que chamamos de loja. A caixa de busca dela precisa de autocompletar, de modo que um cliente que digite coffee veja table sugerido como a próxima palavra, e suas descrições curtas de produtos precisam ser escritas e revisadas. Ambos são problemas de previsão da próxima palavra, e a loja tem o texto para aprender com eles: os nomes e as descrições de todos os produtos do seu catálogo.

Um modelo de linguagem é um programa que atribui uma probabilidade a cada palavra que poderia vir a seguir, dadas as palavras até aqui. Essa única capacidade cobre muita coisa. Sugerir como completar uma consulta de busca é escolher uma próxima palavra provável. Escrever uma frase é escolher uma próxima palavra, acrescentá-la e escolher de novo. Um modelo que prevê bem aprendeu algo sobre o texto com que foi treinado, por isso a qualidade de sua previsão é a forma de medi-lo. Os grandes modelos de linguagem por trás dos assistentes de conversa fazem a mesma coisa em escala muito maior: dado o texto até aqui, atribuem uma probabilidade a cada possível próximo trecho de texto. Este livro constrói essa maquinaria uma parte de cada vez, pequena o bastante para rodar em um notebook, para que você possa ver o que cada parte faz.

Neste capítulo, você conta qual palavra segue qual nos nomes de produtos, transforma as contagens em probabilidades e as coloca para funcionar. O modelo que você constrói aqui tem uma falha séria, e o capítulo termina medindo essa falha.

Carregue o texto da loja

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

Antes de um modelo aprender quais palavras seguem quais, ele precisa de texto para aprender, e de uma forma de saber se o que aprendeu se mantém em texto que não viu. A segunda necessidade importa tanto quanto a primeira. Um modelo pode prever perfeitamente o texto com o qual aprendeu, se o memorizar, o que não diz nada sobre como ele vai se sair com o próximo produto que a loja adicionar. Por isso, o texto é dividido uma única vez, antes que qualquer coisa aprenda com ele, em três partes: uma divisão de treino, com a qual os modelos aprendem; uma divisão de validação, para comparar modelos enquanto você os constrói; e uma divisão de teste, reservada para os relatórios finais. Cada produto pertence a exatamente uma divisão, de modo que nenhum nome ou descrição em que um modelo é avaliado aparece no que ele aprendeu.

O texto da loja, com o qual todos os exemplos deste livro aprendem, é real. Ele vem do WANDS, um conjunto de dados público de busca de produtos que a Wayfair publicou com um artigo na ECIR 2022 (Chen et al., 2022), sob a licença MIT (licença). O script prep/wands_text.py o prepara, e sua ficha de dados, examples/data/wands-text/README.md, explica como: o texto já está em minúsculas, com espaços ao redor da pontuação, e as descrições são cortadas no fim de uma frase para manter o arquivo pequeno. Produtos cujo texto cita a própria loja são deixados de fora, de modo que nenhum modelo deste livro aprende a escrever o nome da loja. Os exemplos leem o texto por meio de lib.store, um dos módulos compartilhados do livro: arquivos curtos em examples/lib/ que reúnem código de configuração que muitos exemplos precisam, e que você pode abrir e ler.

Antes de contar qualquer coisa, observe o texto: o tamanho de cada divisão e alguns nomes:

store-text.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

Os nomes de produtos são curtos e repetitivos o suficiente para que a contagem funcione, então este capítulo aprende apenas com eles. O texto da loja cobre 42,815 produtos, 34,252 deles na divisão de treino. Os nomes de treino somam 231,048 palavras, de 25,907 tipos diferentes. Esse segundo número é grande para um catálogo de móveis, porque muitos nomes começam com o nome de uma linha de produtos, uma palavra que aparece em poucos produtos e em nenhum outro lugar. Este livro não imprime esses nomes. Quando a saída de um exemplo mostraria um deles, ele imprime [name] no lugar, para qualquer palavra usada em menos de 30 das descrições de treino, em geral o nome de uma linha de produtos. Essas palavras raras terão importância até o fim do capítulo.

Regra prática: Divida seu texto em partes de treino, validação e teste antes que qualquer modelo o veja, e divida por documento (aqui, por produto), para que quase duplicatas de um mesmo item nunca fiquem divididas entre duas partes. Compare modelos com texto de validação enquanto trabalha, e toque no texto de teste apenas para o relatório final. Aprenda primeiro com o texto mais curto e mais regular que você tiver; este capítulo começa com nomes, e as descrições vêm mais adiante no livro.

Contar qual palavra segue qual

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

Com os nomes de treinamento carregados, um modelo simples do que vem a seguir é uma tabela de quantas vezes cada palavra seguiu cada outra palavra. Um bigrama é um par de palavras adjacentes, como coffee table. Conte todos os bigramas nos nomes de treinamento e você saberá, para qualquer palavra, quais palavras vieram depois dela e com que frequência. Claude Shannon usou exatamente essa ideia no artigo que fundou a teoria da informação, aproximando o inglês ao escolher cada palavra de acordo com a frequência com que ela segue a palavra anterior (Shannon, 1948).

Dois detalhes tornam as contagens completas. A primeira palavra de um nome não segue nenhuma outra, e a última não é seguida por nenhuma, mas vale a pena prever ambas: a primeira palavra decide que tipo de produto o comprador está digitando, e saber onde um nome termina permite que um modelo pare. Por isso, cada nome recebe dois marcadores, <s> no início e </s> no fim, que contam como palavras. O par <s> coffee registra então que um nome começou com coffee, e table </s> registra que um nome terminou com table.

Comece com uma palavra cuja próxima palavra importa para a caixa de busca, coffee. O exemplo conta todos os pares nos nomes de treinamento e depois lista o que seguiu essa palavra:

count-next-words.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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,}")
Saídapython 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

Uma palavra domina. Quase todo coffee nos nomes da loja faz parte de um coffee table, e, das 1,260 palavras que seguem coffee nos nomes de treinamento, quase todas são table. Uma vírgula aparece em terceiro lugar, porque o texto da loja trata a pontuação como palavras próprias. Essa é uma escolha sobre tokens, as unidades que um modelo conta, e o capítulo 2 mostra o quanto ela importa.

A tabela de contagens é o modelo inteiro. Ele não tem regras de gramática nem conhecimento sobre móveis; já viu coffee table muitas vezes e coffee lamp nunca, e isso é tudo o que ele sabe. O módulo compartilhado lib.bigrams guarda esse mesmo código de contagem, como a classe Bigrams, para que os exemplos seguintes possam construir o modelo em uma linha.

Regra prática: Conte os pares apenas na divisão de treinamento, e acrescente marcadores de início e de fim a cada texto, para que o modelo aprenda como os textos começam e terminam. Mantenha as contagens brutas, e não apenas as probabilidades que você derivará delas: as contagens mostram quanta evidência sustenta cada probabilidade, e as próximas seções precisam delas.

Transforme contagens em probabilidades

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

As contagens dizem o que aconteceu, mas um modelo de linguagem precisa de probabilidades: o quão provável é cada próxima palavra. O passo de uma para a outra é a divisão. A probabilidade de uma palavra dada a palavra anterior é o número de vezes em que o par ocorreu, dividido pelo número de vezes em que a primeira palavra ocorreu seguida de qualquer coisa. Em símbolos, escrevendo w para a palavra anterior e v para a seguinte:

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

Leia como "a probabilidade de v, dado w". Estimar probabilidades a partir da fração de vezes em que algo aconteceu chama-se estimativa por máxima verossimilhança: entre todas as tabelas de probabilidade que você poderia escolher, é a que torna o texto de treinamento o mais verossímil possível (Jurafsky and Martin, capítulo 3).

Aplique a fórmula a coffee e a quatro palavras que poderiam vir depois dela, imprimindo cada probabilidade ao lado das contagens que a sustentam, e depois a soma sobre todas as palavras que seguiram coffee:

next-word-probabilities.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

As probabilidades de todas as palavras que seguiram coffee somam 1.0, como deve ser uma distribuição, porque o que vem a seguir é uma dessas palavras. table concentra a maior parte dessa probabilidade, 0.896 (1129 of 1260), e mug muito menos, 0.036 (45 of 1260).

A quarta linha é a que você deve lembrar. coffee lamp nunca ocorre nos nomes de treinamento, então sua probabilidade é 0.000 (0 of 1260). O modelo não diz que uma "coffee lamp" é improvável; ele diz que uma "coffee lamp" é impossível. Para uma loja de móveis isso é uma aposta razoável, mas o mesmo zero se aplica a todo par que o modelo não viu, inclusive pares perfeitamente comuns. Essa é a falha com que este capítulo termina.

Regra prática: Derive probabilidades de contagens por divisão, e verifique se as probabilidades de cada palavra somam um; uma soma que não dá um é um erro na contagem. Considere uma probabilidade tão boa quanto a contagem que a sustenta, e nada além disso: 0.9 de 1,000 pares é evidência, enquanto 1.0 de um único par é uma anedota.

Sugerir a próxima palavra enquanto o cliente digita

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

O autocompletar, a primeira necessidade da loja, quer as próximas palavras mais prováveis, e uma tabela de probabilidades as classifica. Um cliente que digitou coffee vê table em primeiro lugar. Com o modelo de bigramas, as sugestões para qualquer texto digitado são as palavras de maior probabilidade depois da sua última palavra. A classe do modelo de bigramas, Bigrams, a partir de conte qual palavra segue qual, tem um método, next_words, que as devolve, da mais provável para a menos provável.

Cinco prefixos digitados, de uma palavra a duas, mostram onde as sugestões ajudam e onde erram. São devolvidas três sugestões para cada um:

autocomplete.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

Depois de coffee, bar e kitchen, as principais sugestões são o que um cliente desejaria: mesas, banquetas, pias e ilhas. Depois de outdoor elas são mais fracas. A principal sugestão, door, inicia um tipo de produto real: 214 dos 215 nomes de treinamento que contêm outdoor door seguem para mat. Mas uma sugestão de uma palavra não consegue oferecer um tipo de produto de duas palavras, e depois de door as participações são pequenas, porque outdoor é seguida por muitas palavras diferentes. Uma vírgula e um e comercial também aparecem como sugestões, o que nenhuma caixa de busca deveria oferecer. Filtrar a pontuação das sugestões é um remendo razoável, e o capítulo 2 trata da causa.

A última linha mostra o limite real do modelo. Um cliente que digita patio bar recebe exatamente as sugestões para bar, porque um modelo de bigramas olha uma palavra de contexto e nada antes dela. patio se perde, e o modelo oferece pull e &, que pertencem a ferragens de armários e a nomes como bar & counter stools. Usar mais contexto é o tema do capítulo 3, e um modelo que pondera cada palavra anterior é o rumo que o livro segue.

Regra prática: Para o autocompletar, ofereça as principais próximas palavras por probabilidade e descarte tokens que não são palavras, como a pontuação. Espere que as sugestões de um modelo de bigramas sejam boas depois de palavras que quase sempre são seguidas pela mesma coisa, como coffee, e ruins depois de palavras com muitas continuações possíveis, como outdoor. Quando as palavras anteriores importam, como importam em patio bar, um modelo de bigramas não consegue ajudar, por mais texto que aprenda.

Gerar nomes uma palavra de cada vez

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

A mesma tabela de probabilidades pode escrever texto tanto quanto completá-lo. Para gerar, comece em <s>, sorteie a próxima palavra ao acaso, em proporção à sua probabilidade, acrescente-a e repita a partir da palavra sorteada, até que o modelo sorteie </s>. Sortear ao acaso, em vez de sempre escolher a palavra mais provável, é o que permite ao modelo produzir nomes variados, e não o mesmo nome a cada vez. Os grandes modelos de linguagem para os quais este livro caminha escrevem texto da mesma forma: um token de cada vez, cada um escolhido a partir de probabilidades calculadas com base no texto até ali.

Seis nomes, sorteados a partir dessas probabilidades por um gerador aleatório com semente, saem iguais a cada execução, de modo que os nomes deste livro coincidem com os que o código produz:

generate-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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 palavras adjacentes é plausível, porque cada par ocorreu em um nome real: genuine leather, kitchen cart, lounge chair. Os nomes como um todo muitas vezes não são, porque nada os mantém em um só produto. Um nome vai de um conjunto de bistrô a uma luz regulável e a uma secadora inteligente, unidos por vírgulas, já que depois de uma vírgula quase qualquer coisa pode vir. O modelo não tem memória além da última palavra, por isso não pode saber que estava descrevendo um conjunto de bistrô. Outros acrescentam o nome de uma linha de produtos, impresso como [name], a um produto de outro tipo, como uma poltrona de couro, porque nomes que começam com uma linha de produtos são comuns no texto de treinamento. Nada é inventado: um modelo de bigramas só pode escrever palavras que contou, e a saída confirma isso, com 0 palavras geradas que não aparecem nos nomes de treinamento.

Os nomes gerados tornam visíveis os limites de um modelo de um modo que um número não consegue, o que os torna dignos de leitura. Eles não medem nada, porém: seis nomes são poucos para comparar dois modelos, e o senso de "plausível" de um leitor muda de um dia para o outro. A próxima seção apresenta o número.

Regra prática: Gere amostras sempre que alterar um modelo, e leia-as, porque elas revelam falhas que uma pontuação esconde, como texto que deriva de um produto para outro. Use uma semente fixa para que as amostras sejam reproduzíveis. Nunca compare modelos pelas suas amostras; compare-os pela perplexidade em texto de validação.

Avalie um modelo com a perplexidade

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

Um modelo de linguagem é bom quando atribui alta probabilidade ao texto que de fato ocorre. Isso sugere uma pontuação: rode o modelo sobre um texto real e veja quanta probabilidade ele deu a cada palavra que veio em seguida. A forma padrão de resumir isso é a perplexidade, e este livro a usa para comparar todo modelo que constrói.

Comece por um único par. Se o modelo deu à palavra seguinte real a probabilidade p, sua surpresa diante dessa palavra é −log p: zero quando ele tinha certeza (p = 1) e maior quanto menos ele esperava a palavra. A entropia cruzada de um texto é a média da surpresa sobre todas as palavras dele, escrita com N como o número de palavras previstas:

entropia cruzada = −(1/N) Σ log P(próxima palavra | palavra anterior)

A perplexidade é a entropia cruzada convertida de volta em contagem: perplexidade = exp(entropia cruzada) (Jurafsky e Martin, capítulo 3). Ela se lê como o número de palavras igualmente prováveis entre as quais o modelo escolhia, em média, a cada passo. Uma perplexidade de 10 significa que o modelo era, em média, tão incerto quanto se tivesse de escolher entre 10 palavras igualmente prováveis. Quanto menor, melhor, e um modelo que conhecesse toda próxima palavra teria pontuação 1. Este livro usa logaritmos naturais em todo o texto, o que muda as unidades da entropia cruzada, mas não a perplexidade.

Pontue um nome de treinamento, sled coffee table, par por par para ver onde a surpresa se concentra, e depois todos os nomes de treinamento de uma vez:

perplexity-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

Quase toda a surpresa cai no primeiro par. Poucos nomes começam com sled, então o modelo se surpreendeu com ele, e depois disso cada palavra ficou perto do esperado: coffee segue sled na maioria dos nomes de treinamento que contêm sled, e table segue coffee. A surpresa média do nome é 2.389, e sua perplexidade 10.9. Sobre todos os nomes de treinamento, a perplexidade do modelo é 16.9: no texto do qual aprendeu, ele escolhia entre aproximadamente esse número de palavras prováveis a cada passo.

Esse número favorece o modelo, porque é medido sobre o texto de onde vieram as contagens. Todo par dos nomes de treinamento tem uma contagem, então nenhum par surpreende o modelo infinitamente. O verdadeiro teste é um texto que ele não viu.

Regra prática: Pontue todo modelo de linguagem pela sua perplexidade sobre o texto de validação, calculada exatamente como acima, com logaritmos naturais e contando cada palavra prevista, incluindo o marcador de fim. Compare perplexidades apenas entre modelos que usam os mesmos tokens e o mesmo texto de validação, pois dividir o texto de outra forma altera N e o que conta como palavra. Relate a perplexidade de treinamento somente junto à perplexidade de validação, para mostrar o quanto o modelo memorizou.

Pares de palavras não vistos quebram o modelo

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

Um modelo treinado por contagem conhece apenas os pares que contou, e os nomes de validação foram mantidos separados dos nomes de treinamento exatamente por essa razão: eles mostram o que acontece quando o modelo encontra um texto que nunca viu. O modelo obteve 16.9 nos nomes de treinamento, em calcular a perplexidade de um modelo. Antes de executar o próximo exemplo, chute qual será a perplexidade dele nos 4,282 nomes de validação.

perplexity-on-new-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

A perplexidade de validação é infinita: o exemplo exibe inf. Basta um único par ao qual o modelo atribuiu probabilidade zero, porque a sua surpresa, −log 0, é infinita, e qualquer média que o inclua também será. E não é apenas um. 25% dos pares de palavras de validação nunca aparecem nos nomes de treinamento, e 3,724 dos nomes de validação contêm pelo menos um. Os primeiros pares não vistos mostram o motivo: um nome de validação que começa com uma linha de produto que os nomes de treinamento nunca mencionam, impresso como [name], torna não vistos tanto o seu primeiro par quanto o segundo.

Esta é a falha que a seção sobre probabilidades já havia apontado. A estimativa por máxima verossimilhança atribui probabilidade zero a todo par não visto, e em textos reais a maioria dos novos documentos contém algo não visto: uma nova linha de produto, um tamanho incomum, uma palavra familiar em um lugar inesperado, como half-circle depois de wood. Mais texto de treinamento ajuda um pouco, mas não resolve o problema. A linguagem continua produzindo novas combinações, por isso um modelo que considera impossível toda combinação não vista sempre falhará com textos novos.

A solução é o suavizamento, que atribui alguma probabilidade aos pares não vistos ao retirar um pouco de probabilidade dos pares que o modelo já viu.

Regra prática: Nunca confie em um modelo de linguagem que atribua probabilidade zero a qualquer coisa; verifique se há perplexidade infinita ou indefinida no texto de validação antes de comparar modelos. Quando encontrar uma, conte os pares não vistos, como acima, para saber quanto do texto o modelo não consegue tratar.

Dê uma pequena probabilidade aos pares não vistos

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

O modelo em pares de palavras não vistos quebram o modelo falha porque atribui probabilidade zero aos pares não vistos, e a suavização lhes dá alguma probabilidade. O método de suavização mais simples, a suavização add-one, supõe que cada par possível ocorreu uma vez a mais do que de fato ocorreu. Cada contagem aumenta em um, inclusive as contagens zero, e os totais crescem na mesma medida:

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

onde V é o tamanho do vocabulário, isto é, todas as palavras que o modelo consegue prever. Uma palavra que não aparece de forma alguma no texto de treinamento é contada como mais uma entrada do vocabulário, <unk>, de "unknown" (desconhecida), de modo que as probabilidades ainda somam um. Nenhum par tem agora probabilidade zero, portanto a perplexidade sobre texto novo é finita. A questão é o que isso custa.

Dois números mostram o custo, a probabilidade de table depois de coffee e a perplexidade, em cada modelo:

add-one-smoothing.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""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
Saídapython 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

O vocabulário tem 25,909 palavras, contando o marcador de fim e <unk>, e é aí que está o problema. A suavização add-one acrescenta uma ocorrência imaginária para cada uma delas depois de cada palavra, então depois de coffee ela imagina dezenas de milhares de pares extras contra cerca de mil pares reais.

A probabilidade de table depois de coffee cai de 0.896 para 0.042. O modelo agora acredita muito menos no que viu, e as perplexidades mostram isso: nos nomes de treinamento, a perplexidade sobe de 16.9 para 1,232.8.

A perplexidade de validação é finita, 1,575.1, o que é um avanço, mas o modelo atribui tanta probabilidade a pares de palavras que nunca ocorrem que suas previsões ficam quase inúteis.

A suavização add-one resolve o infinito e quebra quase todo o resto, porque acrescenta um par imaginário para cada palavra do vocabulário, não importa quantas evidências as contagens reais tenham, e os distribui de forma uniforme. Métodos de suavização melhores retiram muito menos probabilidade dos pares vistos e a dão aos pares não vistos em proporção a quantas vezes suas palavras aparecem em outros lugares. O capítulo 3 trata desses métodos. Ali, o modelo contado deste capítulo, olhando mais para trás e com um método de suavização melhor, torna-se a linha de base contra a qual todos os modelos seguintes do livro são medidos.

Regra prática: Nunca entregue um modelo contado sem suavização, e nunca entregue um com suavização add-one: meça a perplexidade de validação e espere que o add-one perca para todos os métodos do capítulo 3, que os compara sobre os mesmos tokens. Use o add-one apenas como este capítulo faz, para mostrar que probabilidades zero podem ser corrigidas e que a correção exige cuidado.

O que dá errado em produção

Um autocomplete baseado em bigramas é barato e rápido, e ainda assim é uma linha de base razoável para uma caixa de busca. Estes são os problemas que vêm com ele:

  • O catálogo muda com o tempo. Um modelo contado a partir dos nomes do mês passado não conhece as linhas de produtos deste mês. Um comprador que digita uma linha de produtos nova não recebe sugestão alguma, porque o modelo não tem contagens depois dela, até que as contagens sejam refeitas. Por isso, reconstrua-as periodicamente e sempre que o catálogo mudar.
  • As sugestões podem constranger. O modelo sugere o que quer que tenha seguido uma palavra no texto de treinamento, inclusive a pontuação. Filtre as sugestões por uma lista de tokens permitidos e revise manualmente as sugestões mais frequentes antes de publicá-las.
  • Produtos populares ofuscam os demais. Uma palavra seguida, na maioria das vezes, por um único tipo de produto, como coffee, sempre sugerirá esse tipo. Compradores que procuram uma caneca de café precisam digitar mais. Ofereça várias sugestões, e não apenas uma.
  • Uma palavra de contexto é muito pouco. Como patio bar mostrou, o modelo ignora tudo, exceto a última palavra. Se os compradores digitarem consultas longas, meça com que frequência as sugestões mudam quando você condiciona o modelo a mais palavras, o que o capítulo 3 faz.
  • A tabela cresce com o texto. Uma tabela de bigramas tem uma entrada para cada par já observado; com contextos mais longos, o número de entradas explode. Conte apenas o que você precisa e pode os pares observados uma única vez, se a memória for escassa.

O que este capítulo decidiu

Última alteração na edição 2026.11.11
  • O texto da loja é dividido uma única vez, por produto, em conjuntos de treinamento, validação e teste, e os modelos aprendem somente com o conjunto de treinamento. Uma pontuação sobre texto que um modelo aprendeu mede memória, não predição, e dividir por produto impede que nomes quase idênticos de um mesmo produto caiam nos dois lados.

  • Todo texto é preenchido com <s> e </s>. Assim, os modelos aprendem como os textos começam e terminam, o que a completação automática precisa para a primeira palavra de um cliente e a geração precisa para saber onde parar.

  • Os modelos são comparados pela perplexidade no texto de validação, com logaritmos naturais e contando cada palavra prevista, inclusive o marcador de fim. As amostras geradas são lidas pelo que mostram, mas nunca usadas para escolher entre modelos.

  • O modelo bigrama dos nomes de produtos da loja, construído a partir de contagens, é o primeiro modelo do livro. Ele sugere boas próximas palavras depois de palavras com uma continuação comum, como coffee, e sugestões ruins depois de palavras com muitas continuações, como outdoor. Ele enxerga uma palavra de contexto, então patio bar e bar recebem as mesmas sugestões.

  • Sem suavização, a perplexidade de validação do modelo é infinita, e com suavização de adição de um ela é finita, mas ruim. Capítulo 3 dá a ele um método de suavização melhor, torna-o a linha de base e mantém as mesmas divisões e a mesma medida, para que todo modelo posterior seja comparado com ele em igualdade de condições.

Este capítulo, nesta edição

Edição 2026.11.16Exemplos aprovados em 19 de nov de 20268 de 8 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 1 de 11: Prevendo a próxima palavra

  1. Carregue o texto da loja
  2. Contar qual palavra segue qual
  3. Transforme contagens em probabilidades
  4. Sugerir a próxima palavra enquanto o cliente digita
  5. Gerar nomes uma palavra de cada vez
  6. Avalie um modelo com a perplexidade
  7. Pares de palavras não vistos quebram o modelo
  8. Dê uma pequena probabilidade aos pares não vistos
  9. O que dá errado em produção
  10. O que este capítulo decidiu

Voltar ao topoTodos os capítulos