Wie Transformer funktionieren – von RNN-Engpässen bis zu Attention, Agenten und Kontextfenstern
Ein schrittweiser Überblick über den Transformer: Warum RNNs ins Stocken gerieten, wie Tokens und Embeddings funktionieren, Attention, QKV, Heads, Positionen, Blockstruktur, Skalierung und Agenten.
Jeder, der nur KI-Tools verwendet, kommt ohne Kenntnis dessen aus, was dahintersteckt. Jeder, der diese Systeme entwickeln, debuggen oder weiterentwickeln möchte, kann das nicht. Jedes weit verbreitete Sprachmodell basiert auf einer Architektur, die in einem 2017 veröffentlichten etwa fünfzehn Seiten langen Artikel mit dem Titel „Attention Is All You Need“ vorgestellt wurde. Nur wenige Forschungspapiere des letzten Jahrzehnts haben die Richtung der künstlichen Intelligenz so sehr verändert. Die dahinterstehenden Ideen sind weniger abschreckend, als sie klingen, und die Mathematik wird verständlich, wenn sie in der richtigen Reihenfolge dargestellt wird. Danach tauchen dieselben Ideen überall auf: bei der Planung von Agenten, beim Funktionieren des In-Context-Lernens, darin, warum ein Modell mitten im Gespräch zwischen Themen wechseln kann, und darin, warum längere Kontextfenster so wichtig sind.
Der untenstehende Weg beginnt mit dem alten sequenziellen Ansatz und den Gründen für dessen Stillstand, geht dann darauf ein, wie aus Text Zahlen werden, anschließend auf Aufmerksamkeit und die vollständige Blockstruktur, und endet damit, wie sich das Design zu den heutigen Sprachmodellen und Agenten entwickelt hat.
Warum das Lesen von Text Wort für Wort an Grenzen stieß
Vor den Transformern wurde Sprache hauptsächlich mit rekurrenten neuronalen Netzen verarbeitet, meist abgekürzt als RNNs. Die Idee ist einfach: Das Netzwerk durchläuft eine Sequenz Wort für Wort und überträgt einen versteckten Zustand weiter, eine laufende Zusammenfassung dessen, was bisher gesehen wurde.
Eine grobe Vorstellung: Jemand liest einen Roman, behält aber vielleicht nur ein Sticker-Zettel bei und muss Seite für Seite voranschreiten, weder überspringen noch zurückblättern. Nach jedem Satz wird der Zettel mit dem Wichtigsten neu geschrieben, doch der Zettel ist klein. Bis zur Seite 300 ist fast nichts mehr von Seite 1 übrig. Auch das Weitergeben des zweiten Kapitels an einen Freund zum gleichzeitigen Lesen ist unmöglich, da die Notizen zum ersten Kapitel zuerst fertiggestellt werden müssen.
Diese strenge Reihenfolge verursacht zwei separate Skalierungsprobleme.
Das erste ist der verschwindende Gradient. Das Training passt die Gewichte mithilfe von Backpropagation an, wobei ermittelt wird, wie sehr jeder Parameter zum Fehler beigetragen hat. In einem RNN, das eine lange Sequenz liest, muss dieses Signal durch jede Zeitstufe rückwärts wandern. Wenn es die frühesten Schritte erreicht, ist es oft bereits fast auf Null geschrumpft, sodass das Netzwerk im Grunde nicht aus den frühen Worten lernen kann.
Der zweite Punkt ist das sequenzielle Engpassproblem. Das Ergebnis an Position n kann nicht vor Abschluss von Position n-1 berechnet werden, da jeder Schritt den vorherigen versteckten Zustand verbraucht. Moderne GPUs sind dafür konzipiert, gleichzeitig eine enorme Anzahl an Operationen auszuführen, während eine RNN ihnen kaum Möglichkeiten zur Parallelverarbeitung bietet. Ein 1.000-Wörter-Dokument erfordert 1.000 aufeinanderfolgende Schritte, wobei die Hardware zwischen ihnen meist untätig bleibt.
Das untenstehende Diagramm vergleicht die beiden Methoden zur Verarbeitung von Tokens: Einerseits die Verarbeitung nacheinander mit einem allmählich verblassenden versteckten Zustand und andererseits die gleichzeitige Verarbeitung jedes Paares.
╔══════════════════════════════════════════════════════════════════════════════╗
║ RNN vs TRANSFORMER: HOW TOKENS ARE PROCESSED ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ RNN ── Sequential (slow, forgets early context) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ║
║ │ │ │ │ │ │ ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ RNN │──▶│ RNN │─▶│ RNN │▶│ RNN │▶│ RNN │▶│ RNN │ ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ h₁ ──▶ h₂ ──▶ h₃ ──▶ h₄ ──▶ h₅ ──▶ h₆ ║
║ ║
║ Step 1 Step 2 Step 3 Step 4 Step 5 Step 6 (must wait!) ║
║ ⚠ "The" signal is diluted through 5 hops by the time we reach "mat" ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ TRANSFORMER ── Parallel (fast, every token sees all others) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ◀── ALL AT ONCE ║
║ │╲╲ │╲ ╲╲ │╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ │ ╲╲ │ ╲ ╲╲ │ ╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ ├───╫──┼───╫───┼───╫───┼────╫──┼────╫───┤ ← every token ║
║ │ ╱╱ │ ╱ ╱╱ │ ╱╱ ╱ │ ╱╱ │ ╱╱ │ attends to ║
║ │╱╱ │╱ ╱╱ │╱╱ ╱ │ ╱╱ │ ╱╱ │ every token ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ out │ │ out │ │ out │ │ out │ │ out │ │ out │ ← all computed ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ simultaneously ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ ✓ "The" has DIRECT connection to "mat" — no information decay ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ LEGEND: ──▶ sequential dependency ╲╱╱ all-pairs attention ║
║ h₁ hidden state ⚠ information bottleneck ║
╚══════════════════════════════════════════════════════════════════════════════╝
Gates halfen, änderten aber nicht die Struktur des Problems
Die Long Short-Term Memory-Netzwerke, die 1997 von Hochreiter und Schmidhuber eingeführt wurden, führten Gates ein, die eine explizite Steuerung darüber ermöglichten, was bei jedem Schritt beibehalten, was weggelassen und was ausgegeben werden sollte. Sie funktionierten gut. In den 2010er Jahren wurden sie für die meisten praktischen Anwendungen in der natürlichen Sprachverarbeitung eingesetzt, einschließlich früher Maschinenübersetzungen, Sentiment-Analysen und Textgenerierung.
Sie blieben dennoch sequenziell. Sehr lange Abhängigkeiten waren weiterhin schwierig zu handhaben, und parallele Hardware konnte weiterhin nicht in vollem Umfang genutzt werden. LSTMs versagten nicht, weil sie die Sprache schlecht modellierten. Sie versagten, weil sie sich nicht skalieren ließen: Der Einsatz zusätzlicher Rechenleistung brachte immer geringere Ergebnisse, und um diese Grenze zu überwinden, war ein völlig anderer Rechungsstil erforderlich.
Von Text zu Zahlen
Neuronale Netze verarbeiten Zahlen und Sprache besteht aus Wörtern, daher muss eine Umwandlung stattfinden, bevor die Aufmerksamkeit einsetzen kann. Dafür sind zwei Schritte notwendig: Tokenisierung und Embedding.
Tokenisierung
Bei der Tokenisierung wird eine Zeichenkette in eine Abfolge von ganzzahligen IDs umgewandelt, die aus einem festen Wortschatz stammen. Zunächst sollte man verstehen, dass Tokens keine Wörter sind. Moderne Tokenisierer teilen den Text in Subwort-Teile auf, meist mithilfe von Byte-Pair Encoding oder WordPiece, und das Ergebnis sieht so aus:
"Hello world" → ["Hello", " world"] → [15496, 995]
"unbelievable" → ["un", "believ", "able"] → [256, 9391, 540]
"ChatGPT" → ["Chat", "G", "PT"] → [14126, 38, 2969]
"antidisestablishmentarianism" → ["ant", "idis", "est", "ablish", "ment", "ari", "an", "ism"]
Häufig vorkommende Wörter erhalten ihren eigenen Token, während seltene oder zusammengesetzte Wörter in kleinere Teile aufgeteilt werden. Dadurch wird bei einer überschaubaren Wortmenge eine gute Abdeckung erreicht, da es nicht notwendig ist, einen Eintrag für jedes mögliche Wort zu erstellen. Die Größe des Wortschatzes reicht von etwa 30.000 bei BERT und 50.257 bei GPT-2 bis über 100.000 in neueren Modellen.
Eine praktische Umrechnung für Englisch: Ein Token entspricht etwa drei Vierteln eines Wortes, oder ein Wort besteht aus etwa 1,3 Token. Ein Roman mit 100.000 Wörtern umfasst daher ungefähr 133.000 Token – was bei Bedarf an Kontextfensterbegrenzungen von Bedeutung ist.
Embeddings
Eine Einbettungsmatrix mit einer Zeile pro Wörterbucheintrag und d_model Spalten wandelt jeden Token-ID in einen dichten Vektor um. Das Abfragen eines Tokens bedeutet lediglich das Auswählen seiner Zeile. Der Token-ID 995, der „world“ darstellt, verweist auf Zeile 995 und liefert die Werte von d_model – beispielsweise 0,24, -0,83, 0,17 und so weiter bis zu 0,91.
Diese Zeilen werden während des Trainings gelernt, und es zeigt sich eine nützliche Eigenschaft: Tokens mit verwandten Bedeutungen weisen Vektoren auf, die geometrisch nah beieinander liegen.
Cosine similarity in embedding space:
similarity("cat", "lion") ≈ 0.89 ← very similar
similarity("cat", "moon") ≈ 0.12 ← not similar
similarity("king", "queen") ≈ 0.91 ← very similar
Eine Einschränkung bezüglich des berühmten Beispiels „König minus Mann plus Frau ergibt Königin“. Diese Arithmetik stammt aus Word2Vec im Jahr 2013 und nicht von Transformer-Embeddings. Transformers lernen ihre Embeddings gemeinsam mit allen anderen Parametern, weshalb die reine Vektorarithmetik weniger zuverlässig ist. Was weiterhin gilt, ist das Prinzip, dass Wörter mit verwandten Bedeutungen benachbarte Bereiche im Raum einnehmen.
Eine Breite überall
Eine feste Dimension, d_model, kommt überall in einem Transformer vor: bei Embeddings, Attention-Ausgaben sowie bei den Eingaben und Ausgaben der Feed-Forward-Schichten. Das ist absichtlich so. Jeder Komponente liest von und schreibt in einen Vektorstrom mit fester Breite, den sogenannten Residualstrom, der durch jede Schicht fließt. Da alle Komponenten mit Vektoren derselben Größe arbeiten und ihre Ergebnisse wieder hinzufügen, ergänzen sich die Teile reibungslos. Es ist auch der Grund, warum positionale Informationen einfach zu einem Token-Embedding hinzugefügt werden können: Beide haben dieselbe Form, und die Summe gelangt direkt in den Strom.
Die Eingabe für den ersten Block besteht also aus dem Token-Embedding zusammen mit einem Positionsvektor. Da beide im selben Raum liegen, erfordert die Addition keine zusätzlichen Parameter, und die Positionsinformation ist in dieselben Vektoren integriert, die die Bedeutung tragen. BERT-basierte Modelle, die zwei Sätze gemeinsam verarbeiten – wie beispielsweise bei der Frage-Antwort-Verarbeitung mit einer Frage und einem Absatz – fügen ein Segment-Embedding hinzu, das anzeigt, zu welchem Satz jedes Token gehört: 0 für den ersten und 1 für den zweiten. GPT-basierte Modelle überspringen dies.
Aufmerksamkeit: Lernen, wohin man schauen soll
Um 2014 und 2015 bemerkten Forscher, die an maschineller Übersetzung arbeiteten, einen Mangel sogar in LSTM-Systemen. Das Modell presste alles, was es über den Eingabesatz wusste, in einen Vektor fester Größe, bevor es mit der Erstellung der Ausgabe begann – was wiederum ein Engpass darstellte. Die offensichtliche Frage war, ob das Modell bei jedem Schritt der Erstellung einen Blick auf den gesamten Eingabetext werfen könnte. Die Antwort auf diese Frage wurde das Aufmerksamkeitsmechanismus, und er veränderte die Art und Weise, wie Sequenzen modelliert werden.
Zwei alltägliche Situationen machen diese Idee intuitiv verständlich.
Bei einer lauten Party mit zehn gleichzeitig geführten Gesprächen verleiht das Gehirn beim Verfolgen eines Freundes nicht jedem Geräusch gleiche Bedeutung. Es verstärkt die Stimme und die Richtung des Freundes und dämpft den Rest, ohne ihn vollständig auszuschalten. Die Gewichtung erfolgt kontinuierlich, es handelt sich nicht um einen Ein-/Ausschalter.
Wenn man eine Klassenaufnahme erhält und nach dem Lehrer suchen soll, scannt eine Person nicht jeden Pixel gleichmäßig. Die Suche konzentriert sich direkt auf Merkmale, die auf ein Erwachsenes hindeuten, wie beispielsweise die Körpergröße im Vergleich zu den anderen sowie die Gesichtsproportionen. Das, wonach gesucht wird, bestimmt, wohin der Blick geht.
Die computergestützte Aufmerksamkeit wandelt diese Intuitionen in vier Schritte um: Etwas zum Suchen haben, was die Abfrage darstellt; eine Gruppe von Kandidaten, die relevant sein könnten; jedem Kandidaten einen kontinuierlichen Relevanzwert zuweisen; sowie die Informationen unter Berücksichtigung dieser Werte zusammenfassen.
Ein Missverständnis, das früh geklärt werden sollte: Aufmerksamkeit bedeutet nicht, dass das Modell sich auf eine Sache konzentriert und alles andere ignoriert. Das Ergebnis ist ein gewichteter Durchschnitt, zu dem jedes Element beiträgt – einige weitaus stärker als andere. Es handelt sich dabei um eine differenzierte Berücksichtigung und nicht um eine binäre Fokussierung.
Die ursprüngliche, angefügte Form
In seiner ursprünglichen Form war die Aufmerksamkeit ein Zusatz für RNN- und LSTM-Modelle. In jedem Dekodierungsschritt würde das Modell Folgendes tun:
- alle versteckten Zustände des Encoders betrachten;
- einen Relevanzwert zwischen dem aktuellen Dekodierzustand und jedem Encoder-Zustand berechnen;
- diese Werte mithilfe von Softmax in Gewichte umwandeln;
- die gewichtete Summe der Encoder-Zustände als Aufmerksamkeitskontext verwenden.
Softmax erfordert eine kurze Erklärung. Es wandelt einen Vektor beliebiger reeller Zahlen in eine Wahrscheinlichkeitsverteilung um. Jeder Wert wird durch e hoch diesen Wert geteilt, wobei das Ergebnis durch die Summe aller Werte von e hoch jeweiligen Wert geteilt wird. Alle Ausgaben sind positiv und addieren sich auf 1. Da die Exponentialfunktion den Unterschied zwischen großen und kleinen Werten verstärkt, erhält der Wert mit dem höchsten Score den größten Anteil am Gewicht.
Das war eine große Verbesserung, da das Modell nun in jedem Schritt jeden Teil der Eingabe erreichen konnte. Danach stellten die Autoren von „Attention Is All You Need“ eine mutigere Frage: Was wäre, wenn die rekurrenten Mechanismen weggelassen würden und die Aufmerksamkeit nicht etwas Zusätzliches wäre, sondern das gesamte Modell?
Selbstaufmerksamkeit und das Trio aus Abfrage, Schlüssel und Wert
Die zentrale Idee der Veröffentlichung von 2017 ist die Selbstaufmerksamkeit. Anstatt von einer Sequenz zur anderen Aufmerksamkeit zu richten, richtet jeder Token in einer einzigen Sequenz Aufmerksamkeit auf jeden anderen Token derselben Sequenz. So erstellt ein Transformer Kontext, und um ihn zu verstehen, sind drei Vektoren erforderlich, die bei jeder Aufmerksamkeitsberechnung vorhanden sind: die Abfrage, der Schlüssel und der Wert.
Ein Video-Suchmaschinen-System
Wenn man auf einer Video-Plattform „Wie macht man Sauerteigbrot“ eingibt, wird der Text nicht mit jedem Frame jedes Videos verglichen. Jedes Video weist Metadaten-Labels auf, die als Schlüssel fungieren: Titel, Tags, Beschreibungsschlüsselwörter. Die Plattform vergleicht die Abfrage mit diesen Labels, um Relevanzbewertungen zu ermitteln, und die am besten bewerteten Videos werden angezeigt, damit ihr tatsächlicher Inhalt abgerufen werden kann.
Es gibt dabei eine wichtige Besonderheit: Das Ergebnis ist kein einzelnes Video, sondern eine gewichtete Mischung aus allen Videos gleichzeitig, wobei jedes Video mit einer Lautstärke abgespielt wird, die proportional zu seiner Relevanz ist. Das am relevantesten ist dominiert, während die Beiträge der anderen Videos leiser untergelegt sind. Die Zuordnung erfolgt wie folgt:
| YouTube Concept | Attention Concept | Question it Answers |
|----------------|------------------|---------------------|
| Search query | **Query (Q)** | "What am I looking for?" |
| Video metadata/tags | **Key (K)** | "What do I contain?" |
| Actual video content | **Value (V)** | "What should I contribute?" |
Warum drei separate Vektoren?
Warum nicht die Embeddings direkt vergleichen? Nehmen wir den Satz „Die Katze saß auf der Matte, weil sie müde war.“ Um herauszufinden, worauf „sie“ sich bezieht, muss das Wort auf „Katze“ achten. Im rohen Embedding-Raum sind jedoch Pronomen und Substantive nicht besonders ähnlich. Durch die Aufteilung in Queries und Keys kann das Modell lernen, dass die Query eines Pronomens zu den Keys der Substantive passen sollte, auf die es sich beziehen könnte – selbst wenn Pronomen und Substantive in ihren Basis-Embeddings völlig unterschiedlich aussehen. Die gelernten Projektionen schaffen einen Relevanzraum, der vom Ähnlichkeitsraum der rohen Embeddings getrennt ist. Relevanz und Ähnlichkeit sind unterschiedliche Konzepte, und das QKV-Design ermöglicht es einem Modell, beide zu kodieren.
Skalierter Skalarprodukt-Attention in vier Schritten
Der erste Schritt ist die Projektion. Die Embedding-Werte jedes Tokens werden mit drei gelernten Matrizen, W_Q, W_K und W_V, multipliziert, wodurch für dieses Token eine Abfrage-, eine Schlüssel- und ein Wertvektor entstehen.
Der zweite Schritt misst die Kompatibilität. Es geht darum, wie gut Token a zu Token b passt, und die Antwort ist das Skalarprodukt aus der Abfrage für a und dem Schlüssel für b. Ein hoher Wert bedeutet, dass Token a Token b besonders genau betrachten sollte. Skalarprodukte nehmen mit der Vektorgröße sowie mit der Dimension d_k des Schlüssels zu – nicht nur mit der Richtung –, weshalb im nächsten Schritt diese Werte neu skaliert werden.
Der dritte Schritt besteht aus Skalierung und Normalisierung. Wenn d_k groß ist, werden die Roh-Skalarprodukte sehr groß und drücken den Softmax-Funktion in Bereiche mit winzigen Gradienten. Das Durchteilen durch die Quadratwurzel von d_k vor der Anwendung von Softmax verhindert dies, was dem Verfahren seinen Namen „skaliertes Skalarprodukt-Aufmerksamkeitsmodell“ gibt. Das Ergebnis ist eine Menge an Gewichten alpha_ab.
Schritt vier ist die Aggregation. Die Ausgabe für Token a ist die Summe über jedes Token b von alpha_ab multipliziert mit dem Wertvektor für b.
Sämtliche Token können zusammen als Matrizen in einer kompakten Form behandelt werden: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Das Diagramm veranschaulicht dies am dreiwortigen Ausdruck „the cat sat“:
╔══════════════════════════════════════════════════════════════════════════════╗
║ SCALED DOT-PRODUCT ATTENTION ── "the cat sat" ║
╚══════════════════════════════════════════════════════════════════════════════╝
STEP 1: Input embeddings - ALL tokens are stacked into one matrix X
┌─────────────────────────────────────────┐
│ "the"→x₁ "cat"→x₂ "sat"→x₃ │ X ∈ ℝⁿˣᵈ
└──────────────────┬──────────────────────┘
│ the SAME X feeds all three projections
STEP 2: Three separate linear projections (each applied to every token)
┌─────────────┴─────────────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ W_Q │ │ W_K │ │ W_V │ ← learned weight matrices
└────┬────┘ └────┬────┘ └────┬────┘
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Q rows │ │ K rows │ │ V rows │
│ q₁ │ │ k₁ │ │ v₁ │
│ q₂ │ │ k₂ │ │ v₂ │
│ q₃ │ │ k₃ │ │ v₃ │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
STEP 3: score = QKᵀ, scale by 1/√dₖ, then softmax row-wise
│ │ │
└──────┬──────┘ │
▼ │
┌─────────────────────┐ │
│ softmax(QKᵀ / √dₖ) │ │
│ the cat sat │ │
│ the[.72 .20 .08] │ │ each row
│ cat[.12 .71 .17] │ │ sums to 1.0
│ sat[.09 .28 .63] │ │
└──────────┬──────────┘ │
│ │
STEP 4: multiply weights by Values V (weighted sum)
└──────────┬─────────┘
▼
┌─────────────────┐
│ output for "cat"│ 0.12·v₁ + 0.71·v₂ + 0.17·v₃
└────────┬────────┘ ← rich context-aware vector
│
OUTPUT: contextualized token representations
┌──────────┐ ┌──────────┐ ┌──────────┐
│"the" │ │"cat" │ │"sat" │
│knows it │ │knows it │ │knows │
│precedes │ │sat, and │ │who was │
│"cat" │ │where │ │sitting │
└──────────┘ └──────────┘ └──────────┘
Ein gelöstes Beispiel: das Wortschatzbank
Nehmen wir den Satz „Sie ging zur Bank, um Geld einzuzahlen“. Während der Transformer das Wort „Bank“ kodiert, ermöglicht die Selbstaufmerksamkeit es diesem Wort, gleichzeitig jedes andere Wort zu prüfen. Starke Gewichte fallen auf „einzahlen“ und „Geld“, wodurch finanzielle Bedeutungen in die Repräsentation von „Bank“ einfließen. Der Kontext beseitigt die Mehrdeutigkeit.
╔══════════════════════════════════════════════════════════════════════════════╗
║ SELF-ATTENTION RESOLVES AMBIGUITY: What does "bank" mean? ║
╚══════════════════════════════════════════════════════════════════════════════╝
Sentence: "I went to the bank to deposit money"
t₁ t₂ t₃ t₄ t₅ t₆ t₇ t₈
ATTENTION WEIGHTS for token "bank" (t₅) attending to all other tokens:
Token │ Weight │ Visualization
──────────┼────────┼───────────────────────────────────────────
"I" │ 0.03 │ ░
"went" │ 0.04 │ ░
"to" │ 0.02 │
"the" │ 0.03 │ ░
"bank" │ 0.08 │ ░░
"to" │ 0.05 │ ░
"deposit" │ 0.38 │ ████████████████████████░░░░░░░░ ← strong!
"money" │ 0.37 │ ████████████████████████░░░░░░░ ← strong!
FULL ATTENTION HEATMAP (rows = query token, columns = key token):
Higher weight → more ░/▒/▓/█
Q\K │ I went to the bank to deposit money
──────────┼──────────────────────────────────────────────
I │ ▓ ░ ░ ░ ░ ░ ░ ░
went │ ░ ▓ ░ ░ ░ ░ ░ ░
bank │ ░ ░ ░ ░ ▒ ░ █ █ ← "bank"→"deposit","money"
deposit │ ░ ░ ░ ░ █ ░ ▓ ▒ ← "deposit"→"bank"
money │ ░ ░ ░ ░ █ ░ ▒ ▓ ← "money"→"bank"
BEFORE attention: "bank" = ambiguous (river bank? financial bank?)
AFTER attention: "bank" ≈ 0.38·v(deposit) + 0.37·v(money) + ...
→ "bank" representation is now strongly financial ✓
The model learned this WITHOUT any explicit disambiguation rules.
Die Gewichte in dieser Darstellung dienen der Klarheit und stammen nicht von einem echten Modell. Tatsächliche Muster sind in der Regel unordentlicher, und die Forschung dazu, wie Aufmerksamkeitsgewichte mit dem Zusammenhang stehen, was ein Modell „denkt“, ist noch im Gange. Der praktische Nutzen unterscheidet sich von dem in der Abbildung: Die Selbst-Aufmerksamkeit für alle Token ist eine Matrixmultiplikation, also eine einzige GPU-Operation. Was einer RNN n sequenzielle Schritte kostet, kostet einen Transformer nur eine parallele Operation – deshalb skalieren Transformers so gut.
Mehrere Köpfe, mehrere Perspektiven
Ein Verarbeitungseinheit berechnet zur gleichen Zeit nur eine Art von Relevanz – was passiert also, wenn mehrere Arten von Beziehungen gleichzeitig relevant sind? Betrachten wir den Satz „Der Musiker, der beim Festival aufgetreten ist, hat den Preis gewonnen.“ Um ihn zu verstehen, muss man mehrere Abhängigkeiten gleichzeitig berücksichtigen: „gewonnen“ in Verbindung mit „Musiker“ als Subjekt und Verb, „Musiker“ in Verbindung mit „aufgetreten ist“ über den Relativsatz, „aufgetreten ist“ in Verbindung mit „Festival“ als Ort sowie „Preis“ in Verbindung mit „gewonnen“ als Verb und Objekt.
Ein einzelner Kopf müsste all das in einen einzigen Gewichtsatz pressen. Multi-Head Attention hingegen führt die Aufmerksamkeitsfunktion h-mal parallel aus, wobei jedes Mal eigene gelernte Projektionen für Abfragen, Schlüssel und Werte verwendet werden. Die h Ausgaben werden zusammengefügt und durch eine weitere gelernte Matrix, W_O, geleitet, die sie in die Modelldimension zurücküberträgt. Jeder Kopf arbeitet in einem kleineren Unterraum, wobei d_k gleich d_model geteilt durch h ist; daher beträgt die Gesamtkostenbelastung aller Köpfe ungefähr die eines einzelnen Kopfs mit voller Breite.
Stellen Sie sich ein Manuskript vor, das an einen Redaktionsausschuss gesendet wird. Ein Grammatikredakteur überprüft die Syntax, ein Stilredakteur achtet auf den Erzählfluss, ein Faktenprüfer sucht nach semantischer Konsistenz und ein Strukturredakteur beobachtet die langfristige Organisation. Sie lesen alle gleichzeitig und unabhängig voneinander, und ihre Notizen werden zu einer einzigen Rezension zusammengeführt. Multi-Head Attention verhält sich auf dieselbe Weise.
╔══════════════════════════════════════════════════════════════════════════════╗
║ MULTI-HEAD ATTENTION (3 heads shown) ║
╚══════════════════════════════════════════════════════════════════════════════╝
Input Embedding x ∈ ℝᵈ_model
┌────────────────────────────┐
│ [ x₁ x₂ x₃ ... xₙ ] │
└──────────┬─────────────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
▼ ▼ ▼
╔══════════════╗ ╔══════════════╗ ╔══════════════╗
║ HEAD 1 ║ ║ HEAD 2 ║ ║ HEAD 3 ║
║ "Syntax" ║ ║ "Semantics" ║ ║ "Position" ║
║ ║ ║ ║ ║ ║
║ W_Q¹ W_K¹ ║ ║ W_Q² W_K² ║ ║ W_Q³ W_K³ ║
║ W_V¹ ║ ║ W_V² ║ ║ W_V³ ║
║ ║ ║ ║ ║ ║
║ ┌──────────┐ ║ ║ ┌──────────┐ ║ ║ ┌──────────┐ ║
║ │ Scaled │ ║ ║ │ Scaled │ ║ ║ │ Scaled │ ║
║ │ Dot- │ ║ ║ │ Dot- │ ║ ║ │ Dot- │ ║
║ │ Product │ ║ ║ │ Product │ ║ ║ │ Product │ ║
║ │Attention │ ║ ║ │Attention │ ║ ║ │Attention │ ║
║ └────┬─────┘ ║ ║ └────┬─────┘ ║ ║ └────┬─────┘ ║
║ │ ║ ║ │ ║ ║ │ ║
║ learns: ║ ║ learns: ║ ║ learns: ║
║ subject-verb ║ ║ word meaning ║ ║ nearby-word ║
║ agreement ║ ║ similarity ║ ║ relationships║
╚══════╤═══════╝ ╚══════╤═══════╝ ╚══════╤═══════╝
│ head₁ ∈ ℝⁿˣ⁽ᵈ/ʰ⁾ │ head₂ │ head₃
└───────────────────┼───────────────────┘
▼
┌──────────────────────────────┐
│ CONCATENATE all heads │
│ [head₁ ║ head₂ ║ head₃] │ ∈ ℝⁿˣᵈ_model
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Final linear projection W_O │ blends info from all heads
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Multi-Head Attention Output │ ∈ ℝⁿˣᵈ_model (same shape as input)
└──────────────────────────────┘
Was die Heads letztendlich tun
Analysen trainierter Modelle haben Heads aufgezeigt, die sich spezialisieren. Einige kümmern sich um Syntaxaspekte wie Subjekt-Verb-Kongruenz und Attribute, die an Substantive angehängt sind. Andere arbeiten über größere Entfernungen und verknüpfen Pronomen mit ihren Bezugswörtern. Wieder andere sind lokal und beziehen sich auf benachbarte Wörter sowie Bigramm-Muster. Einige erfassen die relative Entfernung zwischen Tokens, während andere thematische Rollen erkennen – also herausfinden, wer was zu wem getan hat. Niemand programmiert das. Das Training belohnt genaue Vorhersagen, und das Netzwerk stellt fest, dass die Aufgabenverteilung auf spezialisierte Heads funktioniert.
Eine Einschränkung dieser Ansicht: Diese Kategorien stammen größtenteils aus Arbeiten zur Interpretierbarkeit kleinerer Modelle. In großen Modellen lassen sich viele Komponenten nicht eindeutig erfassen, und Experimente zeigen, dass solche Modelle oft auch nach dem Entfernen vieler Komponenten nur geringe Leistungseinbußen erleiden. Die Architektur ermöglicht Spezialisierung, verspricht aber keine übersichtlichen, für Menschen lesbaren Einteilungen.
Wörtern eine Adresse zuweisen
Die Selbstaufmerksamkeit betrachtet jedes Token-Paar, behandelt die Sequenz dabei jedoch als eine beliebige Menge ohne Ordnung. Die Bewertung zwischen zwei Token a und b hängt ausschließlich vom Inhalt ab, nicht davon, welches zuerst kommt oder wie weit sie voneinander entfernt sind. Sprache ist stark ordnungsbestimmt. „Hund beißt Mann“ und „Mann beißt Hund“ enthalten dieselben Wörter, bedeuten aber das Gegenteil voneinander, und „nicht glücklich“ sagt etwas völlig anderes aus als „glücklich nicht“. Da ein Transformer alle Positionen parallel verarbeitet, wird die Ordnung standardmäßig nicht kodiert, weshalb die Position explizit eingefügt werden muss. Das ist die Aufgabe der positionellen Kodierung.
Bedenken Sie das Hinzufügen von Metadaten zu jedem Gebäude in einer Stadt. Jedes Gebäude benötigt eine Adresse, die seinen genauen Standort angibt, die relative Position ausdrückt (Gebäude 402 liegt in der Nähe von 404) und ohne vorheriges Wissen des gesamten Stadtplans funktioniert. GPS-Koordinaten erledigen dies ordentlich. Die positionale Kodierung ist die sprachliche Variante: Eine mathematische Koordinate wird der Darstellung jedes Wortes hinzugefügt.
Sinus- und Kosinuswellen
Der ursprüngliche Transformer verwendete sinusförmige Funktionen, wobei für jedes Paar von Eingabedimensionen eine Frequenz verwendet wurde. Für die Position pos und den Dimensionenindex k füllen Sinus- und Kosinuswerte von pos, geteilt durch eine Potenz von 10000 und mit k skaliert, den Vektor. Langsame, niederfrequente Wellen kennzeichnen grobe Positionen, während schnelle, hochfrequente Wellen feine Positionen markieren – gemeinsam verleihen sie jeder Position einen eindeutigen „Fingerabdruck“.
╔══════════════════════════════════════════════════════════════════════════╗
║ SINUSOIDAL POSITIONAL ENCODING ║
╚══════════════════════════════════════════════════════════════════════════╝
GRID: exact values for a tiny d_model=8 - positions 0-4, dims 0-7
(frequency denominators are 1, 10, 100, 1000 for dim-pairs 0,1,2,3)
dim→ d=0 d=1 d=2 d=3 d=4 d=5 d=6 d=7
sin cos sin cos sin cos sin cos
pos↓ ──────────────────────────────────────────────────────
pos=0 │ 0.000 1.000 0.000 1.000 0.000 1.000 0.000 1.000 │
pos=1 │ 0.841 0.540 0.100 0.995 0.010 1.000 0.001 1.000 │
pos=2 │ 0.909 -0.416 0.199 0.980 0.020 1.000 0.002 1.000 │
pos=3 │ 0.141 -0.990 0.296 0.955 0.030 1.000 0.003 1.000 │
pos=4 │ -0.757 -0.654 0.389 0.921 0.040 0.999 0.004 1.000 │
↑ fast-changing ↑ medium-changing ↑ very slow
(high frequency) (mid frequency) (low freq)
unique per position gradual shift global structure
WAVE PATTERNS (each row = one dimension across positions):
dim 0 (sin): █ ▇ ▄ ▁ ▂ ▅ ▇ █ ▇ ▄ ▁ ← fast oscillation
dim 2 (sin): █ █ ▇ ▇ ▆ ▅ ▄ ▃ ▂ ▁ ▁ ← medium oscillation
dim 4 (sin): █ █ █ █ █ █ ▇ ▇ ▇ ▇ ▆ ← slow oscillation
dim 6 (sin): █ █ █ █ █ █ █ █ █ █ █ ← very slow oscillation
HOW IT'S USED: Added to the token embedding elementwise
┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│ Token Embedding│ │ Positional Enc. │ │ Final Input x_t │
│ "cat" │ │ position = 2 │ │ │
│ [0.2, 0.8, │ │ [0.9,-0.4, │ │ [1.1, 0.4, │
│ 0.1, 0.5, │ + │ 0.2, 1.0, │ = │ 0.3, 1.5, │
│ 0.9, 0.3] │ │ 0.0, 1.0] │ │ 0.9, 1.3] │
│ (meaning) │ │ (where in seq) │ │ (meaning+position)│
└─────────────────┘ └─────────────────┘ └──────────────────┘
WHY SINUSOIDS?
✓ Each position gets a unique encoding across all dimensions
✓ Distance between nearby positions is consistent and learnable
✓ Can represent any position mathematically (unlike learned embeddings)
✓ Model can attend to relative positions via linear combinations
Niedrigere Dimensionen oszillieren schnell und erfassen fein abgestimmte Positionen, während höhere Dimensionen langsam changieren und die globale Ordnung erfassen. Der Vektor wird einfach zum Token-Embedding hinzugefügt.
Feste Wellen, gelernte Tabellen und Rotation
Das sinusförmige Schema weist eine nützliche mathematische Eigenschaft auf: Die Kodierung an der Position pos+k ist eine lineare Funktion der Kodierung an der Position pos. Relative Abweichungen werden daher konsistent dargestellt, was es erleichtert, positionale Beziehungen zu lernen.
Lernende Positionseinbettungen, also eine separate Tabelle mit einem Eintrag pro Position wie bei BERT, sind einfacher, können aber keine Positionen außerhalb des im Training gesehenen Bereichs extrapolieren, während Sinusfunktionen grundsätzlich jede Position darstellen können. Dennoch lösen Sinusfunktionen das Problem der Generalisierung auf lange Kontexte nicht vollständig. Modelle haben weiterhin Schwierigkeiten mit Sequenzen, die viel länger sind als ihre Trainingsdaten, da auch die Aufmerksamkeitsmuster selbst auf unbekannte Entfernungen generalisiert werden müssen.
Modelle wie Llama verwenden Rotary Position Embeddings, auch RoPE genannt. Bevor Dot-Produkte berechnet werden, werden Queries und Keys um einen Winkel gedreht, der proportional zu ihren Positionen ist. Im Produkt aus einem Query an einer Position und einem Key an einer anderen Position wird die relative Drehung direkt als Abstand kodiert. Indem die relative Position als expliziter Eingabewert für den Attention-Score verwendet wird, anstatt etwas, das nur implizit ist und über Projektionsmatrizen gelernt wird, werden längere Kontexte besser bewältigt.
Die vollständige Architektur
Nun können die Komponenten zusammengesetzt werden. Das Diagramm zeigt die moderne Pre-LayerNorm-Version der gesamten Struktur:
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ THE COMPLETE TRANSFORMER ARCHITECTURE (Pre-LayerNorm, modern) ║
╠═══════════════════════════════════════════╦═══════════════════════════════════════════╣
║ ENCODER (×N layers) ║ DECODER (×N layers) ║
╠═══════════════════════════════════════════╬═══════════════════════════════════════════╣
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ Linear → Softmax → P(next token) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ ⊕ Add (residual) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ FFN( LayerNorm(x) ) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ Encoder output → K, V (to decoder) ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ ⊕ Add (residual) │ ║
║ ┌───────────────────────────────────────┐ ║ └───────────────────────────────────────┘ ║
║ │ ⊕ Add (residual) │ ║ ▲ ║
║ └───────────────────────────────────────┘ ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ Cross-Attention │ ║
║ ┌───────────────────────────────────────┐ ║ │ Q ← decoder │ ║
║ │ FFN( LayerNorm(x) ) │ ║ │ K, V ← encoder output │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ ⊕ Add (residual) │ ║ │ ⊕ Add (residual) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Multi-Head Self-Attention │ ║ │ Masked Multi-Head Self-Attention │ ║
║ │ ( on LayerNorm(x), bidirectional ) │ ║ │ ( on LayerNorm(x), causal ) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Input Embedding + Positional Enc. │ ║ │ Output Embedding + Positional Enc. │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Source: "The cat sat on the mat" │ ║ │ Target (shifted): <BOS> "Le" "chat"… │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
╠═══════════════════════════════════════════╩═══════════════════════════════════════════╣
║ Data flows UPWARD (▲). Each sub-layer is a residual branch over a ║
║ LayerNorm-ed input: h = x + SubLayer( LayerNorm(x) ) ║
║ The encoder's output (K, V) flows into the decoder's Cross-Attention. ║
╚═══════════════════════════════════════════════════════════════════════════════════════╝
Ein Transformer besteht aus zwei Hauptteilen, einem Encoder und einem Decoder. Im ursprünglichen Paper hatte jeder dieser Teile 6 Schichten, jeweils 8 Attention-Heads sowie einen d_model-Wert von 512.
Der Encoder: Verständnis im Kontext
Der Encoder liest die Eingabesequenz und erzeugt eine kontextualisierte Darstellung jedes Tokens – dabei wird nicht nur die Bedeutung eines Wortes für sich genommen berücksichtigt, sondern auch seine Bedeutung in diesem spezifischen Satz. Er verwendet bidirektionale Selbst-Attention, sodass jedes Token auf alle anderen Tokens auf beiden Seiten schauen kann. So wird auch die oben erwähnte Mehrdeutigkeit von „bank“ gelöst: Das Modell erkennt gleichzeitig „deposit“ und „money“.
Sechs Encoder-Ebenen arbeiten nacheinander, wobei jede die Repräsentation weiter verfeinert. Die frühen Ebenen konzentrieren sich auf Aspekte der Syntax wie Wortstellung und Wortart. Die mittleren Ebenen befassen sich mit komplexeren grammatischen Strukturen. Die späteren Ebenen erfassen höherwertige Bedeutungen wie Entity-Typen, Ereignisstrukturen und Pragmatik. Diese Schichtung ist ein Grund dafür, warum der Transfer so gut funktioniert: Die Feinabstimmung prägt hauptsächlich die späteren Ebenen, während die allgemeinen sprachlichen Muster in den frühen Ebenen für verschiedene Aufgaben weiterhin nützlich bleiben.
Der Dekoder: Generierung mit Speicher
Der Dekoder gibt die Ausgabetoken nacheinander, autoregressiv, aus. Jedes neue Token hängt von allem ab, was bisher generiert wurde, sowie vom gesamten kodierten Eingang. Er verfügt über drei Unter-Ebenen.
Die erste ist die maskierte Selbstaufmerksamkeit, auch als kausale Aufmerksamkeit bezeichnet. Der Dekoder darf nur auf die Tokens schauen, die er bereits erzeugt hat, was durch eine kausale Maske erzwungen wird. Werte oberhalb der Diagonale werden vor der Anwendung von Softmax auf minus Unendlich gesetzt, wodurch zukünftige Tokens unsichtbar werden. Dadurch stimmt das Training mit der Inferenz überein, da das Modell jeden Token ausschließlich aus dem vorherigen Kontext vorhersagen muss.
╔══════════════════════════════════════════════════════════════════════════╗
║ DECODER SELF-ATTENTION: Causal (Autoregressive) Masking ║
║ "Each token can only attend to itself and tokens before it" ║
╚══════════════════════════════════════════════════════════════════════════╝
Tokens: [The] [cat] [sat] [on] [mat]
t₁ t₂ t₃ t₄ t₅
ATTENTION SCORE MATRIX (row = query, col = key)
KEY → t₁ t₂ t₃ t₄ t₅
QUERY ↓ "The" "cat" "sat" "on" "mat"
──────────────────────────────────────
t₁ "The" │ ✓ ✗ ✗ ✗ ✗
t₂ "cat" │ ✓ ✓ ✗ ✗ ✗
t₃ "sat" │ ✓ ✓ ✓ ✗ ✗
t₄ "on" │ ✓ ✓ ✓ ✓ ✗
t₅ "mat" │ ✓ ✓ ✓ ✓ ✓
✓ = ALLOWED (score kept, participates in softmax)
✗ = MASKED (score → −∞, becomes 0 after softmax)
When generating t₃ "sat":
Raw scores: [ 2.1 3.4 1.8 -∞ -∞ ]
After softmax: [ 0.18 0.68 0.14 0 0 ]
↑
future tokens are invisible
WHY IS MASKING NECESSARY?
┌──────────────────────────────────────────────────────────┐
│ TRAINING: We feed the whole target sequence at once │
│ (teacher-forcing). Without masking, t₃ could "cheat" │
│ by looking at t₄ and t₅ - the answers it should │
│ be predicting. │
│ │
│ INFERENCE: We generate one token at a time anyway, │
│ so future tokens literally don't exist yet. Masking │
│ makes training match inference behavior exactly. │
└──────────────────────────────────────────────────────────┘
Die zweite Methode ist die Kreuzaufmerksamkeit, die Brücke zwischen Encoder und Decoder. Die Abfragen stammen vom Decoder und repräsentieren den aktuellen Zustand der Generierung, während Schlüssel und Werte vom Encoder stammen und ausdrücken, was die Eingabe gesagt hat. Die Übersetzung funktioniert auf diese Weise: Wenn der Decoder das französische Wort „chat“ erzeugt, fragt er nach der Darstellung des gesamten englischen Satzes im Encoder, und die Kreuzaufmerksamkeit lenkt einen hohen Gewichtsfaktor auf „cat“.
Die dritte Methode ist das Feed-Forward-Netzwerk, das in seiner Funktion dem im Encoder identisch ist und weiter unten erläutert wird.
Drei Familien, die aus denselben Komponenten aufgebaut sind
Die Kombination aus Encoder und Decoder ist nur eine Möglichkeit, diese Komponenten zu nutzen; unterschiedliche Aufgaben erfordern unterschiedliche Anordnungen:
| Model | Architecture | Training Objective | Best For |
|-------|-------------|-------------------|----------|
| **BERT** | Encoder-only | Masked Language Modeling | Understanding: classification, NER, QA |
| **GPT** | Decoder-only | Next token prediction | Generation: writing, coding, conversation |
| **T5** | Encoder-Decoder | Text-to-text seq-to-seq | Transformation: translation, summarization |
╔══════════════════════════════════════════════════════════════════════════════════════╗
║ BERT vs GPT vs T5: Architecture Families ║
╠══════════════════╦═══════════════════════════╦═════════════════════════════════════╣
║ BERT ║ GPT ║ T5 ║
║ Encoder-Only ║ Decoder-Only ║ Encoder + Decoder ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ ATTENTION: ║ ATTENTION: ║ ATTENTION: ║
║ t₁ ● ● ● ● ║ t₁ ● ║ Encoder: ● ● ● ● (bidir) ║
║ t₂ ● ● ● ● ║ t₂ ● ● ║ ● ● ● ● ║
║ t₃ ● ● ● ● ║ t₃ ● ● ● ║ Decoder: causal + ║
║ t₄ ● ● ● ● ║ t₄ ● ● ● ● ║ cross-attn to encoder ║
║ (bidirectional) ║ (causal/left-only) ║ ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ BEST FOR: ║ BEST FOR: ║ BEST FOR: ║
║ ✓ Classification ║ ✓ Text generation ║ ✓ Translation ║
║ ✓ NER / tagging ║ ✓ Completion ║ ✓ Summarization ║
║ ✓ Sentence embeds ║ ✓ Chat / dialogue ║ ✓ Question answering ║
║ ✓ Reading comp. ║ ✓ Code generation ║ ✓ Any seq-to-seq task ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ EXAMPLES: ║ EXAMPLES: ║ EXAMPLES: ║
║ BERT, RoBERTa ║ GPT-4o, Claude 4, ║ T5, BART, ║
║ DeBERTa ║ Llama 4, Gemini 2.5 ║ mT5, FLAN-T5 ║
╚══════════════════╩═══════════════════════════╩═════════════════════════════════════╝
BERT liest in beide Richtungen und eignet sich für Verständnisaufgaben. GPT generiert von links nach rechts unter Verwendung von kausaler Maskierung. T5 behält die vollständige Architektur bei, um strukturierte Sequenz-zu-Sequenz-Transformationen durchzuführen. Die Wahl zwischen ihnen richtet sich danach, welche Architektur am besten zur Aufgabe passt – nicht danach, welche besser ist. Kurz gesagt: Der Encoder erstellt bidirektionale kontextuelle Repräsentationen, der Decoder generiert autoregressiv unter Verwendung von kausaler Maskierung und Cross-Attention, und unterschiedliche Teilmengen der Architektur werden für Verständnis, Generierung und Transformation angepasst.
Die unterstützenden Komponenten
Aufmerksamkeitsmechanismen und die Feed-Forward-Schicht erhalten den größten Teil der Aufmerksamkeit, doch drei weitere Komponenten verhindern, dass tiefe Transformer-Modelle während des Trainings zusammenbrechen: die Feed-Forward-Netzwerke selbst, die Schichtnormalisierung sowie die Residualverbindungen.
Feed-Forward-Netzwerke: Denkzeit pro Token
Nach jeder Aufmerksamkeitsschicht in jedem Block folgt ein positionsspezifisches Feed-Forward-Netzwerk. Der Vektor jedes Tokens durchläuft dasselbe zweischichtige MLP, das jeweils für jede Position separat angewendet wird: Er wird mit W1 multipliziert, ein Bias hinzugefügt, anschließend eine GeLU-Nonlinearität angewendet, danach mit W2 multipliziert und ein weiterer Bias hinzugefügt. W1 führt von d_model auf viermal d_model und W2 zurück. Bei den ursprünglichen Größen bedeutet das eine Erweiterung von 512 auf 2048 und anschließend eine Verkleinerung auf 512, was dem Netzwerk Raum gibt, Informationen zu speichern und umzuwandeln, die allein durch die Aufmerksamkeit nicht erfasst werden können.
„Positionsspezifisch“ ist der Schlüsselbegriff, da die Schicht jedes Token unabhängig behandelt. Die Aufmerksamkeit ist das Kommunikationsmechanismus, bei dem die Tokens miteinander kommunizieren, während das Feed-Forward-Netzwerk der Rechenmechanismus ist, bei dem jedes Token das verarbeitet, was es gesammelt hat.
Geva und Kollegen (2021) stellten fest, dass sich diese Schichten etwas wie Schlüssel-Wert-Speicher verhalten, und dass einzelne Neuronen identifiziert werden können, die für bestimmte semantische Konzepte aktiviert werden. Wenn ein Sprachmodell „weiß“, dass Paris die Hauptstadt Frankreichs ist, liegt diese Assoziation hauptsächlich in den Feed-Forward-Gewichten vor. Dies erklärt zwei Dinge: Das Feintunen kann das faktische Wissen aktualisieren, da es diese Gewichte ändert. Zudem funktioniert die retrieval-augmented Generation, weil sie die Fakten in das Kontextfenster bringt, wo die Aufmerksamkeit sie direkt erreichen kann.
Residuale Verbindungen
Gradienten, die rückwärts durch ein tiefes Netzwerk wandern, schrumpfen über viele Schichten hinweg. Eine Residualverbindung, auch Sprungverbindung genannt, löst dieses Problem elegant: Die Ausgabe einer Unterlayer ist das Ergebnis dieser Unterlayer plus ihre eigene Eingabe. Der Layer muss somit nur die Veränderung, also das Residuum, lernen und nicht die gesamte Abbildung. Dadurch entsteht eine Art Autobahn, über die Gradienten direkt zurückwandern können, ohne irgendeine Schicht zu durchlaufen – und das ist der Grund, warum moderne Transformer 96 oder mehr Schichten übereinander anordnen können, ohne dass das Training zusammenbricht.
Schichtnormalisierung: Die Skalen im Griff halten
Die Schichtnormalisierung standardisiert den Aktivierungsvektor jedes Tokens auf einen Mittelwert von null und eine Varianz von eins, wendet anschließend eine gelernte Skalierung Gamma sowie einen Verschiebungswert Beta an. Die Statistiken stammen von den d_model-Features eines Tokens: Der Mittelwert ist der einfache Durchschnitt seiner Werte, und die Varianz ist der durchschnittliche quadrierte Abstand von diesem Mittelwert. Eine kleine Konstante Epsilon, typischerweise 10 minus 5, wird in den Quadratwurzelzeichen verwendet, damit es niemals zu einer Division durch Null kommt. Im Gegensatz zur Batchnormalisierung erfolgt die Berechnung pro Token und nicht für den gesamten Batch, was sich gut für Sequenzen unterschiedlicher Länge eignet.
Das moderne Blockmuster
Die ursprüngliche Arbeit wendete LayerNorm nach der Residualzusatzoperation an, was als Post-LN bezeichnet wird. Nahezu jedes moderne Modell – von GPT-2 und GPT-3 über Llama bis hin zu praktisch allen seit etwa 2020 trainierten Modellen – verwendet Pre-LayerNorm und normalisiert die Eingaben vor jeder Unter Schicht. Pre-LN führt ein stabileres Training durch und erfordert keinen Lernrate-Warmup.
Jeder Block fügt anschließend zu den normalisierten Eingaben einen Attention-Anteil sowie einen Feed-Forward-Anteil hinzu. Der erste Zwischenzustand besteht aus der Eingabe plus der auf die normalisierte Eingabe angewendeten Attention-Operation, während der zweite Zwischenzustand aus diesem Zustand plus dem Feed-Forward-Netzwerk, das auf seine eigene normalisierte Version angewendet wird, besteht. Ein Blick in den Code eines modernen Transformers zeigt, dass LayerNorm vor der Attention-Operation sowie vor dem Feed-Forward-Schritt steht. Wiederholt man diesen Block N Mal – wobei N 6, 12, 24, 96 oder mehr sein kann, abhängig von der Größe des Modells – entsteht so der gesamte Transformer.
Das Aufmerksamkeitsmechanismus ist die clevere Idee. Diese unterstützenden Komponenten sind die Ingenieurskunst, die diese clevere Idee zum Funktionieren bringt. Feed-Forward-Schichten ermöglichen die Berechnung pro Token und speichern faktische Assoziationen, Residualpfade geben den Gradienten einen Weg durch die Schichtenstruktur, und Pre-LN hält die Aktivierungen stabil. Gemeinsam machen sie das Stapeln von Dutzenden von Blöcken möglich.
Der Weg eines Satzes
Ein durchgehender Ablauf sieht wie folgt aus: Tokenisierung, Einbettung, Hinzufügen einer Positionscodeierung, Kodierung, Dekodierung eines Tokens nach dem anderen und anschließend Projektion in das Vokabular. Das nächste Diagramm zeigt die Übersetzung von „Hello world“:
╔══════════════════════════════════════════════════════════════════════════╗
║ END-TO-END DATA FLOW: "Hello world" → Translation ║
╚══════════════════════════════════════════════════════════════════════════╝
STAGE 1: Tokenization
┌─────────────────────────────────────────────────────────────────┐
│ Raw text: "Hello world" │
│ ↓ Tokenizer (BPE / WordPiece) │
│ Token IDs: [ 7592, 2088 ] ← integers into vocabulary │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 2: Embedding Lookup e_t = E[t] ∈ ℝ^512
┌─────────────────────────────────────────────────────────────────┐
│ 7592 → [0.21, -0.54, 0.88, ...] "Hello" │
│ 2088 → [0.67, 0.12,-0.34, ...] "world" │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 3: Add Positional Encoding x_t = e_t + PE(t)
┌─────────────────────────────────────────────────────────────────┐
│ embedding + PE = input vector carrying BOTH meaning AND order │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 4: Encoder Stack (× N layers)
┌─────────────────────────────────────────────────────────────────┐
│ ╔═══════════════════════════════════╗ │
│ ║ Each Encoder Layer: ║ × 6 │
│ ║ h₁ = x + Attn(LayerNorm(x)) ║ │
│ ║ h₂ = h₁ + FFN(LayerNorm(h₁)) ║ │
│ ╚═══════════════════════════════════╝ │
│ After 6 layers: rich contextual reps - "Hello" knows context │
└──────────────────────┬──────────────────────────────────────────┘
↓ (K, V flow into decoder cross-attention)
STAGE 5: Decoder Stack (generates tokens autoregressively)
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: <BOS> → Decoder → predict "Hola" │
│ Step 2: <BOS> "Hola" → Decoder → predict "mundo" │
│ Step 3: <BOS> "Hola mundo" → Decoder → predict <EOS> │
│ │
│ Each step: ① Masked self-attention on generated tokens │
│ ② Cross-attention: Q←decoder, K,V←encoder │
│ ③ LayerNorm → FFN → residual │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 6: Output Projection & Softmax
┌─────────────────────────────────────────────────────────────────┐
│ hidden state → W_vocab → logits over 50k vocab items │
│ → softmax → probability distribution │
│ → sample or argmax → next token │
└──────────────────────┬──────────────────────────────────────────┘
↓
"Hola mundo" ✓
Wie aus einem Übersetzungspapier ein Sprachmodell entstand
Das umfasst die gesamte Architektur, aber wie entwickelte sich ein Entwurf für die maschinelle Übersetzung zu Systemen, die Essays und Code schreiben sowie schwierige Probleme lösen können? Die kurze Antwort lautet Skalierung.
Die untenstehende Zeitlinie reicht vom Transformer von 2017 bis zu den neuesten Spitzentechnologiemodellen:
YEAR MODEL PARAMS KEY DEVELOPMENT
────────────────────────────────────────────────────────────────────────────────
2017 Transformer 65M "Attention Is All You Need" published
2018 GPT-1 117M First successful generative pre-training
2019 GPT-2 1.5B Improved fluency; staged release
2020 GPT-3 175B Few-shot in-context learning emerges
2022 ChatGPT 175B+ InstructGPT + RLHF = aligned conversational AI
2023 GPT-4 undisclosed Multimodal input + stronger reasoning
2024 GPT-4o undisclosed Natively multimodal, faster & cheaper (May)
2024 o1 undisclosed "Reasoning" model: thinks before answering (Sep)
2025 o3 / o4-mini undisclosed Stronger reasoning, tool use, long-horizon
2025 Claude 4 undisclosed Anthropic: Opus 4 / Sonnet 4 (May)
2025 Gemini 2.5 undisclosed Google: 1M-token context, multimodal
2025 Llama 4 undisclosed Meta: open weights, up to 10M-token context
2026 GPT-5 series undisclosed OpenAI flagship (GPT-5.4 / 5.5); 272K-1M ctx
2026 Gemini 3.x undisclosed Google: frontier reasoning; 1M context
2026 Claude 5 family undisclosed Anthropic: Opus 4.8, Sonnet 5, Fable 5
2026 Grok 4.x undisclosed xAI frontier line (Grok 4.5, Jul 2026)
(Every one is the same core transformer from 2017 — scaled and refined, not replaced)
Die Kernarchitektur hat sich zwischen GPT-1 und den heutigen Spitzendmodellen kaum verändert. Was sich geändert hat, sind folgende Aspekte:
- Skalierung – das bedeutet mehr Parameter, mehr Daten und mehr Rechenleistung.
- Ausrichtung, wobei das durch menschliche Rückmeldungen gestützte Verstärkungslernen dazu beiträgt, dass die Modelle nützlich und sicher sind.
- Anweisungstuning, bei dem Modelle darauf trainiert werden, Anweisungen zu befolgen und nicht nur Text fortzusetzen.
- Logiktraining, bei dem großangelegtes Verstärkungslernen auf überprüfbare Probleme angewandt wird. Dies ist der Grund für die Logikmodelle wie OpenAI’s o-Serie sowie die erweiterten Denkmodi, die heute in Claude, Gemini und anderen Systemen üblich sind – diese investieren zusätzliche Rechenleistung in das Nachdenken, bevor sie antworten.
Fähigkeiten, die scheinbar aktiviert werden
Als die Modelle größer wurden, trat etwas Unerwartetes ein. Bestimmte Fähigkeiten verbesserten sich nicht schrittweise, sondern schienen bei bestimmten Größenplänen sprunghaft zu steigen. Mehrstufige Arithmetik war bei etwa weniger als 10 Milliarden Parametern fast vollständig abwesend, wurde aber bei nahezu 100 Milliarden Parametern zuverlässig. Das Kette-denken-Verfahren fehlte im Grunde, es sei denn, das Modell war groß genug und wurde dazu angesprochen. Die Codeerstellung verbesserte sich deutlich ab der Größenordnung von GPT-3. Nichts davon war programmiert worden, es entstand einfach so.
Es wird diskutiert, wie stark diese Sprünge tatsächlich sind. Eine häufig zitierte Analyse von 2023 von Schaeffer und Kollegen mit dem Titel „Are Emergent Abilities of Large Language Models a Mirage?“ zeigte, dass einige scheinbare Sprünge teilweise auf der verwendeten Messmethode beruhen. Wenn eine Aufgabe entweder vollständig oder gar nicht bewältigt wird, wie es die Genauigkeit bei exakten Übereinstimmungen der Fall ist, können stetige, allmähliche Fortschritte als plötzlicher Sprung erscheinen, während eine kontinuierliche Messmethode den dahinterliegenden stetigen Fortschritt zeigt. Der praktische Aspekt bleibt bestehen – schließlich können große Modelle Dinge tun, die kleinere nicht können – doch bestimmte Schwellenwerte sollten lediglich als grobe Orientierung angesehen werden und nicht als unumstößliche physikalische Gesetze.
Das Trainingsziel jedes GPT-ähnlichen Modells besteht aus derselben einfachen Aufgabe, das nächste Token vorherzusagen. Schlussfolgern, Codegenerierung, mehrsprachiges Verständnis und kreatives Schreiben werden niemals explizit trainiert. Sie entstehen, je besser das Modell darin wird, das nächste Token vorherzusagen, vorausgesetzt, es steht ausreichend Ressourcen zur Verfügung: ein großes, hochwertiges, vielfältiges Korpus sowie ein Modell, das groß genug ist, um die notwendigen Muster zu speichern. Deshalb bezeichnen Forscher dieses Ziel als trügerisch einfach. Das Ziel selbst ist zwar einfach, doch das, was ein Modell lernen muss, um darin gut abzuschneiden, ist es nicht.
Das Kontextfenster als Arbeitsgedächtnis
Die Arbeitsgedächtniskapazität eines Modells entspricht dem Kontextfenster – der größten Anzahl an Token, die es während einer einzigen Verarbeitungsschleife aufnehmen kann. Es gab hier einen dramatischen Anstieg: GPT-2 konnte 2019 1.024 Token verarbeiten, GPT-3 im Jahr 2020 bereits 2.048. GPT-4o erreichte 2024 die Zahl von 128.000 Token. Bis Mitte 2026 hatte sich diese Grenze weiter verschoben: Die GPT-5-Serie von OpenAI bietet standardmäßig 272.000 Token sowie über eine Million über die API; Claude von Anthropic und Gemini 3 von Google liefern ebenfalls mehr als eine Million Token, während Meta mit Llama 4 Scout bis zu 10 Millionen Token, also etwa 15.000 Seiten, verspricht. Diese Zahlen steigen mit jeder neuen Generation weiter an.
Ein größeres Kontextfenster ist wichtig, da es es ermöglicht, eine ganze Code-Datei – und nicht nur Auszüge – zu analysieren, Gespräche über viele Schritte hinweg kohärent zu halten, ganze Dokumente zusammenzufassen sowie mehrstufige Schlussfolgerungen unter Berücksichtigung vieler Zwischenergebnisse zu ziehen.
Es gibt jedoch einen Haken. Die Berechnung der vollständigen Aufmerksamkeitsmatrix, die jeden Token mit jedem anderen Token verknüpft, erfordert beim Training O(n hoch 2) an Zeit und Speicher. Verdoppelt sich die Länge des Kontexts, verdoppeln sich beide Werte ebenfalls. Bei der Inferenz verringert das KV-Caching die Rechenlast pro Schritt, doch der Speicherverbrauch wächst weiterhin linear mit der Kontextlänge. Dieses quadratische Trainingsbottleneck ist ein aktives Forschungsfeld. Sparsame Aufmerksamkeitsmechanismen, schrägfensterbasierte Aufmerksamkeit wie in Mistral sowie andere effiziente Konzepte, Flash Attention (speichereffiziente exakte Aufmerksamkeit) und lineare Approximationen versuchen alle, die Kosten zu senken.
Was auf der Grundlage steht
Aufmerksamkeitsmechanismen, QKV-Strukturen, mehrere Aufmerksamkeitsschichten, positionale Kodierung sowie die Encoder-Decoder-Architektur bilden die Infrastruktur – der Grund, sie zu lernen, liegt darin, dass alles, was darauf aufgebaut wird, davon abhängt.
Generative KI ist wiederholte Vorhersage des nächsten Tokens
Jede generative Anwendung basiert im Grunde auf derselben Schleife, die immer wieder ausgeführt wird:
Prompt: "Write a poem about autumn"
↓
Model predicts most likely next token: "The"
↓
Prompt + "The" → predicts: "leaves"
↓
Prompt + "The leaves" → predicts: "fall"
↓
... continues until <end-of-sequence> token predicted
Wenn man es so betrachtet, verschwindet das Rätsel hinter mehreren Verhaltensweisen:
- Halluzinationen. Das Modell prognostiziert wahrscheinliche Token und holt keine Fakten aus einer Datenbank ab. Wenn ein plausibles, aber falsches Token verfügbar ist, kann es erzeugt werden.
- Warum der Kontext so wichtig ist. Im Rahmen jedes Generierungsschritts wird das gesamte Kontextfenster berücksichtigt, sodass alles, was in die Eingabe gegeben wird, darüber entscheidet, welche Aufmerksamkeitsgewichte berechnet werden und somit auch das Ergebnis.
In-Context-Lernen: Aufmerksamkeit zur Informationsabrufung
Eine der bemerkenswertesten Fähigkeiten großer Transformer ist das In-Context-Lernen, bei dem sie sich an eine neue Aufgabe anhand von Beispielen im Prompt anpassen können, ohne weitere Feinabstimmung. Der Mechanismus entspricht dem, was oben erläutert wurde. Die Beispielsfälle nehmen bestimmte Positionen im „Window“ ein. Wenn das Modell die Testinstanz verarbeitet, wird die Abfrage dieses Tokens mittels Skalarprodukt mit den Schlüsseln aller früheren Tokens verglichen, einschließlich der Beispielpaare. Da die Beispiele ein strukturelles Muster mit der Testinstanz teilen, passen ihre Schlüssel gut zusammen und erhalten hohe Gewichte. Die Aufmerksamkeit ist buchstäblich das Abrufmechanismus – und genau deshalb verändert die Struktur eines Prompts durch ihren Einfluss auf die Aufmerksamkeitsmuster die Ausgabe.
Agenten: Ein Transformer als Reasoning-Engine
KI-Agenten sind Systeme, die Aufgaben selbstständig aufteilen, Tools aufrufen, auf Rückmeldungen reagieren und in mehreren Schritten Ziele verfolgen. Im Jahr 2023 waren sie noch ein Forschungsthema. Heute werden Produkte wie Claude Code, GitHub Copilot, Cursor und Devin täglich von Entwicklern genutzt. Jeder ernstzunehmende Agent basiert in seinem Kern auf einem Transformer-Modell.
╔══════════════════════════════════════════════════════════════════════════════╗
║ THE CONTEXT WINDOW AS AGENT WORKING MEMORY ║
╚══════════════════════════════════════════════════════════════════════════════╝
TIME ──────────────────────────────────────────────────────────────────────▶
┌──────────────┬──────────────┬────────────────┬────────────┬──────────────┐
│ SYSTEM │ USER │ AGENT │ TOOL │ AGENT │
│ PROMPT │ MESSAGE │ THOUGHT │ RESULT │ RESPONSE │
│ │ │ (reasoning) │ │ │
│ "You are a │ "What is │ <think> │ {"temp": │ "The current │
│ weather │ the weather │ I need to │ 22, │ temperature │
│ assistant │ in Paris │ call the │ "unit": │ in Paris │
│ ..." │ today?" │ weather API │ "C", │ is 22°C and │
│ │ │ for Paris... │ "cond": │ cloudy." │
│ │ │ </think> │ "cloudy"} │ │
│ ~200 tokens │ ~15 tokens │ ~80 tokens │ ~40 tokens │ ~25 tokens │
└──────────────┴──────────────┴────────────────┴────────────┴──────────────┘
▲ ▲ ▲ ▲ ▲
└───────────────┴───────────────┴───────────────┴─────────────┘
│
At each generation step:
Full self-attention runs over the
ENTIRE context simultaneously.
Cost: O(n²) in total context length.
WHAT THIS MEANS FOR AGENTS:
✓ Tool results are just tokens - the model attends to them like any text
✓ Reasoning traces are visible - chain-of-thought shapes next generation
✓ Long task history - "memory" without any separate mechanism
⚠ Context fills up - very long loops need summarization/offload
⚠ O(n²) attention cost - longer context = quadratically more compute
KEY INSIGHT: There is no "working memory" separate from the context.
The context window IS the agent's entire cognitive state.
Für einen Agenten ist das Fenster ein flaches, geordnetes Pufferfeld aus Tokens, und jeder Generierungsschritt bezieht sich auf den gesamten Inhalt dieses Puffers, wodurch alles, was bis zu diesem Limit bereits eingetreten ist, weiterhin zugänglich bleibt. Das Fenster stellt das Arbeitsgedächtnis des Agenten dar, die Aufmerksamkeit ist sein Reasoning-Mechanismus und der Loop für das nächste Token ist sein Handlungsloop. KI-Agenten benötigten keine neue Architektur – es reichte aus, zu erkennen, dass der Transformer in ausreichend großer Skala bereits Fähigkeiten zur Handlungsführung bieten kann.
In der Praxis greifen Agenten, die im Jahr 2026 entwickelt wurden, selten allein auf das reine Fenster zurück. Um lange Aufgaben bewältigen zu können, fügen sie externe Speicher hinzu: Scratchpad-Dateien, eine Abrufschicht oder eine Wissensdatenbank, die der Agent ständig aktualisiert. Das steht im Einklang mit dem obigen Punkt, denn der externe Speicher beeinflusst das Modell nur dadurch, dass er wieder in das Fenster eingelesen wird. Er erweitert den Puffer, ersetzt ihn jedoch nicht, und die Aufmerksamkeit des Transformers auf diesen Kontext bleibt der einzige Ort, an dem das Denken stattfindet.
Wohin die Forschung geht
Die Leistung von Transformern folgt vorhersehbaren Potenzgesetzen hinsichtlich Parametern, Trainingsdaten und Rechenleistung, was den Forschern eine Richtlinie bietet. Die Entwicklung bewegt sich in mehreren Richtungen voran:
- Effiziente Architekturen, die durch Flash Attention, sparsame Aufmerksamkeit und lineare Aufmerksamkeit die quadratische Kostenstruktur der Aufmerksamkeit verringern.
Alle diese Ansätze basieren auf der Transformer-Technologie, wodurch ihr Verständnis diese Entwicklungen verständlicher macht.
Die folgende Tabelle fasst alle Komponenten in einem Überblick zusammen, zeigt das jeweilige zu lösende Problem, die Funktionsweise sowie die wichtigsten Eigenschaften:
| Component | Problem it Solves | Core Mechanism | Key Properties |
|-----------|------------------|----------------|----------------|
| **Tokenization** | Text is not natively numeric | Subword BPE/WordPiece splitting | Vocabulary ≈ 30k–100k; subwords handle rare terms |
| **Embeddings** | Discrete IDs have no geometry | $\mathbf{e}_t = E[t] \in \mathbb{R}^{d_{\text{model}}}$ | Semantic similarity → geometric proximity |
| **Positional Encoding** | Parallel attention loses token order | sin/cos at different frequencies (or RoPE) | Multi-scale; encodes absolute and relative position |
| **Self-Attention** | Long-range deps, sequential bottleneck | $\text{softmax}(QK^\top/\sqrt{d_k})V$ | $O(n^2)$ but parallel; dynamic contextual reps |
| **Query/Key/Value** | Separating "what I seek" from "what I offer" | Three separate learned linear projections | Relevance ≠ similarity; flexible dependency modeling |
| **Multi-Head Attention** | Single head captures only one relationship type | $h$ parallel heads, concatenated + $W^O$ | Simultaneously captures syntactic, semantic, positional |
| **Encoder** | Understanding input in full bidirectional context | Full self-attention, no masking | Bidirectional; rich contextualized representations |
| **Decoder** | Generating output autoregressively | Causal self-attention + cross-attention | Predicts one token at a time; teacher-forcing in training |
| **Cross-Attention** | Connecting generation to input understanding | Q from decoder, K/V from encoder | Enables encoder→decoder communication |
| **Feed-Forward Network** | Per-token computation + factual storage | $\text{GeLU}(\mathbf{x}W_1)\,W_2$ per token | Position-wise; stores factual associations in weights |
| **Residual Connections** | Vanishing gradients in deep networks | $\mathbf{h} = \text{SubLayer}(\mathbf{x}) + \mathbf{x}$ | Creates gradient highway; enables 100+ layer models |
| **Pre-LayerNorm** | Unstable activations in deep networks | Normalize before each sublayer | Stable training; standard in all modern transformers |
Was bereits behandelt wurde und wohin es als Nächstes geht
Die Komponenten passen wie folgt zusammen. Parallelisierte Aufmerksamkeit funktioniert besser als schrittweises Verarbeiten und erfasst entfernte Abhängigkeiten effektiver, weshalb Transformer sequenzielle Modelle verdrängt haben. Die Daten fließen vom Text über Tokens zu Embeddings, zur Positionscodeierung, zur Aufmerksamkeit und zu Feed-Forward-Schichten, um anschließend wiederholt zu werden. Die Selbstaufmerksamkeit ist die zentrale Operation, wobei jedes Token durch gelernte Q-, K- und V-Projektionen auf alle anderen Tokens achtet, wie in Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V dargestellt. Mehrere „Heads“ erfassen unterschiedliche Muster, die Positionscodeierung stellt die Reihenfolge wieder her, und das Encoder-Decoder-Design unterstützt sowohl das Verstehen als auch die Erzeugung von Inhalten. Feed-Forward-Schichten speichern Wissen, Residualverbindungen ermöglichen größere Tiefe und Pre-LayerNorm hält das Training stabil. Die Vorhersage des nächsten Tokens in großem Maßstab führt zu emergenten Fähigkeiten, das Kontextfenster dient als Arbeitsgedächtnis des Agents, und die Architektur fr
Ein Übersetzungsartikel aus dem Jahr 2017 treibt die fortschrittlichsten Systeme von heute an.Für ein tieferes Verständnis eignet sich ein schrittweiser Plan gut.
Erste zwei Wochen: Die Mathematik. Arbeiten Sie sich durch Andrej Karpathys Serie „Neural Networks: Zero to Hero“ auf YouTube durch, insbesondere das Video, in dem GPT von Grund auf entwickelt wird. Schreiben Sie anschließend eine einfache Selbst-Aufmerksamkeitsschicht in NumPy. Die Konzepte werden anders verstanden, wenn man sie selbst ausrechnet.
Wochen drei und vier: Die Artikel. Lesen Sie „Attention Is All You Need“ (Vaswani et al., 2017), das heute noch lesbar ist, zusammen mit dem BERT-Artikel (Devlin et al., 2018), dem GPT-3-Artikel „Language Models are Few-Shot Learners“ (Brown et al., 2020) sowie „Scaling Laws for Neural Language Models“ (Kaplan et al., 2020).
Monat zwei: Übung mit Bibliotheken und APIs. Die Hugging Face transformers-Bibliothek macht diese Modelle mit geringer Vorbereitung direkt aus Python ausnutzbar. Feinabstimmen Sie BERT oder ein kleines Open-Weight-Modell wie eine Llama- oder Qwen-Variante für eine Klassifizierungsaufgabe. Anschließend gelangen Sie über die Anthropic- oder OpenAI-Python-SDK zu aktuellen Spitzenmodellen, sei es Claude Sonnet 5 oder eines der GPT-5-Modelle. Beides verbindet Theorie und Praxis, da die gleichen Transformer-Prinzipien sowohl in Open-Weight- als auch in Spitzen-API-Modellen zu finden sind.
Monat drei: Eines Themas im Detail. Wählen Sie eines der Agenten-Frameworks (LangChain, LlamaIndex) oder arbeiten Sie direkt mit Claude Code oder Cursor, um das agentebasierte Verhalten in einem echten Produktionswerkzeug zu beobachten, effiziente Transformer-Methoden (Flash Attention, spärliche und lineare Aufmerksamkeit) oder die Feinabstimmung von LLMs mit LoRA und PEFT. Hier zählt Tiefe mehr als Breite.
Im Gange: Bleiben Sie auf dem Laufenden mit der Forschung. Die Bereiche cs.CL und cs.LG auf arXiv, der Hugging Face Blog, die Forschungsseite von Anthropic sowie das AI Alignment Forum sind gute Quellen. Das Feld entwickelt sich schnell, doch die oben genannten Grundlagen machen neue Arbeiten verständlich.
Der Artikel über Transformer umfasst etwa fünfzehn Seiten, und die beschriebene Architektur ist so klar strukturiert, dass sie bereits am Nachmittag implementiert werden kann. Was dadurch in Gang gesetzt wurde – und was durch weitere Skalierungen und Verbesserungen weiterhin entsteht – hat die Vorstellungen darüber verändert, was Maschinen leisten können.