Redes Neurais Artificiais e Deep Learning · Insper

Transformers

Do texto ao próximo token — e o que mudou desde 2017

O que um modelo de linguagem calcula?

Entrada: "Data visualization empowers users to". O que sai do GPT-2?

  • Não uma palavra: uma probabilidade para cada um dos 50.257 tokens do vocabulário.
  • Medido no laboratório: visualize 0,158, depois create, see, make… — 50.257 números que somam 1.
  • Para escrever texto: escolha um, anexe à entrada, rode de novo.

O caminho completo

texto
"…users to"
→
tokens
n índices
→
embedding
n × d
→
L blocos
n × d → n × d
→
norm +
unembedding
n × V
→
softmax
última linha
V probabilidades

GPT-2 small: tokens no prompt, números por token, blocos, tokens no vocabulário.

unembedding: a camada de saída, d → V, um escore (um logit) por token do vocabulário

  • A forma não muda dentro da pilha — é isso que permite empilhar 12 ou 126 blocos iguais.
  • Toda posição prevê: a linha é a distribuição do token .
  • Gerar é repetir: sorteie, anexe, rode de novo. O cache de KV (as K e V das posições já vistas, guardadas) impede o "de novo" de recalcular tudo.

Tokens não são palavras

"Data visualization empowers users to" → 6 tokens:

Data · visualization · em · powers · users · to

  • O espaço faz parte do token: " the", "the" e " The" são 3 tokens diferentes.
  • 50.257 pedaços, montados em texto da web em inglês.

A mesma frase em português: quantos tokens por palavra?

  • Inglês: 1,08 – 1,15 tokens por palavra (tokens ÷ palavras, nas três frases do laboratório).
  • Português: 1,93 – 2,00 — gato = g + ato, cachorro = 4 pedaços.
  • O dobro de compute e metade do contexto, para a mesma frase.

Toda posição prevê

Logits do prompt: (1, 6, 50257) = (frases, posições, vocabulário) — uma distribuição por posição. GPT-2, medido:

depois de… palpite próximo certo p(certo)
Data . visualization 11,91
Data visualization \n em 11,86
Data visualization em powers powers 0,423 0,86
…empowers you users 0,109 2,22
…empowers users to to 0,847 0,17
…users to visualize ? — —
  • O treino avalia todas as linhas de uma vez: a perda é a média de nas 5 linhas com resposta: 5,40 nats (nat: a unidade do logaritmo natural).
  • A geração só precisa da última linha.

Dentro de um bloco: conversar e depois pensar

x: o fluxo residual, n × d (um vetor por token) · Norm: LayerNorm no GPT-2 · h: o fluxo depois da atenção

Um bloco Transformer pré-LN: o fluxo residual leva x pela parte de cima; a atenção (onde os tokens trocam informação) e depois o MLP (que trabalha em cada token sozinho) leem uma cópia normalizada e somam uma correção de volta ao fluxo. x n × d + h + y n × d fluxo residual: x passa intacto h passa intacto Norm atenção tokens conversam o último token lê os anteriores (máscara causal) Norm MLP cada token sozinho o mesmo MLP em cada token, separadamente

Nenhuma subcamada substitui o vetor: cada uma soma uma correção. O MLP guarda a maior parte do conhecimento. Entra , sai — empilhar é só repetir.

Exercício · siga o tensor

Bloco 0 do GPT-2 small, o prompt de 6 tokens. Preencha antes de virar o slide.

etapa forma
, fluxo residual na entrada ?
Q, K, V por head ?
?
+ atenção ?
camada oculta do MLP ?
, fluxo residual na saída ?

tokens, números por token

12 heads, cada uma com

: máscara causal, acima da diagonal

MLP do GPT-2:

Responda em (heads ×) tokens × números.

Siga o tensor · resposta

6×768Q, K, V12 heads de 6412×6×64QKᵀ/√64 + Msoftmax12×6×6A·V, juntarWO, + x6×768MLP768 → 30726×30723072 → 768+ h6×768

