Antes de tudo: por que o Transformer existe, e onde ele fica no LLM
Onde ele fica. Um LLM é uma linha de montagem: o texto vira tokens, cada token vira um vetor (embedding), os vetores atravessam dezenas de blocos Transformer empilhados, e no fim uma última camada transforma o vetor final numa probabilidade para cada próximo token possível. O Transformer é o motor do meio, e é lá que estão mais de 90% dos números aprendidos de um modelo de 8B. "LLM" diz o que o modelo faz (um modelo de linguagem, grande); "Transformer" diz como ele é construído. GPT, Claude, Llama e Gemini são todos Transformers.
O problema que ele resolveu. Até 2017 o padrão para texto eram as redes recorrentes (RNN, LSTM), que liam uma palavra por vez carregando um único vetor de memória de passo em passo. Isso tinha dois defeitos sérios. Esquecimento: a informação da palavra 1 só chegava à palavra 200 depois de 200 transformações, desbotada como telefone sem fio. Lentidão: o passo 200 dependia do 199, então não dava para usar o paralelismo da GPU, e treinar com bilhões de palavras era inviável.
A ideia de 2017 (o artigo "Attention Is All You Need", do Google): jogar fora a leitura em sequência e deixar cada token olhar diretamente para todos os outros, em um passo só. Esse olhar é a atenção. A distância entre palavras deixou de importar, e o texto inteiro passou a ser processado de uma vez, em paralelo. Foi isso que destravou a escala: com treino paralelo dava para usar trilhões de tokens e centenas de bilhões de parâmetros. Sem o Transformer não haveria GPT-3, nem ChatGPT.
RNN / LSTM (antes)
Transformer (2017 em diante)
Como lê o texto
uma palavra por vez
tudo de uma vez
Palavra 1 até a 500
499 passos, sinal desbota
1 passo, ligação direta
Paralelismo no treino
quase nenhum
total
Custo com contexto n
cresce com n
cresce com n² (o preço da ligação direta)
Até onde escalou
centenas de milhões de parâmetros
centenas de bilhões, ou mais
Um bloco, por dentro
A tese desta página: um Transformer é uma pilha de blocos idênticos, e o que muda entre eles é apenas o que cada um aprendeu a escrever no residual stream. Não há hierarquia declarada, nem módulo de sintaxe, nem módulo de semântica: há a mesma operação repetida, e uma esteira que atravessa tudo carregando as anotações acumuladas.
tudo nesta página é recalculado a partir dela
cortada em 12 tokens: a matriz fica ilegível antes disso
Explore cada etapa →
A matemática, num só lugar
As 4 contas que sustentam um bloco. Clique em qualquer uma para pular direto para a etapa que a explica.
Onde esta página começa
a fronteira com "Dentro de um LLM"
A etapa 4 daquela página mostra que existe atenção, com uma demonstração aproximada e sem fórmula: é a porta de entrada, e continua sendo o lugar certo para começar. Esta página mostra como a atenção funciona, com a conta rodando de verdade. Se você chegou aqui sem passar por lá e algo soar denso demais, o caminho de volta é aquele link.
Honestidade, antes de começar: as contas desta página rodam de verdade, produto escalar, máscara, softmax, tudo calculado no seu navegador a partir da frase que você digitar. Mas os pesos são desenhados à mão, não extraídos de um modelo treinado. Escolhi quatro matrizes que produzem quatro comportamentos legíveis (vizinhança, token anterior, conteúdo, âncora) porque cabeças assim realmente aparecem em modelos reais e foram documentadas em trabalhos de interpretabilidade. Os padrões que você vai ver são plausíveis, não observados. Um modelo de verdade tem centenas de cabeças, a maioria sem interpretação simples nenhuma.
A primeira coisa a entender não é a atenção: é o que ela modifica. Cada token entra no modelo como um vetor e sai como um vetor do mesmo tamanho. Entre os dois, cada bloco soma uma contribuição, nunca substitui. Essa esteira que atravessa o modelo inteiro é o residual stream, e é o objeto central da arquitetura.
Antes do gráfico: o que é o "delta". Pense no vetor do token como uma ficha com uma lista de números (aqui 8; num modelo real, 4096). Cada bloco lê a ficha e devolve uma lista de correções do mesmo tamanho: "some 0,1 no primeiro número, tire 0,2 do segundo, deixe o terceiro como está". Essa lista de correções é o delta (Δ, a letra grega usada para "diferença"). O bloco não apaga a ficha: ele soma as correções a ela.
Com números: a ficha é [1,0 ; 2,0 ; −0,5], o bloco devolve o delta [0,1 ; −0,2 ; 0,0], e a ficha passa a ser [1,1 ; 1,8 ; −0,5]. O próximo bloco recebe essa ficha nova, devolve o seu delta, soma, e assim por diante. O que cada delta "quer dizer" (ex.: "isto é o sujeito da frase", "a próxima palavra deve ser um substantivo") ninguém programa: o treino ensina cada bloco a escrever correções que ajudem a prever a próxima palavra.
Como ler: cada linha é um bloco, de cima para baixo. A coluna verde é o delta, o que aquele bloco escreveu; a azul é a ficha depois da soma. As duas usam a mesma régua, só que o delta aparece com uma lupa de 2 vezes, senão ele viraria um traço: mesmo ampliado, ele é pequeno perto da ficha, e por isso a ficha muda aos poucos. A última coluna confirma: o cosseno com o embedding inicial fica perto de 1, ou seja, mesmo depois de 12 blocos o vetor ainda aponta quase para o mesmo lado. Cada bloco anota; nenhum reescreve. É por isso que dá para ler o estado intermediário de um modelo e ainda reconhecer de que token ele veio.
Honestidade: os deltas aqui saem de uma função fixa, não de um modelo treinado, mas a regra x ← x + Δ é exatamente a de verdade. A norma (o tamanho do vetor, no topo do painel) cresce a cada soma, e isso também acontece em modelos reais: é um dos motivos de cada subcamada normalizar a entrada antes de calcular o delta (etapa 7).
Fórmula · a esteira
xl = xl−1 + Δl · Δl = blocol( xl−1 )
A ficha depois do bloco l é a ficha de antes mais o delta que o bloco calculou a partir dela. Repetindo isso L vezes, o vetor final é o embedding inicial mais a soma de todos os deltas: xL = x0 + Δ1 + Δ2 + … + ΔL.
Por que somar, e não substituir
Porque somar cria um caminho direto da entrada até a saída. O gradiente do treino desce por esse caminho sem atravessar nenhuma multiplicação, o que impede que ele encolha exponencialmente com a profundidade. Foi essa ideia, dos ResNets, em visão computacional, 2015, que destravou redes profundas de verdade. O Transformer a herdou inteira.
A esteira como memória compartilhada
Uma leitura útil: o residual stream é uma memória compartilhada de largura d_model. Cada bloco lê dela, calcula, e escreve de volta. Blocos diferentes usam direções diferentes dessa memória para não se atrapalhar, e a interpretabilidade moderna trata isso literalmente assim: procurando quais direções carregam qual informação.
Q, K e V parecem três coisas diferentes e não são: são três projeções lineares do mesmo vetor x. Multiplicar x por três matrizes distintas produz três leituras dele: a pergunta que ele faz, a etiqueta com que se anuncia, e o conteúdo que entrega. A analogia com busca é boa: consulta, chave e valor.
Escolha um token
Os três vetores saem do MESMO x, multiplicado por três matrizes diferentes. É só isso que separa "pergunta" de "resposta" aqui dentro.
Fórmula · as projeções
Q = x·WQK = x·WKV = x·WV
x é a matriz [n × d_model] saída do residual stream. Cada W é [d_model × d_head], e é aprendida no treino. O resultado são três matrizes [n × d_head]. Numa cabeça de um modelo real, d_head costuma ser 64 ou 128: repare que é pequeno: cada cabeça enxerga um subespaço estreito do residual stream, de propósito.
Detalhe que quase nunca aparece: com GQA, WK e WV são compartilhadas entre grupos de cabeças, enquanto WQ continua uma por cabeça. Cada cabeça continua fazendo a sua pergunta, mas várias consultam o mesmo conjunto de chaves. O ganho não está nos parâmetros: está no KV-cache, que encolhe na mesma proporção. Foi a etapa 4 da página anterior.
Agora a conta inteira. Cada token multiplica a sua consulta pela chave de todos os outros, e sai uma matriz n×n de pontuações. O triângulo acima da diagonal é apagado, nenhum token pode olhar para o futuro, e o softmax transforma cada linha em pesos que somam 1.
A matriz de atenção
linhas = quem pergunta · colunas = quem responde · clique numa linha para abri-la
O softmax não escolhe: ele distribui. Uma pontuação 2 pontos maior vira um peso ~7 vezes maior, e todos somam 1. É por isso que a atenção quase nunca é "só um token" ela é uma média ponderada onde alguém domina.
Fórmula · a atenção inteira
Attn(Q,K,V) = softmax( (QKᵀ + M) / √dk ) · V
QKᵀ é a matriz [n × n] de pontuações: a posição (i,j) é o produto escalar da consulta de i com a chave de j. M é a máscara: 0 onde pode olhar, −∞ onde não pode, e −∞ vira exatamente zero depois do softmax. A divisão por √dk não é enfeite: sem ela, produtos escalares de vetores de 128 dimensões ficam grandes demais, o softmax satura, e o gradiente morre. O resultado multiplica V: cada token recebe a média ponderada dos valores dos outros.
Armadilha de produção: a máscara é o que permite treinar de forma eficiente, o modelo prevê todos os n tokens numa passada só, cada um enxergando apenas o seu passado. Se ela vazar por um bug de off-by-one, o treino converge lindamente e o modelo não generaliza nada: ele aprendeu a copiar o próximo token em vez de prevê-lo. O sintoma é loss de treino excelente com geração inútil. Desligue a máscara acima e veja a diagonal superior acender.
Uma cabeça só sabe fazer uma pergunta por vez, porque tem um só par WQ/WK. Se ela aprendeu a procurar o token anterior, é isso que ela faz sempre. A saída são várias cabeças em paralelo, cada uma com suas matrizes, olhando o mesmo x e chegando a conclusões diferentes.
Escolha uma cabeça
Por que não uma cabeça grande
Porque o softmax é um gargalo de uma escolha só. Com uma cabeça de 512 dimensões, a distribuição continua sendo uma: o modelo precisa decidir, para cada token, um único perfil de atenção. Com 8 cabeças de 64, ele obtém 8 distribuições independentes pelo mesmo custo de conta: a multiplicação total é a mesma. Você não está gastando mais; está gastando melhor.
Honestidade · cabeças de verdade não são assim
As quatro cabeças aqui foram escritas para serem legíveis. Em modelos reais, cabeças de "token anterior" e de "âncora" (attention sink no primeiro token) realmente existem e estão documentadas, mas são a minoria. A maior parte das centenas de cabeças de um modelo grande não tem interpretação simples: elas implementam pedaços de circuitos distribuídos que só fazem sentido em conjunto. Desconfie de qualquer visualização que dê nome a todas elas.
Repare num detalhe da conta anterior: em nenhum momento a posição do token entrou nela. Produto escalar é indiferente à ordem. Se você embaralhar a frase, a matriz sai a mesma com as linhas trocadas de lugar: para a atenção pura, uma frase é um saco de palavras. A ordem precisa ser injetada de fora.
A mesma matriz, com e sem posição
A pontuação depende só da distância entre os dois tokens, não das posições absolutas. Essa é a propriedade que dá nome ao RoPE (Rotary Position Embedding): girar Q e K pelo ângulo da posição faz o produto escalar depender apenas da diferença dos ângulos.
Fórmula · RoPE
⟨Rθiq , Rθjk⟩ = ⟨q , Rθ(j−i)k⟩
R é uma rotação. O lado esquerdo gira a consulta pelo ângulo da posição i e a chave pelo ângulo de j; o lado direito mostra que o resultado só depende de j − i. Cada par de dimensões gira numa frequência diferente: as rápidas resolvem distâncias curtas, as lentas distâncias longas. É por isso que esticar o contexto de um modelo com RoPE é possível (interpolando as frequências) e não é grátis: as frequências rápidas passam a ver ângulos que nunca viram no treino.
Armadilha de produção: "este modelo suporta 128K de contexto" costuma significar que o RoPE foi esticado para 128K, não que o modelo foi treinado com documentos de 128K. A degradação é silenciosa e gradual: nada quebra, a recuperação de informação no meio do contexto é que piora. Se o seu caso depende de achar um detalhe na posição 90.000, teste isso especificamente: não confie no número da model card.
A atenção é a parte famosa, mas ela ocupa menos da metade do bloco. A outra metade é o MLP: uma rede de duas camadas aplicada a cada token isoladamente, sem nenhuma comunicação entre eles. Divisão de trabalho: a atenção move informação entre posições, o MLP processa o que chegou.
Três matrizes e um portão. Wup leva o vetor para o espaço maior; Wgate faz uma segunda leitura que, depois do SiLU, decide quanto de cada neurônio passa; o ⊙ multiplica posição por posição; Wdown volta ao tamanho do residual stream. A sigmoide σ está escondida dentro do SiLU: é ela que transforma um número qualquer num "quanto deixar passar", entre 0 e 1. É esta conta que roda nas barras acima.
Onde mora o peso
É a mesma conta da etapa 2 da página anterior, agora vista de dentro do bloco. A atenção domina o tempo; o MLP domina os parâmetros. Confundir as duas dominâncias é a origem de metade das otimizações que não funcionam.
O MLP como memória de fatos
Uma leitura que ganhou força na interpretabilidade: o MLP funciona como um banco de chave-valor. A primeira matriz decide quais "neurônios" acendem para um padrão de entrada; a segunda decide o que cada neurônio aceso escreve de volta no residual stream. É nesse mecanismo que trabalhos de edição de modelo (ROME, MEMIT) intervêm quando querem trocar um fato específico sem retreinar nada.
Falta explicar por que empilhar 96 desses blocos não vira ruído. Duas peças resolvem isso, e nenhuma delas sozinha basta: o residual, que impede o sinal de morrer, e a normalização, que impede a esteira de explodir. Os três regimes abaixo rodam a mesma recorrência, mudando só isso.
24 blocos, três regimes
Fórmula · o bloco inteiro
x ← x + attn(norm(x)) ; x ← x + mlp(norm(x))
Repare na ordem: a norma é aplicada à entrada da subcamada, não à saída da soma. Isso se chama pré-norm, e é o que praticamente todo modelo moderno usa. O post-norm do artigo original de 2017 (x ← norm(x + attn(x))) põe uma normalização no caminho do residual, o que estraga justamente a autoestrada de gradiente que ele existia para criar: treinar post-norm profundo exige aquecimento cuidadoso de learning rate, e muita gente descobriu isso do jeito difícil.
RMSNorm: a simplificação que venceu. A LayerNorm original subtrai a média e divide pelo desvio-padrão; a RMSNorm só divide pela raiz do valor quadrático médio, sem centralizar. Menos uma passada pelos dados, menos um buffer, e nenhuma perda de qualidade mensurável. É um bom exemplo do padrão que se repete nesta arquitetura: quase toda evolução do Transformer desde 2017 foi tirar coisa, não acrescentar.
Agora a conta que dói. A matriz de atenção tem n² posições: para cada cabeça, de cada camada. Dobrar o contexto não dobra o trabalho: quadruplica. E é essa quadratura que separa "contexto longo funciona" de "contexto longo é viável".
A matriz, por contexto
n = 4.096 ·
Flash-attention: a matriz que não existe
A tabela acima mede a matriz se ela fosse materializada. O truque do flash-attention é nunca escrevê-la na memória: ele processa a atenção em blocos que cabem na SRAM da GPU e acumula o softmax de forma incremental. O custo de conta continua O(n²): isso é irredutível , mas o de memória cai para O(n). Foi essa engenharia, não uma arquitetura nova, que tornou contexto de 100K praticável.
A ponte para a próxima página
Durante a geração, cada token novo precisaria refazer toda a matriz. O KV-cache evita isso: as chaves e valores dos tokens anteriores não mudam, então guarda-se todas elas e o token novo só calcula a sua linha. O custo por token cai de O(n²) para O(n). E daí nasce a pergunta da próxima página: se o cache é tão valioso, por que jogá-lo fora entre uma requisição e outra?
O caminho inteiro
No fim: um bloco Transformer é uma esteira com duas anotações por camada. A atenção decide de onde vem a informação; o MLP decide o que fazer com ela; o residual garante que nada se perca no caminho e a norma garante que nada exploda. Tudo o mais, GQA, RoPE, SwiGLU, flash-attention, é engenharia em cima desse esqueleto, e quase toda ela existe para tornar a mesma conta mais barata, não diferente.
Continue na série
Cache de prompt, o KV-cache virando dinheiro, e a regra de prefixo que decide tudo