Treinando um modelo pequeno

Cerca de 27 minutos min de leitura, com 7 exemplos em 10 seções.

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

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

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

Ao final deste capítulo, você 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

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

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:

training-batches.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Builds one shuffled epoch of batches the way the training script does, and measures the padding in them.The prose's point rests on the share of targets that are padding over that epoch."""import mathimport numpy as npfrom lib import transformerfrom lib.products import product_texts_, vocabulary, manifest = transformer.load()settings = manifest["settings"]pad, end = vocabulary.index(transformer.PAD), vocabulary.index(transformer.END)texts = [ids for ids, _ in product_texts("train")]size = settings["batch"]order = np.random.default_rng(settings["seed"]).permutation(len(texts))   # one shuffled epoch, from the run's seed, so it repeatspadding, targets_seen, shares = 0, 0, []for start in range(0, len(texts), size):    batch = [texts[i] for i in order[start:start + size]]                      # this step's texts: the next `size` in the shuffled order    longest = max(len(ids) for ids in batch)    padded = np.array([ids + [pad] * (longest - len(ids)) for ids in batch])   # short texts filled out with <pad>    inputs, targets = padded[:, :-1], padded[:, 1:]                            # each position predicts the next token    padding, targets_seen = padding + (targets == pad).sum(), targets_seen + targets.size    shares.append((targets == pad).mean())    if start == 0:        first_shape = (inputs.shape, targets.shape)print("training texts:", f"{len(texts):,}")print("tokens in them:", f"{sum(len(ids) for ids in texts):,}")print(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 markerprint("texts per batch:", size)print("one batch's inputs and targets:", *first_shape)print("share of targets that are padding, over one shuffled epoch:", f"{padding / targets_seen:.0%}")print("least and most padding in a batch:", f"{min(shares):.0%} and {max(shares):.0%}")print("steps per epoch:", f"{math.ceil(len(texts) / size):,}")   # the last, partly filled batch is a step tooprint("epochs in the recorded run:", settings["epochs"])print("steps in the recorded run:", f"{manifest['steps']:,}")
Saídapython training-batches.py
training 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

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

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

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

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:

learning-rate-schedule.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Computes the warm-up and cosine schedule by hand from the recorded settings, and checks it against the step sizesthe training script saved. The prose relies on the check: the assert fails the run if the two ever differ."""import jsonimport mathfrom lib import transformer_, _, manifest = transformer.load()settings, total = manifest["settings"], manifest["steps"]recorded_rates = json.loads((transformer.RECORDED / "curves.json").read_text())["rates"]   # every 10th step's, after the scheduler's stepdef rate(step):    """Warm up linearly to the peak, then follow half a cosine down to a tenth of it."""    if step < settings["warmup_steps"]:        return settings["peak_rate"] * (step + 1) / settings["warmup_steps"]   # steps count from 0, so step 0 is already a share of the peak    progress = (step - settings["warmup_steps"]) / (total - settings["warmup_steps"])   # 0 at the warm-up's end, 1 at the last step    return settings["peak_rate"] * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * progress)))print("warm-up steps:", settings["warmup_steps"])print("peak step size:", settings["peak_rate"])print("weight decay:", settings["weight_decay"])for step in [0, settings["warmup_steps"] // 2, settings["warmup_steps"], total // 2, total - 1]:    print(f"step size at step {step:,}:", f"{rate(step):.2e}")gap = 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 + 1assert gap < 1e-9                   # every saved step size matches the hand calculation, to a billionthprint("same as the recorded step sizes:", "yes")
Saídapython learning-rate-schedule.py
warm-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

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

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:

transformer-training-curve.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Prints the recorded run's perplexity for each epoch, then the epoch kept and its validation perplexities.The prose's point rests on the two validation columns and the epoch kept."""import jsonimport mathfrom lib import transformer_, _, manifest = transformer.load()curves = json.loads((transformer.RECORDED / "curves.json").read_text())["epochs"]print("perplexity per token; training mixes names and descriptions, as the training text does")print("epoch  training  validation names  validation descriptions")for curve in curves:    print(f"{curve['epoch']:>5}  {math.exp(curve['train_loss']):>8.1f}  {math.exp(curve['validation_name_loss']):>16.1f}"          f"  {math.exp(curve['validation_description_loss']):>23.1f}")kept = next(curve for curve in curves if curve["epoch"] == manifest["kept_epoch"])   # the epoch whose weights were keptprint("epoch kept, the lowest name and description losses added together:", manifest["kept_epoch"])print("validation perplexity on names, kept epoch:", f"{math.exp(kept['validation_name_loss']):.1f}")print("validation perplexity on descriptions, kept epoch:", f"{math.exp(kept['validation_description_loss']):.1f}")print("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
Saídapython transformer-training-curve.py
perplexity 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

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

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:

