Atenção

Cerca de 28 minutos min de leitura, com 8 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 calcular a atenção à mão: pontuar o quanto a query de cada token corresponde à key de cada token anterior, transformar as pontuações em pesos e calcular a média dos values que esses pesos selecionam. Você vai acrescentar a máscara causal, que impede um modelo de linguagem de ver o futuro, o escalonamento, que impede que os pesos se concentrem em um único token, e várias heads que buscam coisas diferentes ao mesmo tempo. Depois, você vai ler o que um modelo treinado presta atenção, testar o que ele copia e medir até onde ele olha para trás.

O modelo de janela do Capítulo 5 previa o próximo token dos nomes e descrições da loja a partir de exatamente quatro tokens anteriores, justapostos lado a lado, cada posição com seus próprios pesos. Esse desenho tem duas limitações. Ele não consegue enxergar um quinto token para trás, por mais importante que seja, e aprende sobre um token na primeira posição separadamente do mesmo token na terceira. A loja vende móveis e artigos para casa online, e suas descrições mostram por que a primeira limitação prejudica: uma descrição costuma repetir palavras do nome do produto dezenas de tokens depois, como em protect your outdoor patio furniture from harsh elements with this outdoor patio furniture cover. Um modelo que consegue olhar de volta para o nome vê qual palavra vem em seguida. Um que vê apenas os últimos quatro tokens, this outdoor patio furniture, precisa adivinhar entre tudo o que segue essas palavras em outros produtos.

Atenção permite que cada posição olhe para todas as anteriores e decida, a partir de seus conteúdos, o quanto cada uma importa. Ela foi introduzida para permitir que um modelo de tradução olhasse de volta para as palavras da frase que estava traduzindo (Bahdanau et al., 2015). Ela é o núcleo do transformer (Vaswani et al., 2017), o desenho dos modelos abertos que este livro estuda no capítulo 10. Este capítulo constrói a atenção por conta própria e depois a lê dentro do pequeno transformer do livro, que o livro chama de modelo da loja: um transformer treinado uma única vez com o texto da loja, que o capítulo 7 monta peça por peça.

Olhar para trás com uma média ponderada

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

A atenção substitui os espaços fixos do capítulo 5 por uma média ponderada. Em cada posição, o modelo calcula um novo vetor como média de vetores das posições que ele pode ver, com pesos que ele escolhe a partir do conteúdo delas: altos para as posições que importam aqui, baixos para as demais. Os pesos vêm de três vetores nos quais o embedding de cada token é convertido, por meio de três matrizes aprendidas:

  • uma query, um vetor para aquilo que esta posição está procurando,
  • uma key, um vetor para aquilo que esta posição oferece às posições que olham para ela,
  • um value, um vetor para aquilo que esta posição transmite quando é observada.

O escore da posição j para a posição i é o produto escalar da query de i com a key de j, dividido pela raiz quadrada de d, o tamanho de cada query e key, ou seja, quantos números ela contém. O softmax transforma cada linha de escores em pesos positivos que somam um, e a saída na posição i é a soma ponderada dos values. Em forma matricial, para todas as posições de uma vez:

Attention(Q, K, V) = softmax(QKᵀ / √d) V

onde Q, K e V guardam a query, a key e o value de cada posição como linhas (Vaswani et al., 2017, seção 3.2.1). A divisão por √d é o assunto de uma seção posterior.

Para acompanhar a aritmética em algo pequeno, tome quatro tokens do texto da loja: o marcador de início e sled coffee table, uma mesa cuja base tem o formato dos patins de um trenó. Dê a cada um um vetor aleatório de 8 números, como faria uma tabela de embeddings não treinada, e calcule a atenção com matrizes aleatórias de query, key e value de tamanho 8 por 4:

attention-by-hand.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Computes one attention layer by hand for four tokens, with random matrices. The prose's point rests on theprinted weight matrix: each row says which positions one position draws from, and how much."""import numpy as nptokens = ["<s>", "sled</w>", "coffee</w>", "table</w>"]rng = np.random.default_rng(2026)                            # a fixed seed, so the same numbers come out on every runx = rng.normal(0, 1, (4, 8))                        # one 8-number vector per token, as an embedding table givesw_query, w_key, w_value = (rng.normal(0, 0.5, (8, 4)) for _ in range(3))queries, keys, values = x @ w_query, x @ w_key, x @ w_value   # what each token looks for, offers, and passes onscores = queries @ keys.T / np.sqrt(4)                       # how well each query matches each key, scaledweights = np.exp(scores - scores.max(1, keepdims=True))      # subtracting each row's largest score keeps exp from overflowingweights /= weights.sum(1, keepdims=True)                     # softmax along each row: each row sums to 1output = weights @ values                                     # each token: a weighted average of all the valuesnp.set_printoptions(precision=2, suppress=True)print("attention weights (rows attend to columns):")for token, row in zip(tokens, weights):    print(f"  {token:<11}", row)assert np.allclose(weights.sum(1), 1)                        # each row sums to 1, which the prose relies onprint("output shape:", output.shape)
Saídapython attention-by-hand.py
attention weights (rows attend to columns):
  <s>         [0.02 0.97 0.01 0.  ]
  sled</w>    [0.21 0.52 0.16 0.11]
  coffee</w>  [0.04 0.   0.03 0.94]
  table</w>   [0.16 0.   0.03 0.81]
output shape: (4, 4)

