Impara Come viene calcolata l'autoattenzione

Scorri per mostrare il menu

Per comprendere come viene calcolata la self-attention nei transformer, è necessario seguire una sequenza precisa di operazioni matematiche. Il meccanismo di self-attention consente a ciascuna parola in una frase di concentrarsi su altre parole durante la produzione di una rappresentazione in output. Questo viene ottenuto calcolando una somma pesata di tutti i vettori di input, dove i pesi riflettono l'importanza di ciascuna parola rispetto alla parola attualmente in elaborazione.

Supponiamo di avere una breve frase rappresentata come una matrice, in cui ogni riga è un word embedding. Questi embedding vengono prima proiettati in query, key e value utilizzando matrici di pesi apprese. Il nucleo della self-attention è quindi il calcolo degli score di attenzione e l'aggregazione dei vettori value in base a questi score.

Definizione

Query, key e value sono rappresentazioni differenti dell'input, ciascuna utilizzata per uno scopo specifico nel calcolo dell'attenzione.

Calcolo della Self-Attention

La self-attention può essere suddivisa in una serie di passaggi matematici chiari per ogni parola nella sequenza:

Proiezione degli input in query, key e value: proiezione della matrice di input utilizzando matrici di pesi apprese per ottenere query, key e value.


              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

Calcolo dei punteggi di attenzione:

Calcolo della similarità tra ogni query e tutte le key;
Questi punteggi indicano quanto ogni parola deve concentrarsi sulle altre.


              1
            
scores = Q @ K.T

Scalare i punteggi: dividere i punteggi di attenzione per la radice quadrata della dimensione delle chiavi. Questa normalizzazione aiuta a stabilizzare i gradienti durante l'addestramento.


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

Applicare la funzione softmax: convertire i punteggi scalati in pesi di attenzione utilizzando la funzione softmax. Questo garantisce che i pesi siano positivi e che la loro somma per ogni parola sia pari a 1.


              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)

Calcolare la somma pesata dei valori: usare i pesi di attenzione per calcolare una somma pesata dei vettori valore. Questo produce l'output finale della self-attention per ogni parola.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Questi passaggi rappresentano i calcoli essenziali alla base dell'autoattenzione nei modelli transformer.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 5

Chieda ad AI

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

Sezione 1. Capitolo 5

Come viene calcolata l'autoattenzione

Calcolo della Self-Attention

1. Qual è il corretto ordine delle operazioni nell'autoattenzione per una parola in input?

2. Perché si scalano i punteggi di attenzione per la radice quadrata della dimensione delle chiavi?

3. Quali vettori vengono utilizzati per calcolare i punteggi di attenzione