Treinando um modelo pequeno
Cerca de 27 minutos min de leitura, com 7 exemplos em 10 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
- Transforme produtos em lotes
- Atualização com AdamW e gradientes recortados
- Aquecimento e depois decaimento do tamanho do passo
- Leia a curva de treinamento
- Compare com a linha de base nos nomes
- Compare nas descrições
- O que a largura, os dados e os passos trazem
- Sugerir a próxima palavra na caixa de busca
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você será capaz de treinar um pequeno transformer do início ao fim e avaliar o resultado. Você vai transformar textos em lotes, atualizar os pesos com AdamW, definir o cronograma do tamanho do passo, ler a curva de treinamento, medir o modelo de forma justa em comparação com a linha de base por contagem, descobrir o que mais largura, mais texto e mais treinamento proporcionam nessa escala, e identificar onde o modelo supera a contagem e onde ele precisa dela ao seu lado.
O capítulo 7 montou o modelo da loja e usou seus pesos treinados para verificar cada parte. Este capítulo pergunta de onde vieram esses pesos: de uma única execução de treinamento, registrada em recordings/transformer.py. Essa execução ensinou o modelo a prever cada próximo token do catálogo da loja: os nomes e as descrições dos móveis e artigos para casa que ela vende online. Em seguida, o capítulo mede o modelo nas duas tarefas para as quais ele foi feito: sugerir a próxima palavra de um nome de produto na caixa de busca, e prever descrições, nas quais os textos são longos o bastante para que o contexto distante importe.
Como no capítulo 5, o treinamento foi executado uma vez, em PyTorch. Os exemplos leem o que ele salvou: os pesos, as curvas e as configurações, registrados no manifesto da execução. Para treinar você mesmo, instale recordings/requirements.txt em um ambiente próprio, o que adiciona a versão CPU do PyTorch, e execute python recordings/transformer.py a partir da pasta do livro: ele grava os mesmos arquivos em examples/data/recorded/transformer/, e roda no processador de um laptop.
Transforme produtos em lotes
O treinamento começa convertendo o catálogo da loja em números dos quais o modelo pode aprender. Cada produto vira um texto: o marcador de início, o nome, o separador <sep>, a descrição e o marcador de fim, tokenizados pelo tokenizador da loja. Um texto mais longo que o limite do modelo é cortado. Cada passo de treinamento recebe um lote de textos de uma vez, para que as contas rodem sobre matrizes inteiras, e os textos de tamanhos diferentes são completados até o mais longo do lote com um token de preenchimento.
Cada texto então dá ao modelo uma previsão por posição. As entradas são os tokens de um texto sem o último, e os alvos são os tokens do texto sem o primeiro, de modo que a posição i é treinada para prever o token i + 1. Graças à máscara causal, uma única passagem direta faz todas essas previsões de uma vez. A perda é calculada como média sobre os alvos que não são preenchimento: o preenchimento custa computação, mas não ensina nada.
O preenchimento é o custo a vigiar, então monte os lotes de uma época embaralhada como o script de treinamento faz, e conte quanto de cada lote é preenchimento:
1"""Builds one shuffled epoch of batches the way the training script does, and measures the padding in them.2The prose's point rests on the share of targets that are padding over that epoch."""3import math45import numpy as np67from lib import transformer8from lib.products import product_texts910_, vocabulary, manifest = transformer.load()11settings = manifest["settings"]12pad, end = vocabulary.index(transformer.PAD), vocabulary.index(transformer.END)13texts = [ids for ids, _ in product_texts("train")]14size = settings["batch"]1516order = np.random.default_rng(settings["seed"]).permutation(len(texts)) # one shuffled epoch, from the run's seed, so it repeats17padding, targets_seen, shares = 0, 0, []18for start in range(0, len(texts), size):19 batch = [texts[i] for i in order[start:start + size]] # this step's texts: the next `size` in the shuffled order20 longest = max(len(ids) for ids in batch)21 padded = np.array([ids + [pad] * (longest - len(ids)) for ids in batch]) # short texts filled out with <pad>22 inputs, targets = padded[:, :-1], padded[:, 1:] # each position predicts the next token23 padding, targets_seen = padding + (targets == pad).sum(), targets_seen + targets.size24 shares.append((targets == pad).mean())25 if start == 0:26 first_shape = (inputs.shape, targets.shape)2728print("training texts:", f"{len(texts):,}")29print("tokens in them:", f"{sum(len(ids) for ids in texts):,}")30print(f"texts cut at the length limit, {settings['longest']} tokens:", f"{np.mean([ids[-1] != end for ids in texts]):.1%}") # a cut text lost its end marker31print("texts per batch:", size)32print("one batch's inputs and targets:", *first_shape)33print("share of targets that are padding, over one shuffled epoch:", f"{padding / targets_seen:.0%}")34print("least and most padding in a batch:", f"{min(shares):.0%} and {max(shares):.0%}")35print("steps per epoch:", f"{math.ceil(len(texts) / size):,}") # the last, partly filled batch is a step too36print("epochs in the recorded run:", settings["epochs"])37print("steps in the recorded run:", f"{manifest['steps']:,}")
python training-batches.pytraining texts: 34,252
tokens in them: 2,843,222
texts cut at the length limit, 160 tokens: 1.0%
texts per batch: 32
one batch's inputs and targets: (32, 151) (32, 151)
share of targets that are padding, over one shuffled epoch: 46%
least and most padding in a batch: 30% and 59%
steps per epoch: 1,071
epochs in the recorded run: 16
steps in the recorded run: 17,136
O conjunto de treinamento tem 34,252 textos e 2,843,222 tokens. Essa contagem inclui os marcadores de início, separador e fim de cada texto, que a contagem do capítulo 4 de 2,744,320 tokens deixa de fora, e exclui o que o limite de comprimento corta; apenas 1.0% dos textos são cortados.
Cada lote tem 32 textos, então uma passagem por todos os textos de treinamento, uma época, leva 1,071 passos, e a execução registrada levou 17,136 passos ao longo de 16 épocas.
Ao longo de uma época embaralhada, 46% dos alvos são preenchimento, entre 30% and 59% conforme o lote, porque uma descrição longa define a largura de todos os textos mais curtos ao lado dela. Cada lote é um retângulo: uma linha por texto, uma coluna por posição.
Preenchimento nessa escala é desperdício: quase metade de cada passagem direta calcula previsões que a perda depois ignora. Isso não muda o que o modelo aprende, já que o preenchimento nunca conta, mas quase dobra o custo de cada passo. Krell e colegas encontraram preenchimento de até metade de todos os tokens em conjuntos de dados comuns, e propuseram o empacotamento, em que vários textos são colocados em sequência em cada linha, com a atenção impedida de cruzar de um para outro (Krell et al., 2021). Colocar textos de comprimento semelhante no mesmo lote também reduz o preenchimento.
Regra prática: Monte os lotes como entradas e alvos deslocados, retire o preenchimento da perda e embaralhe os textos a cada época com uma semente fixa, para que a execução possa ser repetida. Meça a proporção de preenchimento nos seus lotes; se for grande, empacote os textos ou agrupe-os por comprimento antes de comprar uma máquina maior.
Atualização com AdamW e gradientes recortados
Com os lotes em mãos, cada passo é o laço do capítulo 5: passagem direta, perda, gradientes, atualização. Estas linhas de recordings/transformer.py são o conjunto completo, executado uma vez por lote:
ids = pad([train[i] for i in order[start:start + SETTINGS["batch"]]])
logits = model(ids[:, :-1])
loss = torch.nn.functional.cross_entropy(logits.transpose(1, 2), ids[:, 1:], ignore_index=index[PAD])
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
scheduler.step()
As três primeiras linhas são da seção anterior: um lote com preenchimento, entradas sem o último token e uma perda sobre os alvos deslocados que ignora o preenchimento. Duas linhas diferem do capítulo 5.
O otimizador é o AdamW, o Adam do capítulo 5 com decaimento de peso aplicado separadamente do gradiente. O decaimento de peso reduz cada peso a cada passo na proporção de seu valor, multiplicado pelo tamanho do passo e por um fator de decaimento, aqui 0.1 (AdamW do PyTorch). Loshchilov e Hutter mostraram que aplicar o decaimento dessa forma funciona melhor com Adam do que somá-lo à perda (Loshchilov e Hutter, 2019). O decaimento é uma forma de regularização, que o modelo de janela do capítulo 5 não tinha: ele puxa todos os pesos em direção a zero, de modo que um peso só permanece grande enquanto o texto de treinamento continuar empurrando-o nessa direção.
O script de treinamento também recorta os gradientes: quando o comprimento combinado deles, medido como se todos os gradientes formassem um único vetor longo, ultrapassa 1.0, todos são reduzidos proporcionalmente até esse comprimento (clip_grad_norm_ do PyTorch). Assim, um lote incomum não consegue desviar os pesos para longe. Pascanu e colaboradores propuseram o recorte exatamente para isso: gradientes raros e muito grandes que, de outro modo, desfariam boa parte do que o treinamento havia aprendido (Pascanu et al., 2013).
Regra prática: Use AdamW com um decaimento de peso moderado e recorte os gradientes pelo comprimento combinado. Mantenha o passo de treinamento curto o bastante para ser lido por inteiro, de modo que cada escolha nele fique visível: o que a perda ignora, o que o otimizador decai e o que é recortado.
Aquecimento e depois decaimento do tamanho do passo
A última linha do laço, scheduler.step(), altera o tamanho do passo após cada lote, seguindo um programação, que define o tamanho do passo para cada etapa da execução. Pelas primeiras 200 etapas, o tamanho do passo sobe em linha reta, de quase zero até seu pico, 0.003: um aquecimento, como fazia o cronograma do artigo do transformer (Vaswani et al., 2017, seção 5.3). Nos primeiros passos do Adam, sua média móvel dos gradientes quadrados se apoia em apenas alguns lotes, de modo que seus tamanhos de passo variam muito; Liu e colaboradores mostraram que o aquecimento funciona ao reduzir essa variância (Liu et al., 2020). Após o aquecimento, o tamanho do passo cai ao longo de meia curva cossenoidal, até um décimo do pico na última etapa (Loshchilov and Hutter, 2017). Passos grandes no início percorrem terreno; passos pequenos no fim permitem que os pesos se acomodem em um ponto baixo, em vez de oscilar em torno dele. Em símbolos, após o aquecimento:
taxa = pico × (0.1 + 0.9 × ½ (1 + cos(π × progresso)))
onde o progresso vai de 0 no fim do aquecimento até 1 na última etapa.
É possível verificar se o cronograma corresponde ao da execução: calcule-o à mão a partir das configurações registradas e compare-o com os tamanhos de passo que o script de treinamento salvou a cada dez etapas:
1"""Computes the warm-up and cosine schedule by hand from the recorded settings, and checks it against the step sizes2the training script saved. The prose relies on the check: the assert fails the run if the two ever differ."""3import json4import math56from lib import transformer78_, _, manifest = transformer.load()9settings, total = manifest["settings"], manifest["steps"]10recorded_rates = json.loads((transformer.RECORDED / "curves.json").read_text())["rates"] # every 10th step's, after the scheduler's step111213def rate(step):14 """Warm up linearly to the peak, then follow half a cosine down to a tenth of it."""15 if step < settings["warmup_steps"]:16 return settings["peak_rate"] * (step + 1) / settings["warmup_steps"] # steps count from 0, so step 0 is already a share of the peak17 progress = (step - settings["warmup_steps"]) / (total - settings["warmup_steps"]) # 0 at the warm-up's end, 1 at the last step18 return settings["peak_rate"] * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * progress)))192021print("warm-up steps:", settings["warmup_steps"])22print("peak step size:", settings["peak_rate"])23print("weight decay:", settings["weight_decay"])24for step in [0, settings["warmup_steps"] // 2, settings["warmup_steps"], total // 2, total - 1]:25 print(f"step size at step {step:,}:", f"{rate(step):.2e}")26gap = max(abs(recorded - rate(10 * i + 1)) for i, recorded in enumerate(recorded_rates)) # recorded_rates[i] was saved after step 10 * i, so it is the size used at step 10 * i + 127assert gap < 1e-9 # every saved step size matches the hand calculation, to a billionth28print("same as the recorded step sizes:", "yes")
python learning-rate-schedule.pywarm-up steps: 200
peak step size: 0.003
weight decay: 0.1
step size at step 0: 1.50e-05
step size at step 100: 1.51e-03
step size at step 200: 3.00e-03
step size at step 8,568: 1.68e-03
step size at step 17,135: 3.00e-04
same as the recorded step sizes: yes
O cálculo à mão corresponde a todos os tamanhos de passo salvos. O tamanho do passo começa em 1.50e-05, atinge o pico em 3.00e-03 no fim do aquecimento e vale 3.00e-04 na última etapa, um décimo desse pico.
O decaimento importa. A execução de comparação treinou por quatro épocas na mesma largura, com a mesma semente e os mesmos lotes, de modo que seu cronograma terminou o decaimento na etapa 4,284, e nessa etapa obteve 27.6 de perplexidade nos nomes de validação. A execução registrada ainda estava perto do pico de tamanho de passo nessa etapa e obteve 32.6. Mesmos dados, mesmas etapas: a diferença é o decaimento.
Regra prática: Aqueça o tamanho do passo nas primeiras centenas de etapas e depois faça-o decair, ajustando a duração do cronograma à da execução. Salve o tamanho do passo enquanto o treinamento avança, como faz o script de treinamento, e confira-o com o cronograma que você pretendia: um erro no cronograma parece um problema de treinamento, e é muito mais fácil de encontrar dessa forma.
Leia a curva de treinamento
Com seus lotes, atualizações e cronograma definidos, o modelo da loja foi treinado por 16 épocas, e o script o mediu na divisão de validação após cada uma, em nomes e em descrições separadamente. Ele manteve os pesos da época com a menor perda de validação em nomes e descrições somadas, como o capítulo 5 manteve sua melhor época.
Lidas como perplexidade por token, as curvas registradas, época a época, têm este aspecto:
1"""Prints the recorded run's perplexity for each epoch, then the epoch kept and its validation perplexities.2The prose's point rests on the two validation columns and the epoch kept."""3import json4import math56from lib import transformer78_, _, manifest = transformer.load()9curves = json.loads((transformer.RECORDED / "curves.json").read_text())["epochs"]1011print("perplexity per token; training mixes names and descriptions, as the training text does")12print("epoch training validation names validation descriptions")13for curve in curves:14 print(f"{curve['epoch']:>5} {math.exp(curve['train_loss']):>8.1f} {math.exp(curve['validation_name_loss']):>16.1f}"15 f" {math.exp(curve['validation_description_loss']):>23.1f}")16kept = next(curve for curve in curves if curve["epoch"] == manifest["kept_epoch"]) # the epoch whose weights were kept17print("epoch kept, the lowest name and description losses added together:", manifest["kept_epoch"])18print("validation perplexity on names, kept epoch:", f"{math.exp(kept['validation_name_loss']):.1f}")19print("validation perplexity on descriptions, kept epoch:", f"{math.exp(kept['validation_description_loss']):.1f}")20print("validation perplexity on names, epoch 4:", f"{math.exp(curves[3]['validation_name_loss']):.1f}") # the list starts at epoch 1, so index 3 is epoch 4
python transformer-training-curve.pyperplexity per token; training mixes names and descriptions, as the training text does
epoch training validation names validation descriptions
1 131.4 50.5 50.4
2 41.4 38.8 36.2
3 32.8 34.5 31.5
4 29.0 32.6 29.3
5 26.6 30.9 27.8
6 24.8 30.2 26.4
7 23.3 28.9 25.0
8 21.8 28.1 23.9
9 20.5 27.1 22.9
10 19.2 26.5 22.2
11 17.9 25.8 21.6
12 16.8 25.1 20.8
13 15.8 24.6 20.4
14 14.9 24.2 20.0
15 14.2 24.0 19.9
16 13.8 24.1 19.9
epoch kept, the lowest name and description losses added together: 15
validation perplexity on names, kept epoch: 24.0
validation perplexity on descriptions, kept epoch: 19.9
validation perplexity on names, epoch 4: 32.6
A perplexidade de validação cai até a época 15, a época mantida, e depois se estabiliza: a última época não é melhor. Na época mantida, ela é 24.0 em nomes e 19.9 em descrições. Como no capítulo 5, a perplexidade de treinamento da época 1 está acima da de validação, porque ela é uma média sobre os primeiros lotes da época, quando o modelo não sabia nada. A coluna de treinamento mistura nomes e descrições, como o texto de treinamento, então ela mostra a tendência, não um número para comparar com nenhuma das colunas de validação.
O modelo de janela do capítulo 5 parou de melhorar após a época 5; este modelo continuou melhorando por muito mais tempo. As duas execuções diferem em vários aspectos que poderiam explicar isso. Este modelo aprendeu com nomes e descrições, 2,843,222 tokens, contra os 337,071 tokens de treinamento do modelo de janela, apenas de nomes; seu tamanho de passo diminui; ele tem decaimento de peso; e a atenção aplica os mesmos pesos em todas as posições. A execução não separa esses motivos. O que ela mostra é a diferença entre treinamento e validação, que cresce a cada época: ao final, o modelo prevê seus textos de treinamento muito melhor do que textos novos, então está começando a memorizar.
As descrições têm pontuação menor que os nomes, mas isso não significa que o modelo seja melhor em descrições. Cada tipo de texto tem sua própria previsibilidade: descrições repetem frases de seus gabaritos e de seus nomes, e nomes condensam um produto novo em poucas palavras. Perplexidades comparam modelos sobre o mesmo texto, nunca textos entre si.
Regra prática: Registre a perda de validação por época em cada tipo de texto que importa para você, e mantenha os pesos da melhor época. Leia a diferença entre treinamento e validação como o alerta, não apenas a perda de treinamento isolada. Nunca compare perplexidades entre tipos de texto diferentes.
Compare com a linha de base nos nomes
Com a leitura do treinamento concluída, o resultado pode ser medido. O modelo de contagem mais forte para nomes é a linha de base de 4-gramas treinada nos nomes de treinamento. Ele obtém 23.1 nos nomes de validação, a medida de referência do livro: todo modelo desde o capítulo 3 foi avaliado neles. O mesmo 4-grama treinado em textos inteiros, nomes e descrições, obtém 27.7 neles, porque as descrições diluem suas contagens de como os nomes se organizam.
A comparação precisa contar as mesmas previsões. O 4-grama prevê os tokens de cada nome e depois seu marcador de fim; o transformador prevê os tokens de cada nome e depois <sep>, que desempenha o mesmo papel, pois marca onde o nome termina. Um nome não precisa de nada depois dele, então o transformador lê apenas o nome. Os dois modelos pontuam as mesmas 46,704 previsões.
Faça uma suposição primeiro: o transformador sozinho consegue superar a linha de base por contagem que o modelo de janela do capítulo 5 não conseguiu? Depois, avalie os dois modelos e também misturas entre eles, do modo como o capítulo 5 fez:
1"""Scores every validation name, its end included, with the 4-gram baseline and with the transformer, then mixes them2at several shares. The prose's point rests on the share 0.5 line, the lowest of the five."""3import numpy as np45from lib import transformer6from lib.names import name_tokens7from lib.ngrams import KneserNey, ngrams, padded89_, vocabulary, _ = transformer.load()10index = {token: i for i, token in enumerate(vocabulary)} # each token's id in the vocabulary, which is its column in the model's output11counted = KneserNey(name_tokens("train"), 4) # chapter 3's baseline, trained on names12from_counts, from_transformer = [], []13for name in name_tokens("validation"):14 ids = [index[transformer.START]] + [index[token] for token in name] + [index[transformer.SEP]] # the name as the model reads it15 probabilities = transformer.softmax(transformer.forward(ids)[:-1]) # the last position predicts past <sep>, which a name never needs16 from_transformer += list(probabilities[np.arange(len(ids) - 1), ids[1:]]) # each position's probability for the token after it17 from_counts += [counted.probability(context, token) for context, token in ngrams(padded(name, 4), 4)] # then </s>18from_counts, from_transformer = np.array(from_counts), np.array(from_transformer)1920print("validation tokens scored, each name's end included:", f"{len(from_counts):,}")21for share in [0.0, 0.3, 0.5, 0.7, 1.0]:22 mixed = (1 - share) * from_counts + share * from_transformer23 print(f"validation perplexity on names, transformer share {share:.1f}:", f"{np.exp(-np.log(mixed).mean()):.1f}")
python transformer-on-names.pyvalidation tokens scored, each name's end included: 46,704
validation perplexity on names, transformer share 0.0: 23.1
validation perplexity on names, transformer share 0.3: 18.7
validation perplexity on names, transformer share 0.5: 18.4
validation perplexity on names, transformer share 0.7: 18.8
validation perplexity on names, transformer share 1.0: 24.0
Misturados em partes iguais, o transformador e as contagens obtêm 18.4 nos nomes, o melhor resultado de qualquer modelo deste livro nos nomes. Sozinho, o transformador obtém 24.0, um pouco pior que os 23.1 da linha de base.
O transformador sozinho é muito melhor que o modelo de janela do capítulo 5, que obteve 36.4, e a mistura supera a melhor mistura do capítulo 5, 21.9.
Assim, nos nomes, a contagem ainda é difícil de superar sozinha, pelo motivo apresentado no capítulo 5: nomes são curtos e formulaicos, e três tokens de contexto captam a maior parte do que um nome contém. Mas o transformador erra em lugares diferentes dos das contagens, e a mistura ganha com ambos. A proporção foi escolhida nos nomes de validação, então o ganho é levemente otimista; os nomes de teste permanecem intocados para a comparação final do livro.
Regra prática: Compare um modelo novo com a linha de base mais forte que você conseguir construir, sobre exatamente as mesmas previsões, incluindo a forma como cada um marca o fim de um texto. Quando um modelo aprendido e um modelo de contagem estiverem próximos, misture-os e escolha a proporção em texto não usado no treinamento.
Compare nas descrições
A comparação de nomes favorece a contagem, porque os nomes são curtos. As descrições são muitas vezes mais longas, e o capítulo 6 mostrou o modelo copiando do nome, muitos tokens atrás, então é aqui que o seu alcance maior deve compensar. Uma base de comparação justa aqui é um 4-gram treinado sobre os mesmos textos dos quais o transformer aprendeu, isto é, o nome, <sep> e a descrição unidos, e avaliado sobre os mesmos tokens: os tokens de cada descrição e o seu fim, com o mesmo texto antes deles.
Teste o alcance maior nas descrições: ajuste o 4-gram a todos os textos de treino e depois avalie-o, bem como o transformer e uma mistura igual nas descrições dos primeiros 500 produtos de validação, deixando de fora os textos cortados no limite de comprimento e os produtos sem descrição. Ela também separa os tokens, como o capítulo 5 fez, conforme o seu contexto de três tokens ocorra ou não nos textos de treino:
1"""Scores the descriptions of the first 500 validation products with a 4-gram trained on whole texts, with the transformer,2and with their even mix, then splits the tokens by whether their context was seen in training. The prose's point rests on the34-gram baseline and transformer lines, the half-and-half line and the unseen-context lines."""4import numpy as np56from lib import transformer7from lib.names import name_tokens8from lib.ngrams import KneserNey, ngrams, padded9from lib.products import product_texts1011_, vocabulary, _ = transformer.load()12end = vocabulary.index(transformer.END)13as_tokens = lambda ids: [vocabulary[i] for i in ids[1:] if i != end] # padded() adds its own <s> and </s>14counted = KneserNey([as_tokens(ids) for ids, _ in product_texts("train")], 4) # whole texts: name, <sep>, description1516from_counts, from_transformer, seen, products = [], [], [], 017for ids, sep in product_texts("validation", 500):18 if ids[-1] != end or sep == len(ids) - 2:19 continue # cut at the length limit, or no description20 pairs = list(ngrams(padded(as_tokens(ids), 4), 4))[sep:] # from <sep> on: the description's tokens, then </s>21 from_counts += [counted.probability(context, token) for context, token in pairs]22 seen += [context in counted.totals[4] for context, _ in pairs] # was this 3-token context in the training texts?23 probabilities = transformer.softmax(transformer.forward(ids)[sep:-1]) # from <sep> on: each position predicts the next token24 from_transformer += list(probabilities[np.arange(len(probabilities)), ids[sep + 1:]]) # the description starts after <sep>, at sep + 125 products += 126from_counts, from_transformer, seen = np.array(from_counts), np.array(from_transformer), np.array(seen)27perplexity = lambda p: f"{np.exp(-np.log(p).mean()):.1f}"2829print("products scored:", products)30print("description tokens scored:", f"{len(from_counts):,}")31mixed = (from_counts + from_transformer) / 232for label, p in [("4-gram baseline", from_counts), ("transformer", from_transformer), ("half and half", mixed)]:33 print(f"{label}, validation perplexity on descriptions:", perplexity(p))34print("description tokens whose 3-token context is in the training texts:", f"{seen.mean():.0%}")35for part, where in [("seen", seen), ("unseen", ~seen)]:36 print(f"4-gram, {part} contexts:", perplexity(from_counts[where]))37 print(f"transformer, {part} contexts:", perplexity(from_transformer[where]))3839names = [list(ngrams(padded(name + [transformer.SEP], 4), 4))[:-1] for name in name_tokens("validation")] # to <sep>: the last pair predicts </s>, which a name stops short of40on_names = [counted.probability(context, token) for pairs in names for context, token in pairs]41print("this 4-gram, trained on whole texts, validation perplexity on names:", perplexity(np.array(on_names)))
python transformer-on-descriptions.pyproducts scored: 446
description tokens scored: 35,651
4-gram baseline, validation perplexity on descriptions: 22.5
transformer, validation perplexity on descriptions: 20.1
half and half, validation perplexity on descriptions: 14.7
description tokens whose 3-token context is in the training texts: 74%
4-gram, seen contexts: 16.3
transformer, seen contexts: 16.6
4-gram, unseen contexts: 57.6
transformer, unseen contexts: 35.0
this 4-gram, trained on whole texts, validation perplexity on names: 27.7
Nas descrições, o transformer supera a contagem isolada: ele obtém 20.1 nos 35,651 tokens de descrição de 446 produtos, contra 22.5 do 4-gram. É o primeiro modelo aprendido deste livro que supera, por conta própria, um modelo contado sobre o mesmo texto.
A divisão mostra onde eles diferem. 74% dos tokens têm um contexto que os textos de treino contêm, e nesses os dois modelos empatam: 16.3 para o 4-gram, 16.6 para o transformer. No restante, o transformer obtém 35.0, onde o 4-gram obtém 57.6. As descrições são suficientemente padronizadas para que as contagens se saiam tão bem quanto o transformer sempre que já viram o contexto; onde não viram, o transformer lê mais para trás e relaciona o que vê ao que aprendeu, enquanto as contagens só podem recuar.
É também por isso que a mistura funciona tão bem. Metade e metade, os dois obtêm 14.7, muito abaixo de qualquer um isoladamente: em qualquer token, pelo menos um dos dois costuma estar confiante e certo, e a mistura igual mantém metade dessa probabilidade, o suficiente para evitar as piores surpresas de cada um.
Regra prática: Meça um modelo sobre o tipo de texto que ele vai prever, contra uma base que veja o mesmo texto, e espere que a ordem mude de um tipo de texto para outro. Divida a comparação entre contextos vistos e não vistos para ver onde cada modelo vence. Experimente uma mistura antes de concluir que algum dos modelos basta: a mistura ganhou mais do que qualquer mudança em um dos modelos que este capítulo mediu.
O que a largura, os dados e os passos trazem
O modelo registrado é uma escolha entre muitas: 128 números de largura, treinado com todo o texto de treinamento por 16 épocas. Estudos de modelos muito maiores constataram que a perda cai de forma suave à medida que os modelos crescem, veem mais texto e treinam por mais tempo, e que modelos maiores aprendem mais com cada token que veem (Kaplan et al., 2020). Para um orçamento fixo de computação, Hoffmann e colaboradores constataram que o tamanho do modelo e o texto de treinamento devem crescer juntos (Hoffmann et al., 2022). E Muennighoff e colaboradores constataram que repetir o mesmo texto por até cerca de quatro épocas rende quase tanto quanto texto novo, com menos ganho a cada repetição adicional (Muennighoff et al., 2023). Se algo disso vale nesta escala de brinquedo é algo a medir, não a presumir.
Assim, o script de treinamento registrou sete execuções mais baratas ao lado da principal, cada uma alterando uma coisa:
- três larguras, 64, 128 e 256, cada uma treinada por quatro épocas, com cada cabeça mantida com 32 números de largura;
- quartos e metades aleatórios dos produtos de treinamento, cada um treinado por quatro épocas;
- o mesmo quarto e a mesma metade treinados por tantos passos quanto as quatro épocas de todos os dados, repetindo-os com mais frequência.
Qual mudança rende mais? Leia as oito execuções lado a lado, com o tamanho, os passos e as perplexidades de cada uma em suas melhores e últimas épocas:
1"""Reads eight recorded runs and prints each one's parameters, steps, best epoch, and validation perplexities at its best2and last epochs. The prose's point rests on the perplexity-on-names lines."""3import json4import math56from lib import transformer78runs = [("width 64, 4 epochs", "transformer-width-64"), ("width 128, 4 epochs", "transformer-width-128"),9 ("width 256, 4 epochs", "transformer-width-256"), ("width 128, 16 epochs", "transformer"),10 ("a quarter of the data, 4 epochs", "transformer-data-25"), ("half the data, 4 epochs", "transformer-data-50"),11 ("a quarter of the data, 16 epochs", "transformer-data-25-same-steps"),12 ("half the data, 8 epochs", "transformer-data-50-same-steps")]1314for label, folder in runs:15 run = transformer.RECORDED.parent / folder # every run sits in the folder beside the main run's16 manifest = json.loads((run / "manifest.json").read_text())17 curves = json.loads((run / "curves.json").read_text())["epochs"]18 best = min(curves, key=lambda curve: curve["validation_name_loss"] + curve["validation_description_loss"]) # the epoch the script kept19 print(f"{label}, parameters:", f"{manifest['parameters']:,}")20 print(f"{label}, steps:", f"{manifest['steps']:,}")21 print(f"{label}, best epoch:", best["epoch"])22 print(f"{label}, perplexity on names:", f"{math.exp(best['validation_name_loss']):.1f}")23 print(f"{label}, perplexity on descriptions:", f"{math.exp(best['validation_description_loss']):.1f}")24 print(f"{label}, perplexity on names, last epoch:", f"{math.exp(curves[-1]['validation_name_loss']):.1f}") # the last epoch trained, not the one kept25 print(f"{label}, perplexity on descriptions, last epoch:", f"{math.exp(curves[-1]['validation_description_loss']):.1f}")
python width-data-and-steps.pywidth 64, 4 epochs, parameters: 478,656
width 64, 4 epochs, steps: 4,284
width 64, 4 epochs, best epoch: 4
width 64, 4 epochs, perplexity on names: 36.9
width 64, 4 epochs, perplexity on descriptions: 35.9
width 64, 4 epochs, perplexity on names, last epoch: 36.9
width 64, 4 epochs, perplexity on descriptions, last epoch: 35.9
width 128, 4 epochs, parameters: 1,334,144
width 128, 4 epochs, steps: 4,284
width 128, 4 epochs, best epoch: 4
width 128, 4 epochs, perplexity on names: 27.6
width 128, 4 epochs, perplexity on descriptions: 24.7
width 128, 4 epochs, perplexity on names, last epoch: 27.6
width 128, 4 epochs, perplexity on descriptions, last epoch: 24.7
width 256, 4 epochs, parameters: 4,273,920
width 256, 4 epochs, steps: 4,284
width 256, 4 epochs, best epoch: 4
width 256, 4 epochs, perplexity on names: 23.5
width 256, 4 epochs, perplexity on descriptions: 19.5
width 256, 4 epochs, perplexity on names, last epoch: 23.5
width 256, 4 epochs, perplexity on descriptions, last epoch: 19.5
width 128, 16 epochs, parameters: 1,334,144
width 128, 16 epochs, steps: 17,136
width 128, 16 epochs, best epoch: 15
width 128, 16 epochs, perplexity on names: 24.0
width 128, 16 epochs, perplexity on descriptions: 19.9
width 128, 16 epochs, perplexity on names, last epoch: 24.1
width 128, 16 epochs, perplexity on descriptions, last epoch: 19.9
a quarter of the data, 4 epochs, parameters: 1,334,144
a quarter of the data, 4 epochs, steps: 1,072
a quarter of the data, 4 epochs, best epoch: 4
a quarter of the data, 4 epochs, perplexity on names: 51.9
a quarter of the data, 4 epochs, perplexity on descriptions: 54.1
a quarter of the data, 4 epochs, perplexity on names, last epoch: 51.9
a quarter of the data, 4 epochs, perplexity on descriptions, last epoch: 54.1
half the data, 4 epochs, parameters: 1,334,144
half the data, 4 epochs, steps: 2,144
half the data, 4 epochs, best epoch: 4
half the data, 4 epochs, perplexity on names: 35.2
half the data, 4 epochs, perplexity on descriptions: 34.8
half the data, 4 epochs, perplexity on names, last epoch: 35.2
half the data, 4 epochs, perplexity on descriptions, last epoch: 34.8
a quarter of the data, 16 epochs, parameters: 1,334,144
a quarter of the data, 16 epochs, steps: 4,288
a quarter of the data, 16 epochs, best epoch: 11
a quarter of the data, 16 epochs, perplexity on names: 40.0
a quarter of the data, 16 epochs, perplexity on descriptions: 39.6
a quarter of the data, 16 epochs, perplexity on names, last epoch: 44.1
a quarter of the data, 16 epochs, perplexity on descriptions, last epoch: 45.9
half the data, 8 epochs, parameters: 1,334,144
half the data, 8 epochs, steps: 4,288
half the data, 8 epochs, best epoch: 8
half the data, 8 epochs, perplexity on names: 30.4
half the data, 8 epochs, perplexity on descriptions: 28.6
half the data, 8 epochs, perplexity on names, last epoch: 30.4
half the data, 8 epochs, perplexity on descriptions, last epoch: 28.6
Largura ajuda muito, mas tem um preço. Com os mesmos passos, a perplexidade nos nomes cai de 36.9 na largura 64 para 27.6 na 128 e 23.5 na 256. Nos nomes, o modelo mais largo, treinado por quatro épocas, chega a superar o modelo registrado treinado por dezesseis épocas, 24.0. Mas a largura 256 tem 4,273,920 parâmetros contra 1,334,144 na largura 128, e cada passo custa cerca de isso a mais.
Texto novo ajuda sem custo extra por passo. Com os mesmos passos, um quarto aleatório dos produtos atinge 40.0 nos nomes em seu melhor momento, a metade 30.4, e todos eles 27.6. Dobrar o texto da metade para o total rendeu menos do que dobrar a largura de 128 para 256, mas não exigiu computação extra, e o primeiro dobramento, de um quarto para a metade, rendeu mais do que qualquer um dos dois.
A repetição ajuda por um tempo e depois prejudica. Um quarto do texto visto quatro vezes atinge 51.9; visto com mais frequência, ele melhora até a época 11, depois piora, terminando em 44.1 após dezesseis passagens: o modelo memoriza o que viu com frequência demais. O texto repetido nunca alcançou o texto novo com o mesmo número de passos.
Mais passos ajudam menos. As dezesseis épocas do modelo registrado melhoram sobre as quatro, 24.0 contra 27.6 nos nomes, por quatro vezes mais passos.
Essas execuções também mostram os limites da escala deste livro. O texto de treinamento da loja é fixo no que o seu catálogo contém, 2,843,222 tokens. O SmolLM2-360M, cujo projeto o capítulo 7 comparou com o modelo da loja, foi treinado com 4 trilhões de tokens (cartão do modelo), mais de um milhão de vezes isso, o que permite a um modelo de 960 números de largura e 32 camadas de profundidade continuar aprendendo com texto novo em vez de memorizar o antigo.
Regra prática: Obtenha mais texto do tipo que você vai prever antes de repetir o que tem mais de algumas vezes; ele não custa nada por passo. Com computação sobrando, experimente um modelo mais largo por menos épocas antes de treinar um estreito por mais tempo, e meça ambos. Altere uma coisa por execução e mantenha o número de passos fixo onde importa, ou a comparação medirá duas coisas ao mesmo tempo.
Sugerir a próxima palavra na caixa de busca
Médias dizem quão bom é um modelo; a caixa de busca mostra o que isso significa para o cliente. O 4-grama do capítulo 3 sugeriu & e with depois de outdoor bar, um contexto que nenhum nome de treinamento contém, e o modelo de janela do capítulo 5 sugeriu stool. Algumas descrições de treinamento contêm outdoor bar, e o transformer aprendeu com elas assim como com os nomes, enquanto o 4-grama aprendeu apenas com os nomes.
Um cliente veria os três tokens seguintes mais prováveis do transformer, e os da mistura meio a meio que a comparação entre nomes favoreceu, depois dos mesmos cinco prefixos, cada um tratado como o início de um nome. Uma sugestão de <sep> significa que o modelo espera que o nome termine ali:
1"""Asks the transformer and its half-and-half mix with the 4-gram for their three likeliest next tokens after five prefixes,2treated as the start of a name, and prints the probability of stool after outdoor bar. The prose's point rests on the3stool lines and the control prefixes beside them."""4import numpy as np56from lib import bpe, transformer7from lib.names import name_tokens8from lib.ngrams import KneserNey910_, vocabulary, _ = transformer.load()11index = {token: i for i, token in enumerate(vocabulary)}12counted = KneserNey(name_tokens("train"), 4)13tokenizer = bpe.store_tokenizer()14as_counted = [{transformer.SEP: "</s>"}.get(token, token) for token in vocabulary] # <sep> ends a name, as </s> does15show = lambda token: token.replace("</w>", "")1617for prefix in ["bar", "patio bar", "outdoor bar", "kitchen bar", "wine bar"]:18 tokens = tokenizer.encode(prefix)19 ids = [index[transformer.START]] + [index[token] for token in tokens]20 from_transformer = transformer.softmax(transformer.forward(ids)[-1])21 context = tuple(["<s>"] * 3 + tokens)[-3:] # the 4-gram looks at the last three tokens, padded with start markers for a short prefix22 from_counts = np.array([counted.probability(context, token) for token in as_counted])23 mixed = (from_transformer + from_counts) / 224 for label, p in [("transformer", from_transformer), ("half and half", mixed)]:25 top = np.argsort(-p, kind="stable")[:3] # the three likeliest; a stable sort keeps tied tokens in vocabulary order26 print(f"{prefix:<12} {label:<13} -> " + ", ".join(f"{show(vocabulary[i])} {p[i]:.2f}" for i in top))27 if prefix == "outdoor bar":28 stool = index["stool</w>"] # </w> marks the end of a word in the tokenizer, so this is the whole word stool29 print("P(stool | outdoor bar), transformer:", f"{from_transformer[stool]:.2f}")30 print("P(stool | outdoor bar), 4-gram:", f"{from_counts[stool]:.2f}")31 print("P(stool | outdoor bar), half and half:", f"{mixed[stool]:.2f}")
python transformer-autocomplete.pybar transformer -> with 0.17, & 0.14, and 0.09
bar half and half -> & 0.19, with 0.14, unit 0.07
patio bar transformer -> stool 0.51, table 0.25, set 0.02
patio bar half and half -> stool 0.69, table 0.13, & 0.01
outdoor bar transformer -> stool 0.50, with 0.05, table 0.04
outdoor bar half and half -> stool 0.28, & 0.12, with 0.12
P(stool | outdoor bar), transformer: 0.50
P(stool | outdoor bar), 4-gram: 0.06
P(stool | outdoor bar), half and half: 0.28
kitchen bar transformer -> room 0.14, with 0.08, cabinet 0.08
kitchen bar half and half -> with 0.14, & 0.12, room 0.07
wine bar transformer -> with 0.43, <sep> 0.22, cabinet 0.08
wine bar half and half -> with 0.30, <sep> 0.21, cabinet 0.13
Depois de outdoor bar, o transformer atribui a stool 0.50, enquanto o 4-grama atribui 0.06; a mistura, com 0.28, ainda a coloca em primeiro lugar. Os prefixos de controle mostram que os modelos não sugerem stool depois de todo bar: depois de kitchen bar e wine bar sugerem outras continuações, e depois de wine bar ambos esperam, com razão, que o nome possa já estar completo. Depois de patio bar, um contexto que os nomes contêm com frequência, a mistura tem mais confiança em stool do que o transformer sozinho.
Um prefixo é um exemplo, não uma medida. A medida é a comparação entre nomes, e nela a mistura venceu. Para a caixa de busca, esse é o modelo a ser servido.
Regra prática: Sirva a mistura para o autocompletar e teste-a em prefixos raros, além dos comuns, com prefixos de controle ao lado de cada um. Trate uma única sugestão marcante como uma ilustração de um ganho medido, nunca como a evidência dele.
O que dá errado em produção
O treinamento falha de maneiras que parecem normais enquanto acontecem:
- O preenchimento desperdiça computação. Quase metade das previsões de cada passo eram preenchimento neste caso. Empacote os textos, ou agrupe-os por comprimento, antes de comprar mais computação.
- Um bug no cronograma parece um problema do modelo. Como regra prática, um aquecimento que nunca termina, ou um decaimento que começa cedo demais, aparece como uma perda que cai devagar demais; a comparação de decaimento acima mostra o quanto um cronograma pode alterar o resultado. Salve o tamanho do passo e verifique-o em relação ao cronograma que você pretendia.
- Escolhas feitas com dados de validação inflam o resultado. A época mantida e a proporção de mistura foram ambas escolhidas na divisão de validação, por isso os números dela são levemente otimistas. Mantenha uma divisão de teste intocada até o final.
- Texto repetido acaba memorizado. Um conjunto de dados pequeno visto muitas vezes parece bom na perda de treinamento e ruim em textos novos. Conte quantas vezes o treinamento vê cada texto, e prefira textos novos a mais épocas.
- Um modelo é medido em apenas um tipo de texto. O transformer ficou em segundo lugar atrás das contagens em nomes e em primeiro em descrições. Avalie todos os modelos em cada tipo de texto que vão atender antes de escolher qual implantar.
- Os resultados dependem da máquina. O PyTorch não garante resultados idênticos entre versões ou plataformas (Reproducibility). Registre os pesos, as curvas e o script exato, como
recordings/transformer.pyfaz com o hash do script, e mantenha tudo junto.
O que este capítulo decidiu
- O modelo da loja é treinado em uma única execução registrada: lotes de 32 textos de produtos, AdamW com decaimento de peso 0.1, gradientes recortados, um aquecimento de 200 passos até um tamanho de passo máximo de 0.003, decaimento cossenoidal até um décimo, e os pesos mantidos da época 15 de 16.
- Toda comparação conta as mesmas previsões. Nos nomes, os dois modelos preveem os tokens de cada nome e o seu fim, contra a linha de base só com nomes do capítulo 3, a mais forte para nomes. Nas descrições, um 4-grama treinado nos mesmos textos pontua os mesmos tokens, com o mesmo texto antes deles.
- Nos nomes de validação, o transformador sozinho empata aproximadamente com a linha de base de 4-grama, e misturado meio a meio com ela pontua 18.4, a melhor pontuação em nomes neste livro até agora. A mistura é o modelo que o livro usa para o autocompletar, substituindo a mistura do capítulo 5 entre o modelo de janela e as contagens.
- A partir deste capítulo, os modelos também são medidos nas descrições de validação. Ali o transformador sozinho supera a linha de base, 20.1 contra 22.5, ao vencer onde as contagens não viram o contexto, e a mistura pontua 14.7.
- Nesta escala, texto novo é o ganho mais barato, a largura dá o maior ganho, mas a um preço, e a repetição ajuda só por algumas passagens. O modelo registrado permanece com largura 128, porque todo exemplo a partir do capítulo 6 o lê e os exemplos precisam rodar em segundos em um notebook; um modelo mais largo pontuaria melhor.
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.