transformer-on-names.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Scores every validation name, its end included, with the 4-gram baseline and with the transformer, then mixes themat several shares. The prose's point rests on the share 0.5 line, the lowest of the five."""import numpy as npfrom lib import transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey, ngrams, padded_, vocabulary, _ = transformer.load()index = {token: i for i, token in enumerate(vocabulary)}   # each token's id in the vocabulary, which is its column in the model's outputcounted = KneserNey(name_tokens("train"), 4)                     # chapter 3's baseline, trained on namesfrom_counts, from_transformer = [], []for name in name_tokens("validation"):    ids = [index[transformer.START]] + [index[token] for token in name] + [index[transformer.SEP]]   # the name as the model reads it    probabilities = transformer.softmax(transformer.forward(ids)[:-1])   # the last position predicts past <sep>, which a name never needs    from_transformer += list(probabilities[np.arange(len(ids) - 1), ids[1:]])   # each position's probability for the token after it    from_counts += [counted.probability(context, token) for context, token in ngrams(padded(name, 4), 4)]   # then </s>from_counts, from_transformer = np.array(from_counts), np.array(from_transformer)print("validation tokens scored, each name's end included:", f"{len(from_counts):,}")for share in [0.0, 0.3, 0.5, 0.7, 1.0]:    mixed = (1 - share) * from_counts + share * from_transformer    print(f"validation perplexity on names, transformer share {share:.1f}:", f"{np.exp(-np.log(mixed).mean()):.1f}")
Saídapython transformer-on-names.py
validation 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

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

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:

transformer-on-descriptions.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Scores the descriptions of the first 500 validation products with a 4-gram trained on whole texts, with the transformer,and with their even mix, then splits the tokens by whether their context was seen in training. The prose's point rests on the4-gram baseline and transformer lines, the half-and-half line and the unseen-context lines."""import numpy as npfrom lib import transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey, ngrams, paddedfrom lib.products import product_texts_, vocabulary, _ = transformer.load()end = vocabulary.index(transformer.END)as_tokens = lambda ids: [vocabulary[i] for i in ids[1:] if i != end]          # padded() adds its own <s> and </s>counted = KneserNey([as_tokens(ids) for ids, _ in product_texts("train")], 4)   # whole texts: name, <sep>, descriptionfrom_counts, from_transformer, seen, products = [], [], [], 0for ids, sep in product_texts("validation", 500):    if ids[-1] != end or sep == len(ids) - 2:        continue                                          # cut at the length limit, or no description    pairs = list(ngrams(padded(as_tokens(ids), 4), 4))[sep:]    # from <sep> on: the description's tokens, then </s>    from_counts += [counted.probability(context, token) for context, token in pairs]    seen += [context in counted.totals[4] for context, _ in pairs]   # was this 3-token context in the training texts?    probabilities = transformer.softmax(transformer.forward(ids)[sep:-1])   # from <sep> on: each position predicts the next token    from_transformer += list(probabilities[np.arange(len(probabilities)), ids[sep + 1:]])   # the description starts after <sep>, at sep + 1    products += 1from_counts, from_transformer, seen = np.array(from_counts), np.array(from_transformer), np.array(seen)perplexity = lambda p: f"{np.exp(-np.log(p).mean()):.1f}"print("products scored:", products)print("description tokens scored:", f"{len(from_counts):,}")mixed = (from_counts + from_transformer) / 2for label, p in [("4-gram baseline", from_counts), ("transformer", from_transformer), ("half and half", mixed)]:    print(f"{label}, validation perplexity on descriptions:", perplexity(p))print("description tokens whose 3-token context is in the training texts:", f"{seen.mean():.0%}")for part, where in [("seen", seen), ("unseen", ~seen)]:    print(f"4-gram, {part} contexts:", perplexity(from_counts[where]))    print(f"transformer, {part} contexts:", perplexity(from_transformer[where]))names = [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 ofon_names = [counted.probability(context, token) for pairs in names for context, token in pairs]print("this 4-gram, trained on whole texts, validation perplexity on names:", perplexity(np.array(on_names)))
Saídapython transformer-on-descriptions.py
products 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

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

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:

width-data-and-steps.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Reads eight recorded runs and prints each one's parameters, steps, best epoch, and validation perplexities at its bestand last epochs. The prose's point rests on the perplexity-on-names lines."""import jsonimport mathfrom lib import transformerruns = [("width 64, 4 epochs", "transformer-width-64"), ("width 128, 4 epochs", "transformer-width-128"),        ("width 256, 4 epochs", "transformer-width-256"), ("width 128, 16 epochs", "transformer"),        ("a quarter of the data, 4 epochs", "transformer-data-25"), ("half the data, 4 epochs", "transformer-data-50"),        ("a quarter of the data, 16 epochs", "transformer-data-25-same-steps"),        ("half the data, 8 epochs", "transformer-data-50-same-steps")]for label, folder in runs:    run = transformer.RECORDED.parent / folder   # every run sits in the folder beside the main run's    manifest = json.loads((run / "manifest.json").read_text())    curves = json.loads((run / "curves.json").read_text())["epochs"]    best = min(curves, key=lambda curve: curve["validation_name_loss"] + curve["validation_description_loss"])   # the epoch the script kept    print(f"{label}, parameters:", f"{manifest['parameters']:,}")    print(f"{label}, steps:", f"{manifest['steps']:,}")    print(f"{label}, best epoch:", best["epoch"])    print(f"{label}, perplexity on names:", f"{math.exp(best['validation_name_loss']):.1f}")    print(f"{label}, perplexity on descriptions:", f"{math.exp(best['validation_description_loss']):.1f}")    print(f"{label}, perplexity on names, last epoch:", f"{math.exp(curves[-1]['validation_name_loss']):.1f}")   # the last epoch trained, not the one kept    print(f"{label}, perplexity on descriptions, last epoch:", f"{math.exp(curves[-1]['validation_description_loss']):.1f}")
Saídapython width-data-and-steps.py
width 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.

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

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:

transformer-autocomplete.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Asks the transformer and its half-and-half mix with the 4-gram for their three likeliest next tokens after five prefixes,treated as the start of a name, and prints the probability of stool after outdoor bar. The prose's point rests on thestool lines and the control prefixes beside them."""import numpy as npfrom lib import bpe, transformerfrom lib.names import name_tokensfrom lib.ngrams import KneserNey_, vocabulary, _ = transformer.load()index = {token: i for i, token in enumerate(vocabulary)}counted = KneserNey(name_tokens("train"), 4)tokenizer = bpe.store_tokenizer()as_counted = [{transformer.SEP: "</s>"}.get(token, token) for token in vocabulary]   # <sep> ends a name, as </s> doesshow = lambda token: token.replace("</w>", "")for prefix in ["bar", "patio bar", "outdoor bar", "kitchen bar", "wine bar"]:    tokens = tokenizer.encode(prefix)    ids = [index[transformer.START]] + [index[token] for token in tokens]    from_transformer = transformer.softmax(transformer.forward(ids)[-1])    context = tuple(["<s>"] * 3 + tokens)[-3:]   # the 4-gram looks at the last three tokens, padded with start markers for a short prefix    from_counts = np.array([counted.probability(context, token) for token in as_counted])    mixed = (from_transformer + from_counts) / 2    for label, p in [("transformer", from_transformer), ("half and half", mixed)]:        top = np.argsort(-p, kind="stable")[:3]   # the three likeliest; a stable sort keeps tied tokens in vocabulary order        print(f"{prefix:<12} {label:<13} -> " + ", ".join(f"{show(vocabulary[i])} {p[i]:.2f}" for i in top))    if prefix == "outdoor bar":        stool = index["stool</w>"]   # </w> marks the end of a word in the tokenizer, so this is the whole word stool        print("P(stool | outdoor bar), transformer:", f"{from_transformer[stool]:.2f}")        print("P(stool | outdoor bar), 4-gram:", f"{from_counts[stool]:.2f}")        print("P(stool | outdoor bar), half and half:", f"{mixed[stool]:.2f}")
Saídapython transformer-autocomplete.py
bar          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.py faz 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.

Citar esta seção

Formato

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

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

Nesta página

Capítulo 8 de 11: Treinando um modelo pequeno

  1. Transforme produtos em lotes
  2. Atualização com AdamW e gradientes recortados
  3. Aquecimento e depois decaimento do tamanho do passo
  4. Leia a curva de treinamento
  5. Compare com a linha de base nos nomes
  6. Compare nas descrições
  7. O que a largura, os dados e os passos trazem
  8. Sugerir a próxima palavra na caixa de busca
  9. O que dá errado em produção
  10. O que este capítulo decidiu

Voltar ao topoTodos os capítulos