Um modelo de linguagem neural
Cerca de 26 minutos min de leitura, com 10 exemplos em 11 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
- Prever a partir de uma janela de embeddings
- Calcular gradientes por retropropagação
- Dê passos de gradiente descendente
- Treinar com PyTorch
- Pare quando a perda de validação voltar a subir
- Compare com a linha de base
- Misture a rede com as contagens
- Mais texto ajuda só se for do mesmo tipo
- Sugerir a partir de contextos semelhantes
- 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 neural que prevê o próximo token a partir de uma janela de tokens anteriores, calcular seus gradientes à mão e verificá-los, treiná-lo com PyTorch e medi-lo de forma justa em comparação com a linha de base por contagem. Você também verá que um modelo aprendido não vence por ser aprendido: este perde para a contagem sozinha, e ajuda quando os dois são combinados.
O Capítulo 3 construiu a linha de base do livro, um modelo Kneser-Ney de 4-gramas que prevê cada token dos nomes de produtos da loja a partir dos três tokens anteriores, por contagem. Sua limitação era não conseguir relacionar um contexto a outro: entre os nomes de uma loja de móveis e artigos para o lar, ele tem contagens para patio bar e nenhuma para outdoor bar, e nada liga os dois. O Capítulo 4 mostrou que vetores podem relacionar tokens, já que patio e outdoor recebem vetores próximos quando são aprendidos a partir do texto da loja. Este capítulo coloca vetores dentro de um modelo. Um modelo de linguagem neural lê os tokens anteriores como vetores, combina-os por meio de uma aritmética aprendida e produz uma probabilidade para cada token do vocabulário. Ele aprende seus vetores e sua aritmética ao mesmo tempo, sendo treinado para prever o próximo token. O projeto é o que Bengio e colaboradores introduziram (Bengio et al., 2003).
A loja fornece o texto, e o teste é o mesmo que todo modelo desde o capítulo 3 enfrenta: a perplexidade por token nos nomes de validação, pelo tokenizador da loja. Quanto menor, melhor, e a linha de base obtém 23.1.
Prever a partir de uma janela de embeddings
O modelo deste capítulo observa uma janela fixa dos tokens anteriores, quatro aqui, o mesmo contexto que um 5-gram considera. Cada token é buscado em uma tabela de embeddings, uma matriz com uma linha de números para cada token do vocabulário, como no capítulo 4, exceto que esta tabela é aprendida para prever o próximo token em vez de ser calculada a partir de contagens. As quatro linhas são unidas lado a lado em um único vetor longo, x. Uma camada oculta calcula h = tanh(xW + b) a partir de sua entrada x: ela multiplica x por uma matriz de pesos W, soma um vetor de vieses b e passa cada resultado pela tanh, uma função que comprime qualquer número para o intervalo de −1 a 1, de modo que a camada possa combinar suas entradas de maneiras que somas simples não permitem. Uma camada de saída então calcula z = hU + c a partir da saída h da camada oculta, uma pontuação para cada token do vocabulário, chamadas de logits, no plural.
O último passo transforma pontuações em probabilidades. O softmax calcula a exponencial de cada logit e divide pela soma, de modo que os resultados são positivos e somam um, e uma pontuação maior significa uma probabilidade maior:
P(token i) = exp(zᵢ) / Σⱼ exp(zⱼ)
Desenvolvida com os pesos treinados, uma previsão mostra como o modelo transforma quatro tokens em probabilidades: o próximo token depois de um nome que começa com patio bar. Cada linha do exemplo é uma das fórmulas acima, e as formas impressas mostram o que cada passo faz:
1"""One prediction of the trained window model, computed by hand from its saved weights: the embeddings, the tanh layer,2the output scores and the softmax. The prose's point rests on the shapes, the parameter counts and the three likeliest3tokens after `patio bar`."""4import numpy as np56from lib import bpe, neural7from lib.ngrams import START89weights, vocabulary, manifest = neural.load()10index, width = {t: i for i, t in enumerate(vocabulary)}, manifest["settings"]["context"] # token -> row; the window's width, from the saved settings11context = ([START] * width + bpe.store_tokenizer().encode("patio bar"))[-width:] # pad with start markers, keep the last width tokens12ids = np.array([[index[t] for t in context]])1314vectors = weights["embedding"][ids] # one 64-number vector per token15joined = vectors.reshape(1, -1) # -1 lets numpy work out the length: 4 vectors of 64 make 25616hidden = np.tanh(joined @ weights["hidden_w"] + weights["hidden_b"]) # one layer, squashed into -1 to 117logits = hidden @ weights["output_w"] + weights["output_b"] # one score for every token18probabilities = np.exp(logits - logits.max()) # subtract the largest score first: same probabilities, and exp can't overflow19probabilities /= probabilities.sum() # softmax: scores into probabilities2021print("context:", " ".join(context))22for name, array in [("embeddings", vectors), ("joined", joined), ("hidden", hidden), ("logits", logits)]:23 print(f"{name} shape:", array.shape)24print("vocabulary size:", f"{len(vocabulary):,}")25print("parameters:", f"{sum(w.size for w in weights.values()):,}")26for part in ["embedding", "hidden_w", "output_w"]:27 print(f"parameters in {part}:", f"{weights[part].size:,}")28for i in np.argsort(-probabilities[0], kind="stable")[:3]: # the three likeliest; a stable sort keeps ties in vocabulary order29 print(f"P({vocabulary[i]} | patio bar): {probabilities[0, i]:.2f}")
python window-model-by-hand.pycontext: <s> <s> patio</w> bar</w>
embeddings shape: (1, 4, 64)
joined shape: (1, 256)
hidden shape: (1, 256)
logits shape: (1, 4140)
vocabulary size: 4,140
parameters: 1,394,732
parameters in embedding: 264,960
parameters in hidden_w: 65,536
parameters in output_w: 1,059,840
P(stool</w> | patio bar): 0.63
P(with</w> | patio bar): 0.23
P(&</w> | patio bar): 0.05
A janela é preenchida com marcadores de início, porque o nome tem, até agora, apenas dois tokens. Cada um dos quatro tokens se torna um vetor de 64 números; unidos, formam um vetor de 256; a camada oculta o transforma em outros 256; e a camada de saída fornece uma pontuação para cada um dos 4,140 tokens que o modelo conhece, o vocabulário do tokenizador de lojas mais os marcadores de início e fim. O modelo de janela tem 1,394,732 parâmetros, os números que ele aprende. Cerca de três quartos deles estão nos pesos da camada de saída, 1,059,840, porque ela precisa de uma coluna para cada token, e a maior parte do restante está na tabela de embeddings. Sua previsão é sensata: stool com probabilidade 0.63, depois with e &, que continuam nomes como patio bar with stools.
Regra prática: Construa a passagem direta de qualquer modelo que você treinar à mão pelo menos uma vez, e imprima a forma de cada array intermediário, como este exemplo faz: uma forma errada é um erro comum em código de redes neurais, e as formas dizem exatamente o que o modelo calcula. Espere que a camada de saída concentre a maior parte dos parâmetros sempre que o vocabulário for grande.
Calcular gradientes por retropropagação
Um modelo com pesos aleatórios prevê mal; o treinamento ajusta os pesos para prever bem. Para medir o quão mal um modelo prevê, use a perda: L = −log P(próximo token), o logaritmo negativo da probabilidade que o modelo deu ao token que de fato veio em seguida, a mesma surpresa que o capítulo 1 tornou média na perplexidade. O treinamento reduz a perda média, e menor perda significa menor perplexidade. Para reduzir a perda, cada peso precisa de um gradiente: quanto a perda mudaria se aquele peso mudasse um pouco, escrito ∂L/∂w.
A retropropagação calcula todos os gradientes de uma só vez, aplicando a regra da cadeia do cálculo para trás ao longo da passagem direta: da perda aos logits, dos logits pela camada de saída até a camada oculta, pela tanh, e de volta aos embeddings que foram usados (Rumelhart et al., 1986). Dois de seus passos vale a pena memorizar. O gradiente da perda em relação aos logits é as probabilidades do softmax menos 1 no token verdadeiro. E o gradiente através da tanh é multiplicado por 1 − h², que é pequeno onde h está próximo de ±1. O módulo compartilhado do livro, lib.tinynet, escreve tudo isso linha por linha, para uma versão pequena do modelo da loja, com 5 tokens, embeddings de 2 números, uma janela de 2 e 3 unidades ocultas.
O código de retropropagação costuma dar errado de forma sutil, então confira-o contra um método mais lento que não erra: altere um peso para cima e para baixo por uma quantidade mínima, meça como a perda se move e compare. O modelo da loja exigiria mais de um milhão dessas alterações, então confira cada parâmetro do modelo pequeno:
1"""Backpropagation's gradients for the tiny model, checked against nudging every one of its parameters up and down.2The assert is the check the prose relies on: the two agree to six decimal places, for every parameter."""3import numpy as np45from lib.tinynet import backprop, forward, parameters67p = parameters() # the tiny model: 5 tokens, a window of 2, 3 hidden units; seeded, so the same every run8context, target = np.array([1, 3]), 4 # the window: token ids 1 and 3; the token that came next is id 4910worst, step = 0.0, 1e-6 # the nudge: small enough that the loss is nearly a straight line over it11gradients = backprop(p, context, target)12for name, value in p.items(): # nudge each parameter both ways, and see how the loss moves13 for i in np.ndindex(value.shape):14 value[i] += step15 up = forward(p, context, target)[3] # forward returns (joined, hidden, logits, loss): index 3 is the loss16 value[i] -= 2 * step # from up to down is two steps, so the estimate is centred on the value17 down = forward(p, context, target)[3]18 value[i] += step # back where it started19 worst = max(worst, abs((up - down) / (2 * step) - gradients[name][i]))20agrees = worst < 1e-6 # the largest disagreement over all parameters, against six decimal places21assert agrees22print("loss:", round(float(forward(p, context, target)[3]), 4))23print("parameters checked:", sum(v.size for v in p.values()))24print("backprop agrees with nudging to 6 decimal places:", "yes" if agrees else "no")
python gradients-by-hand.pyloss: 1.5293
parameters checked: 45
backprop agrees with nudging to 6 decimal places: yes
Todos os 45 gradientes da retropropagação concordam com as estimativas por alteração até seis casas decimais, o que o exemplo verifica com uma asserção. O método de alteração custa duas passagens diretas por parâmetro, e por isso ninguém treina com ele, mas em um modelo pequeno ele é a referência que mostra que a retropropagação está correta.
Regra prática: Confira gradientes escritos à mão contra estimativas por alteração em um modelo pequeno antes de confiar neles. Ao usar uma biblioteca que calcula os gradientes para você, como faz a seção de PyTorch, confira em vez disso a passagem direta da biblioteca contra a sua própria.
Dê passos de gradiente descendente
Com os gradientes em mãos, o treinamento é um laço. O gradiente descendente move cada peso um pequeno passo contra o seu gradiente, w ← w − η · ∂L/∂w, onde η, o tamanho do passo, também chamado de taxa de aprendizado, define o quanto cada passo avança. Cada passo faz a perda diminuir um pouco para os exemplos com os quais foi calculado e, repetido sobre muitos exemplos, os pesos se estabilizam onde o modelo prevê bem.
Vinte passos de gradiente descendente com tamanho de passo 0.5, usando os gradientes de lib.tinynet, sobre três exemplos do pequeno modelo da loja apresentado na seção anterior, mostram a perda caindo:
1"""Twenty steps of gradient descent on three examples of the tiny model, printing the average loss before training and2after one, five and twenty steps. The prose's point rests on the average loss at those four points."""3import numpy as np45from lib.tinynet import backprop, forward, parameters67p = parameters() # seeded, so every run starts from the same weights8examples = [(np.array([1, 3]), 4), (np.array([0, 1]), 3), (np.array([3, 4]), 2)] # three (window, next token) pairs: each window is two token ids, then the id of the token after it9rate = 0.5 # the step size101112def average_loss():13 return np.mean([forward(p, c, t)[3] for c, t in examples])141516print("average loss before:", f"{average_loss():.3f}")17for step in range(1, 21): # twenty steps, each one a pass over all three examples18 for c, t in examples:19 for name, gradient in backprop(p, c, t).items():20 p[name] -= rate * gradient / len(examples) # w <- w - rate * dL/dw, with each gradient averaged over the examples21 if step in (1, 5, 20):22 print(f"average loss after {step} steps:", f"{average_loss():.3f}")
python gradient-descent-by-hand.pyaverage loss before: 1.568
average loss after 1 steps: 1.346
average loss after 5 steps: 0.646
average loss after 20 steps: 0.109
A perda média cai a cada passo do exemplo, de 1.568 antes do treinamento para 0.109 após vinte passos. Com apenas três exemplos para aprender, o pequeno modelo consegue levar sua perda para perto de zero, o que é memorização; o modelo da loja aprende com centenas de milhares de exemplos, nos quais o mesmo laço precisa encontrar padrões que valem para todos eles.
O treinamento real altera dois aspectos desse laço. Cada passo do treinamento real é calculado sobre um lote de exemplos, algumas centenas por vez, em vez de todos eles, de modo que cada passo é barato e os passos variam um pouco. E ele usa uma atualização refinada em vez de um tamanho de passo fixo, como descreve a próxima seção.
Regra prática: Comece qualquer modelo novo executando alguns passos sobre um punhado de exemplos e verificando se a perda cai: uma perda que não cai em três exemplos indica um erro, não um problema difícil. Escolha o tamanho do passo testando alguns valores: pequeno demais e a perda rasteja, grande demais e ela oscila ou cresce.
Treinar com PyTorch
Escrever a retropropagação à mão para cada modelo seria lento e sujeito a erros. O PyTorch, uma biblioteca amplamente usada para treinar redes neurais, calcula os gradientes automaticamente a partir da passagem direta, e executa a aritmética com rapidez. O livro treina seu modelo com ele, em recordings/neural_lm.py, que constrói o mesmo modelo de janela da primeira seção: uma tabela de embeddings, uma camada tanh e uma camada de saída, treinado com os nomes de treinamento da loja. O núcleo do script é o laço da seção anterior, sobre lotes de 512 previsões:
loss = loss_of(model(train_x[pick]), train_y[pick]) # forward pass and average loss on one batch
optimizer.zero_grad() # clear the previous batch's gradients
loss.backward() # backpropagation: a gradient for every weight
optimizer.step() # move every weight against its gradient
O otimizador do script de treinamento é o Adam, um refinamento da descida de gradiente (Kingma e Ba, 2015). Ele mantém, para cada peso, uma média móvel de seus gradientes e uma média móvel de seus quadrados, e dá um passo igual ao primeiro dividido pela raiz quadrada do segundo. Um peso cujos gradientes são consistentemente grandes recebe passos de tamanho aproximadamente igual ao de um peso cujos gradientes são pequenos, de modo que um único tamanho de passo funciona para todos eles.
O treinamento depende da aritmética de ponto flutuante da máquina, que o capítulo 4 explica; por isso ele é executado uma única vez, e os exemplos do livro leem os pesos salvos, como leem todos os resultados desse tipo. Os exemplos nunca importam o PyTorch: lib.neural recalcula a passagem direta do modelo em NumPy, a partir desses pesos. Isso só funciona se a versão em NumPy calcular o que o PyTorch calculou, de modo que o script de treinamento salvou os logits do próprio PyTorch para 64 contextos de validação, e o próximo exemplo faz a comparação:
1"""The trained model's logits, recomputed in NumPy from its saved weights and compared with the logits PyTorch computed2for the same saved validation contexts. The prose's point rests on the agreement, which the last line prints."""3import numpy as np45from lib import neural67weights, _, manifest = neural.load()8check = np.load("data/recorded/neural-lm/check.npz") # saved by the training script, so this runs without PyTorch: contexts, and PyTorch's logits for them910ours = neural.forward(weights, check["contexts"])11print("PyTorch version:", manifest["torch"])12print("contexts compared:", len(check["contexts"]))13print("logits compared:", f"{ours.size:,}") # every logit: one per context and per token in the vocabulary14print("same as PyTorch to 4 decimal places:", bool(np.abs(ours - check["logits"]).max() < 1e-4)) # 1e-4: four decimal places
python same-as-pytorch.pyPyTorch version: 2.14.1+cpu
contexts compared: 64
logits compared: 264,960
same as PyTorch to 4 decimal places: True
A passagem direta em NumPy reproduz todos os 264,960 logits do PyTorch com quatro casas decimais, para o modelo treinado com o PyTorch 2.14.1+cpu. Todo número que este capítulo informa sobre o modelo treinado vem desse código em NumPy, exceto a curva de treinamento, que o script registrou durante o treinamento.
Regra prática: Treine com uma biblioteca que calcule os gradientes para você, e mantenha uma passagem direta curta e independente para verificar suas saídas, como lib.neural faz aqui. Registre as saídas da biblioteca para algumas entradas sempre que salvar pesos, para que a verificação possa ser executada em qualquer lugar, muito depois do treinamento.
Pare quando a perda de validação voltar a subir
Um modelo com 1.4 milhão de parâmetros, treinado com algumas centenas de milhares de tokens, pode memorizar seu texto de treinamento, como o 5-grama do capítulo 3 fez. A perplexidade de treinamento continua caindo enquanto isso acontece. A perplexidade de validação cai no início, enquanto o modelo aprende padrões que valem para nomes novos, e depois sobe, quando começa a ajustar particularidades dos nomes de treinamento. Uma perplexidade de validação que sobe enquanto a perplexidade de treinamento continua caindo é sobreajuste, e a defesa mais simples é a parada antecipada: medir a perda de validação ao fim de cada época, uma passagem completa pelo texto de treinamento, e manter os pesos da melhor época.
O script de treinamento registrou as duas perplexidades ao fim de cada uma das suas doze épocas. Observe onde a validação deixa de melhorar:
1"""The training script's record of training and validation perplexity after each epoch, and the epoch whose weights were2kept. The prose's point rests on the validation column, and on the two validation figures printed after the table."""3import json4import math56curves = json.load(open("data/recorded/neural-lm/curves.json", encoding="utf-8"))7manifest = json.load(open("data/recorded/neural-lm/manifest.json", encoding="utf-8"))89print(f"{'epoch':>5} {'training perplexity':>19} {'validation perplexity':>21}")10for c in curves: # losses are averages of log probabilities: exp turns them into perplexities11 print(f"{c['epoch']:>5} {math.exp(c['train_loss']):>19.1f} {math.exp(c['validation_loss']):>21.1f}")12best = min(curves, key=lambda c: c["validation_loss"]) # the epoch with the lowest validation loss, which the kept epoch should match13print("epoch kept:", manifest["kept_epoch"])14print("validation perplexity at the kept epoch:", f"{math.exp(best['validation_loss']):.1f}")15print("validation perplexity at the last epoch:", f"{math.exp(curves[-1]['validation_loss']):.1f}") # curves[-1]: the final epoch's record, whatever was kept
python training-curve.pyepoch training perplexity validation perplexity
1 109.3 51.4
2 37.6 39.9
3 27.3 37.3
4 22.4 36.6
5 19.3 36.4
6 17.2 36.9
7 15.6 37.8
8 14.4 38.6
9 13.5 39.7
10 12.7 40.9
11 12.0 42.1
12 11.5 43.7
epoch kept: 5
validation perplexity at the kept epoch: 36.4
validation perplexity at the last epoch: 43.7
Na época 1, a perplexidade de treinamento é maior que a de validação, porque o valor de treinamento é uma média de toda a época, incluindo os primeiros lotes, quando o modelo ainda não estava treinado, enquanto a validação é medida ao fim da época. A perplexidade de validação atinge o mínimo de 36.4 na época 5 e sobe a partir daí, chegando a 43.7 na última época, enquanto a perplexidade de treinamento cai a cada época após a primeira. O script de treinamento manteve os pesos da melhor época, e todos os resultados do restante deste capítulo usam esses pesos.
A distância entre as duas curvas é a memorização do modelo. Ela cresce a cada época, porque os nomes de treinamento repetem suas linhas de produto e sua redação, e este modelo não tem regularização, que é qualquer recurso do treinamento que desencoraja a memorização, de modo que a parada antecipada é a sua única defesa.
Regra prática: Registre sempre a perda de validação por época e mantenha os pesos da melhor época, nunca os da última. Quando as curvas se separam cedo, como acontece aqui após algumas épocas, o modelo tem mais capacidade do que o texto de treinamento sustenta: regularize-o, use um modelo menor ou obtenha mais texto do mesmo tipo.
Compare com a linha de base
O teste real é o mesmo que todo modelo deste livro enfrenta: a perplexidade por token nos nomes de validação, em comparação com a linha de base de 4-gramas. Qual pesa mais nestes nomes: relacionar contextos semelhantes ou contagens exatas? O modelo neural consegue relacionar contextos semelhantes, o que o 4-grama não consegue; o 4-grama tem contagens exatas para cada contexto que já viu.
1"""The window model and the 4-gram baseline, each scored by perplexity per token on the same validation names. The2prose's point rests on the two printed perplexities."""3from lib import neural4from lib.names import name_tokens5from lib.ngrams import KneserNey, perplexity67train, validation = name_tokens("train"), name_tokens("validation") # both models are scored on the same tokens of the same names8print("window model validation perplexity:", f"{neural.perplexity(validation):.1f}") # the window model, from its saved weights9print("4-gram baseline validation perplexity:", f"{perplexity(KneserNey(train, 4), validation):.1f}") # a 4-gram: each token is predicted from the three before it
python neural-vs-baseline.pywindow model validation perplexity: 36.4
4-gram baseline validation perplexity: 23.1
O modelo de contagem vence, com larga margem: a perplexidade de validação do modelo de janela é 36.4, contra 23.1 da linha de base.
Para ver onde, divida os tokens de validação conforme o contexto de três tokens deles ocorra ou não nos nomes de treinamento, e avalie os dois modelos em cada parte:
1"""Splits the validation tokens by whether their three-token context occurs in the training names, and scores both models2on each part. The prose's point rests on the four perplexities printed for the two parts."""3import math45import numpy as np67from lib import neural8from lib.names import name_tokens9from lib.ngrams import KneserNey, ngrams, padded1011train, validation = name_tokens("train"), name_tokens("validation")12counted = KneserNey(train, 4)13pairs = [(c, t) for text in validation for c, t in ngrams(padded(text, 4), 4)] # padding gives each name's first tokens a context14seen = np.array([c in counted.totals[4] for c, _ in pairs]) # was this 3-token context in the training names?15from_counts = np.array([counted.probability(c, t) for c, t in pairs])16from_network = neural.token_probabilities(validation) # in the same order as pairs, so each entry is for the same token1718print("validation tokens with a context seen in training:", f"{seen.mean():.0%}")19for part, where in [("seen", seen), ("unseen", ~seen)]: # ~seen: the complement, the contexts the training names lack20 for model, p in [("4-gram", from_counts), ("network", from_network)]:21 print(f"{model} perplexity, {part} contexts: {math.exp(-np.log(p[where]).mean()):.1f}") # exp of the average surprise, over this part
python seen-and-unseen-contexts.pyvalidation tokens with a context seen in training: 70%
4-gram perplexity, seen contexts: 17.9
network perplexity, seen contexts: 26.1
4-gram perplexity, unseen contexts: 41.2
network perplexity, unseen contexts: 78.5
A rede é pior nas duas partes, e por uma diferença maior nos contextos não vistos, onde sua capacidade de relacionar contextos deveria ajudar mais. Ali o 4-grama obtém 41.2 e a rede 78.5. Nos contextos vistos, que correspondem a 70% dos tokens de validação, o 4-grama obtém 17.9 e a rede 26.1.
Portanto, esta rede não perde apenas onde as contagens são exatas; ela também não aprendeu a generalizar bem. Duas características deste modelo e deste texto são as razões mais prováveis. A rede não tem regularização e sofre de sobreajuste (overfitting) após algumas épocas, como mostrou a curva de treinamento. E os nomes da loja são curtos e formulaicos: três tokens de contexto cobrem a maior parte do que um nome contém, que é justamente o cenário em que as contagens de Kneser-Ney são mais fortes.
Bengio e colaboradores encontraram o oposto em textos maiores e mais variados: no corpus Brown, com cerca de 800,000 palavras de treinamento, a melhor rede isolada deles teve perplexidade de teste de 268, e combinada com um modelo trigrama, 252, contra 312 do melhor modelo de n-gramas (Bengio et al., 2003, seção 4.2 e tabela 1). Um modelo aprendido não é melhor só por ter aprendido; ele precisa ser medido.
Regra prática: Sempre compare um modelo aprendido com uma linha de base de contagem forte, sobre o mesmo texto e os mesmos tokens, antes de afirmar que ele ajuda, e divida a comparação entre contextos vistos e não vistos para ver onde cada modelo vence. Não conclua, a partir de um único conjunto de dados pequeno, que modelos neurais não funcionam, nem que sempre funcionam.
Misture a rede com as contagens
Um modelo que é pior em média ainda pode ser útil, se seus erros forem diferentes dos erros do modelo melhor. Quando dois modelos cometem erros diferentes, misturar suas probabilidades pode superar os dois, e foi isso que Bengio e colegas fizeram com a rede deles e um modelo trigrama suavizado (Bengio et al., 2003, seção 4). A mistura é uma média ponderada das probabilidades dos dois modelos para cada token, como na interpolação do capítulo 3.
A mistura supera as duas pontas? Pontue os nomes de validação com a participação da rede na mistura em 0, 0.2, 0.3, 0.5 e 1, onde 0 é o modelo de contagem sozinho e 1 é a rede sozinha:
1"""Mixes the network's and the 4-gram's probability of every validation token, at five shares for the network, and prints2the validation perplexity of each mix. The prose's point rests on the printed perplexity at share 0.2, and at the two ends."""3import math45import numpy as np67from lib import neural8from lib.names import name_tokens9from lib.ngrams import KneserNey, ngrams, padded1011train, validation = name_tokens("train"), name_tokens("validation")12from_network = neural.token_probabilities(validation) # the network's probability of each actual next token, in order13counted = KneserNey(train, 4)14# the 4-gram's probability for the same tokens, in the same order: each name padded with three start markers first15from_counts = np.array([counted.probability(c, t) for text in validation for c, t in ngrams(padded(text, 4), 4)])1617for share in [0.0, 0.2, 0.3, 0.5, 1.0]: # the network's share of the mix; the counts get the rest18 mixed = share * from_network + (1 - share) * from_counts19 print(f"validation perplexity, network share {share:.1f}: {math.exp(-np.log(mixed).mean()):.1f}")
python mix-neural-and-counts.pyvalidation perplexity, network share 0.0: 23.1
validation perplexity, network share 0.2: 21.9
validation perplexity, network share 0.3: 22.1
validation perplexity, network share 0.5: 22.9
validation perplexity, network share 1.0: 36.4
A mistura supera os dois modelos. Com uma participação da rede de 0.2, a perplexidade de validação é 21.9, melhor que a da linha de base, 23.1, e muito melhor que a da rede sozinha, 36.4. A rede é pior em média, mas, onde as contagens dão a um token muito pouca probabilidade, a participação da rede impede que ele fique minúsculo, e isso reduz a surpresa média.
A época mantida e a participação foram ambas escolhidas olhando para os nomes de validação, então o ganho é levemente otimista; a comparação final do livro, sobre os nomes de teste, vai verificá-lo. E a mistura só ajuda porque os erros dos dois modelos são diferentes: se cometessem os mesmos erros, fazer a média entre eles não ganharia nada.
Regra prática: Quando um modelo aprendido e um modelo de contagem estiverem próximos, experimente misturar suas probabilidades antes de escolher um deles, e escolha a participação em texto reservado. Mantenha a participação pequena quando um dos modelos for bem mais forte, e confirme o ganho em um conjunto de teste separado antes de confiar nele.
Mais texto ajuda só se for do mesmo tipo
Se a rede sobreajusta porque aprendeu com pouco texto, a solução óbvia é mais texto. A loja tem bastante: as descrições dos produtos. O script de treinamento pode treinar o mesmo modelo com nomes e descrições juntos, e o livro registrou também essa versão, avaliada nos mesmos nomes de validação.
Compare os dois modelos registrados nos nomes de validação, um treinado com nomes e outro com nomes e descrições:
1"""Scores the window model trained on names alone against the one trained on names and descriptions, counts the training2tokens of each kind of text, and prints the second model's validation perplexity after each of its epochs. The prose's3point rests on the two validation perplexities, and on the training token counts printed beside them."""4import json5import math67from lib import neural8from lib.names import name_tokens910validation = name_tokens("validation")11for name in ["neural-lm", "neural-lm-all-text"]: # the recorded runs: names alone, then names and descriptions12 manifest = json.load(open(f"data/recorded/{name}/manifest.json", encoding="utf-8"))13 print(f"learned from {manifest['settings']['text']}:", f"{neural.perplexity(validation, name):.1f}")1415from lib import bpe16from lib.store import load_products1718tokenizer = bpe.store_tokenizer()19names_tokens = sum(len(t) for t in name_tokens("train")) # counted in the store's tokens, the ones the model reads20description_tokens = sum(len(tokenizer.encode(d)) for d in load_products("train")["description"]) # the training split only, as for names21print("training tokens, names:", f"{names_tokens:,}")22print("training tokens, names and descriptions:", f"{names_tokens + description_tokens:,}")23curve = json.load(open("data/recorded/neural-lm-all-text/curves.json", encoding="utf-8"))24print("all-text model, validation perplexity by epoch:", ", ".join(f"{math.exp(c['validation_loss']):.1f}" for c in curve)) # one per epoch, in order
python more-text-of-another-kind.pylearned from names: 36.4
learned from all: 59.0
training tokens, names: 337,071
training tokens, names and descriptions: 2,744,320
all-text model, validation perplexity by epoch: 73.6, 64.0, 60.8, 59.0
Acrescentar as descrições piora o modelo nos nomes. Os nomes de treinamento têm 337,071 tokens, e nomes e descrições juntos têm 2,744,320, cerca de oito vezes mais. O modelo que aprendeu só com nomes obtém 36.4, e o que aprendeu com nomes e descrições obtém 59.0. Esse segundo modelo treinou por quatro épocas, e sua perplexidade de validação ainda caía quando parou, em passos cada vez menores a cada época: 73.6, 64.0, 60.8, 59.0. Nossa avaliação é que mais épocas não o levariam perto do modelo de nomes.
Descrições são um tipo diferente de texto. Elas são escritas em frases completas, com palavras como your, this e perfect, que os nomes raramente contêm, e um modelo que aprende principalmente com elas prevê nomes como se fossem descrições. O texto acrescentado ensinou ao modelo a distribuição errada para a tarefa. Um modelo aprende o texto que recebe, e sua perplexidade mede quão bem ele prevê esse tipo de texto: dados de outro tipo podem piorá-lo, e precisam ser ponderados ou mantidos separados.
Regra prática: Antes de acrescentar texto de treinamento, verifique se ele se parece com o texto que você vai prever; treine com os dois e meça no texto-alvo, em vez de presumir que mais é melhor. Quando o texto extra difere muito, treine apenas com o texto-alvo, ou organize cada texto de modo que o modelo consiga distinguir seus tipos, como o capítulo 8 faz com um separador entre o nome de um produto e a sua descrição.
Sugerir a partir de contextos semelhantes
A rede perdeu, em média, inclusive em contextos que os nomes de treinamento não contêm, mas médias escondem casos isolados. O autocompletar do capítulo 3 mostrou o pior caso do 4-grama, outdoor bar, um contexto que nenhum nome de treinamento contém, em que ele recorreu a continuações genéricas.
A seguir, os três tokens mais prováveis da rede após cinco prefixos de nomes, e alguns embeddings, mostram se outdoor bar recebe a sugestão stool que patio bar recebe:
1"""The network's three likeliest next tokens after five typed prefixes, its probability of `stool` after `outdoor bar`,2and the cosine similarity of `patio` with three other tokens in its embedding table. The prose's point rests on the3suggestions after each prefix, and on the three cosines printed last."""4import numpy as np56from lib import bpe, neural7from lib.ngrams import START89weights, vocabulary, manifest = neural.load()10index, width = {t: i for i, t in enumerate(vocabulary)}, manifest["settings"]["context"]11tokenizer = bpe.store_tokenizer()1213for typed in ["bar", "patio bar", "outdoor bar", "kitchen bar", "wine bar"]: # each typed prefix is read as the start of a name14 context = ([START] * width + tokenizer.encode(typed))[-width:] # pad with start markers, keep the last width tokens15 logits = neural.forward(weights, np.array([[index[t] for t in context]]))[0] # forward takes a batch: one row, so take row 016 probabilities = np.exp(neural.log_softmax(logits[None])[0]) # log_softmax wants a batch too: add an axis, then take it off17 best = np.argsort(-probabilities, kind="stable")[:3] # the three likeliest; a stable sort keeps ties in vocabulary order18 # the end-of-word marker </w> is shown as nothing, so the tokens read as the words they came from19 print(f"{typed:<12} -> " + ", ".join(f"{vocabulary[i].replace('</w>', '')} {probabilities[i]:.2f}" for i in best))2021outdoor_bar = ([START] * width + tokenizer.encode("outdoor bar"))[-width:] # the same padding as above22p_stool = np.exp(neural.log_softmax(neural.forward(weights, np.array([[index[t] for t in outdoor_bar]])))[0, index["stool</w>"]])23print("P(stool | outdoor bar):", f"{p_stool:.2f}")24table = weights["embedding"] / np.linalg.norm(weights["embedding"], axis=1, keepdims=True) # unit-length rows, so a dot product is a cosine25for a, b in [("patio</w>", "outdoor</w>"), ("patio</w>", "kitchen</w>"), ("patio</w>", "wine</w>")]:26 print(f"cosine({a.replace('</w>', '')}, {b.replace('</w>', '')}) in the model's embeddings:", f"{float(table[index[a]] @ table[index[b]]):.2f}")
python neural-autocomplete.pybar -> with 0.22, cabinet 0.14, cart 0.13
patio bar -> stool 0.63, with 0.23, & 0.05
outdoor bar -> stool 0.40, with 0.13, & 0.12
kitchen bar -> & 0.53, with 0.17, cart 0.09
wine bar -> with 0.23, cabinet 0.16, </s> 0.14
P(stool | outdoor bar): 0.40
cosine(patio, outdoor) in the model's embeddings: 0.16
cosine(patio, kitchen) in the model's embeddings: 0.07
cosine(patio, wine) in the model's embeddings: 0.10
Após outdoor bar, a rede sugere stool em primeiro lugar, com probabilidade 0.40, enquanto o 4-grama colocava & e with à frente dele. Os prefixos de controle mostram que stool não é automático após bar: após somente bar, kitchen bar e wine bar, ele não está entre as três sugestões da rede. E na própria tabela de embeddings da rede, patio está um pouco mais próximo de outdoor, com similaridade de cosseno de 0.16, do que de kitchen ou wine. Isso é compatível com a rede ter transferido algo de patio bar para outdoor bar, embora a similaridade seja fraca, e um único prefixo prova pouco.
Este é um caso, não uma média: a divisão entre contextos vistos e não vistos mostrou que a rede foi pior em contextos não vistos, no conjunto. Ele mostra o que um modelo aprendido consegue fazer e a contagem não consegue, e que este modelo faz isso só às vezes.
Regra prática: Observe as previsões de um modelo aprendido em contextos que o texto de treinamento não contém, com prefixos de controle ao lado, mas avalie-o por medições em muitos contextos, não por exemplos. Para autocompletar em produção, use a mistura e teste-o em prefixos raros, além dos comuns.
O que dá errado em produção
Um modelo de linguagem neural traz novos modos de falha junto com suas novas forças:
- O sobreajuste é silencioso. A perda de treinamento sempre parece boa. Sem uma curva de validação, um modelo treinado por tempo demais sai pior do que outro treinado por menos tempo. Guarde a melhor época e acompanhe a diferença entre treinamento e validação.
- Salve os pesos que você entrega. Retreinar em outro processador gera pesos levemente diferentes, portanto guarde o código e as configurações que os geraram, e também as saídas da biblioteca para algumas entradas, como faz o script de treinamento deste capítulo.
- A camada de saída domina. Calcular a pontuação de cada token do vocabulário a cada passo representa a maior parte do cálculo e dos parâmetros. Um vocabulário maior encarece primeiro esta parte.
- Texto de treinamento incompatível prejudica. Acrescentar texto diferente do alvo, como as descrições foram para os nomes, piora as previsões enquanto a perda de treinamento parece boa. Meça no texto-alvo após cada mudança nos dados de treinamento.
- As médias escondem contextos raros. Um modelo pode ter boa pontuação no conjunto todo e, ainda assim, falhar nos prefixos incomuns que os compradores digitam quando procuram algo novo. Avalie os contextos vistos e os não vistos separadamente, como fez este capítulo, e acompanhe de perto os não vistos.
- Uma mistura exige os dois modelos na hora de servir. Combinar uma rede com contagens dobra o que precisa ser carregado e mantido atualizado. Reconstrua as contagens sempre que você retreinar a rede, para que os dois descrevam o mesmo texto.
O que este capítulo decidiu
- Os modelos neurais do livro são treinados em PyTorch, uma única vez, em
recordings/, e os exemplos recalculam esses modelos em NumPy a partir dos pesos salvos. A passagem direta em NumPy reproduz os logits do PyTorch com quatro casas decimais, então os exemplos não precisam de PyTorch. - Os modelos mantêm os pesos da melhor época de validação. A perplexidade de validação do modelo de janela foi mais baixa após a época 5 e subiu a cada época seguinte, enquanto a perplexidade de treinamento continuou caindo: o modelo estava memorizando os nomes de treinamento.
- Nos nomes da loja, o modelo de janela perde para o baseline de 4-gramas sozinho, tanto em contextos vistos quanto em não vistos, e o vence quando os dois são misturados. Uma participação da rede de 0.2 resulta em 21.9, a melhor marca dos modelos do livro até aqui.
- Os modelos aprendidos são comparados com o baseline separadamente em contextos vistos e não vistos, e não apenas na média, porque as duas partes podem contar histórias diferentes. Aqui a rede perdeu nas duas, e por uma margem maior nos contextos não vistos.
- O texto de treinamento deve se parecer com o texto-alvo. Acrescentar as descrições piorou o modelo nos nomes, embora nomes e descrições juntos somassem cerca de oito vezes mais tokens que os nomes sozinhos; por isso, o texto de treinamento de cada modelo é escolhido em função do texto em que ele será avaliado.
- Como os nomes são curtos, a partir do capítulo 8 o livro também avalia os modelos nas descrições da loja.
Este capítulo, nesta edição
Edição 2026.11.16Exemplos aprovados em 19 de nov de 202610 de 10 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.16.