Conteúdo do curso Lição 107 de 250 · Intuição de Redes Neurais, LLMs e Conclusão de IA
Intuição de Redes Neurais, LLMs e Conclusão de IA

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 1

A 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 @ V

Juntando 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.

Sua vez

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.