Zum Inhalt springen
LLM Engineering Course
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

T04 — Self-Attention als Zahlenexperiment

← T03 — Datenpipeline & Embeddings · T05 — Mini-GPT → · Glossar

Lernziel

In 90–110 Minuten implementierst du Scaled Dot-Product Attention von Grund auf, prüfst sie gegen eine Handrechnung und gegen die fusionierte PyTorch-Referenz, weist nach, dass die Causal Mask die Zukunft blockiert, erweiterst einen Head zu mehreren und diagnostizierst vier absichtlich fehlerhafte Varianten über Messungen statt über Intuition.

Das Lab läuft auf den eingebetteten Batches aus T03; Attention arbeitet also auf echten Tokens und nicht auf Rauschen.

Vorhersagen · Was darf eine Position wissen?

Sage vor dem ersten Lauf voraus:

  1. welche Shape die Score-Matrix für einen Batch [B,T,D] mit H Heads hat;
  2. warum die Scores durch dk\sqrt{d_k} geteilt werden und was ohne passiert;
  3. ob Attention-Gewichte in Zeile t rechts von t ungleich null sein dürfen.

Starte dann die CPU-Referenz:

python examples/run_attention_lab.py

Sie druckt den Report und schreibt artifacts/attention/heatmap-head-0.svg (beides bleibt außerhalb von Git).

Verfolgen · Ein Beispiel von Hand rechnen

hand_check_example() nutzt drei Tokens in zwei Dimensionen; Queries, Keys und Values sind identisch:

X=(100111).X=\begin{pmatrix}1&0\\0&1\\1&1\end{pmatrix}.

Attention besteht aus fünf sichtbaren Schritten:

S=QK⊤dk,S′=mask(S),A=softmax(S′),Y=AVS=\frac{QK^\top}{\sqrt{d_k}},\qquad S'=\mathrm{mask}(S),\qquad A=\mathrm{softmax}(S'),\qquad Y=AV

Mit dk=2d_k = 2 vergleicht Zeile 1 die Scores 00 und 1/21/\sqrt{2}; ihre Gewichte sind

[11+e1/2, e1/21+e1/2]=[0,330, 0,670].\left[\frac{1}{1+e^{1/\sqrt{2}}},\ \frac{e^{1/\sqrt{2}}}{1+e^{1/\sqrt{2}}}\right] = [0{,}330,\ 0{,}670].

Zeile 0 darf nur sich selbst lesen und gibt daher V0=[1,0]V_0=[1,0] unverändert zurück. Rechne Zeile 2 selbst und vergleiche sie mit dem Report, bevor du weitermachst. Weicht deine Zahl ab, hast du entweder deinen Fehler oder den des Codes gefunden.

Interaktiv · Eine Attention-Zeile

Q → K → V

Vorhersagen. Verändern. Gewichte ablesen.

Drei Positionen, zwei Dimensionen. Q = K = V. Wähle eine Query und sage vor dem Maskenwechsel voraus, welche Keys sie lesen darf.

Q = K = V = [[1, 0], [0, 1], [1, 1]]

Skalarprodukte → Skalierung → Temperatur → Maske → zeilenweiser Softmax → gewichtete Values. Die Temperatur ist ein Zusatzexperiment; die Lektion nutzt 1. Positionen zählen ab 0.

KeyRoher ScoreSoftmax-EingabeGewichtValue
00,0000,0000,330[1, 0]
11,0000,7070,670[0, 1]
21,000−∞0,000[1, 1]

Gewichtete Ausgabe Y: [0,330; 0,670]

Gewichtssumme: 1,000

Attention-Masse in der Zukunft: 0,000

Mit Maske erhalten zukünftige Keys vor dem Softmax −∞ und exakt Gewicht null.

Bauen · Ein Head

SingleHeadSelfAttention enthält drei Projektionen und sonst nichts. Verfolge die Shapes für einen Batch [4,23,16] mit head_dim=8:

Wert Shape Bedeutung
inputs [4,23,16] eingebettete Tokens aus T03
queries, keys, values [4,23,8] was jede Position fragt, anbietet und trägt
scores [4,23,23] Ähnlichkeit jeder Query zu jedem Key
weights [4,23,23] zeilennormiert; jede Zeile summiert zu 1
output [4,23,8] Value-Mischung pro Position

Zwei Eigenschaften werden geprüft, nicht angenommen: Jede Zeile summiert zu eins, und future_attention_mass(weights) ist exakt 0.0. Letzteres ist die Wirkung der Causal Mask — eine boolesche untere Dreiecksmatrix [T,T], die gesperrte Scores vor dem Softmax auf −∞-\infty setzt, sodass sie exakt null Gewicht bekommen statt eines kleinen.

Zusätzliche boolesche Masken schränken die kausale Maske durch Schnittbildung ein: True bedeutet erlaubt, kann bei causal=True aber keinen zukünftigen Key freigeben. Masken müssen [T,T] abdecken; pro Batch-Beispiel mit mehreren Heads verwende [B,1,T,T]. Jede Query benötigt mindestens einen erlaubten Key; vollständig gesperrte Zeilen lösen vor Softmax einen ValueError aus. Für unbeschränkte Attention setzt du ausdrücklich causal=False.