etapa forma de onde vem
6 × 768 tokens, números cada
Q, K, V por head 12 × 6 × 64 é 6 × 768, cortado em 12 heads de 768/12 = 64
12 × 6 × 6 por head, = (6 × 64)(64 × 6): cada token contra cada token
+ atenção 6 × 768 é 12 × 6 × 64; heads lado a lado, 12 · 64 = 768; e soma com
camada oculta do MLP 6 × 3072 = 4 · 768 = 3072, cada token sozinho
6 × 768 3072 → 768 e soma com : a mesma forma que entrou

Um bloco à mão = a biblioteca

O bloco 0 do GPT-2 só com @, uma máscara, um softmax, LayerNorm e GELU — com os pesos do próprio modelo:

comparado com a biblioteca diferença máxima
saída do bloco 0, 6 × 768
pesos de atenção, 12 × 6 × 6
logits depois dos 12 blocos + norm final + wteᵀ

wte: a tabela de embedding de tokens, 50.257 × 768; transposta, ela é a camada de saída (768 → 50.257).

Arredondamento de float32, nada mais: as duas equações de "Dentro de um bloco" são o modelo.

Simulador · um bloco, linha a linha

x · fluxo residual de entrada

O exemplo: de y a “␣telhado”

O brinquedo (d = 4, um bloco, V = 12), último token de "o gato subiu no": .

  1. Norma final: , →
  2. Unembedding (): coluna de ␣telhado = →
  3. Softmax: → ␣
token
␣telhado 2,491 0,395
␣muro 1,463 0,141
␣sofá 0,999 0,089
␣chão 0,970 0,086
␣gato 0,634 0,062
outros 7 0,227

Cada linha prevê o seu próximo token: p(alvo) = 0,500; 0,444; 0,274; 0,311; 0,395 → média de −ln p = 0,979 nats (uniforme: ln 12 = 2,485). Sem atenção a última linha diz ␣gato 0,455, ␣telhado 0,143.

Onde estão os parâmetros

GPT-2 small, um bloco, medido (; toda linear tem pesos e vieses):

parte conta parâmetros
atenção: (768 → 3 · 768) e (768 → 768) 2.362.368
MLP: 768 → 3072 → 768 4.722.432
duas LayerNorms (ganho e viés) 3.072
o bloco a soma 7.087.872 · MLP 66,6%
  • MHA (multi-head attention: K e V próprios em cada head): MLP = dois terços. GQA (grouped-query attention: 32 heads de query dividem 8 de K/V), classe 8B, : MLP M, atenção 42M → três quartos de 177M.
  • GPT-2 inteiro: 124,4M. A tabela de embedding, M, é 31% e a camada de saída é essa tabela.
  • A MoE (mixture of experts: vários MLPs e um roteador que manda cada token para poucos deles) substitui o MLP, porque é lá que estão os parâmetros.

Verifique você mesmo: tire a atenção

Zere a saída de todas as subcamadas de atenção e mantenha os MLPs. Em que a previsão se baseia agora?

  • Duas frases de 10 tokens, ambas terminando em the:
…cat… climbed onto the …cash… walked to the
com atenção roof 0,083 · bed 0,059 bank 0,092 · front 0,028
sem atenção same 0,047 · first 0,019 same 0,047 · first 0,019
  • Sem atenção as duas distribuições são idênticas (diferença 0): a última posição só vê the e o seu índice (9). Perda média no parágrafo de 72 tokens do laboratório: 3,96 → 5,71 nats.

O que heads de verdade fazem

144 heads (12 blocos × 12), pontuadas em três funções — GPT-2 small, medido:

função melhor head (bloco.head) peso
olhar o token anterior 4.11 1,00
olhar o primeiro token ("sumidouro") 5.1 0,99 — 64 de 144 heads põem > metade ali
indução: "da última vez que vi isto, o que veio depois?" 5.5 0,95

