7.3 NLP, Embeddings & LLMs

Worum geht’s#

Bilder und Tabellen lassen sich als Zahlenmatrizen direkt in ein neuronales Netz schieben. Sprache nicht: Ein Computer kennt keine Wörter, nur Bytes, und der Satz „Die Katze schläft” ist für ihn zunächst eine bedeutungslose Zeichenkette. Die ganze Disziplin NLP (Natural Language Processing) dreht sich um eine einzige, folgenreiche Frage — wie macht man aus Sprache Zahlen, ohne ihre Bedeutung zu verlieren?

Mich fasziniert an diesem Kapitel, dass die Antwort eine durchgehende Kette ist, die ich auf dieser Seite Glied für Glied nachbaue. Text wird zunächst in Tokens zerlegt, jedes Token bekommt einen Vektor (sein Embedding), und die Geometrie dieses Vektorraums trägt am Ende tatsächlich Bedeutung: Wörter, die in ähnlichen Kontexten vorkommen, liegen nah beieinander, und Bedeutungsunterschiede werden zu Richtungen im Raum. Aus dieser Idee — Sprache als Geometrie — sind über die Zwischenstufen RNN und Transformer die heutigen Large Language Models gewachsen. Die Anwendungs- und Prompting-Seite dieser Modelle habe ich schon in 1.3 behandelt; hier liegt der Fokus auf der Technik darunter, die dort bewusst offengelassen wurde.

Kernkonzepte#

Tokenisierung: der erste Schnitt#

Bevor irgendetwas gelernt werden kann, muss Text in diskrete Einheiten zerfallen. Die naheliegenden Extreme haben beide einen Haken. Wort-Tokenisierung ist intuitiv, scheitert aber an Komposita und unbekannten Wörtern: Das Deutsche bildet beliebig neue Wörter („Donaudampfschifffahrtsgesellschaft”), die nie im Vokabular stünden. Zeichen-Tokenisierung kennt kein unbekanntes Symbol mehr, macht Sequenzen aber sehr lang und zwingt das Modell, Wortbedeutung mühsam aus Einzelzeichen zu rekonstruieren. Der heutige Kompromiss ist die Subwort-Tokenisierung.

In der Praxis unten lasse ich BPE auf meinem Mini-Korpus tatsächlich laufen und beobachte, wie es als ersten Merge die Endung „-er” und kurz darauf das ganze Wort „und” lernt — genau das erwartete Verhalten.

Wort-Embeddings & distributionelle Semantik#

Jedes Token wird auf einen Vektor in einem $d$-dimensionalen Raum abgebildet, das Embedding. Anfangs sind diese Vektoren zufällig; entscheidend ist, woraus sie gelernt werden. Die Leitidee ist die distributionelle Hypothese, die die Folien philosophisch mit Wittgenstein begründen — „Die Bedeutung eines Wortes ist sein Gebrauch in der Sprache”. Die Arbeitshypothese der Folien dazu: Wenn zwei Wörter häufig in ähnlichen Kontexten auftreten, dann haben sie eine verwandte Bedeutung. In der NLP-Tradition geht dieselbe Idee auf Firth (1957) zurück — „You shall know a word by the company it keeps.”

Das berühmte Verfahren ist word2vec (Mikolov et al. 2013): Ein flaches Netz wird darauf trainiert, aus einem Wort seine Nachbarn vorherzusagen (Skip-Gram) oder umgekehrt (CBOW). Verblüffend daran ist, dass der entstehende Raum eine lineare Struktur bekommt — Bedeutungsbeziehungen werden zu Vektordifferenzen. Das ikonische Beispiel:

Die Differenz $v_{\text{König}} - v_{\text{Mann}}$ isoliert gewissermaßen das Konzept „königlich”; addiert man es zu „Frau”, landet man bei „Königin”. Die Folien veranschaulichen das mit einer (idealisierten) Merkmalstabelle für King, Queen, Woman und Princess über Dimensionen wie Royalty, Masculinity, Femininity und Age — King und Queen teilen hohe Royalty, unterscheiden sich aber in Masculinity/Femininity. Genau diese Analogie-Arithmetik rechne ich in der Praxis an einem deutschen Mini-Raum nach.

Von Embeddings zu Kontext: RNN, LSTM, Transformer#