Im JSON-Report steht für gesperrte Scores die Zeichenfolge "-inf", da JSON keine unendlichen Zahlen kennt. Die Berechnung nutzt weiterhin negative Unendlichkeit. Heatmap-Labels gehören zur ausgewählten Batch-Sequenz (die CLI verwendet Sequenz 0).

Bauen · Mehrere Heads

MultiHeadSelfAttention projiziert auf die volle Breite, teilt sie in H Heads zu je D/H Dimensionen, rechnet Attention pro Head, führt zusammen und mischt einmal nach:

Wert Shape Bedeutung
queries [4,4,23,4] [B,H,T,D/H] nach split_heads
weights [4,4,23,23] eine Attention-Matrix je Head
output [4,23,16] zusammengeführte Heads, zurück auf Modellbreite

Genau das Reshape scheitert lautlos, denn eine falsche view/transpose- Reihenfolge liefert trotzdem die richtige Shape. head_by_head_reference rechnet dasselbe Ergebnis deshalb mit einer expliziten Python-Schleife über die Heads und ganz ohne Reshape nach. Die Referenzkonfiguration erreicht eine maximale Differenz von 0.000; PyTorchs fusioniertes scaled_dot_product_attention weicht um 2.4e-7 ab — Float32-Arithmetik, kein Fehler.

gradient_check vergleicht die Input-Gradienten von Autograd mit zentralen Differenzen in Float64 und meldet einen maximalen relativen Fehler von 3.3e-11.

Brechen · Vier Defekte, vier Messungen

diagnose_broken_variants führt jeden Defekt auf denselben Eingaben aus und hält fest, was ihn aufdeckt:

Variante Symptom Aufgedeckt durch
no_mask Zukunftsmasse 179,05 statt 0,0 Kausalitätsprüfung
no_scaling Gewichtsentropie 1,82 statt 2,11 — zu spitze Attention Entropievergleich
wrong_transpose Score-Matrix [d_k,d_k] Shape-Prüfung
softmax_over_queries Zeilensummen um 3,82 daneben Normierungsprüfung

Der Transpose-Defekt fliegt nur auf, wenn T != d_k. silent_transpose_case() setzt beides auf 4: Nichts wirft eine Exception, die Shape stimmt, und erst der Wertevergleich zeigt eine maximale Differenz von 1,007 und eine Zukunftsmasse von 1,21. Ein Test, der nur Shapes prüft, ginge bei einem Modell durch, das die Zukunft liest.

Beantworte für jede Variante: Welcher deiner Tests wäre zuerst rot geworden?

Messen · Die Heatmap lesen

Öffne artifacts/attention/heatmap-head-0.svg. Zeilen sind Query-Positionen, Spalten sind Keys; oben rechts bleibt es leer wegen der Maske. Frühe Positionen müssen ihr Gewicht auf wenige Keys konzentrieren — Position 0 hat genau eine Wahl —, während spätere Zeilen es verteilen.

Ändere einen Faktor und sage die Wirkung zuerst voraus:

python examples/run_attention_lab.py --heads 1
python examples/run_attention_lab.py --heads 8

Mehr Heads bei gleicher Breite bedeuten kleineres head_dim; jeder Head vergleicht also in einem schmaleren Raum. Die Parameterzahl bleibt bei embedding_dim=16 unabhängig von der Head-Zahl 1024 — Heads teilen Kapazität auf, sie fügen keine hinzu.

Referenzwerte und Änderungsprotokoll stehen in der versionierten Attention-Referenz.

Erklären · Dein Attention-Absatz

Schreibe einen Absatz, der benennt:

  • Shape und Bedeutung von Queries, Keys, Values, Scores, Weights und Output;
  • warum die Scores mit dk\sqrt{d_k} skaliert werden;
  • wie die Maske Kausalität erzwingt und an welcher Stelle sie greift;
  • was das Aufteilen in Heads ändert und was nicht;
  • die Messung, die jeden der vier Defekte aufdeckt;
  • die beiden Referenzen, gegen die deine Implementierung geprüft wurde.

Abschluss-Gate

Du bestehst, wenn du eine Zeile der Attention-Matrix von Hand herleiten kannst und dein Report die Implementierung belegt. Erforderliche Nachweise:

  • deine eigene Rechnung für Zeile 2 passend zu hand_check im Report;
  • [B,H,T,T]-Gewichte mit Zeilensummen 1 und Zukunftsmasse 0.0;
  • Übereinstimmung mit der Head-für-Head-Referenz und mit PyTorch (< 1e-5);
  • ein Gradient Check unter 1e-5 relativem Fehler;
  • alle vier fehlerhaften Varianten samt aufdeckender Messung;
  • eine Heatmap, in zwei Sätzen laut vorgelesen.

Führe die automatischen Vertragstests aus:

pytest tests/test_attention.py

Wie es weitergeht

Eine Attention-Schicht mischt Information über Positionen hinweg, kann sie aber kaum transformieren. Als Nächstes ergänzt du Residualpfade, Normierung und ein Feed-Forward-Netz zu einem vollständigen Decoder-Block und einem Mini-GPT.

← T03 — Datenpipeline & Embeddings · T05 — Mini-GPT → · Glossar

War diese Seite hilfreich?