Innenleben des Transformers

Alles, was Sie lokal ausführen können, ist ein Transformer, und die Architektur passt auf eine Serviette: Tokens in Vektoren verwandeln, durch N identische Layer schieben, in denen Tokens einander anschauen, den finalen Vektor zurück auf Vokabular-Scores projizieren. Keine Analysis nötig — Skalarprodukte und ein Softmax tragen die gesamte Show. Diese Seite geht den Weg einmal, langsam.

Der Residual-Stream

Stellen Sie sich ein Förderband vor, das durch das Model läuft. In jedem Layer lesen Submodule das Band und addieren ihren Beitrag zurück darauf — nichts ersetzt, alles akkumuliert:

x = embed(token_ids) + positions      # Tokens werden Vektoren (Dim ~4k)
for layer in range(N):                # N ≈ 32 bei einem 8B-Modell
    x = x + attention(x)              # Tokens tauschen Information aus
    x = x + ffn(x)                    # jedes Token transformiert sich selbst
logits = unembed(x[-1])               # letzte Position → Score pro Vokabulareintrag
p = softmax(logits)                   # Wahrscheinlichkeit über jedes nächste Token

Embedding: Jede Token-ID indiziert eine gelernte Vektortabelle. Positionsinformation wird eingemischt (rotary Embeddings in modernen Modellen), deshalb unterscheidet sich „Hund beißt Mann“ von „Mann beißt Hund“.
Layer sind in der Form identisch, im Inhalt verschieden. Frühe Layer behandeln Syntax und Oberflächenmuster; tiefere Layer tragen Bedeutung, Fakten und Aufgabenverhalten.
Unembedding: Der finale Vektor wird mit jedem Vokabulareintrag verglichen; Softmax macht Scores zu Wahrscheinlichkeiten. Das Sampling wählt eines aus (Sampling).

Self-Attention in vier Tokens

Der Austauschmechanismus. Der Vektor jedes Tokens erzeugt drei abgeleitete Vektoren: eine Query (wonach suche ich), einen Key (was biete ich an) und einen Value (was ich bei Auswahl übergebe). Satz: „The cat sat on“. Was sollte die Position von „sat“ hereinziehen?

token:          The     cat     sat     on
q·k scores:     1.2     4.1     3.0     0.4      (Skalarprodukte, illustrativ)
softmax →        0.05    0.60    0.31   0.04     (Gewichte summieren sich zu 1.0)

output("sat") = 0.05·v(The) + 0.60·v(cat) + 0.31·v(sat) + 0.04·v(on)

„sat“ attendiert meist auf „cat“ — das Subjekt, das es braucht. Jede Position macht das gleichzeitig. Eine Nebenbedingung macht es zum Sprachmodell: Causal Masking — jedes Token darf nur auf frühere Tokens schauen, nie auf spätere, sodass ein einziger Durchlauf jede Next-Token-Vorhersage in der Sequenz zugleich trainiert.

Das ist das gesamte mathematische Werkzeug: Ähnlichkeitsscores (Skalarprodukte), normalisiert zu einer Mischung (Softmax), über Value-Vektoren.

Als Rezept, ein Attention-Head an einer Position:

Berechne Query-, Key- und Value-Vektoren für jedes Token.
Bilde das Skalarprodukt aus Query und dem Key jedes früheren Tokens; skaliere um √(head_dim) herunter.
Wende Softmax auf die Scores an, zu Gewichten, die sich zu 1 summieren.
Gib die gewichtete Summe der Values dieser Tokens aus.
Konkateniere die Ausgaben aller Heads und projiziere — das ist der Attention-Beitrag des Layers.

Multi-Head: Muster parallel

Ein Head = ein Query/Key/Value-Tripel = eine Art von Beziehung, die er ausdrücken kann (Subjekt↔Verb, Adjektiv↔Nomen, Koreferenz). Layer fahren viele Heads parallel (z. B. 32) auf niedrigdimensionalen Scheiben und konkatenieren die Ergebnisse. Mehr Heads heißt mehr Beziehungstypen pro Layer — Breite des Musters, nicht Tiefe des Denkens.

Heads sind beim Training festgelegt; „Denken“ über Positionen hinweg ist das, was Attention in den Residual-Stream zurückschreibt.
Head-Dim (z. B. 128) × Heads (z. B. 32) = Hidden-Dim (4096): Heads sind parallele Scheiben desselben Förderbands, keine eigenen Modelle.

