Lære Hvordan Selvopmærksomhed Beregnes | Forståelse af Transformer-Grundlag

Stryg for at vise menuen

For at forstå, hvordan self-attention beregnes i transformers, skal du følge en præcis sekvens af matematiske operationer. Self-attention-mekanismen gør det muligt for hvert ord i en sætning at fokusere på andre ord, når der dannes en outputrepræsentation. Dette opnås ved at beregne en vægtet sum af alle inputvektorer, hvor vægtene afspejler betydningen af hvert ord for det aktuelle ord, der behandles.

Antag, at du har en kort sætning repræsenteret som en matrix, hvor hver række er en word embedding. Disse embeddings projiceres først til queries, keys og values ved hjælp af lærte vægtmatricer. Kernen i self-attention er derefter beregningen af attention scores og aggregeringen af value-vektorer baseret på disse scores.

Definition

Queries, keys og values er forskellige repræsentationer af inputtet, hver med en specifik rolle i attention-beregningen.

Beregning af selv-opmærksomhed

Selv-opmærksomhed kan opdeles i en række klare matematiske trin for hvert ord i sekvensen:

Projektion af input til forespørgsler, nøgler og værdier: projekter inputmatricen ved hjælp af lærte vægtmatricer for at opnå forespørgsler, nøgler og værdier.


              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

Beregning af opmærksomhedsscorer:

Beregn ligheden mellem hver forespørgsel og alle nøgler;
Disse scorer angiver, hvor meget fokus hvert ord skal have på de andre.


              1
            
scores = Q @ K.T

Skalér scorerne: divider opmærksomhedsscorerne med kvadratroden af nøgle-dimensionen. Denne skalering hjælper med at stabilisere gradienterne under træning.


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

Anvend softmax-funktionen: konverter de skalerede scorer til opmærksomhedsvægte ved hjælp af softmax-funktionen. Dette sikrer, at vægtene er positive og summerer til 1 for hvert ord.


              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)

Beregn den vægtede sum af værdier: brug opmærksomhedsvægtene til at beregne en vægtet sum af value-vektorerne. Dette giver det endelige self-attention output for hvert ord.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Disse trin indfanger de væsentlige beregninger bag self-attention i transformer-modeller.

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 5

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Sektion 1. Kapitel 5

Hvordan Selvopmærksomhed Beregnes

Beregning af selv-opmærksomhed

1. Hvad er den korrekte rækkefølge af operationer i self-attention for ét inputord?

2. Hvorfor skalerer vi opmærksomhedsscorer med kvadratroden af nøgle-dimensionen?

3. Hvilke vektorer bruges til at beregne opmærksomhedsscorer