Cada linha dos pesos impressos é a média de uma posição: de quais posições ela tira informação, e em que medida. Cada linha soma um, o que o exemplo verifica, e a saída tem um vetor de 4 números por posição. Os pesos são aleatórios, porque as matrizes também são, mas já mostram a liberdade da atenção: coffee concentra a maior parte do peso em table, um token posterior a ele, e o marcador de início concentra a maior parte do peso em sled. Nada na aritmética impede uma posição de olhar para frente. Para prever o próximo token, essa liberdade é um defeito, como mostra a próxima seção.

Três propriedades dessa aritmética importam para tudo o que vem depois. Os pesos dependem do conteúdo, por meio de queries e keys, de modo que o mesmo token pode prestar atenção em lugares diferentes em textos diferentes. O número de posições não importa: as mesmas três matrizes servem para um nome de 4 tokens ou para uma descrição de 150, de modo que o modelo aprende uma única forma de olhar para trás, e não uma por posição. E uma média ponderada ignora a ordem do que ela pondera. Sem máscara, a atenção dá a bar a mesma saída em bar stool que em stool bar. A máscara causal da próxima seção devolve um pouco de ordem, porque cada token passa a ver um número diferente de tokens anteriores, e Haviv e colegas mostraram que modelos de linguagem conseguem inferir posições apenas a partir disso (Haviv et al., 2022). Ainda assim, os modelos acrescentam informação explícita de posição, como faz o capítulo 7.

Regra prática: escreva as quatro linhas da atenção uma vez, como este exemplo faz, e imprima a matriz de pesos: suas linhas dizem exatamente onde cada posição olha. Mantenha queries, keys e values como matrizes separadas enquanto estiver aprendendo. As bibliotecas costumam guardá-las em uma única matriz, como o MultiheadAttention do PyTorch faz com o seu in_proj_weight (fonte), e depois separam o resultado, o que dá o mesmo resultado.

Oculte o futuro com uma máscara causal

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

Na primeira seção, coffee tirou a maior parte de sua média de table, um token posterior. Não se pode permitir que um modelo de linguagem faça isso, porque ele prevê cada token a partir dos tokens que vêm antes dele. Se a posição i pudesse prestar atenção à posição i + 1, ela veria a resposta: o treinamento recompensaria a cópia do próximo token, e o modelo não aprenderia nada que pudesse usar na geração de texto, em que o próximo token ainda não existe. A solução é a máscara causal: antes do softmax, defina como menos infinito cada escore de uma posição posterior. A exponencial de menos infinito é zero, então essas posições recebem peso zero, e cada posição faz a média apenas sobre si mesma e sobre as posições anteriores.

A máscara também torna o treinamento eficiente. Com ela, uma passagem sobre um texto prevê todas as posições de uma só vez, cada uma a partir do seu próprio passado, enquanto o modelo de janela do capítulo 5 precisava de uma janela separada para cada previsão.

Uma mudança no último token só pode alcançar coffee se coffee puder olhar adiante. Aplique a máscara aos escores dos mesmos quatro tokens, substitua table por um vetor diferente e meça o quanto a saída em coffee se move, sem a máscara e com ela:

causal-mask.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Applies the causal mask to the same four tokens, then changes the last token and measures how far the output atcoffee moves, with and without the mask. The prose's point rests on the last printed line: with the mask, that change is zero."""import numpy as nptokens = ["<s>", "sled</w>", "coffee</w>", "table</w>"]rng = np.random.default_rng(2026)x = rng.normal(0, 1, (4, 8))w_query, w_key, w_value = (rng.normal(0, 0.5, (8, 4)) for _ in range(3))   # the same draws as attention-by-handallowed = np.tril(np.ones((4, 4), dtype=bool))               # position i may look at positions 0 to i onlydef attend(x, mask):    scores = (x @ w_query) @ (x @ w_key).T / np.sqrt(4)    if mask:        scores = np.where(allowed, scores, -np.inf)          # a score of minus infinity becomes a weight of 0    weights = np.exp(scores - scores.max(1, keepdims=True))    weights /= weights.sum(1, keepdims=True)    return weights, weights @ (x @ w_value)weights, _ = attend(x, mask=True)np.set_printoptions(precision=2, suppress=True)print("weights with the causal mask:")for token, row in zip(tokens, weights):    print(f"  {token:<11}", row)print("weight on later tokens:", float(weights[~allowed].sum()))   # ~allowed marks the positions above the diagonalchanged = x.copy()changed[3] = rng.normal(0, 1, 8)                             # a different last token in place of `table`for mask in [False, True]:    before, after = attend(x, mask)[1][2], attend(changed, mask)[1][2]   # attend returns (weights, output); 2 is coffee    change = float(np.abs(after - before).max())    print(f"largest change in coffee's output, {'with' if mask else 'without'} the mask: {change:.2f}")    assert (change == 0) == mask      # the mask's job: with it, nothing after coffee reaches coffee, so the change is zero
Saídapython causal-mask.py
weights with the causal mask:
  <s>         [1. 0. 0. 0.]
  sled</w>    [0.29 0.71 0.   0.  ]
  coffee</w>  [0.58 0.01 0.41 0.  ]
  table</w>   [0.16 0.   0.03 0.81]
weight on later tokens: 0.0
largest change in coffee's output, without the mask: 4.69
largest change in coffee's output, with the mask: 0.00

A matriz de pesos agora é triangular inferior, com zeros acima da diagonal, de modo que o peso total sobre tokens posteriores é 0.0. O marcador de início só pode prestar atenção a si mesmo, então sua linha é um único 1. sled divide seu peso entre o marcador de início e ele mesmo. coffee, que antes da máscara colocava quase todo o seu peso no posterior table, agora o distribui pelas posições permitidas, porque o softmax divide apenas entre as posições restantes. A última linha, table, não muda, já que não tinha posições posteriores a perder.

