Funktionsweise von LLMs

Die meisten, die ChatGPT zum ersten Mal benutzen, sind beeindruckt. Da sitzt scheinbar jemand am anderen Ende, der mühelos auf fast jede Frage antwortet - in fließendem Deutsch, Englisch oder Klingonisch, mal als Shakespeare, mal als SQL-Profi. Doch hinter dem freundlichen Chatfenster steckt kein kleiner Mensch, sondern viel Mathematik, noch mehr Daten und ein bisschen Magie (die wir gleich entzaubern).

Bevor wir jedoch lernen, wie man diese Werkzeuge mit guten Prompts zur Höchstform bringt, sollten wir verstehen, wie sie funktionieren.

Drei Fähigkeiten, die beeindrucken

Wenn man ChatGPT & Co. genauer betrachtet, machen vor allem drei Fähigkeiten den beeindruckenden Eindruck aus¹:

1. natürliche Sprache zu produzieren - und das in vielen verschiedenen Sprachen,
2. den Input des Nutzers sprachlich und inhaltlich zu verstehen,
3. scheinbar kreativ tätig zu werden und Dinge zu erschaffen, die es so vorher nicht gab.

Während Maschinen Sprache schon länger übersetzen können (Google Translate, DeepL), ist besonders das Verstehen und das kreative Erzeugen neu. Schauen wir uns an, wie das gelingt.

Das Zauberwort: Transformer

Das Herzstück moderner Sprachmodelle heißt Transformer. Und nein - damit ist nicht das Auto gemeint, das sich in einen Roboter verwandelt. Gemeint ist eine Architektur, die einen Input (Text, mittlerweile auch Bilder oder Audio) in einen Output transformiert.

Populär wurde der Transformer durch eine Veröffentlichung mit dem wohl coolsten Titel der KI-Geschichte: „Attention Is All You Need"². Acht Google-Forscher legten damit den Grundstein für so ziemlich jeden Chatbot, den du heute kennst.

Grob besteht ein Transformer aus zwei Teilen:

flowchart LR
    A[Input<br/>z. B. dein Prompt]:::peach --> B(Encoder<br/> versteht den Input):::teal
    B --> C(Decoder<br/>erzeugt den Output):::teal
    C --> D[Output<br/>z. B. die Antwort]:::peach

    classDef peach fill:#FFB482aa,stroke:#333,stroke-width:1px;
    classDef teal fill:#009485aa,stroke:#333,stroke-width:1px;

• Der Encoder analysiert den Input und versteht ihn im Kontext.
• Der Decoder erzeugt daraus Wort für Wort den Output.

Wie kommt das Modell aber von „deinem Prompt" zu „dem Verständnis"? Dafür durchläuft der Text mehrere Stationen. Gehen wir sie der Reihe nach durch.

1) Tokenization

Ein Computer kann mit Buchstaben nichts anfangen. Deshalb wird dein Text zuerst in kleine Bausteine zerlegt, sogenannte Tokens. Ein Token kann ein ganzes Wort sein - oft aber auch nur ein Wortteil.

Ein Beispiel mit dem Tokenizer, den OpenAI nutzt (Python-Bibliothek tiktoken):

import tiktoken as tt

# "cl100k_base" ist das Tokenizer-Modell, das ChatGPT-4 verwendet
enc = tt.get_encoding("cl100k_base")

encoded = enc.encode('He said: "Let me explain tokenization to you. It is comparably easy."')

print(encoded)

[1548, 1071, 25, 330, 10267, 757, 10552, 4037, 2065, 311, 499, 13, 1102, 374, 7809, 2915, 4228, 1210]

Der Satz oben hat 69 Zeichen, wird aber zu 18 Tokens zerlegt. Wörter wie tokenization zerfallen dabei in mehrere Häppchen (token + ization).

2) Word Embeddings

Tokens sind erstmal nur IDs - nackte Zahlen ohne Bedeutung. Damit das Modell mit Bedeutung arbeiten kann, wird jedes Token in einen Vektor aus vielen Zahlen übersetzt: das Embedding.

Man kann sich jedes Element des Vektors als einen Aspekt des Wortes vorstellen. Je höher der Wert, desto stärker ist dieser Aspekt ausgeprägt:

„Programmierer" und „Entwickler" haben ähnliche Vektoren - kein Wunder, sie bedeuten fast dasselbe. „Wald" zeigt in eine ganz andere Richtung.

Das Faszinierende: Mit Embeddings kann man sogar rechnen. Das berühmteste Beispiel:

import gensim.downloader as api

# Wir laden fertige Wortvektoren - **GloVe**, trainiert auf englischen Wikipedia-Texten
modell = api.load("glove-wiki-gigaword-50") 

# König - Mann + Frau = ?
ergebnis = modell.most_similar(positive=["king", "woman"], negative=["man"], topn=3)

for wort, aehnlichkeit in ergebnis:
    print(f"{wort:<12} {aehnlichkeit:.3f}")

queen        0.852
throne       0.766
prince       0.759

3) Positional Encoding

Bedeutung allein reicht nicht. Vergleiche:

„Hans fütterte das Eichhörnchen." 🧑➡️🐿️

„Das Eichhörnchen fütterte Hans." 🐿️➡️🧑

Gleiche Wörter, völlig andere Bedeutung - nur die Reihenfolge ist anders (und in einem Fall ist Hans in Schwierigkeiten). Anders als ältere Ansätze (RNNs) verarbeitet der Transformer alle Wörter gleichzeitig. Das ist schnell, hat aber einen Haken: Ohne Zusatzinfo wüsste das Modell gar nicht mehr, welches Wort wo stand.

