Lernen Wie Selbstaufmerksamkeit Berechnet Wird | Understanding Transformer Foundations

Swipe um das Menü anzuzeigen

Um zu verstehen, wie die Selbstaufmerksamkeit (Self-Attention) in Transformern berechnet wird, muss eine präzise Abfolge mathematischer Operationen befolgt werden. Der Self-Attention-Mechanismus ermöglicht es jedem Wort in einem Satz, sich beim Erzeugen einer Ausgabedarstellung auf andere Wörter zu konzentrieren. Dies wird erreicht, indem eine gewichtete Summe aller Eingabevektoren berechnet wird, wobei die Gewichte die Bedeutung jedes Wortes für das aktuell verarbeitete Wort widerspiegeln.

Angenommen, ein kurzer Satz wird als Matrix dargestellt, wobei jede Zeile ein Wort-Embedding ist. Zunächst werden diese Embeddings mithilfe gelernter Gewichtsmatrizen in Abfragen (Queries), Schlüssel (Keys) und Werte (Values) projiziert. Das Kernstück der Selbstaufmerksamkeit ist dann die Berechnung der Aufmerksamkeitswerte und die Aggregation der Wertvektoren basierend auf diesen Werten.

Definition

Abfragen (Queries), Schlüssel (Keys) und Werte (Values) sind unterschiedliche Repräsentationen der Eingabe, die jeweils eine spezifische Rolle bei der Berechnung der Aufmerksamkeit übernehmen.

Berechnung der Selbstaufmerksamkeit

Die Selbstaufmerksamkeit lässt sich für jedes Wort in der Sequenz in eine Reihe klarer mathematischer Schritte unterteilen:

Projektion der Eingaben auf Abfragen, Schlüssel und Werte: Die Eingabematrix wird mithilfe gelernter Gewichtsmatrizen projiziert, um Abfragen (Queries), Schlüssel (Keys) und Werte (Values) zu erhalten.


              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

Berechnung der Aufmerksamkeitswerte:

Berechnung der Ähnlichkeit zwischen jeder Abfrage und allen Schlüsseln;
Diese Werte geben an, wie stark sich jedes Wort auf die anderen konzentrieren sollte.


              1
            
scores = Q @ K.T

Skalierung der Scores: Division der Attention-Scores durch die Quadratwurzel der Schlüssel-Dimension. Diese Skalierung trägt zur Stabilisierung der Gradienten während des Trainings bei.


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

Anwenden der Softmax-Funktion: Umwandlung der skalierten Werte in Aufmerksamkeitsgewichte mithilfe der Softmax-Funktion. Dadurch wird sichergestellt, dass die Gewichte positiv sind und sich für jedes Wort auf 1 summieren.


              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)

Berechnung der gewichteten Summe der Werte: Verwendung der Aufmerksamkeitsgewichte zur Berechnung einer gewichteten Summe der Wertvektoren. Dies ergibt die finale Self-Attention-Ausgabe für jedes Wort.


              12345
            
# Weighted sum of values
output = attention_weights @ V

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

Diese Schritte erfassen die grundlegenden Berechnungen hinter Self-Attention in Transformer-Modellen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 5

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Abschnitt 1. Kapitel 5

Wie Selbstaufmerksamkeit Berechnet Wird

Berechnung der Selbstaufmerksamkeit

1. Was ist die korrekte Reihenfolge der Operationen bei Self-Attention für ein Eingabewort?

2. Warum skalieren wir Aufmerksamkeitswerte mit der Quadratwurzel der Schlüsseldimension?

3. Welche Vektoren werden zur Berechnung der Aufmerksamkeitswerte verwendet?