As duas últimas linhas mostram o vazamento que a máscara fecha. Sem a máscara, mudar o último token move a saída em coffee em até 4.69. Com a máscara, a saída de coffee não pode depender do que vem depois, e o exemplo afirma que a mudança é zero. Um modelo treinado sem a máscara pode aprender a copiar cada resposta da posição seguinte, de modo que sua perda de treinamento pode cair para perto de zero enquanto ele não aprende nada que possa usar para gerar texto. Nada falha pelo caminho, e é isso que torna uma máscara errada difícil de notar.

Regra prática: Aplique a máscara aos escores antes do softmax, nunca aos pesos depois dele, de modo que cada linha ainda some um. Teste-a da maneira como este exemplo faz: verifique se o peso sobre as posições posteriores é exatamente zero, e se mudar um token posterior deixa as saídas anteriores inalteradas. Se a perda de treinamento de um modelo cair muito mais rápido do que o esperado, verifique a máscara primeiro.

Escale os scores

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

A fórmula da atenção divide cada score por √d, e a razão está no produto escalar. O produto escalar de dois vetores soma um produto por número. Se os números em queries e keys são independentes e aleatórios, com média 0 e variância 1, um score tem variância d, de modo que queries e keys de tamanho maior produzem scores maiores (Vaswani et al., 2017, seção 3.2.1, nota de rodapé 4). O softmax transforma grandes diferenças entre scores em pesos extremos: uma posição recebe quase todo o peso, e as demais quase nenhum. Vaswani e colaboradores suspeitaram que um modelo nesse estado aprende devagar, porque os gradientes do softmax são minúsculos quando um dos pesos está próximo de 1. Dividir por √d devolve os scores à variância 1, qualquer que seja o tamanho (d).

O modelo da loja torna isso concreto: suas heads trabalham com queries e keys de 32 números. Gere queries e keys aleatórios em três tamanhos, 4, 32 e 256, calcule o score de cada query contra 16 keys com e sem a divisão, e registre o maior peso de cada linha, com média sobre 1,000 queries. Antes de calcular, faça uma estimativa: com 256 números e sem a divisão, qual é, em média, o maior peso de uma linha?

scaling-matters.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Measures the largest softmax weight in each row, at three sizes of query and key, with and without dividing by thesquare root of the size. The prose's point rests on the unscaled averages growing with the size, and the scaled ones staying level."""import numpy as nprng = np.random.default_rng(2026)                            # a fixed seed, so the printed averages are the same on every runfor size in [4, 32, 256]:    # numbers with mean 0 and variance 1, the case the scaling argument assumes; 1,000 queries against 16 keys    queries, keys = rng.normal(0, 1, (1000, size)), rng.normal(0, 1, (16, size))    for divide in [False, True]:        scores = queries @ keys.T / (np.sqrt(size) if divide else 1)        weights = np.exp(scores - scores.max(1, keepdims=True))        weights /= weights.sum(1, keepdims=True)        label = "scaled" if divide else "unscaled"        print(f"size {size}, {label}, average largest weight in a row: {weights.max(1).mean():.2f}")
Saídapython scaling-matters.py
size 4, unscaled, average largest weight in a row: 0.45
size 4, scaled, average largest weight in a row: 0.25
size 32, unscaled, average largest weight in a row: 0.78
size 32, scaled, average largest weight in a row: 0.24
size 256, unscaled, average largest weight in a row: 0.92
size 256, scaled, average largest weight in a row: 0.25

Sem a divisão, o maior peso cresce com o tamanho: 0.45 com 4 números, 0.78 com 32, o tamanho das heads do modelo da loja, e 0.92 com 256. Nos tamanhos maiores, cada query presta atenção sobretudo a uma única key antes de qualquer treinamento. Com a divisão, o maior peso permanece em 0.25 em todos os tamanhos: distribuído por várias keys, embora não de forma uniforme, pois 16 pesos iguais seriam cerca de 0.06 cada.

Esse é o estado a partir do qual o treinamento deve começar. Cada posição observa várias outras, de modo que os gradientes chegam a todas elas, e o treinamento afia os pesos onde pesos mais concentrados ajudam. Uma head treinada ainda pode concentrar a maior parte do peso em uma única posição, como algumas das heads do modelo da loja; a escala apenas evita que as heads comecem nesse ponto.

Regra prática: Divida os scores de atenção pela raiz quadrada do tamanho da query, como faz o artigo do transformer. Alguns modelos, como o T5, deixam a divisão de fora e incorporam, em vez disso, o fator na inicialização dos pesos da query (fonte), então verifique qual deles um modelo usa antes de carregar seus pesos. Se você alterar a forma como queries e keys são calculados ou inicializados, imprima o maior peso médio de um modelo não treinado e espere que ele fique bem abaixo de 1.

Várias cabeças procuram coisas diferentes

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

Cada computação de atenção feita até aqui produz um conjunto de pesos por posição, que pode procurar um tipo de coisa: o token anterior, por exemplo, ou o nome do produto. Um modelo normalmente precisa de várias ao mesmo tempo. A atenção de múltiplas cabeças executa várias computações de atenção, chamadas cabeças, lado a lado, cada uma com suas próprias matrizes de consulta, chave e valor, e cada uma em uma parte dos números do vetor: com 8 números e 2 cabeças, cada cabeça trabalha com 4. As saídas das cabeças são unidas lado a lado e misturadas de volta por mais uma matriz aprendida, a projeção de saída (Vaswani et al., 2017, seção 3.2.2).