Ein statisches Embedding hat eine fundamentale Schwäche: In „Wir treffen uns bei der Bank hinter der Bank” (das mehrdeutige Beispiel der Folien) bekommt „Bank” einen Vektor, obwohl einmal das Geldhaus und einmal die Sitzgelegenheit gemeint ist. Bedeutung hängt vom Kontext ab. Die erste Generation kontextsensitiver Modelle für seq2seq-Aufgaben (Übersetzung, Chatbots) waren rekurrente Netze (RNN) und ihre Varianten LSTM und GRU, im Encoder-Decoder-Aufbau: Ein Encoder-RNN liest Text Token für Token und kondensiert ihn zu einer Kontextinformation $K$, aus der ein Decoder-RNN auto-regressiv die Zielsequenz erzeugt. Ihr Problem ist die Sequenzialität — Wort 1000 hängt nur über eine lange Kette von Zwischenzuständen mit Wort 1 zusammen, weite Abhängigkeiten verblassen, und nichts lässt sich parallelisieren.

Der Durchbruch von Vaswani et al. (2017), „Attention is all you need”, ersetzt die Rekurrenz durch Self-Attention: Jedes Token darf in einem Schritt direkt auf alle anderen Tokens der Sequenz schauen und gewichten, wie relevant jedes für seine eigene Neuberechnung ist.

Die Folien machen das an „blue fluffy creature” anschaulich: Die Adjektive „blue” und „fluffy” schränken die Bedeutung von „creature” ein, also wird dessen Embedding-Vektor im Raum verschoben — „creature” wird danach eher mit blauen oder fellbedeckten Objekten assoziiert. Genau dieses Verschieben leistet Attention rechnerisch.

Ein Transformer stapelt viele solcher Attention-Schichten (Multi-Head Attention: mehrere parallele „Köpfe”, die unterschiedliche Beziehungstypen lernen) und macht Bedeutung damit vollständig kontextabhängig und parallelisierbar — der Grund, warum sich diese Architektur überhaupt auf Internet-Maßstab trainieren ließ. Aus ihren Bausteinen entstehen die beiden LLM-Familien der Folien: BERT (nur Encoder, bidirektional, für NLU-Aufgaben) und GPT (nur Decoder, für die Textgenerierung).

LLMs: Skalierung eines simplen Trainingsziels#

Auf einem Transformer-Decoder ruht das, was 1.3 als nächstes-Token-Vorhersager eingeführt hat. Das selbstüberwachte Pre-Training eines GPT-artigen LLM ist im Kern eine einzige Aufgabe: Sage aus dem bisherigen Text das nächste Token voraus. Formal maximiert man

über riesige Textmengen. Es braucht keine von Hand gelabelten Daten — der Text ist sein eigenes Trainingssignal, weshalb sich (laut Folien) bei GPT-1 schon rund 7000 Bücher und bei GPT-3 Internet-Text im Hundertmilliarden-Token-Maßstab heranziehen ließen. Der Skalierungseffekt ist beeindruckend: Vergrößert man Modell, Daten und Rechenzeit gemeinsam (die „Scaling Laws”), schneiden die Modelle in Benchmarks deutlich besser ab und lösen Aufgaben — Übersetzen, Rechnen, Zusammenfassen —, für die sie nie eigens trainiert wurden. Die Folien halten dem aber eine Kritik entgegen: Die Scaling Laws können weder erklären, wie diese Leistungssteigerung zustande kommt, noch ist gesichert, dass weiteres Skalieren immer weiter hilft.

Die folgende Insel macht den allerletzten Schritt dieser Kette greifbar — wie aus dem Kontext über Logits, Softmax und Temperatur eine Verteilung über das nächste Token entsteht, aus der dann dekodiert wird. Die Folien nennen dafür konkrete Strategien: stets das Spitzen-Token nehmen (Greedy-Search), mehrere Fortsetzungen parallel verfolgen (Beam-Search) oder unter den besten Kandidaten zufällig ziehen (Top-K- bzw. Top-P/Nucleus-Sampling, gesteuert über die Temperatur):

Praxis#

Es gibt zu diesem Kapitel kein Übungsblatt. Stattdessen baue ich die zentrale Behauptung dieser Seite — Bedeutung lässt sich als Geometrie eines Vektorraums darstellen — in scikit-learn von Grund auf nach, ohne vortrainiertes Modell. So wird die distributionelle Semantik nicht nur behauptet, sondern an echten Zahlen sichtbar.

Tokenisierung & Mini-BPE#

Zuerst der erste Schnitt: derselbe deutsche Satz auf Wort- und Zeichenebene, und ein BPE-Lerner, der die häufigsten Symbolpaare meines Korpus verschmilzt. Der BPE-Kern ist klassisch:

def bpe_merges(words, n_merges):
    vocab = Counter(tuple(w) + ("</w>",) for w in words)   # Wörter als Zeichenfolgen
    merges = []
    for _ in range(n_merges):
        pairs = Counter()
        for symbols, freq in vocab.items():
            for a, b in zip(symbols, symbols[1:]):
                pairs[(a, b)] += freq                       # alle benachbarten Paare zählen
        best = pairs.most_common(1)[0][0]                   # häufigstes Paar verschmelzen
        merges.append(best)
        vocab = _apply_merge(vocab, best)                   # im ganzen Vokabular ersetzen
    return merges

Embeddings aus Kookkurrenz#

Den Embedding-Raum baue ich rein distributionell: eine Wort-Wort-Kookkurrenzmatrix mit Kontextfenster über zwölf thematische Sätze (Wetter, Tiere, KI/Code), gewichtet mit PPMI (Positive Pointwise Mutual Information, dämpft häufige Allerweltswörter) und mit TruncatedSVD auf wenige dichte Dimensionen reduziert — das ist im Kern nichts anderes, was word2vec implizit tut, nur explizit ausgerechnet. Aus den dichten Vektoren folgen Nachbarschaften und Analogien per Kosinus-Ähnlichkeit:

def build_embeddings(corpus, window, dim, seed):
    # ... Kookkurrenz co[i, j] über Fenster zählen ...
    pmi  = np.log((co * total) / (row @ col))               # punktweise Mutual Information
    ppmi = np.maximum(np.nan_to_num(pmi), 0.0)              # nur positive Assoziationen
    dense = TruncatedSVD(dim, random_state=seed).fit_transform(ppmi)
    return vocab, dense, dense[:, :2]                        # dichte Vektoren + 2D-Plot

Das vollständige Skript liegt in python/src/eport_figures/praxis/p_7_3_nlp.py. Seine echte Ausgabe:

Tokenisierung von: "Die KI lernt schnell."
  Wortebene  ( 5 Tokens): ['die', 'ki', 'lernt', 'schnell', '.']
  Zeichenebene (21 Tokens): ['d', 'i', 'e', '_', 'k', 'i', '_', 'l', 'e', 'r', 'n', 't', '_', 's', 'c', 'h', 'n', 'e', 'l', 'l', '.']

BPE auf dem Korpus — erste 8 gelernte Merges:
  1. 'e' + 'r' -> 'er'
  2. 'er' + '</w>' -> 'er</w>'
  3. 't' + '</w>' -> 't</w>'
  4. 'd' + '</w>' -> 'd</w>'
  5. 'u' + 'n' -> 'un'
  6. 'n' + '</w>' -> 'n</w>'
  7. 'un' + 'd</w>' -> 'und</w>'
  8. 'e' + '</w>' -> 'e</w>'

Korpus: 12 Sätze, 49 eindeutige Wörter.
Kookkurrenz -> PPMI -> TruncatedSVD(8D), 2D zum Plotten.

Nächste Kosinus-Nachbarn (semantische Nähe):
    wetter:  kalt (+0.88), morgen (+0.88), heute (+0.81)
     katze:  tier (+0.73), sommer (+0.66), schläft (+0.63)
      code:  computer (+0.89), programmierer (+0.73), schreibt (+0.73)
     lernt:  modell (+0.89), neuronales (+0.86), junger (+0.80)

Analogie  'hund' − 'tier' + 'modell'  ≈  lernt (+0.70), junger (+0.63), neuronales (+0.49)

Softmax-Verteilung über dieselben Logits bei T ∈ {0.5, 1.0, 2.0}:
  T=0.5:  wetter=93.1%, ki= 5.7%, ist= 1.1%, und= 0.1%, (rest)= 0.0%
  T=1.0:  wetter=72.0%, ki=17.8%, ist= 8.0%, und= 2.0%, (rest)= 0.3%
  T=2.0:  wetter=48.6%, ki=24.1%, ist=16.2%, und= 8.0%, (rest)= 3.1%

