Impara Come implementare l'attenzione multi-testa | Costruire Componenti Dei Transformer

Scorri per mostrare il menu


              12345678910111213141516171819202122232425262728293031323334353637383940
            
import numpy as np

# Toy input: 3 tokens, embedding size 6
x = np.array([
    [0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
    [0.6, 0.5, 0.4, 0.3, 0.2, 0.1],
    [0.2, 0.1, 0.4, 0.3, 0.6, 0.5],
])

# Multi-head attention parameters
num_heads = 2
embed_size = x.shape[1]
head_dim = embed_size // num_heads

# Random weights for queries, keys, and values for each head
np.random.seed(42)
W_q = np.random.randn(num_heads, embed_size, head_dim)
W_k = np.random.randn(num_heads, embed_size, head_dim)
W_v = np.random.randn(num_heads, embed_size, head_dim)

attention_outputs = []

for head in range(num_heads):
    # Linear projections
    Q = x @ W_q[head]
    K = x @ W_k[head]
    V = x @ W_v[head]
    
    # Scaled dot-product attention
    scores = Q @ K.T / np.sqrt(head_dim)
    attention_weights = np.exp(scores) / np.sum(np.exp(scores), axis=-1, keepdims=True)
    head_output = attention_weights @ V
    attention_outputs.append(head_output)

# Concatenate outputs from all heads
multi_head_output = np.concatenate(attention_outputs, axis=-1)

print("Output from head 0:\n", attention_outputs[0])
print("Output from head 1:\n", attention_outputs[1])
print("Concatenated multi-head output:\n", multi_head_output)

L'attenzione multi-testa funziona applicando lo stesso meccanismo di self-attention in modo indipendente su più teste in parallelo. Ogni testa utilizza il proprio set di matrici di pesi per query, key e value (W_q, W_k e W_v), proiettando l'input in sottospazi a dimensione inferiore. L'input x in questo esempio contiene tre token, ciascuno con una dimensione di embedding pari a 6, ed è suddiviso in due teste.

Per ogni testa, il codice ripete i passaggi standard della self-attention: calcola le matrici di query (Q), key (K) e value (V), determina gli score di attenzione tramite il prodotto scalare tra Q e K.T (opportunamente scalato) e utilizza una funzione softmax per ottenere i pesi di attenzione. Questi pesi vengono poi utilizzati per combinare i vettori value, producendo l'output di ciascuna testa.

Non viene introdotto alcun nuovo meccanismo: l'attenzione multi-testa è semplicemente il processo di self-attention eseguito in parallelo per ogni testa. Una volta elaborate tutte le teste, i loro output vengono concatenati sull'ultima dimensione. Questo approccio consente al modello di catturare relazioni diverse nei dati, poiché ogni testa può concentrarsi su aspetti differenti dell'input. I risultati stampati illustrano come eseguire più volte lo stesso meccanismo di self-attention e combinare i risultati fornisca una rappresentazione più ricca per ciascun token.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 2

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Sezione 2. Capitolo 2