Auto-Atenção do Zero
Você já construiu um neurônio e um forward pass. Agora vai construir a ideia que transformou redes neurais simples em transformers e, a partir daí, nos LLMs por trás de todo assistente de chat: a self-attention. São algumas multiplicações de matrizes, e você pode fazer tudo em numpy.
A intuição
Imagine que cada palavra de uma frase quer reunir informação das outras palavras. A self-attention dá a cada posição três vetores:
- Uma query (Q): o que esta posição está procurando.
- Uma key (K): o que cada posição oferece, usada para a comparação.
- Um value (V): a informação real que cada posição carrega.
Uma posição compara sua query com cada key para decidir quanto ouvir cada uma das outras posições, e depois faz uma mistura ponderada dos values usando essas quantidades. Correspondência forte -> peso grande -> aquele value contribui mais. Esse é todo o mecanismo: queries prestam atenção a keys, e a resposta é uma mistura ponderada de values.
A matemática: scaled dot-product attention
A pontuação de correspondência entre uma query e uma key é o produto escalar delas (maior quando apontam na mesma direção). Empilhe todas as queries em uma matriz Q e todas as keys em K, e todas as pontuações de uma vez são Q @ K.T. Dividimos por sqrt(d_k) (a dimensão das keys) para que as pontuações não explodam quando os vetores ficam mais longos:
scores = Q @ K.T / np.sqrt(d_k)Por que dividir? Um produto escalar cresce com a dimensão. Se d_k é 64 e as entradas ficam em torno de 1, as pontuações brutas ficam perto de 64, e números tão grandes empurram a softmax para uma única key e achatam o gradiente. Dividir por sqrt(d_k), aqui sqrt(64) = 8, traz as pontuações de volta para um intervalo razoável, para que a atenção continue suave e treinável. No pequeno exemplo com d_k = 1 que você roda abaixo, o divisor é só 1, então você não vai ver o efeito, mas em modelos de tamanho real ele é essencial.
Cada linha de scores guarda as pontuações de uma query contra todas as keys. Transformamos cada linha em pesos positivos que somam 1 com uma softmax sobre o último eixo:
weights = softmax(scores, axis=-1) # each row sums to 1A softmax exponencia e normaliza. Feito de forma ingênua, o np.exp de uma pontuação grande estoura para inf e os pesos saem como nan. A correção é o truque padrão numericamente estável: subtraia o máximo de cada linha antes de exponenciar. Matematicamente isso não muda o resultado (a mesma constante se cancela em cima e embaixo), mas mantém todo expoente <= 0:
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # stability: largest exponent is now 0
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)Por fim, a saída de cada query são seus pesos aplicados aos values, o que é mais uma multiplicação de matrizes:
output = weights @ VJuntando tudo, a famosa fórmula é só softmax(Q @ K.T / sqrt(d_k)) @ V. Se Q é (n, d_k), K é (m, d_k) e V é (m, d_v), então weights é (n, m) e output é (n, d_v): um vetor de saída por query, cada um uma mistura das linhas de values.
Este é todo o truque do transformer
Um transformer real não para em um único cálculo de atenção. A multi-head attention roda vários desses em paralelo (cada head aprende suas próprias projeções Q, K, V, então heads diferentes prestam atenção a coisas diferentes) e concatena os resultados. Um bloco de transformer então empilha a atenção com uma pequena rede feed-forward e uma conexão residual, e um modelo empilha dezenas desses blocos. Mas o coração de cada um deles é exatamente a função que você está prestes a escrever: pontuações, softmax estável, soma ponderada dos values. Construa isto e você entende a operação central que um LLM repete quando "presta atenção" ao prompt.
Uma ressalva honesta: aqui Q, K e V são entregues a você como arrays fixos. Em um modelo real eles não são dados, eles são produzidos multiplicando o embedding de cada token por três matrizes de pesos aprendidas, W_q, W_k e W_v. Essas matrizes, e as de todos os blocos, são exatamente o que o treino ajusta usando o gradient descent da última lição. Então o que você constrói aqui é o núcleo fixo da atenção, idêntico em todo transformer; o aprendizado mora nas projeções que o alimentam.
Clique em Run para ver a atenção transformar um pequeno Q/K/V em uma saída e imprimir a matriz de pesos, para você ler quem prestou atenção em quem.
Implemente scaled dot-product attention em numpy. Escreva attention(Q, K, V) que retorna uma tupla (output, weights). Calcule scores = Q @ K.T / np.sqrt(d_k) onde d_k é a última dimensão de Q; aplique um numerically stable softmax sobre o último eixo (subtraia o máximo de cada linha antes de np.exp) para obter weights cujas linhas somam 1; então output = weights @ V. Retorne output primeiro, depois a matriz weights. Depois defina out, w = attention(Q, K, V) para os arrays fornecidos.
Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição
Este exercício abre em breve
Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.
Este navegador está bloqueando cookies para learn.floati.life, então as lições que você terminou aqui não podem abrir em ordem. Permita cookies para este site e recarregue.