Die FFN: wo die Parameter wohnen

Die zweite Hälfte jedes Layers ist ein Zwei-Matrizen-Netz, das auf jedes Token unabhängig angewandt wird: den Vektor expandieren (~4×), Nichtlinearität, zurückprojizieren. In einem typischen dichten Model leben hier grob zwei Drittel aller Parameter, nicht in der Attention. Die nützliche Intuition: Key-Value-Gedächtnis — die erste Matrix hält Muster zum Erkennen, die zweite hält, was beim Feuern eines Musters auf das Band zu addieren ist. Vieles, was Leute „die Fakten des Modells“ nennen, steckt in FFN-Gewichten (siehe Parameter).

Komponente	Anteil der Parameter (typisch 7–9B dicht)
Attention (Q, K, V, O)	~10–15%
FFN	~60–70%
Embedding + Output-Head	~10–25% (wächst mit der Vokabulargröße)

Zählen Sie die Parameter selbst

Model Cards veröffentlichen fünf Zahlen; multiplizieren Sie sie, und Sie landen bei der Parameterzahl. Für ein reales offenes Modell der 8B-Klasse (32 Layer, Hidden-Dim 4096, 32 Heads mit 8 KV-Heads, FFN-Breite 14336, Vokabular ~128k):

attention/layer:  q: 4096×4096 + k,v: 2×(4096×1024) + o: 4096×4096
                  ≈ 42M per layer × 32 layers            ≈ 1.3B
FFN/layer:        3 × (4096×14336), gated ≈ 176M × 32     ≈ 5.6B
embeddings:       2 × (128k × 4096), input + output head  ≈ 1.1B
total                                                     ≈ 8.0B

Die Arithmetik trifft die „8B“ der Model Card fast exakt. Zwei Lehren fallen ab: Die FFN dominiert die Parameterzahl (und damit das Speicherbudget), und ein großes Vokabular kostet rund eine Milliarde Parameter, bevor überhaupt der erste Layer läuft — ein Teil dessen, warum großvokabulare multilinguale Modelle mehr wiegen, als ihre dichten Geschwister vermuten lassen.

GQA: Attentions Kosten-Fix

Während der Generierung muss jedes neue Token die Keys und Values aller vorherigen Tokens lesen — gespeichert im KV-Cache. Die ursprüngliche Multi-Head-Attention speichert pro Head und Token ein K und ein V. Grouped-Query-Attention (GQA) teilt eine Handvoll KV-Heads über viele Query-Heads (z. B. 32 Query-Heads, 8 KV-Heads) und schrumpft den Cache um 4× bei vernachlässigbarem Qualitätsverlust. Multi-Query-Attention (MQA) teilt einen einzigen KV-Head. Praktisch jedes moderne offene Model nutzt GQA; diese Ersparnisse sind ein großer Grund, warum langer Kontext überhaupt nutzbar ist (KV-Cache).

Kontextlänge = Aufmerksamkeitsspanne

Attention lässt jedes Token jedes frühere Token sehen, deshalb wächst die Prefill-Rechenlast quadratisch mit der Prompt-Länge und der Cache linear mit jedem generierten Token. Ein Modell mit „128k Kontext“ kommt mit Positionstricks und trainierter Erweiterung dahin, und die Qualität am fernen Ende des Fensters ist meist schwächer als am Anfang. Füllen Sie lange Fenster nur, wenn es sein muss.

Testen Sie es selbst: Legen Sie eine Fakten an den Anfang des Fensters, füllen Sie die Mitte mit Füllmaterial, fragen Sie danach. Die meisten Modelle bestehen nahe Anfang und Ende des Fensters und dippen in der Mitte — das bekannte „Lost in the Middle“-Muster. Behandeln Sie beworbenen Kontext als Kapazität, nicht als Qualitätsgarantie.

Warum das genügt

Aus dieser Struktur allein lassen sich die praktischen Fakten ableiten: Speicherbedarf = Gewichte + KV-Cache (VRAM-Mathematik); Decode-Geschwindigkeit = wie schnell Sie die Gewichte neu lesen können (Prefill vs. Decode); Fähigkeit folgt der Parameterzahl (Parameter); Kontextkosten = Aufmerksamkeitsspanne. Die Architektur ist einfach — die Milliarden trainierter Gewichte darin sind der Teil, den niemand von Hand schreiben könnte.

Verwandt: Was ist ein LLM · KV-Cache · Prefill vs. Decode · Parameter