4.11 = bloco 4, head 11, contando do 0 · peso = atenção média que a head põe no alvo (0 a 1)

  • Uma sequência aleatória de 50 tokens, repetida: perda de 11,95 nats na primeira cópia (chutar ao acaso daria ), 0,21 na segunda, top-1 100%.
  • O modelo copia uma sequência que nunca viu — e essas heads são o como.

Vá e experimente · Transformer Explainer

O GPT-2 small rodando no seu navegador, cada etapa desenhada para o texto que você digitar — poloclub.github.io/transformer-explainer (Cho et al., 2024).

  1. Embedding: conte os tokens do exemplo e depois os de uma frase em português. O vetor de posição é aprendido — nem senoide nem RoPE.
  2. Atenção: expanda a matriz. Tudo acima da diagonal está vazio. Passe por heads e blocos: ache uma head do token anterior e heads que carregam o primeiro token.
  3. Temperatura: leve de 0,2 a 2 e aperte Generate algumas vezes em cada ajuste. Observe a barra do topo e a cauda.

A primeira visita baixa cerca de 660 MB de pesos; o capítulo tem um roteiro passo a passo das sete etapas.

As seis coisas que mudaram desde 2017

peça 2017 GPT-2 (2019) 2026
posição da norma depois da soma (pós-LN) antes da subcamada (pré-LN) pré-LN
normalizador LayerNorm LayerNorm RMSNorm
MLP ReLU, 2 matrizes, GELU, 2 matrizes, SwiGLU, 3 matrizes,
atenção MHA MHA GQA — cache de KV 4× menor (8 heads de K/V para 32 de Q)
posição senoidal, na entrada aprendida, na entrada RoPE, em Q e K
viés em toda parte em toda parte nenhum

O mecanismo não mudou; a engenharia em volta dele, sim. O GPT-2 — o modelo do Explainer e do laboratório — já tinha a primeira linha. RoPE: rotary position embedding — Q e K giram por um ângulo proporcional à posição, então o escore entre eles depende da distância entre os tokens.

Simulador · configure o bloco

Pré-LN: onde a norma fica

  • O pós-LN põe um normalizador no caminho residual em cada camada: o gradiente perde a rota identidade — não treina sem warmup (taxa de aprendizado começando pequena) e piora com a profundidade.
  • O pré-LN se desenrola em a entrada mais a soma de todas as correções (: o que o bloco soma; : a identidade):

  • Esse é o motivo pelo qual pilhas de 100 camadas são banais.

O fluxo residual, lido em cada profundidade

Aplique a norm final e a camada de saída ao fluxo depois de cada bloco ("logit lens"). Resposta final: visualize. Posição 1 = o mais provável dos 50.257.

lido depois do bloco embedding 3 6 8 9 10 11 12
posição de visualize 8532 381 62 12 2 1 1 1
sua probabilidade 0,000 0,000 0,002 0,012 0,285 0,919 0,941 0,158
  • A resposta é acumulada num fluxo só, bloco a bloco — não calculada no fim.
  • O bloco 12 baixa a confiança para os 0,158 do primeiro slide: o último bloco espalha massa pelas alternativas.

RMSNorm e SwiGLU

A RMSNorm mantém o reescalonamento e abandona a centragem. :

  • LayerNorm: média 3,5, desvio 0,5 →
  • RMSNorm: só a raiz da média dos quadrados →

Uma redução em vez de duas, sem custo mensurável de qualidade.

O SwiGLU — um ramo abre a passagem do outro:

Swish(u) = u·σ(u), σ: a sigmoide · ⊙: produto elemento a elemento

  • Três matrizes de : , o mesmo que duas de ().
  • Um ganho pequeno e consistente — o bastante para todo grande modelo aberto desde o Llama.

Encoder, decoder: qual sobreviveu

família atenção treinada por em 2026
só encoder — BERT bidirecional tokens mascarados embeddings, busca, rerankers; não gera
encoder–decoder — T5, BART as duas + cruzada sequência a sequência onde os dois lados diferem: fala (Whisper), texto em imagens
só decoder — GPT, Llama, Claude causal próximo token venceu — todo modelo de linguagem de fronteira

O só-decoder vê menos contexto por token. Por que venceu?

