Lära Hur självuppmärksamhet beräknas | Förstå Grunderna I Transformer

Svep för att visa menyn

För att förstå hur självuppmärksamhet beräknas i transformatorer behöver du följa en exakt sekvens av matematiska operationer. Självuppmärksamhetsmekanismen gör det möjligt för varje ord i en mening att fokusera på andra ord när en utdatarepresentation skapas. Detta uppnås genom att beräkna en viktad summa av alla inmatningsvektorer, där vikterna återspeglar betydelsen av varje ord för det aktuella ordet som behandlas.

Anta att du har en kort mening representerad som en matris, där varje rad är en ordinbäddning. Du projicerar först dessa inbäddningar till queries, keys och values med hjälp av inlärda viktmatriser. Kärnan i självuppmärksamhet är sedan beräkningen av uppmärksamhetspoäng och aggregeringen av value-vektorer baserat på dessa poäng.

Definition

Queries, keys och values är olika representationer av indata, där varje används för en specifik roll i uppmärksamhetsberäkningen.

Beräkning av självuppmärksamhet

Självuppmärksamhet kan delas upp i en serie tydliga matematiska steg för varje ord i sekvensen:

Projektera indata till queries, keys och values: projektera inmatningsmatrisen med hjälp av inlärda viktmatriser för att erhålla queries, keys och values.


              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

Beräkna uppmärksamhetspoäng:

Beräkna likheten mellan varje query och alla keys;
Dessa poäng visar hur mycket fokus varje ord bör lägga på de andra.


              1
            
scores = Q @ K.T

Skala poängen: dividera uppmärksamhetspoängen med kvadratroten av nyckeldimensionen. Denna skalning hjälper till att stabilisera gradienterna under träningen.


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

Applicera softmax-funktionen: konvertera de skalade poängen till uppmärksamhetsvikter med hjälp av softmax-funktionen. Detta säkerställer att vikterna är positiva och summerar till 1 för varje 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)

Beräkna den viktade summan av värden: använd uppmärksamhetsvikterna för att beräkna en viktad summa av värdevektorerna. Detta ger det slutliga självuppmärksamhetsutdata för varje ord.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Dessa steg fångar de grundläggande beräkningarna bakom självuppmärksamhet i transformer-modeller.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 5

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Avsnitt 1. Kapitel 5

Hur självuppmärksamhet beräknas

Beräkning av självuppmärksamhet

1. Vilken är den korrekta ordningen av operationer i självuppmärksamhet för ett inmatningsord?

2. Varför skalar vi attentionspoäng med kvadratroten av nyckeldimensionen?

3. Vilka vektorer används för att beräkna attentionspoäng