Drei Dinge bestätigen die Theorie an echten Zahlen. Erstens lernt BPE erwartungsgemäß zuerst die produktive Endung „-er”, dann das ganze Hochfrequenzwort und</w> als ein Token — häufige Stücke verdichten sich, genau wie es soll. Zweitens sind die Kosinus-Nachbarn semantisch plausibel: „code” liegt bei „computer/programmierer”, „lernt” bei „modell/neuronales”, „katze” bei „tier” — und das, obwohl das Modell nie etwas über Bedeutung erfahren hat, nur über Mit-Vorkommen. Drittens liefert die Vektorarithmetik selbst auf diesem Spielzeugkorpus einen interpretierbaren Hinweis: hund − tier + modell landet bei „lernt”. Das ist kein stabiler Analogie-Beweis wie in großen word2vec-Räumen, sondern zeigt nur, dass selbst die kleine Kookkurrenzgeometrie eine lesbare Richtung zwischen den Themenfeldern erzeugt.

Querbezüge#

• 1.3 (LLMs & Prompting): Die direkte Schwester dieser Seite. Dort steht das LLM als nächstes-Token-Vorhersager, Temperatur, Halluzination und Prompting; hier die Technik darunter — Tokenisierung, Embeddings, Attention, Pretraining. Die Softmax-Temperatur-Abbildung oben ist exakt die Formel, die 1.3 für das Sampling einführt. Beide Seiten sind zwei Hälften desselben Gegenstands.
• 7.2 (Deep Learning & CNN): Sowohl CNN als auch Transformer lösen dasselbe Problem — Gewichte teilen statt für jede Position neu lernen. Das CNN tut es über räumliche Faltung (lokale Nachbarschaft im Bild), der Transformer über Attention (jede Position darf jede andere gewichten). Der Weg von der lokalen Faltung zur globalen Aufmerksamkeit ist der rote Faden dieses Kapitels.
• 7.1 (Neuronale Netze): Jede Attention-Schicht und jedes Embedding ist letztlich aus den gewichteten Summen und Aktivierungen des MLP zusammengesetzt; Self-Attention fügt nur eine datenabhängige Gewichtung hinzu. Das Bauteil bleibt das Neuron aus 7.1.
• Computerlinguistik: Die klassische NLP-Pipeline (Tokenisierung, Stemming, Parsing, Bag-of-Words) ist der Vorläufer, den Embeddings und Transformer abgelöst — aber nicht überflüssig gemacht — haben. Die distributionelle Hypothese stammt aus genau dieser Tradition (Firth, Harris).
• Lineare Algebra: Das ganze Kapitel ist angewandte lineare Algebra. Embeddings sind Vektoren, Ähnlichkeit ist der Kosinus des eingeschlossenen Winkels, Analogien sind Vektoraddition, und die Dimensionsreduktion per SVD ist die Singulärwertzerlegung. Attention ist eine Folge von Matrixprodukten $QK^\top$ und $\cdot V$. Wer Skalarprodukt und Eigenwertzerlegung kennt, kennt das Skelett.
• Stochastik: Die Softmax ist eine Wahrscheinlichkeitsverteilung, das Pretraining ist Maximum-Likelihood über eine Token-Folge, und PMI ist ein informationstheoretisches Maß ($\log$ des Verhältnisses von gemeinsamer zu unabhängiger Wahrscheinlichkeit).

Quellen#

• Foliensätze _730_DL_NLP.pdf, _740_DL_Embedding.pdf, _750_LLMs.pdf — die Landkarte für den Bogen von der NLP-Aufgabe über Tokenisierung und Embeddings bis Transformer und LLM. Ich habe die Begriffskette daraus übernommen, die Argumentation (Sprache als Geometrie, von lokaler Faltung zu globaler Attention) aber selbst gesetzt und nicht Folie für Folie nacherzählt.
• Mikolov et al. (2013), Efficient Estimation of Word Representations (word2vec) — Primärquelle für die Analogie-Arithmetik; mein PPMI-+-SVD-Aufbau ist die explizit ausgerechnete Variante derselben distributionellen Idee (Levy & Goldberg 2014 zeigen die Äquivalenz).
• Vaswani et al. (2017), Attention Is All You Need — die Transformer-Originalarbeit; daraus die Query–Key–Value-Formulierung und der skalierte Softmax.
• Russell & Norvig, Artificial Intelligence: A Modern Approach, Kap. 23–24 (Natural Language) — als Referenz für die saubere Einordnung von Sprachmodellen und Embeddings.
• TensorFlow Projector — ausprobiert, um einen echten, großen word2vec-Raum interaktiv zu drehen; hat meine Intuition bestätigt, dass Themenfelder als Cluster auftauchen, und mein eigenes Streudiagramm motiviert.
• BertViz — angeschaut, um zu sehen, was Attention-Köpfe konkret aufeinander beziehen (Syntax, Koreferenz); half, die Query–Key–Value-Mechanik anschaulich zu verankern.