Die Lösung heißt Positional Encoding: Die Position eines Wortes wird über (Sinus-/Kosinus-)Werte direkt in seinen Embedding-Vektor hineingerechnet. So tragen die Vektoren ab jetzt zwei Informationen: Was bedeutet das Wort und wo steht es im Satz.

flowchart LR
    E[Embedding<br/>Bedeutung]:::teal --> P((+)):::peach
    POS[Positional Encoding<br/>Position im Satz]:::teal --> P
    P --> R[Vektor mit<br/>Bedeutung + Position]:::peach

    classDef peach fill:#FFB482aa,stroke:#333,stroke-width:1px;
    classDef teal fill:#009485aa,stroke:#333,stroke-width:1px;

import numpy as np

def positional_encoding(position, d_model):
    """Sinus-/Kosinus-Positionscodierung nach Vaswani et al. (2017)."""
    i = np.arange(d_model) // 2 * 2          # 0,0,2,2,4,4,...
    winkel = position / np.power(10000, i / d_model)
    return np.where(np.arange(d_model) % 2 == 0, np.sin(winkel), np.cos(winkel))

np.set_printoptions(precision=2, suppress=True)

for pos in range(4):
    print(f"Position {pos}: {positional_encoding(pos, d_model=8)}")

Position 0: [0. 1. 0. 1. 0. 1. 0. 1.]
Position 1: [0.84 0.54 0.1  1.   0.01 1.   0.   1.  ]
Position 2: [ 0.91 -0.42  0.2   0.98  0.02  1.    0.    1.  ]
Position 3: [ 0.14 -0.99  0.3   0.96  0.03  1.    0.    1.  ]

hans = np.array([0.9, 0.1, 0.5, 0.2, 0.7, 0.3, 0.4, 0.6])

print(f"'Hans' roh          : {hans}")
print(f"'Hans' an Position 0: {np.round(hans + positional_encoding(0, 8), 2)}")
print(f"'Hans' an Position 3: {np.round(hans + positional_encoding(3, 8), 2)}")

'Hans' roh          : [0.9 0.1 0.5 0.2 0.7 0.3 0.4 0.6]
'Hans' an Position 0: [0.9 1.1 0.5 1.2 0.7 1.3 0.4 1.6]
'Hans' an Position 3: [ 1.04 -0.89  0.8   1.16  0.73  1.3   0.4   1.6 ]

4) Attention

Jetzt kommt der Teil, der dem Paper seinen Namen gab. Bisher hat jedes Wort einen Vektor, der seine Bedeutung und Position kennt. Aber die wahre Stärke von LLMs liegt darin, Wörter im Kontext der anderen Wörter zu verstehen.

Das Lieblingsbeispiel dafür ist das Wort „Bank":

Aus dem Wort „Bank" allein lässt sich das nicht erkennen - nur aus dem Kontext. Genau das leistet die (Self-)Attention: Sie passt den Embedding-Vektor jedes Wortes ein wenig an, indem sie ihn in Richtung der relevanten Nachbarwörter verschiebt.

Du musst die Matrizenrechnung nicht auswendig können. Wichtig ist die Intuition:

5) Das nächste Token

Jetzt versteht das Modell deinen Input. Aber wie entsteht die Antwort? Überraschend simpel: Das Modell sagt immer nur das nächste Token voraus - und zwar das mit der höchsten Wahrscheinlichkeit.

Dann hängt es dieses Token an den bisherigen Text an, schaut erneut, sagt das nächste Token voraus - und so weiter. Wie eine sehr, sehr gute Autovervollständigung. 📱

flowchart LR
    A["Die Katze sitzt auf der ___"]:::peach --> B(LLM berechnet<br/>Wahrscheinlichkeiten):::teal
    B --> C["Matte (72%)<br/>Couch (15%)<br/>Banane (0.1%)"]:::peach
    C --> D["wählt: Matte"]:::teal
    D -->|hängt an & wiederholt| A

    classDef peach fill:#FFB482aa,stroke:#333,stroke-width:1px;
    classDef teal fill:#009485aa,stroke:#333,stroke-width:1px;

Das Spiel läuft so lange, bis ein spezielles Stop-Token erzeugt wird - das Signal: „Antwort fertig."

Wie wird ein LLM eigentlich klug?

Die beeindruckenden Fähigkeiten stecken in Milliarden von Parametern (GPT-3.5 z. B. ~175 Milliarden). Diese Werte entstehen in drei Trainingsphasen¹:

flowchart TB
    A["`**1 · Unsupervised Pre-Training**
    ────────────────────────────────
    liest riesige Textmengen aus dem Internet`"]:::teal
    B["`**2 · Supervised Fine-Tuning (SFT)**
    ────────────────────────────────
    lernt aus Beispiel-Antworten menschlicher Trainer`"]:::peach
    C["`**3 · RLHF**
    ────────────────────────────────
    lernt aus Bewertungen, welche Antworten gut sind`"]:::teal

    A --> B --> C

    classDef peach fill:#FFB482aa,stroke:#333,stroke-width:1px;
    classDef teal fill:#009485aa,stroke:#333,stroke-width:1px;

Zusammenfassung 📌

flowchart LR
    A[Dein Prompt]:::peach --> B[Tokenization]:::teal
    B --> C[Embeddings<br/>+ Position]:::teal
    C --> D[Attention<br/>Kontext]:::teal
    D --> E[nächstes Token<br/>vorhersagen]:::teal
    E --> F[Antwort]:::peach
    E -.wiederholen.-> E

    classDef peach fill:#FFB482aa,stroke:#333,stroke-width:1px;
    classDef teal fill:#009485aa,stroke:#333,stroke-width:1px;

Quellen

Zur Ausarbeitung wurden generative Tools unterstützend eingesetzt.