Carregando
0xE0Lição 15 de 17

Atenção e transformadores

Deixe que cada posição olhe uma para a outra com atenção e monte o bloco transformador por trás da IA ​​moderna.

34 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Calcule a atenção do produto escalar a partir de consultas, chaves e valores
  • Aplique máscaras causais e explique a atenção de múltiplas cabeças e codificações posicionais
  • Descreva um bloco transformador: atenção, feed-forward, resíduos e norma de camada

“Neuro perseguiu a bola porque ela continuava quicando.” Para entender ela, você olha para bola. Atenção permite que cada posição em uma sequência analise todas as outras posições diretamente e decida o quanto cada uma é importante.

O vetor de cada token é projetado de três maneiras:

  • uma consulta qq - o que estou procurando?
  • uma chave kk - o que eu contenho?
  • um valor vv - o que eu passo se você me atender?

A atenção de um token para outro é o produto escalar de sua consulta pela chave do outro: semelhante significa relevante. Softmax transforma essas pontuações em pesos e o resultado é a média ponderada dos valores:

Attention(Q,K,V)=softmax(QK⊤dk)V\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right) V

A divisão por dk\sqrt{d_k} (o tamanho da chave) evita que os produtos escalares cresçam com a dimensão, o que empurraria o softmax para regiões planas e sem gradiente.

Experimente

Até 15 XP

Onde fica cada palavra?

Clique em uma palavra para ver como ela distribui sua atenção pela frase. Clique em ela: qual palavra recebe mais atenção? Depois, aumente a temperatura para ver a atenção se espalhar.

Clique em uma palavra para ver para onde ela olha

“Neuro” dá mais atenção a “Neuro” (34%). Os pesos somam 100%.

  • Neuro34,0%
  • perseguiu20,6%
  • a7,6%
  • bola7,6%
  • porque7,6%
  • ela7,6%
  • continuou7,6%
  • quicando7,6%
attention.py
1import numpy as np
2
3def softmax(z):
4    e = np.exp(z - z.max(axis=-1, keepdims=True))
5    return e / e.sum(axis=-1, keepdims=True)
6
7def attention(Q, K, V, causal=False):
8    scores = Q @ K.T / np.sqrt(K.shape[1])        # (seq, seq)
9    if causal:
10        future = np.triu(np.ones_like(scores), k=1).astype(bool)
11        scores = np.where(future, -np.inf, scores)
12    weights = softmax(scores)
13    return weights @ V, weights
14
15rng = np.random.default_rng(0)
16X = rng.normal(size=(4, 8))                        # 4 tokens, 8 features each
17W_q, W_k, W_v = (rng.normal(size=(8, 8)) for _ in range(3))
18out, weights = attention(X @ W_q, X @ W_k, X @ W_v, causal=True)
19print(out.shape)
20print(np.round(weights, 2))
Saída
(4, 8)
[[1.   0.   0.   0.  ]
 [1.   0.   0.   0.  ]
 [0.17 0.36 0.47 0.  ]
 [0.05 0.35 0.04 0.56]]

A máscara causal define pontuações para posições futuras como −∞ antes do softmax, de modo que cada token pode atender apenas a si mesmo e aos tokens anteriores. Os modelos de linguagem precisam disso: ao prever a próxima palavra, espiar seria trapaça. (O triângulo superior dos pesos é todo zero.)

Atenção com múltiplas cabeças executa várias atenções em paralelo com diferentes projeções - uma cabeça pode rastrear a gramática, outra a qual substantivo um pronome se refere - e concatena os resultados. E como a atenção trata a entrada como um conjunto, os transformadores adicionam codificações posicionais (ondas senoidais fixas ou vetores aprendidos) aos embeddings de token para que a ordem das palavras não seja perdida.

O bloco transformador

O artigo de 2017 “Atenção é tudo que você precisa” construiu toda uma arquitetura a partir da atenção. Um bloco transformador é:

x = x + MultiHeadAttention(LayerNorm(x))     # combina informações entre posições
x = x + FeedForward(LayerNorm(x))            # processa cada posição: Linear → GELU → Linear

Empilhe dezenas deles. Tudo desta trilha está lá: camadas lineares, ativação GELU, conexões residuais, normalização de camadas, softmax. Um modelo de linguagem como Claude é uma grande pilha desses blocos treinados com entropia cruzada para prever o próximo token - com AdamW, aquecimento e recorte de gradiente. Agora você conhece cada peça.

Principais conclusões

  • Atenção: softmax(QKᵀ/√dₖ)V - cada posição obtém uma média ponderada de todos os valores, ponderada pela similaridade da chave de consulta.

  • Uma máscara causal esconde posições futuras; a atenção multicabeças executa várias atenções em paralelo.

  • As codificações posicionais dão à atenção um senso de ordem.

  • Um bloco transformador = atenção + feed-forward, cada um com norma de camada e conexão residual.

Quiz da aula

7 perguntas · aprovação com 5 acertos · até 50 XP

Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.

Pratique: escreva código em Python

Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.

Exercício 1

Autoatenção causal

+25 XP

A entrada é tokens dim seed causal (causal é 1 ou 0). O código inicial desenha X e os pesos de projeção de np.random.default_rng(seed). Implemente a atenção do produto escalar com uma máscara causal opcional e, em seguida, imprima os pesos da atenção (cada linha com 2 casas decimais) e a soma de cada linha de saída com 3 casas decimais.

  • Causal
  • Não causal
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Exercício 2

Codificações posicionais sinusoidais

+25 XP

O transformador original codifica a posição pospos em um vetor de tamanho dd com senos e cossenos de diferentes frequências:

PE(pos,2i)=sin⁡(pos100002i/d),PE(pos,2i+1)=cos⁡(pos100002i/d)PE(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d}}\right), \qquad PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d}}\right)

A entrada é positions d. Imprima a codificação para as posições 0 a posições −1, uma linha cada, valores com 3 casas decimais.

  • 3 posições, d = 4
main.py
Carregando editor…

O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.

Dúvidas sobre esta lição

Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.

Carregando publicações…