llm transformers attention tokenization code-generation

Von der Vorhersage des nächsten Tokens bis zum funktionsfähigen Code: Wie LLMs Python erzeugen

Tokens, Softmax, Temperatur, Selbstaufmerksamkeits- und Feed-Forward-Schichten werden nacheinander erläutert, zusammen mit einem schrittweisen Sortierbeispiel sowie den daraus resultierenden Grenzen bei der Vorhersage.

Verlag: REACTAPP.TOPAuf dieser Website hinzugefügt 28. Okt. 20269 Min. Lesezeit1998 Wörter

Quellen: How LLMs Actually Work: From Predicting the Next Word to Writing Code.

Tools wie ChatGPT und Copilot schreiben Funktionen, beheben Fehler und erklären Algorithmen – es kann den Anschein haben, als ginge es um mehr als nur die Vervollständigung von Texten. Das folgende mentale Modell beginnt unten: Tokenvorhersage, Attention sowie der Grund, warum das Mechanismus, der einen Satz abschließt, gleichzeitig gültigen Python-Code erzeugt.

Eine Frage, die immer wieder gestellt wird

Egal ob das Ergebnis ein Haiku, eine Werbe-E-Mail oder ein Merge-Sort ist – ein Sprachmodell beantwortet immer wieder dieselbe Frage: Angesichts dessen, was bisher gesehen wurde, welches ist das wahrscheinlichste nächste Token?

Es gibt kein semantisches Verständnis im traditionellen Sinne, und es gibt keine Phase, in der das Modell vor der Erzeugung des Wortes def bereits entscheidet, eine Funktion zu schreiben. Es prognostiziert Token für Token. Mit Milliarden von Parametern sowie Trainingstexten, die in Hunderten von Milliarden von Tokenen angegeben werden, sehen die Prognosen letztendlich sehr nach logischem Denken aus.

Was ein Token ist

Genauigkeit ist wichtig, bevor man sich mit der Prognose beschäftigt. Modelle arbeiten nicht mit Zeichen oder Wörtern, sondern mit Tokenn – Unterwort-Einheiten, die durch Algorithmen wie Byte Pair Encoding erzeugt werden. Im Großen und Ganzen:

Übliche Wörter werden in der Regel zu einzelnen Tokenn, wie zum Beispiel "the", "def" und "return".
Seltene Wörter werden in Teile aufgeteilt, sodass "unhappiness" zu ["un", "happiness"] wird.

Code-Symbole sind oft einzelne Token, beispielsweise "(", ":", "==" und "->".