Por que o só-decoder venceu

  1. Todo token é sinal de treino. Uma passagem sobre tokens dá previsões; o BERT aprende com os ~15% que mascara.
  2. Um objetivo cobre toda tarefa. Prever o próximo token engloba classificação, extração, tradução, diálogo — assim que o modelo pode ser instruído.
  3. O cache de KV só funciona causalmente. Um modelo bidirecional recodifica tudo quando a entrada cresce; um causal acrescenta.

O BERT treina com [MASK], um token que nunca aparece na inferência. Prever o próximo token não tem esse buraco: o treino é a produção.

Escolhendo o próximo token: temperatura

zi: o logit do token i (a saída do modelo antes do softmax) · T: a temperatura

GPT-2, depois de …empowers users to:

p( visualize) tokens p/ 90%
0,2 0,976 1
0,5 0,656 6
0,8 0,294 97
1,0 0,158 294
2,0 0,013 5.956

tokens p/ 90%: quantos dos mais prováveis somam 0,9

  • concentra, achata; a ordem nunca muda — a decodificação gulosa (sempre o token mais provável) é a mesma em qualquer .
  • : guloso. : uniforme sobre 50.257.
  • Logits , : no topo. os dobra para : .

Top-k, top-p — e o que sai

  • O top-k mantém os mais prováveis; o top-p mantém o menor conjunto que soma — o tamanho acompanha a confiança do modelo:
prompt o mais provável (top-1) top-p 0,9 mantém
…44th President of the United States 0,998 1 token
Once upon a time, there was a man 0,044 3.651 tokens
  • Guloso: "visualize and visualize data in a way that is easy to understand." — e depois entra em laço.
  • , sem filtro: "along button pilot discriminationave…" — a cauda vence.

Gerando o exemplo

␣telhado ␣muro ␣sofá
0,5 0,761 0,097 0,039
1 0,395 0,141 0,089
2 0,208 0,124 0,098
  • top-k 2: ␣telhado 0,737, ␣muro 0,263
  • top-p 0,9 com : ficam 8 de 12 (uma distribuição achatada)
  • + top-p 0,9: ficam 6; soma acumulada 0,626; 0,770; 0,845… → dá ␣telhado, dá ␣sofá
passo ids de entrada próximo
1 [0, 2, 4, 5, 1] ␣telhado 0,395
2 … + 6 . 0,538
3 … + 10 <|endoftext|> 0,401
  • As linhas 1–5 nunca mudam (máscara causal): o cache de KV guarda K e V delas; cada passo calcula uma linha.
  • Decodificar: o ␣gato ␣sub iu ␣no ␣telhado . → "o gato subiu no telhado."

Simulador · escolher, anexar, rodar de novo

Escala: três perguntas, três respostas

O orçamento é o compute , em FLOPs (operações de ponto flutuante), dividido entre parâmetros e tokens de treino :

  • 6 = cerca de 2 operações por parâmetro por token na ida (multiplicação, soma) + 4 na volta.
  • Com fixo, dobrar o modelo corta os dados pela metade.

Chinchilla: 70B () de parâmetros, 1,4T () de tokens. Quanto foi ?

  • FLOPs.

Simulador · reparta o compute

Kaplan, Chinchilla e a prática

modelo tokens / parâmetro, (FLOPs)
GPT-3 (2020) — vá maior 175B 0,3T 1,7
Chinchilla (2022) — juntos 70B 1,4T 20
Llama 3 8B (2024) — sobretreine 8B 15T 1875 ≈ 1900
  • O Chinchilla e o Llama 3 8B custam quase o mesmo para treinar.
  • O segundo é 9× menor (70B / 8B ≈ 9), então cada token que ele serve custa cerca de 9× menos — e esse custo se paga bilhões de vezes.

Mais duas correções

  • Os dados são finitos. Texto de qualidade é limitado e repeti-lo tem retornos fortemente decrescentes depois de algumas épocas: o eixo tem parede.
  • O compute de treino não é mais o único eixo. Mais compute na inferência — várias cadeias de raciocínio, busca, verificação — também escala (aula de LLMs).

