Overview

O capítulo anterior construiu um mecanismo. Um Transformer é o que se obtém quando se decide que esse mecanismo é suficiente — que dá para jogar fora a recorrência e a convolução e ficar só com atenção, mais a menor quantidade possível de andaime em volta¹.

O andaime acaba sendo curto: um MLP por posição, uma conexão residual, uma normalização. Esse bloco, repetido, é a arquitetura inteira — do GPT, do Llama, do ViT, do Whisper, dos backbones de difusão do capítulo 22. Quase nada mais em IA moderna tem essa propriedade de ser um único desenho usado em toda parte.

Este capítulo tem duas tarefas. A primeira é mostrar o que o bloco faz. A segunda é mais útil e menos frequente: mostrar quais partes do desenho de 2017 continuam ali e quais foram silenciosamente substituídas, porque o diagrama do artigo original não é o bloco que você escreveria hoje.

Os sete passos e onde está o exemplo

O modelo de brinquedo do exemplo tem um vocabulário de 12 tokens, \(d = 4\), duas cabeças e um bloco; o GPT-2 small tem 50.257 tokens, \(d = 768\), doze cabeças e doze blocos (a tabela compara os dois). O capítulo de atenção terminou com a saída da atenção \(a\) dos cinco tokens; este a soma à entrada, termina o bloco e transforma o resultado em " telhado".

Slides

Clique nos slides e use as setas ← → para navegar; F abre em tela cheia e P abre a visão do apresentador, com as notas. Quatro simuladores destas páginas rodam dentro dos slides. Abrir os slides numa aba nova

Do texto à próxima palavra: o caminho completo

Antes de abrir o bloco, vale ver onde ele fica. Um modelo de linguagem recebe "o gato subiu no" e devolve uma probabilidade para cada token do vocabulário ser o próximo:

(Os índices e as probabilidades são ilustrativos.) Três coisas para reparar:

• A forma não muda dentro da pilha. O embedding transforma os \(n\) tokens numa matriz \(n \times d\) e cada bloco recebe \(n \times d\) e devolve \(n \times d\). É isso que permite empilhar 32 ou 126 blocos iguais. Só a última camada volta para o tamanho do vocabulário \(V\).
• Cada posição produz uma previsão. A linha \(i\) da saída é a distribuição do token \(i+1\). Na geração, só a última linha interessa; no treino, todas contam — a máscara causal do capítulo anterior garante que nenhuma delas veja a resposta.
• Gerar é repetir. Sorteie um token da distribuição (como sortear é uma decisão à parte), anexe-o à entrada e rode de novo. O cache de KV é o que impede esse "rode de novo" de recalcular tudo.

Veja rodar: Transformer Explainer

Tudo até aqui pode ser visto num modelo de verdade. O Transformer Explainer², do Polo Club da Georgia Tech, roda o GPT-2 small³ no navegador — 124M de parâmetros, 12 blocos de 12 heads, \(d = 768\), vocabulário de 50.257 tokens — e desenha cada etapa do caminho acima para o texto que você digitar, dos tokens à probabilidade do próximo. As visões expandidas descem até as multiplicações de matrizes e cada número na tela vem do modelo, não de uma ilustração.

Vinte minutos, nesta ordem. Cada passo diz onde clicar, o que procurar e que parte deste capítulo (ou do anterior) ele mostra.

1. Tokens e embedding — o caminho completo; a camada de embedding. Mantenha o prompt de exemplo e expanda a coluna Embedding. Conte os tokens: eles não são as palavras. Ache o ID de cada token, seu vetor de 768 números e o vetor de posição somado a ele. No GPT-2 essa posição é uma tabela aprendida, um vetor por posição até 1024 — nem a senoide de 2017 nem a RoPE. Depois digite uma frase em português e conte de novo: mais tokens por palavra, porque o vocabulário foi montado em texto em inglês.
2. Q, K e V — dentro de um bloco; Query, Key, Value. Expanda a etapa que transforma o vetor de cada token em três. Confira os tamanhos: Q, K e V têm 768 números cada, divididos em 12 heads de 64. Nada passou de um token para outro ainda — isso só acontece na etapa seguinte.
3. Atenção e máscara — máscaras. Expanda a matriz de atenção e siga os três passos: \(QK^\top\), a divisão por \(\sqrt{64} = 8\) com a máscara causal e o softmax. Confira que tudo acima da diagonal está vazio e que cada linha soma 1: o primeiro token só pode olhar para si mesmo, o último para todos. Depois passe pelas heads e pelos blocos e ache dois padrões: uma head em que cada token olha para o token anterior e heads que despejam a maior parte do peso no primeiro token. O laboratório mede os dois e um terceiro tipo — as heads de indução⁴, que copiam um padrão visto antes no texto.
4. MLP — dentro de um bloco e onde estão os parâmetros. Expanda: 768 → 3072 → 768 com uma GELU, aplicado a cada token separadamente (nenhuma linha cruza entre tokens). No GPT-2 small são 4,7M dos 7,1M de parâmetros do bloco — os dois terços da nota sobre os parâmetros, com MHA.
5. Residual e normalização — pré-LN. Passe o mouse nas linhas tracejadas (o residual) e nos pontos antes da atenção e antes do MLP (LayerNorm). A norma está dentro do ramo: em 2019 o GPT-2 já era pré-LN. O dropout também aparece; na inferência ele não faz nada.
6. Logits — o caminho completo. Depois do 12º bloco só o vetor do último token segue: passa por uma LayerNorm final e, multiplicado pela tabela de embedding transposta (o GPT-2 a reaproveita como camada de saída), dá 50.257 logits, um por token do vocabulário. O treino usaria todas as linhas; a geração só precisa da última.
7. Temperatura e amostragem — escolhendo o próximo token. Expanda as probabilidades e leve a temperatura de 0,2 a 2: veja a barra do topo cair e a cauda subir. Troque top-k por top-p e aperte Generate várias vezes em cada ajuste. Com \(T = 0{,}2\) o mesmo token volta quase sempre; com \(T = 2\) e um \(k\) grande, tokens estranhos começam a ganhar.

