Self-Attention von Grund auf
Du hast ein Neuron und einen Vorwärtsdurchlauf gebaut. Jetzt baust du die eine Idee, die einfache neuronale Netze in Transformer verwandelt hat und von dort in die LLMs hinter jedem Chat-Assistenten: Self-Attention. Es ist eine Handvoll Matrixmultiplikationen, und du kannst das Ganze in numpy machen.
Die Intuition
Stell dir vor, jedes Wort in einem Satz will Informationen von den anderen Wörtern sammeln. Self-Attention gibt jeder Position drei Vektoren:
- Eine Query (Q): wonach diese Position sucht.
- Einen Key (K): was jede Position anbietet, benutzt zum Abgleichen.
- Einen Value (V): die eigentliche Information, die jede Position trägt.
Eine Position vergleicht ihre Query mit jedem Key, um zu entscheiden, wie sehr sie jeder anderen Position zuhört, und nimmt dann eine gewichtete Mischung der Values mit diesen Anteilen. Starke Übereinstimmung -> großes Gewicht -> dieser Value trägt mehr bei. Das ist der ganze Mechanismus: Queries achten auf Keys, und die Antwort ist eine gewichtete Mischung von Values.
Die Mathematik: skalierte Skalarprodukt-Attention
Die Übereinstimmung zwischen einer Query und einem Key ist ihr Skalarprodukt (größer, wenn sie in dieselbe Richtung zeigen). Stapel alle Queries in eine Matrix Q und alle Keys in K, und alle Punktzahlen auf einmal sind Q @ K.T. Wir teilen durch sqrt(d_k) (die Key-Dimension), damit die Punktzahlen nicht explodieren, wenn die Vektoren länger werden:
scores = Q @ K.T / np.sqrt(d_k)Warum überhaupt teilen? Ein Skalarprodukt wächst mit der Dimension. Ist d_k gleich 64 und liegen die Einträge um 1, landen die rohen Punktzahlen bei etwa 64, und so große Zahlen drücken den Softmax auf einen einzigen Key und machen den Gradienten flach. Durch sqrt(d_k) zu teilen, hier sqrt(64) = 8, holt die Punktzahlen in einen vernünftigen Bereich zurück, damit die Attention glatt und trainierbar bleibt. Im winzigen Beispiel mit d_k = 1, das du unten laufen lässt, ist der Teiler einfach 1, also merkst du es nicht, aber bei echten Modellgrößen ist es unverzichtbar.
Jede Zeile von scores enthält die Punktzahlen einer Query gegen jeden Key. Wir machen aus jeder Zeile Gewichte, die positiv sind und sich zu 1 summieren, mit einem Softmax über die letzte Achse:
weights = softmax(scores, axis=-1) # each row sums to 1Softmax potenziert und normiert. Naiv gemacht läuft np.exp einer großen Punktzahl zu inf über, und die Gewichte kommen als nan heraus. Die Lösung ist der übliche numerisch stabile Trick: Zieh vor dem Potenzieren das Maximum jeder Zeile ab. Mathematisch ändert das nichts am Ergebnis (dieselbe Konstante kürzt sich oben und unten), aber es hält jeden Exponenten <= 0:
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # stability: largest exponent is now 0
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)Zum Schluss ist die Ausgabe jeder Query ihre Gewichte, angewendet auf die Values, also noch eine Matrixmultiplikation:
output = weights @ VZusammengesetzt ist die berühmte Formel einfach softmax(Q @ K.T / sqrt(d_k)) @ V. Ist Q gleich (n, d_k), K gleich (m, d_k) und V gleich (m, d_v), dann ist weights gleich (n, m) und output gleich (n, d_v): ein Ausgabevektor pro Query, jeder eine Mischung der Value-Zeilen.
Das ist der ganze Transformer-Trick
Ein echter Transformer hört nicht bei einer Attention-Berechnung auf. Multi-Head-Attention lässt mehrere davon parallel laufen (jeder Head lernt seine eigenen Q-, K- und V-Projektionen, also achten verschiedene Heads auf verschiedene Dinge) und hängt die Ergebnisse aneinander. Ein Transformer-Block stapelt dann Attention mit einem kleinen Feed-Forward-Netz und einer Residualverbindung, und ein Modell stapelt Dutzende dieser Blöcke. Aber das schlagende Herz jedes einzelnen ist genau die Funktion, die du gleich schreibst: Punktzahlen, stabiler Softmax, gewichtete Summe der Values. Bau das, und du verstehst die Kernoperation, die ein LLM wiederholt, wenn es dem Prompt "Aufmerksamkeit schenkt".
Ein ehrlicher Vorbehalt: Hier bekommst du Q, K und V als feste Arrays. In einem echten Modell sind sie nicht gegeben, sie werden erzeugt, indem das Embedding jedes Tokens mit drei gelernten Gewichtsmatrizen multipliziert wird, W_q, W_k und W_v. Diese Matrizen, und die in jedem Block, sind genau das, was das Training mit dem Gradientenabstieg aus der letzten Lektion anpasst. Was du hier baust, ist also der feste Kern der Attention, der in jedem Transformer gleich ist; das Lernen steckt in den Projektionen, die ihn füttern.
Drück auf Run, um zu sehen, wie Attention aus einem winzigen Q/K/V eine Ausgabe macht, und um die Gewichtsmatrix auszugeben, damit du ablesen kannst, wer auf wen geachtet hat.
Implementiere scaled dot-product attention in numpy. Schreibe attention(Q, K, V), das ein Tupel (output, weights) zurückgibt. Berechne scores = Q @ K.T / np.sqrt(d_k), wobei d_k die letzte Dimension von Q ist; wende eine numerically stable softmax über die letzte Achse an (ziehe das Maximum jeder Zeile vor np.exp ab), um weights zu erhalten, dessen Zeilen auf 1 summieren; dann output = weights @ V. Gib output zuerst zurück, dann die weights Matrix. Setze dann out, w = attention(Q, K, V) für die bereitgestellten Arrays.
Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion
Diese Übung öffnet bald
Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.
Dieser Browser blockiert Cookies für learn.floati.life, daher können hier beendigte Lektionen nicht in der richtigen Reihenfolge geöffnet werden. Erlaube Cookies für diese Seite und lade sie neu.