Leer Hoe Zelf-Attentie Wordt Berekend | Begrip van Transformer-Grondslagen

Veeg om het menu te tonen

Om te begrijpen hoe self-attention wordt berekend in transformers, moet een nauwkeurige reeks wiskundige bewerkingen worden gevolgd. Het self-attention-mechanisme maakt het mogelijk dat elk woord in een zin zich richt op andere woorden bij het produceren van een outputrepresentatie. Dit wordt bereikt door het berekenen van een gewogen som van alle invoervectoren, waarbij de gewichten de belangrijkheid van elk woord voor het huidige verwerkte woord weergeven.

Stel dat er een korte zin is weergegeven als een matrix, waarbij elke rij een woordembedding is. Deze embeddings worden eerst geprojecteerd naar queries, keys en values met behulp van getrainde gewichtsmatrices. De kern van self-attention is vervolgens de berekening van attentiescores en de aggregatie van value-vectoren op basis van deze scores.

Definitie

Queries, keys en values zijn verschillende representaties van de input, elk gebruikt voor een specifieke rol in de attention-berekening.

Zelf-Attentie Berekening

Zelf-attentie kan worden opgesplitst in een reeks duidelijke wiskundige stappen voor elk woord in de reeks:

Projecteer invoer naar queries, keys en values: projecteer de invoermatrix met behulp van geleerde gewichtsmatrices om queries, keys en values te verkrijgen.


              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

Bereken attentiescores:

Bepaal de gelijkenis tussen elke query en alle keys;
Deze scores geven aan hoeveel aandacht elk woord aan de andere woorden moet besteden.


              1
            
scores = Q @ K.T

Schaal de scores: deel de attentiescores door de vierkantswortel van de sleutel-dimensie. Deze schaalverdeling helpt de gradiënten te stabiliseren tijdens het trainen.


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

Pas de softmax-functie toe: converteer de geschaalde scores naar attentiegewichten met behulp van de softmax-functie. Dit zorgt ervoor dat de gewichten positief zijn en voor elk woord optellen tot 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)

Bereken de gewogen som van waarden: gebruik de attentiegewichten om een gewogen som van de waardevectoren te berekenen. Dit levert de uiteindelijke self-attention-uitvoer voor elk woord op.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Deze stappen vatten de essentiële berekeningen samen achter self-attention in transformermodellen.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 5

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 1. Hoofdstuk 5

Hoe Zelf-Attentie Wordt Berekend

Zelf-Attentie Berekening

1. Wat is de juiste volgorde van bewerkingen in self-attention voor één invoerwoord?

2. Waarom schalen we attentiescores met de vierkantswortel van de sleutel-dimensie?

3. Welke vectoren worden gebruikt om attentiescores te berekenen