O que ele não mostra é tão útil quanto o que mostra. O GPT-2 é um bloco de 2019: já pré-LN, mas com LayerNorm, MLP com GELU em \(4d\), atenção multi-head completa, posições absolutas aprendidas e vieses em toda parte — cinco das seis linhas da tabela do que mudou ainda estão do lado de 2017. Nada é treinado na página (os pesos são fixos) e um padrão de atenção é um retrato do que uma head faz numa frase, não uma explicação do modelo.

Laboratório: o caminho completo, medido no GPT-2

Cada afirmação deste capítulo é medida num notebook no Colab com o GPT-2 small — o mesmo modelo que roda no Transformer Explainer. Ele roda no navegador, em CPU; não é preciso instalar nada. Ele complementa o exercício de Transformers (que será publicado mais adiante), em que você constrói as peças do zero: aqui você abre um modelo treinado. São nove seções, cada uma terminando num checkpoint com valor de verificação:

1. texto → tokens e por que o português custa o dobro de tokens do inglês;
2. onde moram os 124M de parâmetros: dois terços de cada bloco são MLP e a camada de saída é a tabela de embedding;
3. o caminho completo em formas e a previsão de cada posição lida nos logits;
4. o bloco 0 escrito à mão com produtos de matrizes, batendo com a biblioteca a menos de \(10^{-5}\);
5. o que heads de verdade fazem: a máscara causal, uma head do token anterior, o sumidouro no primeiro token e heads de indução copiando uma sequência que o modelo nunca viu;
6. a atenção tirada de todos os blocos: duas frases diferentes recebem a mesma previsão;
7. o fluxo residual lido em cada profundidade, onde a resposta se constrói bloco a bloco;
8. temperatura, top-k e top-p nos logits do GPT-2, geração e o cache de KV cronometrado;
9. sua vez: escolha a decodificação para três prompts seus.

Abrir o laboratório no Colab — salve uma cópia no seu Drive (Arquivo → Salvar uma cópia no Drive) para rodar e editar.

Pontos principais

1. Um modelo de linguagem é embedding → \(L\) blocos iguais → projeção para o vocabulário. Dentro da pilha a forma é sempre \(n \times d\); cada posição prevê o token seguinte.
2. A camada de saída transforma o último vetor em um score por token do vocabulário (os logits) e o softmax transforma os scores em probabilidades. Cada posição prevê o seu próximo token, então o treino pontua todas as linhas de uma vez; a geração lê só a última.
3. Um bloco é atenção para conversar (a única troca de informação entre posições), MLP para pensar (cada token sozinho) e residuais que somam correções em vez de substituir o vetor.
4. O pré-LN substituiu o pós-LN e essa é a mudança mais consequente desde 2017 — restaura o caminho identidade (\(x_L = x_0 + \sum f_\ell\)) e elimina a necessidade de warmup.
5. Pense em termos de um fluxo residual do qual cada bloco lê e ao qual soma, não de um pipeline que transforma.
6. RMSNorm, SwiGLU, RoPE, GQA, sem vieses — cinco padrões que você deve assumir salvo aviso em contrário. Entre dois terços e três quartos dos parâmetros de um bloco estão no MLP.
7. O só-decoder venceu porque todo token é sinal de treino, um objetivo cobre toda tarefa e só a atenção causal suporta um cache de KV. Encoders sobrevivem como modelos de embedding e reranking.
8. O próximo token é escolhido, não calculado: a temperatura remodela a distribuição sem mudar a ordem, top-k e top-p cortam a cauda e a decodificação gulosa entra em laço. O id escolhido é anexado, o modelo roda de novo (o cache de KV guarda as linhas antigas) e no fim os ids voltam a ser texto.
9. Leis de escala são o produto real do Transformer. Com \(C \approx 6ND\), Kaplan disse "vá maior", o Chinchilla corrigiu para "20 tokens por parâmetro" e a prática passou dos dois: sobretreine um modelo menor, porque a inferência é paga para sempre.
10. Dados são finitos e compute na inferência é um segundo eixo de escala. Foi para lá que a fronteira se moveu.