O produto real do Transformer não é uma escolha de projeto: é que a perda cai de forma previsível com parâmetros, dados e compute.

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

Notebook no Colab, ~2 h, GPT-2 small em CPU. Cada seção termina num checkpoint com valor de verificação.

  1. texto → tokens, em dois idiomas
  2. onde moram os 124M de parâmetros
  3. o caminho completo, em formas
  4. um bloco à mão = a biblioteca
  5. o que heads de verdade fazem
  1. tire a atenção, mantenha o resto
  2. o fluxo residual em cada profundidade
  3. temperatura, top-k, top-p, cache de KV
  4. sua vez: escolha a decodificação

abrir no Colab →

Para levar

  1. Um modelo de linguagem é embedding → blocos iguais → projeção para o vocabulário; o caminho todo e toda posição prevê.
  2. Um bloco: atenção para conversar, MLP para pensar, residuais que somam correções.
  3. O pré-LN restaura o caminho identidade; pense num fluxo residual.
  4. RMSNorm, SwiGLU, RoPE, GQA, sem vieses; de dois terços a três quartos de um bloco é MLP.
  5. O só-decoder venceu: todo token é sinal, um objetivo só, cache de KV.
  6. O próximo token é escolhido: a temperatura remodela, top-k / top-p cortam a cauda.
  7. : Kaplan, Chinchilla e depois sobretreinar pequeno, porque a inferência se paga para sempre.

Roteiro: (1) o caminho completo, do texto ao próximo token, num GPT-2 de verdade; (2) dentro de um bloco: conversar e depois pensar; (3) Transformer Explainer; (4) as seis coisas que mudaram desde 2017; (5) qual família venceu; (6) escolhendo o próximo token; (7) escala. Fecha com o laboratório no Colab.

Deixe a turma responder "a próxima palavra" primeiro e então corrija: uma distribuição. Escolher é uma etapa separada, com controles próprios, no fim da aula.

No laboratório (seção 4) a função bloco_a_mao imprime exatamente estas seis formas.

A bloco_a_mao do laboratório com uma head, 3 tokens, d = 4 e pesos escolhidos à mão. Avance com Avançar e leia a legenda: a fórmula com os números do token 3 (linha 3 de A = 0,107; 0,787; 0,107; y31 = 1,651). Depois os casos: "linha 2 × 10" (o u não muda, só o residual carrega o tamanho), "só o último token muda" (as linhas 1 e 2 não se mexem: máscara causal), "sem atenção" (h = x, cada linha sozinha).

As páginas do capítulo levam o brinquedo do texto até aqui, com cada número conferível. O GPT-2 faz as mesmas três contas com d = 768 e V = 50.257. A W_U dele é a wte transposta; o brinquedo tem a sua.

Dez minutos em aula ou como tarefa antes do laboratório. O roteiro na página liga cada etapa a uma seção do capítulo. O GPT-2 é um bloco de 2019: o próximo slide mostra que partes já são modernas.

Comece do padrão (2026). Mude todos os controles para a primeira opção e marque os vieses: o artigo de 2017. Veja a linha do residual ficar cinza com o pós-LN e a divisão dos parâmetros: dois terços de MLP com MHA, três quartos com GQA.

O guloso escreve ␣telhado sempre. A amostragem às vezes escreve ␣sofá: uma frase boa que o modelo também considerou. O token de fim de texto é o jeito de o modelo parar sozinho.

Padrão: T = 0,7, top-p 0,9, u = 0,5 → ␣telhado; a última linha roda de novo e prevê "." (0,538). Depois: guloso (u não importa), quente T = 2 (a cauda cresce), top-k 2; mova u para 0,8 → ␣sofá.

Ache o mínimo da curva em 1e23: cerca de 20 tokens por parâmetro. Depois marque "precificar a inferência também" e arraste os tokens a servir de 1e10 a 1e15: o modelo mais barato encolhe e é treinado em muito mais tokens do que o Chinchilla diria.