O bloco transformer
Cerca de 29 minutos min de leitura, com 8 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
- Add each part's output to a residual stream
- Normalizar antes de cada parte
- Transform each position with a gated feed-forward layer
- Dê posições à atenção com rotações
- Amarre a camada de saída aos embeddings
- Verificar o modelo contra o PyTorch
- Remova um bloco para ver o que ele faz
- Meça o custo de um detalhe incompatível
- Conte onde vão os parâmetros
- O que dá errado em produção
- O que este capítulo decidiu
Ao final deste capítulo, você será capaz de montar um bloco transformer a partir de suas partes, unidas por conexões residuais: atenção, normalização, uma camada feed-forward com portas e informação de posição. Em seguida, poderá empilhar blocos para formar um modelo de linguagem completo. Você verificará cada parte no modelo treinado da loja, comparará o modelo inteiro com as implementações do próprio PyTorch, medirá o que cada bloco e cada detalhe contribui e contará onde os parâmetros se concentram.
O capítulo 6 construiu a atenção: cada posição olha para as posições anteriores e calcula uma média ponderada do que encontra. A atenção sozinha não é um modelo de linguagem, e a loja, uma loja on-line de móveis e artigos para casa, precisa de mais do que atenção. Ela move informação entre posições, mas transforma pouco essa informação, e tem quase nenhuma noção da ordem das palavras. Camadas de atenção empilhadas diretamente também se degradam: sem as outras partes de um bloco, a saída da atenção pura tende ao mesmo vetor em todas as posições, e isso acontece mais rápido a cada camada (Dong et al., 2021). O bloco transformer acrescenta partes em torno da atenção que transformam cada posição, dão a ela a ordem das palavras e impedem que uma pilha profunda se degrade (Vaswani et al., 2017).
Este capítulo constrói o bloco na forma popularizada pelos modelos LLaMA: normalização da entrada de cada parte com RMSNorm, uma camada feed-forward com portas e embeddings de posição rotacionais em todas as camadas (Touvron et al., 2023, seção 2.2). O SmolLM2, cujo tokenizador você leu no capítulo 2, é construído da mesma maneira. Seu modelo de 360 milhões de parâmetros tem 960 dimensões, 32 camadas e 15 cabeças, e difere do modelo da loja em dois detalhes explicados abaixo: suas cabeças compartilham chaves e valores, e suas posições rotacionais giram mais devagar (configuração).
O modelo da loja, treinado com o texto dos produtos da loja, é formado por 4 desses blocos entre uma tabela de embeddings e uma camada de saída, e o capítulo 6 leu suas cabeças. Este livro chama cada bloco de camada do modelo. Em cada posição, cada bloco faz duas coisas, em ordem:
- normaliza o vetor, executa a atenção e soma o resultado de volta ao vetor;
- normaliza novamente, executa uma camada feed-forward e soma também esse resultado de volta.
Esta parte ainda não foi traduzida, por isso está em inglês.
Add each part's output to a residual stream
In chapter 5's window model, each layer replaced its input: the hidden layer's output was all the output layer saw. A transformer block adds to its input instead. Each part computes something from the current vector and adds its output to it: x ← x + attention(x), then x ← x + feed-forward(x). Adding a part's output to its input, instead of replacing the input, is a residual connection. It comes from image models, where very deep stacks of layers trained well only once each layer added to its input instead of replacing it (He et al., 2016).
Two consequences follow. With the additions, the signal can pass "directly from one block to any other block", forwards and, as gradients, backwards, so a deep stack trains far more reliably than it would without them (He et al., 2016b). And every position's vector becomes a shared workspace that each part reads from and writes to: the token's embedding goes in at the bottom, each part adds what it computes, and the output layer reads the sum at the top. Elhage and colleagues call this running sum, each position's vector with every part's output added to it, the residual stream (Elhage et al., 2021).
Run the store's model on one validation product and, at every layer, measure the length of what attention adds, of what the feed-forward layer adds, and of the vectors after both additions, averaged over positions. A vector's length here is the square root of the sum of its squared numbers:
1"""Runs the store's model on one validation product, one block at a time, and prints how much attention and the2feed-forward layer add to the residual stream at each layer. The prose's point rests on the two lengths printed3first and last: the vectors entering layer 1 and leaving the last layer."""4import numpy as np56from lib import transformer7from lib.products import product_texts89weights, _, manifest = transformer.load()10ids, sep = product_texts("validation", 1)[0] # the first validation product; sep, its <sep> position, isn't needed here11x = weights["embedding"][np.array(ids)] # the stream entering block 1: each token's embedding12print("length of the vectors entering layer 1:", f"{np.linalg.norm(x, axis=1).mean():.2f}")13for layer in range(manifest["settings"]["layers"]):14 layer_weights = transformer.layer_weights(layer)15 added_by_attention, _ = transformer.attention(transformer.rms_norm(x, layer_weights["norm1"]), layer_weights, manifest["settings"]["heads"])16 x = x + added_by_attention17 normalized = transformer.rms_norm(x, layer_weights["norm2"])18 added_by_feed_forward = (transformer.silu(normalized @ layer_weights["gate"]) * (normalized @ layer_weights["up"])) @ layer_weights["down"]19 x = x + added_by_feed_forward20 print(f"layer {layer + 1}: attention adds {np.linalg.norm(added_by_attention, axis=1).mean():.2f}, "21 f"feed-forward adds {np.linalg.norm(added_by_feed_forward, axis=1).mean():.2f}, "22 f"vectors now {np.linalg.norm(x, axis=1).mean():.2f}")23print("length of the vectors leaving the last layer:", f"{np.linalg.norm(x, axis=1).mean():.2f}")24print("largest number in the stream:", f"{np.abs(x).max():.1f}")
python residual-stream.pylength of the vectors entering layer 1: 1.17
layer 1: attention adds 2.90, feed-forward adds 3.00, vectors now 4.65
layer 2: attention adds 2.05, feed-forward adds 2.90, vectors now 6.14
layer 3: attention adds 2.26, feed-forward adds 4.12, vectors now 8.46
layer 4: attention adds 4.08, feed-forward adds 6.33, vectors now 13.16
length of the vectors leaving the last layer: 13.16
largest number in the stream: 50.6
The stream grows through the layers, because each addition piles onto the last. It goes from an average length of 1.17 entering the first layer to 13.16 leaving the last. Every layer adds to it, and what attention adds is comparable in size to what the feed-forward layer adds, though the feed-forward layer adds more at every layer, and by more in the later ones: both parts do real work at every layer. A layer reading the long vectors near the top would need very differently scaled weights from one reading the short ones at the bottom, unless something rescales what each layer reads; the next section does.
Working rule: Write every block as additions to the residual stream, never as replacements, and keep the stream's width the same through the whole model so the additions line up. When you debug a deep model, measure what each part adds: a part that adds almost nothing is doing almost nothing.
Normalizar antes de cada parte
O fluxo residual cresce através das camadas, como a seção anterior mediu, então cada parte deve ler uma cópia reescalada dele. Normalização reescala um vetor para um tamanho padrão antes que uma parte o leia, de modo que os pesos da parte funcionem da mesma forma, quer o fluxo seja curto ou longo. O transformer original normalizava após cada soma, com normalização por camada (layer normalization), que subtrai a média de cada vetor e divide pelo seu desvio padrão (Ba et al., 2016). Xiong e colaboradores mostraram que normalizar antes de cada parte, em vez disso, treina de forma mais estável, porque apenas a cópia que cada parte lê é reescalada, nunca o próprio fluxo (Xiong et al., 2020). E RMSNorm descarta a média: divide cada vetor pela sua raiz do valor quadrático médio (root mean square), a raiz quadrada da média dos seus números elevados ao quadrado, e multiplica cada dimensão por um ganho aprendido (Zhang e Sennrich, 2019):
RMSNorm(x) = x / √(mean(x²) + ε) · g
em que ε é um número muito pequeno, 10⁻⁵ aqui, que mantém a divisão segura, e g é o ganho, que começa em 1. Zhang e Sennrich constataram que o RMSNorm é quase tão preciso quanto a normalização por camada, e mais rápido. O modelo da loja o usa antes da atenção, antes da camada feed-forward e mais uma vez antes da camada de saída.
Normalize o fluxo do mesmo produto de validação à mão nas duas extremidades do modelo, ao entrar no primeiro bloco e ao sair do último, com o ganho mantido em 1, e compare o vetor de cada posição com lib.transformer.rms_norm:
1"""Normalizes one validation product's residual stream by hand, entering the first block and leaving the last, and2asserts that the result matches the shared module's rms_norm. The prose's point rests on the root mean square before3and after normalizing, and on the largest mean of a position's numbers, which RMSNorm does not remove."""4import numpy as np56from lib import transformer7from lib.products import product_texts89ids, _ = product_texts("validation", 1)[0] # the first validation product; its <sep> position isn't needed10streams, _ = transformer.run(ids) # the residual stream entering block 1 and leaving each block11gain = np.ones(streams[0].shape[1]) # the learned gain set to 1, to show the normalization alone12for label, x in [("entering block 1", streams[0]), ("leaving the last block", streams[-1])]:13 root_mean_square = np.sqrt((x ** 2).mean(1, keepdims=True) + 1e-5) # one per position; 1e-5 is the ε14 by_hand = x / root_mean_square * gain15 print(f"root mean square {label}, before:", f"{root_mean_square.mean():.2f}")16 print(f"root mean square {label}, after:", f"{np.sqrt((by_hand ** 2).mean(1)).mean():.2f}")17 assert np.allclose(by_hand, transformer.rms_norm(x, gain), atol=1e-4) # the library's function, to 4 decimal places18 print(f"same as lib.transformer.rms_norm, {label}:", "yes")19 # layer normalization would subtract the mean first; RMSNorm doesn't, so this mean need not be zero20 print(f"largest mean of a position's numbers after, {label}:", f"{np.abs(by_hand.mean(1)).max():.2f}")
python rms-norm-by-hand.pyroot mean square entering block 1, before: 0.10
root mean square entering block 1, after: 1.00
same as lib.transformer.rms_norm, entering block 1: yes
largest mean of a position's numbers after, entering block 1: 0.23
root mean square leaving the last block, before: 1.16
root mean square leaving the last block, after: 1.00
same as lib.transformer.rms_norm, leaving the last block: yes
largest mean of a position's numbers after, leaving the last block: 0.26
A normalização traz as duas extremidades para a mesma escala. A raiz da média quadrática vale 0.10 ao entrar no primeiro bloco e 1.16 ao sair do último, e 1.00 em ambos após a normalização; o cálculo à mão coincide com o da biblioteca nas duas extremidades. O RMSNorm reescala, mas não centraliza: a média dos números de uma posição ainda pode se afastar de zero depois da normalização, em até 0.26 aqui. Esse é o passo que ele economiza em relação à normalização por camada.
Assim, embora o fluxo tenha crescido muitas vezes ao longo das camadas, cada camada de atenção e feed-forward lê vetores da mesma escala, multiplicados pelos seus ganhos aprendidos.
Regra prática: Normalize antes de cada parte do bloco, e não depois, e normalize o fluxo mais uma vez antes da camada de saída. Use RMSNorm, a menos que você esteja reproduzindo um modelo que usa normalização por camada. Ao carregar os pesos de outro modelo, verifique qual normalização ele usa, onde e com qual ε, antes de qualquer outra coisa: o exemplo de detalhes incompatíveis mostra o que uma pequena incompatibilidade custa.
Esta parte ainda não foi traduzida, por isso está em inglês.
Transform each position with a gated feed-forward layer
Attention moves information between positions; the feed-forward layer transforms it, at each position separately. It's the same idea as chapter 5's hidden layer: widen the vector, apply a function that isn't a straight line, and narrow the result back to the stream's width. The store's model widens 128 numbers to 352.
The form the LLaMA models use is gated. A gated feed-forward layer computes two widened vectors from the input, passes one through a function called SiLU, and multiplies the two number by number, so the first decides how much of the second gets through (Shazeer, 2020):
FFN(x) = (SiLU(x W_gate) ⊙ (x W_up)) W_down
where ⊙ multiplies number by number, and SiLU(z) = z · σ(z), with σ the logistic function from chapter 4. SiLU passes large positive numbers almost unchanged and turns large negative ones to nearly zero, smoothly. Shazeer compared several gated forms with the plain one, at the same number of parameters, and found the gated ones predicted better; this form is called SwiGLU.
What does the gate shut? Compute SiLU at three points, then run the first block's real feed-forward layer on the same validation product and count, at each position, how many of its hidden units the gate nearly shuts:
1"""Computes SiLU at three points, then runs block 1's feed-forward layer on one validation product and counts the hidden2units its gate nearly shuts at each position. The prose's point rests on the three SiLU values and on that count."""3import numpy as np45from lib import transformer6from lib.products import product_texts78print("silu(-3), silu(0), silu(3):", ", ".join(f"{v:.2f}" for v in transformer.silu(np.array([-3.0, 0.0, 3.0]))))910ids, _ = product_texts("validation", 1)[0] # the first validation product; its <sep> position isn't needed11heads = transformer.load()[2]["settings"]["heads"] # load returns (weights, vocabulary, manifest): index 2 is the manifest12first = transformer.layer_weights(0) # block 1's weights13x = transformer.load()[0]["embedding"][np.array(ids)] # index 0 is the weights: the embeddings, the stream entering block 114attended, _ = transformer.attention(transformer.rms_norm(x, first["norm1"]), first, heads)15normalized = transformer.rms_norm(x + attended, first["norm2"]) # what block 1's feed-forward layer reads16gate = transformer.silu(normalized @ first["gate"]) # how much of each hidden unit to let through17up = normalized @ first["up"] # what each hidden unit carries18output = (gate * up) @ first["down"] # gated, then projected back to the stream's width19shut = (np.abs(gate) < 0.05).sum(1) # per position; 0.05 is the threshold for "nearly shut"20print("hidden units:", gate.shape[1])21print("hidden units nearly shut at a position (gate under 0.05 in size), on average:", f"{shut.mean():.0f}")22print("fewest and most nearly shut at a position:", f"{shut.min()} and {shut.max()}")23print("positions:", len(ids))24print("output shape:", output.shape)
python gated-feed-forward.pysilu(-3), silu(0), silu(3): -0.14, 0.00, 2.86
hidden units: 352
hidden units nearly shut at a position (gate under 0.05 in size), on average: 49
fewest and most nearly shut at a position: 33 and 67
positions: 133
output shape: (133, 128)
SiLU of −3, 0 and 3 gives -0.14, 0.00, 2.86: nearly zero for the negative number, nearly unchanged for the positive one.
Which units the gate shuts depends on the input. At a typical position it nearly shuts 49 of the first block's 352 hidden units, and the count ranges between 33 and 67 over the positions. So each position uses its own mix of them. The output has one vector per position at the stream's width again, (133, 128), ready to add.
The feed-forward layers hold most of a block's parameters: in the store's model, three matrices of 128 by 352, against attention's four of 128 by 128. Geva and colleagues found that in trained models these layers work like stores of patterns: each hidden unit responds to particular patterns in the text, and pushes the prediction towards particular next tokens (Geva et al., 2021).
Working rule: Use a gated feed-forward layer with SiLU. Set its width so its three matrices hold as many parameters as a plain layer four times the stream's width, the original transformer's ratio, 2,048 for 512 (Vaswani et al., 2017, section 3.3): that's about 8/3 times the width. SmolLM2-360M uses exactly 8/3, 2,560 for 960. The store's model rounds 8/3 of its width up to a multiple of 32, a rule of thumb that keeps matrix sizes convenient for hardware. When you load another model, check whether its feed-forward layer is gated, since a gated layer has three matrices where a plain one has two.
Dê posições à atenção com rotações
Uma média ponderada ignora a ordem dos itens que ela promedia, como o capítulo 6 mostrou, então a atenção obtém, no máximo, uma noção fraca de posição só a partir da máscara causal. O transformer original somava um vetor para cada posição ao embedding de cada token (Vaswani et al., 2017, seção 3.5). Os modelos LLaMA usam, em vez disso, embeddings de posição rotacionais, RoPE, que atuam dentro da atenção, em cada camada (Su et al., 2021; Touvron et al., 2023, seção 2.2). Antes de calcular as pontuações, o RoPE gira cada query e cada key por ângulos que crescem com a sua posição. Os d números do vetor são tomados em pares, o número i com o número i + d/2 no modelo da loja, e cada par (a, b) é tratado como um ponto em um plano e girado em torno da origem. Na posição p, o par i gira pelo ângulo p·θᵢ, onde θᵢ = 10000^(−i/(d/2)):
(a, b) → (a cos pθᵢ − b sin pθᵢ, a sin pθᵢ + b cos pθᵢ)
Assim, os primeiros pares giram rapidamente, um radiano inteiro por posição, e os últimos giram devagar. A linha angles = ... em lib.transformer.rope calcula p·θᵢ para cada posição e cada par, e a linha seguinte aplica a rotação.
A rotação tem duas propriedades que combinam com a atenção. Ela não altera o comprimento de um vetor, então acrescenta posição sem distorcer o conteúdo. E se uma query na posição m for girada por mθᵢ e uma key na posição n por nθᵢ, o produto escalar entre elas depende apenas da diferença, (m − n)θᵢ: a pontuação depende de quão distantes elas estão, e não de onde se encontram no texto. Uma cabeça pode aprender a olhar 3 tokens para trás, e isso funciona da mesma forma no início de um nome e no meio de uma descrição.
Gire uma query e uma key aleatórias de 32 números, o tamanho das cabeças do modelo da loja, para as posições 0 a 19, e compare as pontuações escalonadas, como o capítulo 6 as define, em três pares, o que testa isso:
1"""Rotates one random query and key for each of 20 positions, checks that the rotation keeps their lengths, and scores2three pairs of positions. The prose's point rests on the two scores for pairs 3 apart, which match, and the score for3the pair 6 apart, which doesn't."""4import numpy as np56from lib.transformer import rope78rng = np.random.default_rng(2026) # a fixed seed: the same random query and key on every run9size = 32 # 32 numbers: the store's width of 128 split across 4 heads10query, key = rng.normal(0, 1, size), rng.normal(0, 1, size)11positions = 2012rotated_q = rope(np.tile(query, (positions, 1))) # the same query, rotated for each position 0 to 1913rotated_k = rope(np.tile(key, (positions, 1)))14kept = np.allclose(np.linalg.norm(rotated_q, axis=1), np.linalg.norm(query)) and \15 np.allclose(np.linalg.norm(rotated_k, axis=1), np.linalg.norm(key)) # rotation turns a vector, never changes its length16assert kept17print("length kept by the rotation, for the query and the key:", "yes")18for i, j in [(2, 5), (12, 15), (2, 8)]: # (key position, query position): the first two are 3 apart, the third 619 print(f"score with the key at {i} and the query at {j}:", f"{rotated_q[j] @ rotated_k[i] / np.sqrt(size):.3f}") # scaled, as chapter 6 defines it
python rope-by-hand.pylength kept by the rotation, for the query and the key: yes
score with the key at 2 and the query at 5: 0.217
score with the key at 12 and the query at 15: 0.217
score with the key at 2 and the query at 8: -0.765
Pares separados pela mesma distância recebem a mesma pontuação, onde quer que estejam. A key na posição 2 e a query na posição 5 pontuam 0.217, e a key na posição 12 e a query na posição 15 pontuam 0.217, o mesmo valor, porque ambos os pares estão a 3 de distância. A key na posição 2 e a query na posição 8, a 6 de distância, pontuam -0.765: a mesma query e a mesma key, pontuadas de forma diferente porque estão mais distantes. A rotação preserva o comprimento de ambos os vetores, o que o exemplo verifica.
O RoPE não tem parâmetros aprendidos: os ângulos são fixos, e o modelo aprende queries e keys que os utilizam. O modelo da loja aplica o RoPE às queries e keys de todas as cabeças em todas as camadas, o que dá às cabeças de token anterior do capítulo 6 um meio direto de encontrar o token anterior, além do sinal fraco que a máscara fornece.
Regra prática: Use embeddings de posição rotacionais, aplicados às queries e às keys, nunca aos values. Ao carregar os pesos de outro modelo, verifique como o RoPE dele emparelha os números e qual base utiliza. Algumas implementações emparelham números vizinhos; outras emparelham a primeira metade com a segunda, como lib.transformer.rope faz e como a configuração do SmolLM2 declara com "rope_interleaved": false. O SmolLM2 usa base 100,000, enquanto o modelo da loja usa 10,000.
Amarre a camada de saída aos embeddings
Com todas as partes construídas, o modelo inteiro é curto o bastante para ser lido de uma vez. lib.transformer.block é um bloco, exatamente como o capítulo o descreveu:
def block(x: np.ndarray, layer_weights: dict[str, np.ndarray], heads: int, positions=rope):
"""One transformer block: attention, then the gated feed-forward layer, each added to the residual stream."""
attended, weights = attention(rms_norm(x, layer_weights["norm1"]), layer_weights, heads, positions)
x = x + attended
normalized = rms_norm(x, layer_weights["norm2"])
x = x + (silu(normalized @ layer_weights["gate"]) * (normalized @ layer_weights["up"])) @ layer_weights["down"]
return x, weights
lib.transformer.run passa o embedding de cada token pelos blocos em sequência, e estas linhas de lib.transformer.forward transformam o fluxo final em um logit por token do vocabulário, as pontuações que o softmax do capítulo 5 converte em probabilidades:
streams, kept = run(ids, name, positions, skip)
weights, _, _ = load(name)
logits = rms_norm(streams[-1], weights["final_norm"]) @ weights["embedding"].T
A última linha traz mais uma ideia, o weight tying: a camada de saída reaproveita a tabela de embeddings, virada de lado, em vez de aprender uma matriz própria. O logit de um token é o produto escalar do vetor final com o embedding desse token. Press e Wolf constataram que o amarre reduz a perplexidade e também economiza os parâmetros da camada de saída (Press and Wolf, 2017). O SmolLM2 também faz esse amarre ("tie_word_embeddings": true em sua configuração), pois, para um modelo do seu tamanho, uma camada de saída separada representaria uma parcela grande do total. A contagem de parâmetros mostra o que o amarre economiza no modelo da loja.
Regra prática: Amarre a camada de saída aos embeddings em um modelo pequeno, e verifique se um modelo carregado já faz esse amarre antes de procurar uma matriz de saída separada. Mantenha o seu próprio passe direto curto o bastante para ser lido por inteiro, como é o de lib.transformer, para que cada detalhe que as próximas seções testam fique visível.
Verificar o modelo contra o PyTorch
O PyTorch treinou o modelo da loja uma vez, em recordings/transformer.py, como fez no capítulo 5 (veja Treinar com PyTorch), e o script salvou os logits do próprio PyTorch para cada posição de um produto de validação. O script de treinamento usa o RMSNorm, a atenção causal e a SiLU do próprio PyTorch, então compará-los com lib.transformer verifica o código em NumPy contra o de uma biblioteca, e não contra uma segunda cópia de si mesmo. O RoPE é a exceção: o PyTorch não tem versão embutida, então os dois programas o escrevem explicitamente, e a verificação confirma apenas que eles concordam. O exemplo do RoPE feito à mão verifica as propriedades dele em vez disso.
Para testar a passagem direta completa, recalcule os logits do produto salvo em NumPy e compare todas as posições com as do PyTorch:
1"""Recomputes the store's model's logits in NumPy for the validation product the training script saved, and checks every2one against PyTorch's to four decimal places. The prose's point rests on the count of logits compared, and on the3assertion that they all match."""4import numpy as np56from lib import transformer78_, _, manifest = transformer.load()9check = np.load("data/recorded/transformer/check.npz") # one validation product's ids, and PyTorch's logits1011ours = transformer.forward(list(check["ids"])) # forward takes a list of token ids, not an array12print("PyTorch version:", manifest["torch"])13print("positions compared:", len(check["ids"]))14print("logits compared:", f"{ours.size:,}")15assert np.abs(ours - check["logits"]).max() < 1e-4 # 1e-4 is four decimal places16print("same as PyTorch to 4 decimal places:", "yes")
python transformer-same-as-pytorch.pyPyTorch version: 2.14.1+cpu
positions compared: 133
logits compared: 550,886
same as PyTorch to 4 decimal places: yes
O modelo em NumPy reproduz todos os 550,886 logits do PyTorch, para 133 posições, até a quarta casa decimal, usando o PyTorch 2.14.1+cpu. Como a verificação cobre um texto inteiro, ela cobre as partes que dependem da posição, a máscara e as rotações, assim como as normalizações, as portas e a saída com pesos compartilhados.
Regra prática: Verifique sua própria passagem direta contra as saídas da biblioteca de treinamento em um texto completo, não em uma única posição. Quando a biblioteca tem sua própria implementação de uma parte, treine com ela, para que a verificação compare duas implementações independentes; quando não tem, como no caso do RoPE aqui, teste as propriedades da parte à mão.
Remova um bloco para ver o que ele faz
O modelo está verificado; agora meça o que cada um de seus blocos contribui. Como cada bloco acrescenta algo ao fluxo residual, um bloco pode ser removido e o modelo continua funcionando: o fluxo passa por ele sem alteração, e o bloco seguinte o lê como antes. Retirar uma parte permite um experimento simples, chamado de ablação: remova uma parte e meça o que o modelo perde. Isso mostra quanto cada bloco contribui para as previsões do modelo treinado, o que não se consegue ao ler seus pesos.
A remoção de qual bloco prejudica mais? Faça uma previsão e, em seguida, pontue os nomes e as descrições dos primeiros 100 produtos de validação, 7,624 previsões no total, com o modelo completo e com cada bloco removido por vez:
1"""Scores the names and descriptions of the first 100 validation products with the full model, and with each block left2out in turn, reporting perplexity and the top token's average probability. The prose's point rests on the perplexity3with each block left out, set against the full model's."""4import numpy as np56from lib import transformer7from lib.products import product_texts89layers = transformer.load()[2]["settings"]["layers"] # load returns (weights, vocabulary, manifest): index 2 is the manifest10texts = [ids for ids, _ in product_texts("validation", 100)] # the <sep> positions aren't needed: each text is scored whole111213def measure(skip=None):14 """Perplexity per token, and the average probability of the top token, with one block left out."""15 surprise, top, count = 0.0, 0.0, 016 for ids in texts:17 p = transformer.softmax(transformer.forward(ids, skip=skip)[:-1]) # [:-1] drops the last position: nothing follows it18 surprise -= np.log(p[np.arange(len(ids) - 1), ids[1:]]).sum() # position i predicts token i + 119 top += p.max(1).sum()20 count += len(ids) - 121 return np.exp(surprise / count), top / count # perplexity: exp of the average surprise per token222324print("tokens scored, names and descriptions:", f"{sum(len(ids) - 1 for ids in texts):,}")25for skip in [None] + list(range(layers)): # None keeps all four blocks: the full model26 label = "all blocks" if skip is None else f"without block {skip + 1}" # skip counts blocks from 0, so block skip + 1 is left out27 perplexity, top = measure(skip)28 print(f"{label}:", f"{perplexity:,.1f}")29 print(f"{label}, average probability of the top token:", f"{top:.2f}")
python skip-a-block.pytokens scored, names and descriptions: 7,624
all blocks: 24.3
all blocks, average probability of the top token: 0.42
without block 1: 17,896.9
without block 1, average probability of the top token: 0.21
without block 2: 77.8
without block 2, average probability of the top token: 0.29
without block 3: 64.3
without block 3, average probability of the top token: 0.34
without block 4: 77.3
without block 4, average probability of the top token: 0.37
Remover o bloco 2, 3 ou 4 mais que dobra a perplexidade por token, passando de 24.3 com os quatro blocos para 77.8, 64.3 e 77.3: cada bloco posterior contribui com uma parcela da habilidade do modelo, e nenhum deles é dispensável. Essa perplexidade abrange nomes e descrições em conjunto, por isso não pode ser comparada com a linha de base do capítulo 3 nem com o modelo de janela do capítulo 5, que são avaliados apenas nos nomes de validação. O capítulo 8 faz essa comparação.
Remover o bloco 1 falha de outra forma. A perplexidade sobe para 17,896.9, pior do que adivinhar de forma uniforme entre todos os 4,142 tokens, o que daria 4,142.
A razão está no que os blocos posteriores esperam. Eles foram treinados com um fluxo no qual o bloco 1 já havia gravado seu resultado, e sem ele leem vetores diferentes de qualquer um que viram no treinamento. Suas previsões ficam menos confiantes, com a probabilidade média do token mais provável caindo de 0.42 para 0.21, e atribuem essa probabilidade aos tokens errados. O bloco 1 transforma os embeddings brutos na forma sobre a qual tudo o que vem depois é construído, em parte reunindo contexto do texto anterior, como fizeram três das cabeças da primeira camada do capítulo 6. Os blocos de um modelo treinado não são módulos independentes: cada um depende do que os anteriores escrevem.
Regra prática: Para entender o que uma parte de um modelo faz, remova-a e meça, em vez de inferir a partir de seus pesos. Espere que o primeiro bloco seja o mais importante, já que tudo o que vem depois é construído sobre ele; além disso, meça, porque aqui o segundo e o último bloco pesaram aproximadamente o mesmo, e mais que o terceiro. Interprete com cuidado uma perda pequena ao remover uma parte: as partes restantes foram treinadas em conjunto com ela, de modo que a medida indica de que o modelo treinado depende, não o que a parte poderia fazer sozinha.
Meça o custo de um detalhe incompatível
Cada detalhe de um bloco precisa corresponder aos pesos com que ele roda, e uma incompatibilidade não se anuncia: o modelo continua produzindo probabilidades. Os detalhes que mais costumam estar errados ao carregar pesos de outro modelo estão no RoPE, porque as implementações diferem na forma de emparelhar os números e em sua base, como a do SmolLM2 difere da do modelo da loja.
Um detalhe errado do RoPE por vez mostra o que cada um custa: pontue os mesmos 100 produtos de validação com os pesos treinados, emparelhando números vizinhos em vez de metades, com uma base de 100,000, a do SmolLM2, em vez dos 10,000 do modelo da loja, e sem RoPE algum:
1"""Scores the same 100 validation products with the trained weights, changing one detail of RoPE at a time: how it pairs2numbers, its base, and whether it is applied at all. The prose's point rests on each variant's perplexity, printed3beside the trained model's."""4import numpy as np56from lib import transformer7from lib.products import product_texts89texts = [ids for ids, _ in product_texts("validation", 100)] # the <sep> positions aren't needed: each text is scored whole101112def neighbours(x, base=10000.0):13 """RoPE that pairs neighbouring numbers, (0, 1), (2, 3) and so on, instead of the first half with the second."""14 half = x.shape[-1] // 215 rotated = transformer.rope(np.concatenate([x[..., 0::2], x[..., 1::2]], axis=-1), base) # even numbers, then odd: rope pairs halves, so these are neighbours16 out = np.empty_like(x)17 out[..., 0::2], out[..., 1::2] = rotated[..., :half], rotated[..., half:] # each rotated number back where its dimension was18 return out192021for label, positions in [("as trained", transformer.rope),22 ("RoPE pairing neighbouring numbers", neighbours),23 ("RoPE with base 100,000", lambda x: transformer.rope(x, base=100000.0)), # 100,000 is SmolLM2's base24 ("no RoPE", lambda x: x)]: # no RoPE: the queries and keys pass through unrotated25 print(f"perplexity, {label}:", f"{transformer.perplexity(texts, positions=positions):,.1f}")
python mismatched-details.pyperplexity, as trained: 24.3
perplexity, RoPE pairing neighbouring numbers: 112.2
perplexity, RoPE with base 100,000: 26.4
perplexity, no RoPE: 182.0
Duas incompatibilidades seriam percebidas já na primeira amostra de texto gerado (ok). Emparelhar números vizinhos em vez de metades eleva a perplexidade de 24.3 para 112.2, e deixar o RoPE de fora a eleva para 182.0.
A base é a mais perigosa. Com 100,000, a perplexidade é 26.4, um pouco pior que 24.3, sem nenhum erro e com uma saída que parece fluente, um equívoco que poderia ir para produção.
A outra diferença em relação ao SmolLM2 é a atenção de consultas agrupadas: suas 15 cabeças de consulta compartilham 5 conjuntos de chaves e valores, de modo que suas matrizes de chaves e valores têm um terço do tamanho da matriz de consultas (Ainslie et al., 2023). Carregar esses pesos em um modelo que espera uma chave e um valor para cada cabeça falha com um erro de forma, que é exatamente o tipo de incompatibilidade que você quer ver.
Regra prática: Confira a configuração de outro modelo contra o seu código, linha por linha, ao carregar os pesos dele: a normalização e o seu ε, o emparelhamento e a base do RoPE, o gating (a função de portão) da camada feed-forward, as saídas atreladas e quantas cabeças compartilham chaves e valores. Em seguida, pontue um texto que você conhece contra as saídas da implementação original; uma pequena perda sem erro é o caso que se deve temer.
Conte onde vão os parâmetros
Com todas as partes construídas, conte o que o modelo aprende e onde. Os parâmetros de um modelo são a sua capacidade de aprender, e onde eles estão indica em que o modelo gasta essa capacidade. A contagem do modelo treinado, por parte:
1"""Counts the store's model's parameters by part from its saved weights, and prints its settings. The prose's point2rests on the total, the feed-forward count and the embedding's share of it."""3from lib import transformer45weights, vocabulary, manifest = transformer.load()6settings = manifest["settings"]7# one table serves as input and output, so the embedding is counted once; a weight's group is the last part of its name8groups = {"embedding (shared with the output)": ["embedding"], "attention": ["q", "k", "v", "o"],9 "feed-forward": ["gate", "up", "down"], "normalization": ["norm1", "norm2", "final_norm"]}10for group, parts in groups.items():11 count = sum(v.size for k, v in weights.items() if k.split(".")[-1] in parts) # a weight's name ends in its part: layer3.q is attention's q12 print(f"{group}:", f"{count:,}")13print("total:", f"{sum(v.size for v in weights.values()):,}")14print("embedding's share of the total:", f"{weights['embedding'].size / sum(v.size for v in weights.values()):.0%}")15print("layers:", settings["layers"])16print("width:", settings["dimensions"]) # the width of the residual stream, which the manifest calls dimensions17print("heads:", settings["heads"])18print("feed-forward width:", settings["feed_forward"])19print("longest text, in tokens:", settings["longest"]) # longer texts were cut to this many tokens20print("vocabulary:", f"{len(vocabulary):,}") # the store tokenizer's tokens, plus the four markers
python transformer-parameters.pyembedding (shared with the output): 530,176
attention: 262,144
feed-forward: 540,672
normalization: 1,152
total: 1,334,144
embedding's share of the total: 40%
layers: 4
width: 128
heads: 4
feed-forward width: 352
longest text, in tokens: 160
vocabulary: 4,142
O modelo tem 1,334,144 parâmetros, um pouco menos que os 1,394,732 do modelo de janela do capítulo 5. Os dois têm tamanhos parecidos, mas gastam seus parâmetros de maneiras diferentes. O modelo de janela colocou cerca de três quartos dos seus parâmetros na camada de saída, e conseguia enxergar quatro tokens para trás. O transformer coloca a maior parte dos seus parâmetros nos blocos, sendo 540,672 deles apenas nas camadas feed-forward. Ele compartilha os embeddings com a saída, e consegue enxergar todos os tokens anteriores em um texto de até 160 tokens.
A tabela de embeddings, compartilhada com a camada de saída, tem 530,176 parâmetros, 40% do total, porque tem uma linha de 128 números para cada um dos 4,142 tokens. Esses são o vocabulário do tokenizador da loja mais quatro marcadores: início, separador, fim e preenchimento, que completa os textos curtos em um lote de treinamento. O capítulo 8 explica como o modelo foi treinado e o mede contra a linha de base.
Regra prática: conte os parâmetros por parte sempre que você projetar ou carregar um modelo. Em tamanhos pequenos, a tabela de embeddings é uma grande parcela do total, então associe-a à camada de saída, e escolha o tamanho do vocabulário com esse custo em mente, como fez a escolha do número de merges do capítulo 2.
O que dá errado em produção
As partes de um transformer precisam se encaixar exatamente, e a maior parte dos problemas vem de uma parte que quase se encaixa:
- Detalhes divergentes podem falhar silenciosamente. Onde ficam as normalizações, como o RoPE agrupa os números e qual é a sua base, se a camada feed-forward usa gating e se a saída compartilha pesos com a entrada precisam corresponder aos pesos treinados. Algumas divergências produzem resultados sem sentido de imediato; outras, como a base do RoPE medida aqui, custam um pouco de precisão sem nenhum erro. Verifique contra saídas de referência.
- Comprimentos além do treinamento não foram testados. O RoPE fornece um ângulo para qualquer posição, mas um modelo treinado com textos de até 160 tokens nunca aprendeu a usar os ângulos além desse ponto. Trate o comprimento de treinamento como o limite do modelo até que você tenha medido além dele.
- Valores grandes podem estourar em precisão reduzida. Formatos com menos bits mantêm a mesma precisão relativa em qualquer magnitude comum, mas o float16 não consegue representar valores acima de 65,504, e em formatos de 8 bits alguns poucos valores atípicos grandes arruínam a precisão de todos os outros valores (Dettmers et al., 2022). O fluxo do modelo da loja chega ao pico de 50.6 para o produto medido aqui, bem abaixo do limite do float16; verifique os maiores valores do fluxo do seu modelo antes de servi-lo em precisão menor.
- Guarde as saídas de referência junto com os pesos. Os resultados dependem da máquina, como explica o capítulo 4, então mantenha juntos os pesos, as saídas de referência e o script de treinamento exato, e refaça a verificação após qualquer mudança no código ou nas bibliotecas.
- Cada parte roda em cada posição. As camadas feed-forward custam o mesmo em todas as posições, e o custo da atenção cresce com o quadrado do comprimento, como o capítulo 6 mostrou. Meça qual dos dois domina nos seus textos antes de otimizar qualquer um deles.
O que este capítulo decidiu
- O transformer da loja usa o bloco estilo LLaMA, em um tamanho de brinquedo: RMSNorm antes de cada parte, posições rotativas na atenção, uma camada feed-forward com SiLU controlada por porta, e uma camada de saída atrelada aos embeddings. Ele tem 4 camadas, largura de 128, 4 cabeças e largura da camada feed-forward de 352. O SmolLM2-360M tem os mesmos tipos de partes, em tamanho maior, com atenção de consultas agrupadas e uma base RoPE de 100,000.
- O passo direto em NumPy de
lib.transformeré a referência do livro, verificado contra o RMSNorm, a atenção e o SiLU do próprio PyTorch em cada posição de um produto de validação, com quatro casas decimais. Todo exemplo posterior que usa o modelo executa esse código. - Cada bloco soma à corrente residual, e cada parte lê uma cópia normalizada dela, de modo que a corrente pode crescer ao longo das camadas enquanto cada parte enxerga vetores de escala fixa.
- As partes são avaliadas medindo o modelo sem elas, ou com elas alteradas. Retirar qualquer bloco deixa o modelo da loja muito pior, e retirar o primeiro o torna inútil; por isso o livro trata os blocos de um modelo treinado como um único sistema. Uma base RoPE errada custa um pouco e não gera erro, por isso os pesos carregados são sempre verificados contra saídas de referência.
- O modelo tem aproximadamente o mesmo tamanho do modelo de janela do capítulo 5, com seus parâmetros gastos nos blocos em vez da camada de saída. A tabela de embeddings, compartilhada com a saída, ainda representa 40% do total, então o tamanho do vocabulário continua sendo um custo que o livro acompanha.
Este capítulo, nesta edição
Edição 2026.11.16Exemplos aprovados em 19 de nov de 20268 de 8 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.16.