Bei GPT-4 entspricht ein Token etwa 0,75 englischen Wörtern, während es im Code eher 3 bis 4 Zeichen umfasst, da Code voller einzeiliger Token wie : und ( ist.

Das Modell verfügt außerdem über ein Wörterbuch, eine feste Liste bekannter Token, die in der Regel zwischen 50.000 und 100.000 Einträgen umfasst. Bei jedem Schritt weist es jedem Eintrag eine Wahrscheinlichkeit zu und wählt entweder den wahrscheinlichsten oder zieht zufällig aus der Verteilung – wobei die Auswahl durch die Temperatur gesteuert wird.

Der Vorhersagezyklus

Für die Sequenz „The cat sat on the“ muss eine bedingte Wahrscheinlichkeit berechnet werden:

P(next_token | "The", "cat", "sat", "on", "the")

Das ist eine Verteilung über das gesamte Vokabular. Ein Vorwärtslauf durch das Netzwerk erzeugt einen Vektor der Größe des Vokabulars, den eine softmax-Funktion in eine gültige Wahrscheinlichkeitsverteilung umwandelt:

P(token_i) = exp(logit_i) / Σⱼ exp(logit_j)

Bei der gierigen Dekodierung wird das Token mit der höchsten Wahrscheinlichkeit ausgewählt. Andernfalls wird ein Token proportional zur Verteilung ausgewählt, wobei temperature die Streuung steuert:

temperature = 0 wählt immer das am häufigsten vorkommende Token, sodass die Ausgabe deterministisch ist.
temperature = 1 wählt aus der Rohverteilung aus, was für vielfältige und kreative Ergebnisse sorgt.
Über 1 flacht die Verteilung ab und die Ausgabe wird zufälliger.
Unter 1 wird die Verteilung schärfer und die Ausgabe wird konservativer.

Deshalb kann derselbe Prompt bei verschiedenen Ausführungen unterschiedliche Antworten liefern.

Der Transformer

Die Funktion, die eine Tokenfolge in eine Verteilung der nächsten Token umwandelt, ist ein Transformer – genauer gesagt ein rein dekodierender Transformer –, was die Grundlage von GPT, Llama, Mistral und Claude darstellt. Der übergeordnete Ablauf:

Token IDs → Embedding layer → [Attention + FFN] × N layers → Linear head → Softmax → P(next token)

Die Komponenten in der Reihenfolge:

Embedding-Schicht. Jeder Ganzzahl-Token-ID wird zu einem dichten Vektor der Größe d_model – beispielsweise 4096 bei Llama-3 8B. Positionale Embeddings oder RoPE in modernen Modellen fügen Informationen über die Reihenfolge hinzu.
Transformer-Schichten, insgesamt N Mal wiederholt. Jede Schicht enthält mehrköpfige Selbstaufmerksamkeit, ein Feed-Forward-Netzwerk, Schichtnormalisierung im „pre-norm“-Stil vor jeder Unter-Schicht sowie Residualverbindungen.
Lineare Schicht und Softmax. Der finale versteckte Zustand wird in Logits der Form [|V|] umgewandelt, und Softmax erzeugt die Verteilung.

Selbstaufmerksamkeit

Die Selbstaufmerksamkeit ermöglicht es einem Token, auf andere Tokens in der Sequenz zu blicken, um ein umfassenderes Bild von sich selbst zu erstellen. Dadurch haben Transformers einen Vorteil gegenüber RNNs: Jedes Token kann in einem Schritt auf jedes andere Token zugreifen, ohne dass es zu einem Abklingen der Gradienten aufgrund der Entfernung kommt.

Gegeben sind n Tokens, so werden jeweils alle davon auf drei Arten projiziert:

Q = XWᴬ_Q    (Query: what am I looking for?)
K = XWᴬ_K    (Key: what do I contain?)
V = XWᴬ_V    (Value: what do I contribute?)

Hier ist X die Eingabematrix mit der Größe [n, d_model] und die drei W-Matrizen sind die gelernten Gewichte. Die Ähnlichkeitswert zwischen dem Token i, das als Abfrage dient, und dem Token j, das als Schlüssel dient, beträgt:

score(i, j) = qᵢ · kⱼᵀ / √dₖ

Durch Division durch die Quadratwurzel der Schlüsseldimension wird verhindert, dass die Skalarprodukte zu groß werden, wenn dₖ hoch ist – andernfalls würde das softmax in Bereiche mit sehr kleinen Gradienten gedrängt. Die vollständige Berechnung lautet:

Attention(Q, K, V) = softmax(QKᵀ / √dₖ) · V

In einem reinen Dekodierungsmodell wie GPT ist die Aufmerksamkeit kausal oder maskiert: Das Token i kann sich nur auf Positionen bis i konzentrieren. Zukünftige Positionen erhalten vor der Anwendung von softmax einen Wert von negativer Unendlichkeit, wodurch ihre Gewichte genau null sind.

Mehrkopf-Aufmerksamkeit führt h unabhängige Aufmerksamkeitsfunktionen parallel aus, wobei jede Funktion die kleinere Dimension d_model / h hat, und verknüpft anschließend die Ausgaben miteinander:

MultiHead(Q, K, V) = Concat(head₁, ..., headₕ) · W_O
headᵢ = Attention(QWᵢ_Q, KWᵢ_K, VWᵢ_V)

Andere „Köpfe“ kümmern sich schließlich um unterschiedliche Beziehungen. Einige können syntaktische Abhängigkeiten berücksichtigen, andere Koinferenz und wieder andere die räumliche Nähe.

Das Feed-Forward-Netzwerk

Nach der Aufmerksamkeitsberechnung durchläuft die Repräsentation jedes Tokens ein positionsspezifisches FFN:

FFN(x) = max(0, xW₁ + b₁)W₂ + b₂

Moderne Architekturen wie Llama und Mistral verwenden stattdessen SwiGLU:

FFN(x) = (SiLU(xW_gate) ⊙ xW_up) · W_down

Der größte Teil des memorisierten Wissens eines Modells befindet sich im FFN. Es funktioniert wie ein Schlüssel-Wert-Speicher für faktische Zusammenhänge. Die Aufmerksamkeit leitet Informationen zwischen Tokens weiter, und das FFN sucht nach gespeicherten Fakten und Mustern. In großen Modellen ist das FFN etwa viermal so breit wie d_model. Llama-3 70B hat d_model = 8192 sowie eine mittlere Größe von 28672, und dort befinden sich die meisten Parameter.

Warum Modelle Code schreiben können

Code ist eine Tokenfolge, genauso wie natürliche Sprache. Für ein Modell ist eine Python-Funktion nichts Besonderes – es handelt sich dabei lediglich um eine Abfolge von Tokens wie def, sort, _list, (, arr, ), : und so weiter.

Syntaktisch gültiger Ausgabe ist rein eine Folge der Trainingsverteilung. Betrachten Sie diese bedingten Wahrscheinlichkeiten:

P("(" | ..., "def", " quicksort") ≈ 1.0
P(":" | ..., "def", " quicksort", "(", "arr", ")") ≈ 1.0
P("return" | context inside function body) >> P("import" | same context)

Sie weisen eine scharfe Spitze auf, weil das Modell Millionen von Python-Dateien gesehen hat, die alle denselben Regeln folgen. Pythons Grammatik ist nirgends im Netzwerk fest codiert – sie ergibt sich aus den Statistiken des Korpus.

Das erklärt auch, warum Modelle manchmal Code schreiben, der zwar perfekt strukturiert ist, aber logisch falsch ist. Sie maximieren die Wahrscheinlichkeit des nächsten Tokens unter Berücksichtigung der Trainingsverteilung. Sie führen den Code nicht aus und überprüfen ihn nicht.

Eine Sortierfunktion, Schritt für Schritt

Nehmen wir an, die Anfrage lautet „Schreiben Sie eine Python-Funktion, um eine Liste zu sortieren“. Das Modell behandelt dies als eine Tokenfolge und fügt die Ausgabe nacheinander ein Token hinzu. Grob gesagt:

Schritt 1, nach der Anfrage: def mit einer Wahrscheinlichkeit von etwa 0,91.
Schritt 2, nach def: sort mit einer Wahrscheinlichkeit von etwa 0,78.
Schritt 3: _list oder ( mit einer Wahrscheinlichkeit von etwa 0,65.
Schritt 4, nach sort(: arr oder lst bei etwa 0,71.
Schritte 5 bis 7: ), dann :, dann eine Zeile Leerzeichen, jeweils bei etwa 0,99.
Schritt 8: die vier Raumzeichen umfassende Einrückung bei etwa 0,97.

In den Schritten 5 bis 8 nähert sich das Modell der Gewissheit bezüglich syntaktischer Token an. Das bedeutet jedoch kein Verständnis von Python. Es handelt sich dabei um reine Musterergänzung, die aus einem Korpus gelernt wurde, in dem jede Funktionseintragung gleich aussieht.

Die eigentlichen Entscheidungen fallen früher, in den Schritten 1 bis 4, wo der Funktionsname, die Parameterbezeichnungen sowie die Gesamtstruktur gewählt werden. Diese Entscheidungen werden durch den Inhalt der Anfrage über die Aufmerksamkeit beeinflusst. Das Token sort in der Anfrage erhält ein hohes Aufmerksamkeitsgewicht, wenn der Funktionsname generiert wird.

Temperatur bei der Codegenerierung

Copilot und ähnliche Tools laufen im Allgemeinen bei niedriger Temperatur, etwa 0,1 bis 0,3, für den Code:

Syntaktische Token müssen nahezu deterministisch sein.
Oft gibt es nur eine korrekte Implementierung.
Eigene API-Strukturen stellen bei hoher Temperatur eine große Fehlerquelle dar.

Bei kreativen Elementen wie Variablennamen, Docstrings und Kommentaren ist eine etwas höhere Temperatur zulässig. Einige Tools verwenden außerdem Beam Search, bei dem gleichzeitig die besten k-k Partialsequenzen beibehalten werden und am Ende diejenige mit der höchsten gemeinsamen Wahrscheinlichkeit ausgewählt wird.

Warum größere Modelle sich anders verhalten

Ein 7B-Modell und ein 70B-Modell teilen dieselbe Architektur. Der Unterschied liegt in der Skalierung: mehr Schichten, ein größeres d_model sowie mehr Attention-Heads. Dennoch weisen die größeren Modelle qualitative Vorteile auf, darunter mehrschrittiges Denken, korrekteren Code sowie emergentes Lernen im Kontext.

In großem Maßstab lernt das Modell mehr als nur oberflächliche Token-Statistiken. Es erstellt komprimierte Repräsentationen tieferer Muster wie algorithmischer Struktur, logischer Abhängigkeiten und Typbeschränkungen. Ein 70B-Modell hat bereits genug fehlerhaften Code sowie Testfehler gesehen, wodurch es bestimmte Muster implizit mit Korrektheit in Verbindung gebracht hat. Dies bildet die empirische Grundlage der Skalierungshypothese: Die Leistungsfähigkeit folgt einer glatten Kurve in Bezug auf Rechenleistung, Datenmenge und Parameter, und die Codequalität folgt dieser Kurve genauso zuverlässig wie jede andere Fähigkeit.

Durch das Design bedingte Grenzen

Durch Kenntnis des Mechanismus werden einige harte Grenzen offensichtlich:

Ausführung. Im Inneren des Modells gibt es keinen Laufzeitmechanismus. Was es ausgibt, ähnelt dem Ausgabeergebnis einer korrekten Ausführung, doch tatsächlich wurde nichts ausgeführt.
Garantierte Korrektheit. Die Vorhersage maximiert die Wahrscheinlichkeit innerhalb der Trainingsverteilung, nicht die logische Gültigkeit.
Wahre Neuheit. Ein Algorithmus ohne statistische Vorbilder in den Trainingsdaten kann nicht erfunden werden. Das Modell kann kombinieren und anpassen, aber nicht neu erschaffen.
Genaue Erinnerung. Es gibt keine Abfrageschlüsseltabelle. Der gesamte Speicher ist in den Gewichten verteilt, wodurch API-Einträge, Funktionssignaturen und Bibliotheksversionen manchmal falsch angegeben werden.

Keines davon sind Fehler, die behoben werden müssen. Sie folgen direkt aus der Architektur, und ihr Wissen macht jeden zu einem besseren Nutzer von Programmier-Assistenten.

Kurzer Überblick

Ein Token ist eine Unterwort-Einheit, etwa 0,75 englische Wörter.
Die Vorhersage erfolgt bei jedem Schritt mittels Softmax über das Vokabular.
Die Selbstaufmerksamkeit ermöglicht es jedem Token, sich durch skalierte Produktionen von Abfrageschlüsseln an allen früheren Tokenen zu orientieren.
Mehrkopf-Aufmerksamkeit führt mehrere dieser Prozesse parallel durch, um unterschiedliche Beziehungen zu erfassen.
Der FFN fungiert als Schlüssel-Wert-Speicher für faktische Assoziationen.
Die Codegenerierung funktioniert ähnlich wie die Textgenerierung, wobei die Syntax aus den Trainingsstatistiken entsteht.
Die Temperatur legt fest, wie schmal die Stichprobenverteilung ist.
Die grundlegenden Einschränkungen sind keine Ausführung, keine garantierte Korrektheit und keine wahre Neuheit.

Alles in diesem Mechanismus – von der Aufmerksamkeit und dem FFN über Residuen bis hin zur Schichtnormalisierung – dient einem einzigen Zweck: Die bedingte Wahrscheinlichkeit des nächsten Tokens unter Berücksichtigung aller vorherigen Token so genau wie möglich zu machen. Alles Weitere entsteht daraus.