Contando mais para trás
Cerca de 24 minutos min de leitura, com 7 exemplos em 9 seções.
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
Nesta página
- Contextos mais longos se ajustam melhor ao texto de treino
- Contextos mais longos ficam sem evidências
- Misture contextos curtos e longos
- Conte os contextos que um token segue
- Suavize com Kneser-Ney
- Autocompletar com três tokens de contexto
- A referência contra a qual todo modelo posterior é medido
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você será capaz de construir um modelo de linguagem n-grama que olha vários tokens para trás, suavizá-lo com Kneser-Ney para que lide com textos que ele não viu (a suavização atribui alguma probabilidade ao que as contagens nunca viram, como o capítulo 1 mostrou), medir a linha de base contra a qual todo modelo neural deste livro é medido e entender por que a contagem, por mais engenhosa que seja, esgota suas possibilidades.
O capítulo 1 construiu um modelo que previa a próxima palavra a partir da anterior, e duas coisas deram errado. Ele olhava apenas uma palavra para trás, então quem digitava patio bar recebia as sugestões para bar. E atribuía probabilidade zero a todo par de palavras que não havia contado, o que tornava sua perplexidade em textos novos infinita. O capítulo 2 então deu unidades melhores para contar: o tokenizador da loja, que divide cada palavra em pedaços que ele conhece, de modo que quase toda palavra é escrita com tokens que já foram vistos. Este capítulo volta à contagem com esses tokens, olha mais para trás e trata o que não foi visto de forma adequada.
Cada método aqui é testado onde a loja, uma loja on-line de móveis e artigos para casa, precisa deles: nos nomes de produtos que sua caixa de busca completa. A partir deste capítulo, cada modelo do livro é avaliado do mesmo modo: pela perplexidade por token nos nomes de validação da loja, tokenizados com o tokenizador da loja. Nomes de produtos são o que o autocompletar da caixa de busca precisa prever, e são curtos o bastante para que cada exemplo seja executado em segundos. Um único texto fixo, um único tokenizador e uma única medida tornam cada modelo do livro comparável a todos os outros sobre nomes; capítulos posteriores acrescentam descrições, a partir do capítulo 8, e pontuações por palavra, no capítulo 10, em que o tokenizador de um modelo é diferente.
Contextos mais longos se ajustam melhor ao texto de treino
Um modelo de n-gramas prevê cada token a partir dos n − 1 tokens que vêm antes dele: um modelo de bigrama (n = 2) a partir de um, um modelo de trigrama (n = 3) a partir de dois, e assim por diante. Os tokens anteriores ao que está sendo previsto formam o seu contexto. Mais contexto deveria significar previsões melhores: depois de patio bar, o próximo token é muito mais previsível do que depois de apenas bar. A contagem funciona exatamente como no capítulo 1, exceto que as contagens agora são de um contexto de n − 1 tokens seguido de um token, e cada texto é preenchido com n − 1 marcadores de início, de modo que até o seu primeiro token tem um contexto completo.
Avaliados sobre os nomes a partir dos quais foram contados, sem suavização, as diferentes ordens mostram o que um modelo faz com um texto que já memorizou:
1"""Counts the n-grams of orders 1 to 5 in the training names, and scores each order on those same names with no smoothing.2Read the training perplexity lines, which fall as the order grows, against the seen-once lines, which rise."""3import math4from collections import Counter56from lib.names import name_tokens7from lib.ngrams import ngrams, padded89train = name_tokens("train")10for n in [1, 2, 3, 4, 5]:11 # padded adds n-1 start markers and one end marker, so a name's first token has a full context12 pairs = Counter(pair for text in train for pair in ngrams(padded(text, n), n))13 contexts = Counter()14 for (context, _), count in pairs.items():15 contexts[context] += count16 # the total surprise, in nats: each n-gram's probability is its count over its context's count, the model's own estimate17 surprise = -sum(count * math.log(count / contexts[context]) for (context, _), count in pairs.items())18 print(f"{n}-gram training perplexity: {math.exp(surprise / sum(pairs.values())):.1f}")19 print(f"{n}-grams seen once: {sum(1 for c in pairs.values() if c == 1) / len(pairs):.0%}")
python ngram-memorizes.py1-gram training perplexity: 676.4
1-grams seen once: 8%
2-gram training perplexity: 23.9
2-grams seen once: 60%
3-gram training perplexity: 4.9
3-grams seen once: 76%
4-gram training perplexity: 3.2
4-grams seen once: 82%
5-gram training perplexity: 2.9
5-grams seen once: 85%
A perplexidade cai rapidamente à medida que o contexto cresce: 676.4 sem nenhum contexto, 23.9 com um token, e 2.9 com quatro. Com quatro tokens de contexto, o modelo escolhe entre cerca de três tokens a cada passo, porque a maioria dos n-gramas tão longos ocorre apenas uma vez: 85% dos 5-gramas nos nomes de treino são vistos uma única vez, e o modelo memorizou o que veio depois de cada um.
Esta é a armadilha. No texto que contou, um contexto mais longo sempre parece melhor, porque com contexto suficiente cada texto é único e o modelo consegue recitá-lo. Avaliar um modelo sobre o seu próprio texto de treino mede memória, e é por isso que o capítulo 1 separou, desde o início, um texto de validação.
Regra prática: Nunca avalie um modelo de n-gramas, ou qualquer modelo de linguagem, pela sua perplexidade sobre o próprio texto de treino: ela cai em direção a 1 à medida que o modelo memoriza. Escolha a ordem pela perplexidade sobre texto reservado (held-out), como faz o restante deste capítulo.
Contextos mais longos ficam sem evidências
Memorizar os nomes de treinamento não diz nada sobre nomes novos. Um modelo só pode usar um contexto que tenha contado, e o número de contextos possíveis cresce exponencialmente com o comprimento deles: com 4000 tokens, há 16 milhões de pares possíveis e 64 bilhões de trincas possíveis. Nenhum texto de treinamento chega perto de cobri-los. Por isso, quanto mais longo o contexto, com mais frequência um texto novo usa um contexto que o modelo nunca viu.
Antes de tudo, fixe um número: para os 4-gramas, qual é a proporção dos 4-gramas dos nomes de validação que nunca aparecem nos nomes de treinamento? A proporção para cada ordem de 1 a 5 é apresentada a seguir:
1"""Counts, for each order from 1 to 5, the share of the validation names' n-grams that never occur in the training names.2Compare the lines for 2-grams to 5-grams: that share rises with the order."""3from lib.names import name_tokens4from lib.ngrams import ngrams, padded56train, validation = name_tokens("train"), name_tokens("validation")7print("training tokens:", f"{sum(len(t) for t in train):,}")8print("validation tokens:", f"{sum(len(t) for t in validation):,}")9for n in [1, 2, 3, 4, 5]:10 seen = {pair for text in train for pair in ngrams(padded(text, n), n)} # padded, as in the model, so name starts count too11 held_out = [pair for text in validation for pair in ngrams(padded(text, n), n)]12 unseen = sum(pair not in seen for pair in held_out)13 print(f"{n}-grams in validation never seen in training: {unseen / len(held_out):.1%}")
python unseen-ngrams.pytraining tokens: 337,071
validation tokens: 42,422
1-grams in validation never seen in training: 0.1%
2-grams in validation never seen in training: 12.7%
3-grams in validation never seen in training: 31.1%
4-grams in validation never seen in training: 43.9%
5-grams in validation never seen in training: 53.4%
Quanto mais longo o contexto, maior a parcela dos n-gramas dos nomes de validação que são novos. Apenas 0.1% dos tokens de validação não foram vistos, o que mostra o tokenizador da loja fazendo seu trabalho. Entre os bigramas de validação, 12.7% não foram vistos, 43.9% dos 4-gramas e 53.4% dos 5-gramas. Com quatro tokens de contexto, o modelo nunca viu mais da metade do que precisa para prever.
Mais texto de treinamento ajuda menos do que se poderia esperar. Na linguagem, alguns n-gramas ocorrem com muita frequência e a maioria ocorre raramente; assim, cada duplicação do texto acrescenta principalmente n-gramas vistos uma ou duas vezes, que pouco melhoram as contagens por trás de qualquer previsão. O catálogo da loja mostra o mesmo padrão em miniatura: uma frase comum, como coffee table, é contada mais de mil vezes, enquanto 82% dos 4-gramas dos nomes de treinamento é contado uma única vez. Nossa avaliação, e não uma medição, é que um catálogo dez vezes maior ainda deixaria uma grande parcela de 4-gramas novos sem ser vista, porque novas linhas de produtos e novas combinações de tamanhos e materiais continuam surgindo.
Os dois exemplos juntos revelam o problema central da contagem. Contextos mais longos preveem melhor quando já foram vistos, mas são vistos cada vez com menos frequência. Todo método no restante deste capítulo é uma forma de usar contextos longos quando as contagens os sustentam, e de recorrer a contextos mais curtos quando não os sustentam.
Regra prática: Antes de escolher a ordem de um n-grama, meça a proporção dos n-gramas de validação que o texto de treinamento nunca contém. Como regra de bolso, quando ela se aproxima de um terço, como acontece com os trigramas dos nomes da loja, um modelo dessa ordem depende principalmente de como trata os casos não vistos, de modo que sua suavização importa mais do que sua ordem.
Misture contextos curtos e longos
A correção óbvia para contextos longos não vistos é recorrer a contextos mais curtos. A interpolação recorre a eles de forma suave: a probabilidade de um token é uma mistura ponderada do que as contagens de trigramas, bigramas e unigramas indicam, de modo que um contexto longo que o modelo já viu contribui com sua previsão precisa, e os contextos mais curtos completam o que ele não conhece. Com pesos λ₃, λ₂ e λ₁ que somam um:
P(token | a b) = λ₃ · P₃(token | a b) + λ₂ · P₂(token | b) + λ₁ · P₁(token)
onde cada P é uma estimativa de máxima verossimilhança a partir de contagens, como nas probabilidades do capítulo 1. O estudo de Chen e Goodman sobre métodos de suavização trata da interpolação e de suas variantes em detalhes (Chen e Goodman, 1996).
Pesos definidos manualmente tornam a ideia clara. Considere um trigrama interpolado com 0.6, 0.3 e 0.09 para as três ordens, e os 0.01 restantes distribuídos igualmente entre todos os tokens, de modo que nenhum token receba probabilidade zero. Quando um contexto nunca foi visto, seu peso passa para as ordens inferiores, e as probabilidades continuam somando um:
1"""Builds an interpolated trigram model by hand, with fixed weights, and an add-one bigram model on the same tokens.2The two validation perplexity lines to compare are the interpolated trigram's and the add-one bigram's."""3import math4from collections import Counter56from lib.names import name_tokens7from lib.ngrams import ngrams, padded, perplexity89train, validation = name_tokens("train"), name_tokens("validation")10counts = {k: Counter() for k in (1, 2, 3)} # counts[k][(the k-1 tokens before, token)]11for text in train:12 for context, token in ngrams(padded(text, 3), 3):13 for k in (1, 2, 3):14 # a trigram's context holds two tokens; an order-k model conditions on the last k-1 of them15 counts[k][(context[3 - k:], token)] += 116totals = {k: Counter() for k in (1, 2, 3)}17for k in (1, 2, 3):18 for (context, _), count in counts[k].items():19 totals[k][context] += count20# the tokens the training names contain, plus one slot for a token they never contain21vocabulary = len({token for (_, token) in counts[1]}) + 122weights = {3: 0.6, 2: 0.3, 1: 0.09} # and 0.01 spread evenly over every token232425class Interpolated:26 n = 32728 def probability(self, context, token):29 p, carried = 0.0, 0.030 for k in (3, 2, 1):31 # each order's own context32 weight, total = weights[k] + carried, totals[k][context[3 - k:]]33 if total: # an unseen context passes its weight down34 p, carried = p + weight * counts[k][(context[3 - k:], token)] / total, 0.035 else:36 carried = weight37 # the even 0.01 share, plus any weight passed down from unseen contexts, over the vocabulary38 return p + (0.01 + carried) / vocabulary394041print("interpolated 3-gram validation perplexity:", round(perplexity(Interpolated(), validation), 1))4243# a bigram's context is the one token before the token44bigram_pairs = Counter((context[-1:], token) for text in train for context, token in ngrams(padded(text, 2), 2))45bigram_totals = Counter()46for (context, _), count in bigram_pairs.items():47 bigram_totals[context] += count484950class AddOne:51 n = 25253 def probability(self, context, token):54 # add-one: one added to every pair's count, and one per vocabulary token added to the total55 return (bigram_pairs[(context, token)] + 1) / (bigram_totals[context] + vocabulary)565758print("add-one 2-gram validation perplexity:", round(perplexity(AddOne(), validation), 1))
python interpolate-orders.pyinterpolated 3-gram validation perplexity: 31.4
add-one 2-gram validation perplexity: 218.6
Misturar ordens supera a suavização de soma um do capítulo 1. Para uma comparação justa, a soma um aqui é executada sobre um modelo de bigramas com os mesmos tokens de validação, já que perplexidades sobre tokens diferentes não podem ser comparadas. O trigrama interpolado obtém 31.4, e a soma um obtém 218.6. A soma um espalha a maior parte de sua probabilidade por pares que nunca ocorrem; misturar ordens preserva o que cada ordem sabe.
O método tem duas fraquezas. Os pesos são fixos, e estes foram escolhidos manualmente, não ajustados: o mesmo 0.6 é atribuído ao trigrama quer seu contexto tenha sido visto uma vez, quer mil vezes, embora um contexto visto mil vezes mereça mais confiança. E a parte de unigramas atribui a cada token uma probabilidade proporcional à sua frequência, o que, como mostra a próxima seção, é a pergunta errada para um recurso de recuo.
Regra prática: Nunca use uma única ordem de n-gramas isoladamente; combine-a sempre com as ordens inferiores, para que cada token mantenha alguma probabilidade. Prefira métodos que definam o peso de cada contexto a partir de suas contagens, como o Kneser-Ney abaixo, em vez de pesos fixos. Se você usar pesos fixos, escolha-os em um texto separado (held-out), não no texto que você contou.
Conte os contextos que um token segue
Quando um modelo recua para um contexto mais curto, ele está fazendo uma pergunta específica: qual é a probabilidade de este token aparecer em um contexto que ainda não vimos? A frequência bruta responde a outra pergunta. Um token pode ser muito comum e, mesmo assim, ocorrer apenas depois de um ou dois tokens específicos, e um token assim é um palpite ruim para um contexto novo. A medida melhor é a contagem de continuações de um token, o número de tokens diferentes que ele segue: um token que seguiu muitos tokens diferentes tende a seguir também um novo.
Entre os 300 tokens mais frequentes nos nomes de treinamento, estes três aparecem depois do menor número de tokens diferentes em relação a quantas vezes ocorrem, colocados ao lado de duas palavras comuns de produtos:
1"""Counts, for each token in the training names, how often it occurs and how many different tokens come right before it.2Look at the three narrowest tokens, which occur often but follow few different tokens, beside table and chair."""3from collections import Counter, defaultdict45from lib.names import name_tokens67occurrences, before = Counter(), defaultdict(set)8for text in name_tokens("train"):9 for previous, token in zip(["<s>"] + text, text): # the start marker stands before each name's first token, so that token has something to follow too10 occurrences[token] += 111 before[token].add(previous) # the different tokens this one follows1213common = [t for t, _ in occurrences.most_common(300)] # the 300 most frequent tokens: the pool the prose ranks14# different tokens followed, per occurrence, lowest first: the three narrowest15narrow = sorted(common, key=lambda t: len(before[t]) / occurrences[t])[:3]16for token in narrow + ["table</w>", "chair</w>"]: # </w> marks a token that ends a word, as the store's tokenizer writes it17 print(f"{token:<14} occurs {occurrences[token]:>5,} times, after {len(before[token]):>4,} different tokens")
python continuation-counts.pytvs</w> occurs 323 times, after 1 different tokens
wide</w> occurs 1,985 times, after 14 different tokens
''</w> occurs 10,335 times, after 85 different tokens
table</w> occurs 3,487 times, after 154 different tokens
chair</w> occurs 2,791 times, after 138 different tokens
O token tvs ocorre centenas de vezes, depois de apenas um outro token: nos nomes da loja ele faz sempre parte da mesma expressão, em produtos feitos para TVs. Um modelo que recuasse para a frequência bruta consideraria tvs um palpite razoável em qualquer lugar, e quase nunca é. wide segue apenas um punhado de tokens, em sua maioria os sinais de polegada depois de números, e o próprio sinal de polegada, '', segue principalmente dígitos. Enquanto isso, table e chair seguem cada um bem mais de cem tokens diferentes: coffee table, side table, outdoor table. Suas contagens de continuações dizem o que a frequência não diz: eles aparecem depois de bem mais de cem tokens diferentes.
Contagens de continuações são baratas de calcular: para cada token, guarde o conjunto de tokens vistos antes dele e conte o conjunto. Elas não precisam de texto extra nem de ajuste, apenas de uma pergunta diferente feita sobre as mesmas contagens, e a próxima seção se apoia nelas.
Esta é a ideia por trás do alisamento de Kneser-Ney (Kneser and Ney, 1995): quando o modelo recorre a um contexto mais curto, ele usa contagens de continuações em vez de contagens brutas, de modo que tokens que aparecem em muitos contextos recebem a probabilidade, e tokens que aparecem em uma única expressão fixa não.
Regra prática: Pondere os tokens pelo número de contextos diferentes que eles seguem, não pela frequência com que ocorrem, sempre que você recuar de um contexto longo para um curto. Use contagens brutas apenas na ordem mais alta, onde o contexto de fato já foi visto.
Suavize com Kneser-Ney
A suavização de Kneser-Ney combina interpolação de ordens com contagens de continuação. Em cada ordem, o Kneser-Ney subtrai um desconto d fixo de cada contagem que viu e entrega a probabilidade que tirou à ordem inferior seguinte, de modo que um contexto visto com frequência mantém quase toda a sua própria previsão, enquanto um contexto visto raramente depende do contexto mais curto, e o desconto liberado vai para tokens que aparecem em muitos contextos.
A mesma fórmula vale em todas as ordens. Abaixo da mais alta, as contagens são contagens de continuação, exceto para n-gramas que começam um texto, que mantêm suas contagens brutas, como faz o conjunto de ferramentas KenLM. Para um contexto h e um token w, sendo c(h w) a contagem do par, c(h) a contagem do contexto e N(h) o número de tokens distintos vistos depois de h:
P(w | h) = max(c(h w) − d, 0) / c(h) + d · N(h) / c(h) · P(w | h menor)
O módulo compartilhado do livro, lib.ngrams, implementa o Kneser-Ney interpolado como descrito por Chen e Goodman (Chen e Goodman, 1999), com desconto de 0.75, um padrão comum. Sua ordem mais baixa mistura uma parcela uniforme sobre o vocabulário, de modo que até um token nunca visto no treinamento mantém uma pequena probabilidade.
Antes de confiar no módulo, calcule uma probabilidade à mão: stool depois de um nome que começa com patio bar, ordem por ordem. Coloque-a ao lado da resposta do módulo e ao lado das probabilidades do módulo depois desse contexto, somadas sobre todos os tokens:
1"""Works out the probability of stool after a name that starts patio bar, order by order, with the chapter's formula.2It checks the result against lib.ngrams and against the module's probabilities summed over the vocabulary: the3by hand line should match the lib.ngrams line, and the summed line should be a probability distribution's total."""4from lib import bpe5from lib.names import name_tokens6from lib.ngrams import START, KneserNey78model = KneserNey(name_tokens("train"), 4) # a 4-gram model; below the top order its counts are continuation counts, except for n-grams that start a name9context = tuple([START] + bpe.store_tokenizer().encode("patio bar")) # a name that starts "patio bar"10token, d = "stool</w>", model.d # </w> ends a word; d is the discount, 0.75 by default111213def by_hand(context, k): # the chapter's formula, one order at a time14 if k == 0:15 return 1 / (len(model.vocabulary) + 1) # order 0 is uniform over the vocabulary, with one more slot for an unseen token16 context = context[len(context) - (k - 1):] if k > 1 else () # the last k-1 tokens: the order-k model's own context17 following, total = model.counts[k][context], model.totals[k].get(context, 0)18 if total == 0:19 return by_hand(context, k - 1) # a context never seen gives all its weight to the order below20 kept = max(following[token] - d, 0) / total # the discounted count21 passed_down = d * len(following) / total # what the discount frees for the order below22 print(f"order {k}: kept {kept:.4f}, passed down {passed_down:.4f}")23 return kept + passed_down * by_hand(context, k - 1)242526print("by hand:", f"{by_hand(context, 4):.4f}")27print("lib.ngrams:", f"{model.probability(context, token):.4f}")28total = sum(model.probability(context, t) for t in model.vocabulary)29print("probabilities after the context, summed:", f"{total:.4f}")
python kneser-ney-by-hand.pyorder 4: kept 0.2500, passed down 0.7500
order 3: kept 0.8056, passed down 0.1667
order 2: kept 0.0630, passed down 0.1275
order 1: kept 0.0007, passed down 0.0318
by hand: 0.8621
lib.ngrams: 0.8621
probabilities after the context, summed: 1.0000
Calculada à mão, a fórmula dá 0.8621 para stool, igual ao 0.8621 do módulo. Cada ordem fica com uma parcela e passa o restante adiante; as parcelas somam essa resposta. Sobre todos os tokens do vocabulário, as probabilidades do módulo depois desse contexto somam 1.0000, como deve fazer uma distribuição de probabilidade.
Modelos Kneser-Ney de todas as ordens de 1 a 5, avaliados nos nomes de validação, mostram se contextos mais longos agora compensam:
1"""Builds Kneser-Ney models of orders 1 to 5 on the training names, scores each on the validation names, and estimates a2discount from the 4-gram counts. The lines to read are the validation perplexities, the 3-gram's set against the interpolated trigram's, and the discount line."""3from lib.names import name_tokens4from lib.ngrams import KneserNey, perplexity56train, validation = name_tokens("train"), name_tokens("validation")7for n in [1, 2, 3, 4, 5]:8 model = KneserNey(train, n)9 print(f"{n}-gram validation perplexity: {perplexity(model, validation):.1f}")1011model = KneserNey(train, 4)12# the highest order keeps raw counts, not continuation counts, so these are how often each 4-gram occurs in training13top = [c for following in model.counts[4].values() for c in following.values()]14once, twice = top.count(1), top.count(2)15print("4-grams seen once:", f"{once:,}")16print("4-grams seen twice:", f"{twice:,}")17# Chen and Goodman's estimate of the discount: D = n1 / (n1 + 2 n2), with n1 and n2 the counts seen once and twice18print("discount estimated from them:", f"{once / (once + 2 * twice):.2f}")
python kneser-ney-by-order.py1-gram validation perplexity: 687.2
2-gram validation perplexity: 46.9
3-gram validation perplexity: 24.9
4-gram validation perplexity: 23.1
5-gram validation perplexity: 23.5
4-grams seen once: 164,374
4-grams seen twice: 18,359
discount estimated from them: 0.82
O Kneser-Ney supera o trigrama interpolado com pesos escolhidos à mão da seção de interpolação na mesma ordem, sem pesos a escolher. Seu trigrama obtém 24.9, contra 31.4 do que tem pesos escolhidos à mão.
Contextos mais longos agora ajudam em textos novos, e não apenas no texto que o modelo contou, até certo ponto: a perplexidade de validação cai de 46.9 no bigrama para 23.1 no 4-grama, depois sobe para 23.5 no 5-grama. O salto do trigrama para o 4-grama é pequeno, e o 5-grama é pior, porque até lá a maioria dos contextos não foi vista e a ordem extra acrescenta ruído. O desconto também pode ser estimado a partir das contagens: Chen e Goodman dão D = n₁ / (n₁ + 2 n₂), em que n₁ e n₂ são os números de n-gramas vistos uma e duas vezes, e nos 4-gramas da loja ele é 0.82, próximo do padrão.
Regra prática: Suavize modelos de n-gramas com Kneser-Ney interpolado e desconto de 0.75, a menos que um texto reservado indique outra coisa. Aumente a ordem apenas enquanto a perplexidade de validação continuar caindo de forma notável, e pare quando um passo quase não ajudar ou atrapalhar, como acontece no salto do 4-grama para o 5-grama. Uma variante, o Kneser-Ney modificado, usa três descontos em vez de um e é a que ferramentas como o KenLM constroem; provavelmente reduziria um pouco a linha de base, mas este livro mantém o desconto único porque é mais fácil de acompanhar à mão.
Autocompletar com três tokens de contexto
Um contexto mais longo deve corrigir a pior sugestão da caixa de busca do capítulo 1, em que patio bar recebeu as mesmas sugestões que bar. O modelo Kneser-Ney de 4-gramas enxerga os últimos três tokens que o cliente digitou, então patio permanece em evidência.
As sugestões mudam de bar para patio bar e depois para outdoor bar? Considere os três próximos tokens mais prováveis do modelo de 4-gramas depois de cada um. Cada prefixo é tratado como o início de um nome, como acontece com a digitação do cliente, e cada sugestão mostra o seu token sem o marcador de fim de palavra:
1"""Asks the 4-gram model for its three likeliest next tokens after bar, patio bar and outdoor bar, each typed as the start2of a name, then counts the training names that contain outdoor bar. The three suggestion lines carry the point, and the last line3counts the training names with outdoor bar in them."""4from lib import bpe5from lib.names import name_tokens6from lib.ngrams import START, KneserNey78model = KneserNey(name_tokens("train"), 4)9tokenizer = bpe.store_tokenizer()10candidates = sorted(model.vocabulary) # sorted first, so tokens with equal probability keep alphabetical order1112for typed in ["bar", "patio bar", "outdoor bar"]:13 # padded with start markers, then the last three tokens: a short prefix still gives a full context14 context = tuple([START] * 3 + tokenizer.encode(typed))[-3:]15 ranked = sorted(candidates, key=lambda t: -model.probability(context, t))[:3] # negated, so the likeliest sort first16 print(f"{typed:<12} -> " + ", ".join(f"{t.replace('</w>', '')} {model.probability(context, t):.2f}" for t in ranked))17# each name as one string of tokens, so the check below matches whole tokens rather than parts of them18names = [" ".join(t) for t in name_tokens("train")]19print("training names containing 'outdoor bar':", sum("outdoor</w> bar</w>" in n for n in names))
python ngram-autocomplete.pybar -> & 0.23, unit 0.13, with 0.11
patio bar -> stool 0.86, & 0.03, with 0.02
outdoor bar -> & 0.23, with 0.19, stool 0.06
training names containing 'outdoor bar': 0
Depois de bar sozinho, o modelo sugere continuações como & e with, que pertencem a nomes que começam como bar & counter stools; o bigrama do capítulo 1, que ignorava onde a palavra estava, sugeriu stool em primeiro lugar. Depois de patio bar, ele sugere stool com alta probabilidade: o contexto mudou a previsão, algo que um modelo de bigramas não consegue fazer. Depois de outdoor bar, porém, as sugestões voltam a se aproximar de & e with, porque nenhum nome de treinamento contém outdoor bar, como mostra a última linha do exemplo, e o modelo recua para o que segue bar.
Sugestões como & e with são continuações reais dos nomes da loja, mas raramente um cliente quer vê-las oferecidas. Uma caixa de busca as filtraria, como o capítulo 1 sugeriu para a pontuação, ou completaria com frases inteiras em vez de tokens isolados. Essa é uma escolha de apresentação; as probabilidades do modelo são as mesmas de qualquer forma.
A linha outdoor bar é o limite da contagem em miniatura. O modelo viu patio bar stool, outdoor patio e bar stool muitas vezes, então tem as peças para supor que um bar ao ar livre provavelmente vem com banquetas. Mas a contagem de outdoor bar stool é uma entrada separada em uma tabela, e nada a liga a patio bar stool. Um modelo precisa de alguma noção de que outdoor e patio são parecidos, o que a contagem não tem. O Capítulo 4 dá aos tokens da loja essa noção.
Regra prática: Use o contexto mais longo que seu modelo suporta para as sugestões, e verifique separadamente as sugestões para contextos raros no treinamento, como outdoor bar, das comuns: é aí que um modelo por contagem recorre a palpites genéricos.
A referência contra a qual todo modelo posterior é medido
Cada capítulo a partir daqui constrói um modelo que aprende, e não apenas conta, e cada um afirma prever melhor o texto da loja. Uma afirmação desse tipo exige uma referência, uma medida fixa: um modelo, um texto, um tokenizador e uma métrica aos quais todos os modelos posteriores são comparados. Uma referência deve ser o modelo simples mais forte disponível, para que superá-la tenha significado.
A referência deste livro é o modelo Kneser-Ney de 4 gramas deste capítulo, avaliado nos nomes de validação da loja com o tokenizador da loja. Sua perplexidade de validação é 23.1 por token, conforme o exemplo de Kneser-Ney. O modelo de 5 gramas é pior, com 23.5, e mantém mais contagens, então o de 4 gramas é a referência: o melhor dos modelos contados deste capítulo nos nomes da loja. Existe uma referência contada mais forte, o Kneser-Ney modificado, e o livro não a usa, pelo motivo que a seção sobre Kneser-Ney apresenta.
A referência também define expectativas. Uma perplexidade próxima de vinte significa que o modelo, em média, escolhe entre cerca de vinte tokens prováveis a cada passo do nome de um produto. Alguns passos são quase certos, como table depois de coffee, e outros estão totalmente em aberto, como o primeiro token do nome de uma linha de produtos. Um modelo neural que supere a referência deve fazê-lo prevendo melhor os passos em aberto, porque consegue relacionar um contexto a outro, e não por memorizar mais.
Dois aspectos da referência permanecerão fixos pelo resto do livro. Toda perplexidade é por token do tokenizador da loja, nos nomes de validação, de modo que os números de todos os capítulos possam ser comparados lado a lado. E os nomes de teste permanecem intocados até a comparação final do livro, de modo que nada no livro é ajustado com base neles.
Regra prática: Antes de construir um modelo aprendido, construa o modelo contado mais forte que puder e registre sua perplexidade em dados não vistos como a referência. Compare todo modelo posterior com ela, sobre o mesmo texto e com o mesmo tokenizador, e trate um modelo aprendido que não supere a referência como um resultado a ser explicado, nunca como um sucesso. Capítulos posteriores encontram exatamente isso, e conquistam para os modelos aprendidos o seu lugar por outro caminho.
O que dá errado em produção
Os modelos de n-gramas ainda são úteis onde velocidade e transparência importam mais do que o último ponto de perplexidade, como em autocompletar rápido. Estes são os problemas que eles trazem:
- As tabelas crescem. Cada ordem acrescenta outra tabela de contagens, e o número de n-gramas distintos cresce quase tão rápido quanto o texto. Elimine os n-gramas vistos uma única vez, e meça a perplexidade de validação depois da poda, já que alguns n-gramas raros carregam informação real.
- Contextos raros recebem respostas genéricas. Como
outdoor barmostrou, um contexto que o modelo raramente viu recua para o que o contexto mais curto sugere. Monitore as sugestões para prefixos raros, e não apenas para os comuns. - O desconto é uma escolha. Um desconto de 0.75 é um padrão sólido, e não uma lei. Se o seu texto difere muito do da loja, ajuste-o com texto reservado (held-out).
- Textos novos mudam as contagens. Linhas de produtos surgem e saem, e as contagens por trás de cada sugestão são tão atuais quanto a última reconstrução. Reconstrua em intervalos regulares, e compare a perplexidade de validação em textos recentes com a linha de base para perceber quando o modelo ficou desatualizado.
- As probabilidades devem somar um. Esquemas de recuo escritos à mão frequentemente perdem ou contam em dobro probabilidade, o que faz a perplexidade parecer melhor ou pior do que é. Verifique, em alguns contextos, se as probabilidades de cada um sobre o vocabulário somam um.
O que este capítulo decidiu
- Todo modelo do livro é avaliado por perplexidade por token nos nomes de validação da loja, usando o tokenizador da loja. Um único texto, um único tokenizador e uma única medida tornam os números de todos os capítulos comparáveis entre si, nos nomes, e os nomes de teste são mantidos para a comparação final do livro, no capítulo 11.
- Os modelos de n-gramas são suavizados com Kneser-Ney interpolado, com desconto de 0.75. Ele superou a interpolação com pesos definidos à mão na mesma ordem, sem pesos para ajustar, porque confia em cada contexto na proporção de suas contagens e recua para tokens que seguem muitos contextos.
- A referência é o modelo de 4-gramas Kneser-Ney, com 23.1 por token nos nomes de validação. O modelo de 5-gramas tem pontuação pior e guarda mais contagens, então o 4-grama é a referência.
- O autocompletar usa as sugestões do modelo de 4-gramas, com três tokens de contexto. Ele corrige
patio bar, e ainda recorre a sugestões genéricas para contextos raros, comooutdoor bar, que é onde um modelo aprendido precisa fazer melhor. - Contextos longos deixam de ajudar porque não foram vistos, e não porque não importam. Mais da metade dos 5-gramas dos nomes de validação nunca ocorre no treino, e o modelo não consegue relacionar um contexto não visto a contextos vistos parecidos. O capítulo 4 começa por esse problema, ao dar aos tokens vetores que indicam quais deles são parecidos.
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.