Dividir os números mantém o custo praticamente igual ao de uma cabeça sobre todos eles, e dá a cada cabeça seu próprio padrão de pesos. O modelo da loja tem 4 cabeças em cada camada, cada uma trabalhando com 32 números.

Execute duas cabeças sobre quatro posições de vetores aleatórios, com a máscara causal, e veja se a última posição olha para os mesmos lugares em cada uma:

attention-heads.py Python 3.12.15 · numpy 2.5.5 Aprovado
"""Runs two heads of causal attention over four positions, each head working in four of the eight numbers, then mixesthe heads with an output projection. The prose's point rests on the last position's weights differing between the heads,and on the output keeping the input's shape."""import numpy as nprng = np.random.default_rng(2026)                            # a fixed seed, so the printed weights are the same on every runpositions, dims, heads = 4, 8, 2size = dims // heads                                          # each head works in 4 of the 8 dimensionsx = rng.normal(0, 1, (positions, dims))w_query, w_key, w_value, output_projection = (rng.normal(0, 0.5, (dims, dims)) for _ in range(4))def split(m):                                                 # (positions, dims) -> (heads, positions, size)    return m.reshape(positions, heads, size).transpose(1, 0, 2)   # head 1 takes the first four numbers of each vectorqueries, keys, values = split(x @ w_query), split(x @ w_key), split(x @ w_value)scores = queries @ keys.transpose(0, 2, 1) / np.sqrt(size)             # one score matrix per headscores = np.where(np.tril(np.ones((positions, positions), dtype=bool)), scores, -np.inf)   # the causal mask, for both headsweights = np.exp(scores - scores.max(-1, keepdims=True))weights /= weights.sum(-1, keepdims=True)joined = (weights @ values).transpose(1, 0, 2).reshape(positions, dims)   # the heads' outputs side by sideoutput = joined @ output_projection                                       # mixed back together by one more matrixprint("weights shape (heads, positions, positions):", weights.shape)print("what the last token attends to, head 1:", np.round(weights[0, -1], 2))   # -1 is the last position, which sees all fourprint("what the last token attends to, head 2:", np.round(weights[1, -1], 2))print("output shape:", output.shape)
Saídapython attention-heads.py
weights shape (heads, positions, positions): (2, 4, 4)
what the last token attends to, head 1: [0.41 0.18 0.29 0.11]
what the last token attends to, head 2: [0.04 0.32 0.14 0.5 ]
output shape: (4, 8)

Agora os pesos têm uma matriz por cabeça, com formato (2, 4, 4). As linhas da última posição diferem entre as cabeças, embora ambas leiam a mesma entrada: a cabeça 1 dá seu maior peso à primeira posição, e a cabeça 2, à última, à sua própria. Com matrizes aleatórias, a diferença ainda não significa nada, mas é esse o espaço que o treinamento usa: cada cabeça pode aprender um modo diferente de olhar para trás, e a projeção de saída combina o que elas encontraram. A saída tem de novo o formato da entrada, (4, 8), de modo que as camadas de atenção podem ser empilhadas, como faz o capítulo 7.

Regra prática: como orientação geral, mantenha cada cabeça com pelo menos 32 números de largura. Nos experimentos do artigo do transformer, 16 cabeças de 32 tiveram o mesmo desempenho que 8 cabeças de 64, enquanto 32 cabeças de 16 tiveram desempenho pior, e reduzir o tamanho das chaves prejudicou o resultado (Vaswani et al., 2017, tabela 3). Verifique o formato do tensor de pesos, cabeças por posições por posições, sempre que você alterar o modelo: um eixo de cabeças no lugar errado mistura as cabeças entre si sem gerar nenhum erro.

Veja para onde as cabeças treinadas prestam atenção

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

Matrizes aleatórias mostram a aritmética; um modelo treinado mostra para que serve a atenção. O modelo da loja tem 4 camadas, cada uma com 4 cabeças de atenção. Ele foi treinado uma vez, em recordings/transformer.py, com os nomes e as descrições de treinamento da loja, sendo cada produto um único texto: o marcador de início, o nome, um token separador <sep>, a descrição e o marcador de fim. A atenção de cada camada lê a saída da camada anterior, de modo que as camadas posteriores podem prestar atenção com base no que as anteriores encontraram. Como no capítulo 5, os exemplos leem os pesos salvos e recalculam o modelo em NumPy, com lib.transformer, que também devolve os pesos de cada cabeça.

A questão é onde o modelo olha para cover em um produto de validação com o qual ele nunca foi treinado, double chaise patio furniture cover, cuja descrição repete o final do nome. Pare na segunda ocorrência de furniture na descrição, onde o próximo token é cover, e imprima a probabilidade que o modelo atribui a cover, além dos três maiores pesos de cada cabeça na primeira e na última camada. current: marca a posição a partir da qual se faz a previsão, name: um token do nome, e description: um token anterior na descrição:

trained-attention.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Runs the store's trained model on one validation product, up to the description's second furniture, and prints whereits heads attend there. The prose's point rests on the last layer's head with the most weight on the name's cover, and onthe probability it gives cover."""import numpy as npfrom lib import transformerfrom lib.store import load_products_, vocabulary, manifest = transformer.load()   # forward reads the weights itself, so only the vocabulary and manifest are keptsettings = manifest["settings"]index = {t: i for i, t in enumerate(vocabulary)}product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]ids = transformer.product_ids(product["name"], product["description"], index, settings["longest"])sep = ids.index(index[transformer.SEP])position = ids.index(ids[sep - 1], sep) - 1           # just before the description first repeats the name's last tokenlogits, attention = transformer.forward(ids, keep=True)probabilities = transformer.softmax(logits[position])def label(i):    """Where a token sits: the current position, the name, the description, or a marker."""    if i == position:        return f"current:{vocabulary[ids[i]]}"    if i == 0 or i == sep:        return vocabulary[ids[i]]    return f"{'name' if i < sep else 'description'}:{vocabulary[ids[i]]}"print("layers:", settings["layers"])print("heads per layer:", settings["heads"])print("dimensions per head:", settings["dimensions"] // settings["heads"])print("name:", " ".join(vocabulary[i] for i in ids[1:sep]))# after <sep>, up to and including the current positionprint("description so far:", " ".join(vocabulary[i] for i in ids[sep + 1:position + 1]))# position + 1 is the token that really comes next in the textprint(f"P(next token is {vocabulary[ids[position + 1]]}): {probabilities[ids[position + 1]]:.2f}")for layer in [0, len(attention) - 1]:    for head, weights in enumerate(attention[layer]):        top = np.argsort(-weights[position], kind="stable")[:3]        print(f"layer {layer + 1}, head {head + 1}: " + ", ".join(f"{label(i)} {weights[position, i]:.2f}" for i in top))name_cover = sep - 1                                     # the name's last token, `cover`earlier = ids.index(ids[position], sep + 1)              # the description's earlier `furniture`last = attention[-1][:, position]                        # the last layer's heads, at the current positionhead = int(last[:, name_cover].argmax())print("last-layer head with the most weight on the name's cover:", f"head {head + 1}")print("its weight on the name's cover:", f"{last[head, name_cover]:.2f}")print(f"its weight on {vocabulary[ids[earlier + 1]].removesuffix('</w>')}, after the description's earlier furniture:",  # earlier + 1: the token after the first furniture      f"{last[head, earlier + 1]:.2f}")
Saídapython trained-attention.py
layers: 4
heads per layer: 4
dimensions per head: 32
name: double</w> chaise</w> patio</w> furniture</w> cover</w>
description so far: protect</w> your</w> outdoor</w> patio</w> furniture</w> from</w> har sh</w> elements</w> with</w> this</w> outdoor</w> patio</w> furniture</w>
P(next token is cover</w>): 0.97
layer 1, head 1: current:furniture</w> 0.80, description:furniture</w> 0.11, description:elements</w> 0.03
layer 1, head 2: current:furniture</w> 0.31, name:furniture</w> 0.13, description:furniture</w> 0.11
layer 1, head 3: current:furniture</w> 0.18, description:patio</w> 0.18, <sep> 0.12
layer 1, head 4: description:protect</w> 0.17, current:furniture</w> 0.14, description:patio</w> 0.11
layer 4, head 1: name:cover</w> 0.48, name:double</w> 0.18, name:furniture</w> 0.13
layer 4, head 2: name:cover</w> 0.37, <s> 0.13, name:chaise</w> 0.11
layer 4, head 3: description:patio</w> 0.27, current:furniture</w> 0.25, description:outdoor</w> 0.21
layer 4, head 4: description:with</w> 0.38, description:from</w> 0.21, description:elements</w> 0.06
last-layer head with the most weight on the name's cover: head 1
its weight on the name's cover: 0.48
its weight on from, after the description's earlier furniture: 0.00

O modelo atribui a cover uma probabilidade de 0.97, e as cabeças mostram onde ele pode ter olhado. Na primeira camada, uma cabeça presta atenção sobretudo ao token atual, furniture, e as outras três distribuem seu peso entre a descrição e o nome até ali. Na última camada, head 1 dedica 0.48 de seu peso a cover no nome, muitos tokens atrás: o token que seguiu furniture no nome. A ocorrência anterior de furniture na descrição foi seguida de from, e essa cabeça dá a from apenas 0.00. Uma segunda cabeça da última camada também coloca seu maior peso no cover do nome.

Esse padrão tem nome. Olsson e colaboradores encontraram pares de cabeças que funcionam dessa forma em modelos pequenos formados apenas por camadas de atenção, e cabeças com o mesmo comportamento em modelos grandes. Eles chamam a cabeça posterior de cada par de cabeça de indução: uma cabeça em uma camada anterior copia o predecessor de cada token para a sua posição, e a cabeça de indução usa isso para encontrar posições anteriores que seguiram o token atual e presta atenção a elas (Olsson et al., 2022). Os pesos acima são consistentes com esse comportamento, mas pesos mostram de onde uma cabeça extraiu sua média ponderada, não o que o modelo de fato usou; por isso a próxima seção testa essa hipótese.

Regra prática: Inspecione um modelo treinado começando por tokens específicos em textos que você comprende, nos quais sabe o que o modelo deveria observar. Trate o que os pesos sugerem como uma hipótese e teste-a alterando a entrada, como faz a próxima seção.

Teste o que o modelo copia

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

Se o modelo prevê cover copiando-o do nome, então mudar o nome deve mudar a previsão. Se ele prevê cover porque descrições desse tipo costumam continuar assim, o nome não deve importar muito. Um teste que muda a entrada e observa a saída responde a essa questão, o que os pesos de atenção não conseguem fazer.

Mantenha a descrição e mude o nome: como vendido, sem cover, ou terminando em set. As probabilidades de cover e set em uma mesma posição mostram se a previsão segue o nome. Depois, conte o que segue this outdoor patio furniture nas descrições de treinamento, os quatro tokens que um modelo de janela veria:

copy-from-the-name.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Changes the name of one validation product and reads the model's probabilities for cover and set at the same position,then counts what follows this outdoor patio furniture in the training descriptions. The prose's point rests on P(cover)falling when cover leaves the name, and on how rarely this outdoor patio furniture is followed by cover in the trainingdescriptions, which is all the four tokens alone give."""from lib import transformerfrom lib.store import load_products_, vocabulary, manifest = transformer.load()   # forward reads the weights itself, so only the vocabulary and manifest are keptindex = {t: i for i, t in enumerate(vocabulary)}product = load_products("validation").query("name == 'double chaise patio furniture cover'").iloc[0]cover, other = index["cover</w>"], index["set</w>"]for name, label in [("double chaise patio furniture cover", "name as sold"),                    ("double chaise patio furniture", "name without cover"),                    ("double chaise patio furniture set", "name ending in set")]:    ids = transformer.product_ids(name, product["description"], index, manifest["settings"]["longest"])    sep = ids.index(index[transformer.SEP])    furniture = [i for i in range(sep + 1, len(ids)) if ids[i] == index["furniture</w>"]]    p = transformer.softmax(transformer.forward(ids)[furniture[1]])   # at the description's second `furniture`    print(f"{label}, P(cover): {p[cover]:.2f}")    print(f"{label}, P(set): {p[other]:.2f}")phrase = "this outdoor patio furniture "                    # the trailing space makes the phrase end at a word boundary# the word after the phrase, in each description that has one; a phrase at the very end has no next word and is skippedafter = [d.split(phrase, 1)[1].split()[0] for d in load_products("train")["description"]         if isinstance(d, str) and phrase in d and d.split(phrase, 1)[1].split()]print("training descriptions with 'this outdoor patio furniture':", len(after))print("followed by cover:", after.count("cover"))
Saídapython copy-from-the-name.py
name as sold, P(cover): 0.97
name as sold, P(set): 0.02
name without cover, P(cover): 0.00
name without cover, P(set): 0.29
name ending in set, P(cover): 0.00
name ending in set, P(set): 0.70
training descriptions with 'this outdoor patio furniture': 6
followed by cover: 2

O nome decide a previsão. Com o nome como vendido, o modelo atribui cover 0.97, e sem cover no nome ele cai para 0.00. Se o nome terminar em set, o modelo atribui set 0.70 e cover 0.00.

Os quatro tokens sozinhos apontam apenas fracamente para cover: das 6 descrições de treinamento que contêm this outdoor patio furniture, 2 seguem com cover.

Esse é o comportamento que os pesos da seção anterior sugeriam, agora demonstrado pelo seu efeito: o modelo copia uma palavra do nome do produto, muitos tokens antes, o que um modelo limitado a uma janela de quatro tokens não consegue fazer. Um único produto não mede com que frequência o modelo faz isso; as duas seções seguintes medem as suas cabeças de atenção em muitos produtos.

Regra prática: Teste uma afirmação sobre o que um modelo usa mudando essa entrada e medindo a saída, e inclua uma mudança que não deveria alterar a saída. Leia os pesos de atenção para formular hipóteses, e use testes como este para conclusões.

Algumas cabeças prestam atenção ao token anterior

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

Um texto pode induzir ao erro; uma média sobre muitos mostra os hábitos de uma cabeça. Um hábito que vale medir é prestar atenção ao token anterior. Uma cabeça que faz isso leva o predecessor de cada token para a sua posição, de modo que as camadas seguintes veem pares de tokens, como ocorreu com as contagens de bigramas do capítulo 1, e a cópia das seções anteriores depende disso: para descobrir o que seguiu furniture antes, uma cabeça precisa que cada posição anterior conheça o seu predecessor.

Calcule a média do peso de cada cabeça sobre o token anterior nos primeiros 300 produtos de validação, e compare a cabeça com maior peso sobre o token anterior com uma distribuição uniforme, que coloca 1 / (i + 1) em cada um dos i + 1 tokens que a posição i pode ver:

previous-token-heads.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Averages each head's weight on the previous token over 300 validation products, and sets the largest average besidean even spread. The prose's point rests on the head with the most weight on the previous token, and on the even spread beside it."""import numpy as npfrom lib import transformerfrom lib.products import product_textstexts = product_texts("validation", 300)                    # the first 300 validation products, which the model never trained on# with keep=True, forward's second value is every layer's weights; the head count is in the manifest's settingslayers, heads = len(transformer.forward(texts[0][0], keep=True)[1]), transformer.load()[2]["settings"]["heads"]on_previous = np.zeros((layers, heads))for ids, _ in texts:    _, attention = transformer.forward(ids, keep=True)    for layer, weights in enumerate(attention):        # weights: (heads, positions, positions)        on_previous[layer] += weights[:, np.arange(1, len(ids)), np.arange(len(ids) - 1)].mean(1)   # position i's weight on i - 1, for i after the starton_previous /= len(texts)even = np.mean([np.mean(1 / np.arange(2, len(ids) + 1)) for ids, _ in texts])   # position i sees i + 1 tokens, so 1 / (i + 1) eachprint("average weight on the previous token (rows: layers, columns: heads):")for layer, row in enumerate(on_previous, start=1):    print(f"  layer {layer}: " + "  ".join(f"{w:.2f}" for w in row))layer, head = np.unravel_index(on_previous.argmax(), on_previous.shape)print("head with the most weight on the previous token:", f"layer {layer + 1}, head {head + 1}")print("its weight on the previous token:", f"{on_previous.max():.2f}")print("an even spread's weight on the previous token:", f"{even:.2f}")
Saídapython previous-token-heads.py
average weight on the previous token (rows: layers, columns: heads):
  layer 1: 0.03  0.06  0.13  0.10
  layer 2: 0.32  0.13  0.27  0.24
  layer 3: 0.13  0.33  0.09  0.07
  layer 4: 0.11  0.07  0.35  0.27
head with the most weight on the previous token: layer 4, head 3
its weight on the previous token: 0.35
an even spread's weight on the previous token: 0.07

A cabeça que coloca o maior peso sobre o token anterior é layer 4, head 3, com 0.35 em média. Uma distribuição uniforme, calculada da mesma forma, colocaria 0.07 ali, de modo que essa cabeça favorece o token anterior cerca de cinco vezes mais. Várias cabeças nas camadas posteriores colocam um quarto ou mais do seu peso ali, enquanto as cabeças da primeira camada colocam bem menos: no exemplo de atenção treinada, uma delas prestava atenção sobretudo ao token atual.

Nenhuma cabeça é puramente uma cabeça de token anterior; cada uma mistura esse hábito com outros. A média de uma cabeça indica o que ela faz na maior parte do tempo, não tudo o que ela faz, de modo que descrever uma cabeça como tendo uma única função é uma simplificação excessiva.

Regra prática: Descreva uma cabeça treinada por médias medidas, como o seu peso sobre o token anterior, sobre o token atual ou sobre o marcador de início, calculadas sobre algumas centenas de textos. Compare cada uma com o que uma distribuição uniforme daria, calculada da mesma forma, para que um número como 0.3 possa ser lido como grande ou pequeno.

Alcançar além da janela

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

A promessa da atenção era enxergar além da janela de quatro tokens do capítulo 5, que prevê a partir do token atual e dos três anteriores. Se o modelo da loja faz isso, é algo mensurável. Quanta atenção cai além da janela? Para cada token de descrição nos primeiros 300 produtos de validação, deixando de fora o marcador de fim, some o peso que cada cabeça atribui aos tokens situados 4 ou mais posições para trás, a posição mais próxima que uma janela de quatro tokens não consegue enxergar, e separadamente o peso dado aos dois marcadores, <s> e <sep>. Calcule a média sobre tokens, cabeças e camadas, e compare com uma distribuição uniforme sobre as posições que cada token pode enxergar:

attention-reaches-back.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Measures how much attention a description token puts on tokens four or more positions back, and on the two markers,against an even spread, over 300 validation products. The prose's point rests on the all-layers share four or more back,and on the count of descriptions that repeat a token of the name."""import numpy as npfrom lib import transformerfrom lib.products import product_texts_, vocabulary, manifest = transformer.load()end = vocabulary.index(transformer.END)texts = product_texts("validation", 300)                    # the first 300 validation products, which the model never trained onlayers = manifest["settings"]["layers"]far, markers, even_far, even_markers, counted = np.zeros(layers), np.zeros(layers), 0.0, 0.0, 0for ids, sep in texts:    # the description's tokens: after <sep>, so not the name, and without the end marker    queries = np.array([i for i in range(sep + 1, len(ids)) if ids[i] != end])    if len(queries) == 0:        continue                                          # a product with no description    _, attention = transformer.forward(ids, keep=True)    stacked = np.stack(attention)[:, :, queries]          # (layers, heads, description tokens, positions)    positions = np.arange(len(ids))    is_marker = np.isin(positions, [0, sep])              # <s> and <sep>    beyond = (queries[:, None] - positions[None, :] >= 4) & ~is_marker   # 4 positions back is the nearest a four-token window can't see    far += (stacked * beyond).sum(-1).mean(1).sum(-1)    markers += (stacked * is_marker).sum(-1).mean(1).sum(-1)    even_far += (beyond.sum(1) / (queries + 1)).sum()     # an even spread over the positions each token can see    even_markers += (2 / (queries + 1)).sum()             # two markers among the query's i + 1 visible positions    counted += len(queries)print("description tokens measured:", f"{counted:,}")print("average attention weight of a description token, by layer:")for layer in range(layers):    print(f"  layer {layer + 1}: 4 or more tokens back {far[layer] / counted:.2f}, on <s> and <sep> {markers[layer] / counted:.2f}")print("all layers, weight 4 or more tokens back:", f"{far.mean() / counted:.2f}")print("an even spread's weight 4 or more tokens back:", f"{even_far / counted:.2f}")print("all layers, weight on <s> and <sep>:", f"{markers.mean() / counted:.2f}")print("an even spread's weight on <s> and <sep>:", f"{even_markers / counted:.2f}")# the name without <s>, and what follows <sep>; a product counts as described if anything but the end marker followsdescribed = [(ids[1:sep], ids[sep + 1:]) for ids, sep in texts if any(i != end for i in ids[sep + 1:])]print("products with a description:", len(described))print("descriptions that repeat a token of the name:", sum(bool(set(n) & set(d)) for n, d in described))
Saídapython attention-reaches-back.py
description tokens measured: 20,571
average attention weight of a description token, by layer:
  layer 1: 4 or more tokens back 0.42, on <s> and <sep> 0.12
  layer 2: 4 or more tokens back 0.39, on <s> and <sep> 0.04
  layer 3: 4 or more tokens back 0.58, on <s> and <sep> 0.13
  layer 4: 4 or more tokens back 0.47, on <s> and <sep> 0.13
all layers, weight 4 or more tokens back: 0.46
an even spread's weight 4 or more tokens back: 0.85
all layers, weight on <s> and <sep>: 0.11
an even spread's weight on <s> and <sep>: 0.05
products with a description: 262
descriptions that repeat a token of the name: 244

As cabeças favorecem tokens próximos, como seria de esperar para prever a próxima palavra, e ainda assim enviam uma grande parcela de sua atenção para além da janela, algo que nenhum modelo anterior deste livro conseguia aproveitar. Considerando todas as camadas, os tokens de descrição colocam 0.46 de sua atenção em tokens situados 4 ou mais posições para trás, onde uma distribuição uniforme colocaria 0.85, porque a maior parte do que um token de descrição pode enxergar está longe.

Isso importa para este texto: dos 262 produtos com descrição, 244 têm uma que repete pelo menos um token do nome.

Os marcadores recebem 0.11 da atenção, contra 0.05 de uma distribuição uniforme: cerca de duas vezes o que o acaso daria, embora não prevejam palavra alguma. Uma razão provável é um padrão encontrado em modelos maiores. O softmax faz com que cada linha de pesos some um, de modo que uma cabeça que não encontra nada útil em uma posição ainda precisa colocar seu peso em algum lugar. Xiao e colaboradores descobriram que modelos de linguagem atribuem pesos grandes aos primeiros tokens de um texto, quaisquer que sejam eles, e os chamaram de sumidouros de atenção (Xiao et al., 2024). No modelo da loja, <s> sempre vem primeiro e <sep> está em todos os textos, de modo que ambos poderiam cumprir esse papel; <sep> também marca onde a descrição começa, o que já é útil por si só. Este exemplo não consegue distinguir as duas hipóteses.

Regra prática: Meça até onde um modelo treinado presta atenção antes de decidir qual deve ser o comprimento do seu contexto, e compare com uma distribuição uniforme para que o número tenha sentido. Informe o peso dos marcadores separadamente, para que ele não pareça atenção de longo alcance, e mantenha os primeiros tokens ao reduzir o contexto de um modelo para economizar espaço.

O que dá errado em produção

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

A atenção é a parte de um modelo de linguagem cujo custo cresce mais rápido com o comprimento do texto, e a parte mais frequentemente mal interpretada:

  • O custo cresce com o quadrado do comprimento. Cada posição pontua todas as anteriores, de modo que um texto duas vezes mais longo custa quatro vezes mais em atenção. Defina um comprimento máximo, como o modelo da loja faz em 160 tokens, e verifique quantos dos seus textos o limite corta.
  • Uma máscara errada falha em silêncio. Um modelo que consegue ver o futuro pode alcançar uma perda baixa no treinamento e, mesmo assim, ser inútil para gerar texto. Teste se o peso sobre as posições posteriores é zero, e se alterar um token posterior deixa intactas as saídas anteriores, tanto no código de treinamento quanto no código de geração.
  • Pesos de atenção não são explicações. Um peso alto indica de onde uma cabeça tirou sua média, não por que o modelo previu o que previu. No mesmo modelo, pesos de atenção muito diferentes podem produzir a mesma previsão (Jain e Wallace, 2019, sobre classificadores recorrentes e convolucionais). Use os pesos para formular hipóteses e teste-as alterando a entrada, como este capítulo fez com o nome do produto.
  • O peso em marcadores parece importância. Um peso alto sobre o primeiro token ou sobre um separador pode indicar apenas que a cabeça não tem nada a fazer ali. Não remova esses tokens, e não interprete o peso deles como significado.
  • O softmax transborda sem cuidado. Subtraia o maior escore de cada linha antes de aplicar a exponencial, como faz lib.transformer.softmax. Garanta que cada linha mantenha pelo menos uma posição não mascarada, ou a linha se torna NaN: uma máscara causal sempre deixa cada posição visível para si mesma, mas uma máscara que oculta o preenchimento pode ocultar uma linha inteira.

O que este capítulo decidiu

  • Os modelos do livro usam atenção causal, escalonada e multicabeça, como Vaswani et al. a definiram: os escores divididos pela raiz quadrada do tamanho das consultas e chaves de cada cabeça, menos infinito em cada posição posterior antes do softmax, e cabeças que trabalham cada uma com uma parte dos números, combinadas por uma projeção de saída.
  • O modelo da loja tem 4 camadas de 4 cabeças, cada cabeça com 32 números de largura, treinado uma vez em recordings/transformer.py sobre nomes e descrições unidos por um marcador <sep>, e recalculado em NumPy por lib.transformer.
  • Afirmações sobre o que um modelo usa são testadas alterando sua entrada. Os pesos de atenção sugerem hipóteses; alterar o nome do produto mostrou que o modelo copia cover a partir dele.
  • As cabeças treinadas são descritas por médias medidas sobre muitos textos, comparadas com uma distribuição uniforme: o peso no token anterior, o peso em tokens 4 ou mais posições atrás e o peso em marcadores, contados separadamente.
  • Nas descrições da loja, a atenção alcança bem além da janela do capítulo 5. Os tokens da descrição concentram 0.46 de sua atenção em tokens 4 ou mais posições atrás, e o modelo copia do nome, algo que uma janela fixa não consegue.
  • A atenção precisa de informação explícita de posição. Uma média ponderada ignora a ordem, e a máscara causal restaura apenas um pouco dela, por isso o capítulo 7 acrescenta posições rotacionais, como o modelo da loja faz dentro de cada cabeça.

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.

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 6 de 11: Atenção

  1. Olhar para trás com uma média ponderada
  2. Oculte o futuro com uma máscara causal
  3. Escale os scores
  4. Várias cabeças procuram coisas diferentes
  5. Veja para onde as cabeças treinadas prestam atenção
  6. Teste o que o modelo copia
  7. Algumas cabeças prestam atenção ao token anterior
  8. Alcançar além da janela
  9. O que dá errado em produção
  10. O que este capítulo decidiu

Voltar ao topoTodos os capítulos