Aprenda Como a Autoatenção é Calculada | Compreendendo os Fundamentos dos Transformers

Deslize para mostrar o menu

Para compreender como a autoatenção é calculada em transformers, é necessário seguir uma sequência precisa de operações matemáticas. O mecanismo de autoatenção permite que cada palavra em uma frase foque em outras palavras ao produzir uma representação de saída. Isso é alcançado ao calcular uma soma ponderada de todos os vetores de entrada, onde os pesos refletem a importância de cada palavra para a palavra atual em processamento.

Suponha que você tenha uma frase curta representada como uma matriz, onde cada linha é um embedding de palavra. Primeiro, esses embeddings são projetados em queries, keys e values utilizando matrizes de pesos aprendidas. O núcleo da autoatenção é então o cálculo dos scores de atenção e a agregação dos vetores de value com base nesses scores.

Definição

Queries, keys e values são diferentes representações da entrada, cada uma utilizada para um papel específico no cálculo da atenção.

Cálculo de Self-Attention

A autoatenção pode ser decomposta em uma série de etapas matemáticas claras para cada palavra na sequência:

Projeção dos inputs em queries, keys e values: projetar a matriz de entrada utilizando matrizes de pesos aprendidas para obter queries, keys e values.


              123456789101112131415161718192021222324252627282930313233
            
import numpy as np

# Example input: 3 words, embedding size 4
X = np.array([
    [1.0, 0.0, 1.0, 0.0],   # word 1
    [0.0, 2.0, 0.0, 2.0],   # word 2
    [1.0, 1.0, 1.0, 1.0]    # word 3
])

# Weight matrices for queries, keys, values (embedding size 4 -> 4)
W_q = np.array([
    [0.1, 0.2, 0.0, 0.0],
    [0.0, 0.1, 0.3, 0.0],
    [0.1, 0.0, 0.0, 0.2],
    [0.0, 0.0, 0.2, 0.3]
])
W_k = np.array([
    [0.2, 0.0, 0.1, 0.0],
    [0.0, 0.1, 0.0, 0.3],
    [0.1, 0.0, 0.2, 0.0],
    [0.0, 0.2, 0.0, 0.1]
])
W_v = np.array([
    [0.0, 0.1, 0.0, 0.2],
    [0.2, 0.0, 0.2, 0.0],
    [0.0, 0.3, 0.1, 0.0],
    [0.1, 0.0, 0.0, 0.3]
])

# Compute queries, keys, values
Q = X @ W_q
K = X @ W_k
V = X @ W_v

Cálculo dos scores de atenção:

Calcular a similaridade entre cada query e todas as keys;
Esses scores indicam o quanto cada palavra deve focar nas outras.


              1
            
scores = Q @ K.T

Escalonar os scores: dividir os scores de atenção pela raiz quadrada da dimensão das chaves. Esse escalonamento ajuda a estabilizar os gradientes durante o treinamento.


              12
            
d_k = Q.shape[1]
scaled_scores = scores / np.sqrt(d_k)

Aplicar a função softmax: converter os scores escalados em pesos de atenção usando a função softmax. Isso garante que os pesos sejam positivos e somem 1 para cada palavra.


              123456
            
# Softmax to get attention weights
def softmax(x):
    e_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return e_x / np.sum(e_x, axis=-1, keepdims=True)

attention_weights = softmax(scaled_scores)

Calcular a soma ponderada dos valores: usar os pesos de atenção para calcular uma soma ponderada dos vetores de valor. Isso produz a saída final de self-attention para cada palavra.


              12345
            
# Weighted sum of values
output = attention_weights @ V

print("Attention weights:\n", attention_weights)
print("Self-attention output:\n", output)

Esses passos capturam os cálculos essenciais por trás do mecanismo de self-attention em modelos transformer.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 5

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Seção 1. Capítulo 5

Como a Autoatenção é Calculada

Cálculo de Self-Attention

1. Qual é a ordem correta das operações em self-attention para uma palavra de entrada?

2. Por que escalamos os scores de atenção pela raiz quadrada da dimensão das chaves?

3. Quais vetores são usados para calcular os scores de atenção