Lære Hvordan Egenoppmerksomhet Beregnes | Forståelse av transformer-grunnprinsipper

Sveip for å vise menyen

For å forstå hvordan selvoppmerksomhet beregnes i transformere, må du følge en presis sekvens av matematiske operasjoner. Selvoppmerksomhetsmekanismen gjør det mulig for hvert ord i en setning å fokusere på andre ord når en utdatarepresentasjon produseres. Dette oppnås ved å beregne en vektet sum av alle inngangsvektorene, der vektene reflekterer viktigheten av hvert ord for det aktuelle ordet som behandles.

Anta at du har en kort setning representert som en matrise, der hver rad er en ordembedding. Du projiserer først disse embeddingene til spørringer, nøkler og verdier ved hjelp av lærte vektmatriser. Kjernen i selvoppmerksomhet er deretter beregningen av oppmerksomhetspoeng og aggregering av verdi-vektorer basert på disse poengene.

Definisjon

Spørringer, nøkler og verdier er ulike representasjoner av input, hver brukt for en spesifikk rolle i oppmerksomhetsberegningen.

Beregning av selvoppmerksomhet

Selvoppmerksomhet kan deles opp i en serie tydelige matematiske trinn for hvert ord i sekvensen:

Projiserer inndata til spørringer, nøkler og verdier: projiserer inndatamatrisen ved hjelp av lærte vektmatriser for å oppnå spørringer, nøkler og verdier.


              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 av oppmerksomhetspoeng:

Beregn likheten mellom hver spørring og alle nøkler;
Disse poengene indikerer hvor mye fokus hvert ord bør ha på de andre.


              1
            
scores = Q @ K.T

Skaler poengene: del oppmerksomhetspoengene med kvadratroten av nøkkeldimensjonen. Denne skaleringen bidrar til å stabilisere gradientene under trening.


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

Bruk softmax-funksjonen: konverter de skalerte poengene til oppmerksomhetsvekter ved hjelp av softmax-funksjonen. Dette sikrer at vektene 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 vektede summen av verdier: bruk oppmerksomhetsvektene til å beregne en vektet sum av verdi-vektorene. Dette gir det endelige selvoppmerksomhetsresultatet 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 trinnene fanger opp de grunnleggende beregningene bak self-attention i transformer-modeller.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 5

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Seksjon 1. Kapittel 5

Hvordan Egenoppmerksomhet Beregnes

Beregning av selvoppmerksomhet

1. Hva er den riktige rekkefølgen av operasjoner i self-attention for ett inndataord?

2. Hvorfor skalerer vi oppmerksomhetspoeng med kvadratroten av nøkkeldimensjonen?

3. Hvilke vektorer brukes til å beregne oppmerksomhetspoeng