Apprendre How Self-Attention Is Calculated | Compréhension des Bases des Transformers

Glissez pour afficher le menu

Pour comprendre comment l'auto-attention est calculée dans les transformers, il faut suivre une séquence précise d'opérations mathématiques. Le mécanisme d'auto-attention permet à chaque mot d'une phrase de se concentrer sur d'autres mots lors de la production d'une représentation en sortie. Cela est réalisé en calculant une somme pondérée de tous les vecteurs d'entrée, où les poids reflètent l'importance de chaque mot par rapport au mot en cours de traitement.

Supposons que vous disposiez d'une phrase courte représentée sous forme de matrice, où chaque ligne correspond à une représentation vectorielle d'un mot. Vous projetez d'abord ces représentations en requêtes, clés et valeurs à l'aide de matrices de poids apprises. Le cœur de l'auto-attention réside ensuite dans le calcul des scores d'attention et l'agrégation des vecteurs de valeur en fonction de ces scores.

Définition

Les requêtes, clés et valeurs sont des représentations différentes de l'entrée, chacune utilisée pour un rôle spécifique dans le calcul de l'attention.

Calcul du self-attention

Le mécanisme de self-attention peut être décomposé en une série d'étapes mathématiques claires pour chaque mot de la séquence :

Projection des entrées en requêtes, clés et valeurs : projeter la matrice d'entrée à l'aide de matrices de poids apprises pour obtenir les requêtes, les clés et les valeurs.


              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

Calcul des scores d'attention :

Calculer la similarité entre chaque requête et toutes les clés ;
Ces scores indiquent dans quelle mesure chaque mot doit se concentrer sur les autres.


              1
            
scores = Q @ K.T

Mise à l'échelle des scores : division des scores d'attention par la racine carrée de la dimension des clés. Cette mise à l'échelle permet de stabiliser les gradients pendant l'entraînement.


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

Appliquer la fonction softmax : conversion des scores mis à l'échelle en poids d'attention à l'aide de la fonction softmax. Cela garantit que les poids sont positifs et que leur somme est égale à 1 pour chaque mot.


              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)

Calcul de la somme pondérée des valeurs : utilisation des poids d'attention pour calculer une somme pondérée des vecteurs de valeurs. Cela produit la sortie finale de l'auto-attention pour chaque mot.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Ces étapes résument les calculs essentiels derrière l’auto-attention dans les modèles de transformeurs.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 1. Chapitre 5

How Self-Attention Is Calculated

Calcul du self-attention

1. Quel est l’ordre correct des opérations dans l’auto-attention pour un mot en entrée ?

2. Pourquoi met-on à l'échelle les scores d'attention par la racine carrée de la dimension des clés ?

3. Quels vecteurs sont utilisés pour calculer les scores d'attention