Wie Embedding-Layer funktionieren: vom Text über Token-IDs zu Vektoren im LLM

Tippen Sie den Satz "I love cats" in ein LLM, und das Modell bekommt nie drei englische Wörter zu sehen. Neuronale Netze arbeiten mit Zahlen. Wie wird diese kurze Phrase also zu etwas, das ein Transformer verarbeiten kann? Die Antwort beginnt beim Embedding-Layer.

1. Vom Text zu Token-IDs

Zuerst kommt die Tokenisierung. Ein Tokenizer zerlegt den Text in Stücke, die Tokens heißen, und gibt jedem Stück eine ID. Der Einfachheit halber nehmen wir dieses winzige Vokabular an:

"I"     → 10
"love"  → 25
"cats"  → 47

Der Satz wird dann zu einer kurzen Liste von Ganzzahlen:

"I love cats"
      ↓
[10, 25, 47]

Das sind Token-IDs, und für sich genommen tragen sie keine Bedeutung. Die Zahl 47 sagt nicht, dass "cats" siebenundvierzig von irgendetwas wert ist. Sie ist nur ein Index, ein Label, das auf einen Eintrag im Vokabular zeigt. Bevor das Modell etwas Nützliches tun kann, ist noch ein Schritt nötig.

2. Von Token-IDs zu Embeddings

Dieser Schritt gehört dem Embedding-Layer. Stellen Sie ihn sich als große Tabelle vor, mit einer Zeile, also einem Vektor, für jedes Token im Vokabular.

Angenommen, das Vokabular hat nur 50 Tokens und jedes Token wird durch 4 Zahlen beschrieben. Jede Zeile ist ein Embedding-Vektor:

Embedding vector

Die Tabelle könnte so beginnen:

Token 0    →    [ 0.2, -0.4,  0.7,  0.1 ]
Token 1    →    [ 0.6,  0.1, -0.3,  0.8 ]
...
Token 10   →    [ 0.3, -0.2,  0.9,  0.4 ]
...
Token 25   →    [-0.5,  0.7,  0.2, -0.1 ]
...
Token 47   →    [ 0.8,  0.1, -0.6,  0.5 ]
...

Nehmen wir nun die Eingabesequenz:

[10, 25, 47]

Der Layer schlägt diese Zeilen einfach nach. Token 10 bekommt seinen Vektor:

10 → [ 0.3, -0.2,  0.9,  0.4 ]

und die anderen beiden folgen auf dieselbe Weise:

25 → [-0.5,  0.7,  0.2, -0.1 ]47 → [ 0.8,  0.1, -0.6,  0.5 ]

Der ursprüngliche Text durchläuft also diese Stufen:

"I love cats"

      ↓ Tokenizer[10, 25, 47]      ↓ Embedding lookup[
 [ 0.3, -0.2,  0.9,  0.4 ],
 [-0.5,  0.7,  0.2, -0.1 ],
 [ 0.8,  0.1, -0.6,  0.5 ]
]      ↓Transformer

Das ist die Aufgabe in Kürze: Der Embedding-Layer macht aus Token-IDs Vektoren.

3. Warum Vektoren und nicht die rohen IDs?

Man könnte fragen, warum der Transformer die IDs nicht direkt bekommt. Der Grund: IDs sind nur Labels. Sehen Sie sich die drei Werte an:

10
25
47

Der Abstand zwischen 25 und 47 sagt nichts darüber, wie "love" mit "cats" zusammenhängt. Embedding-Vektoren sind anders, weil sie gelernte Repräsentationen sind. Während des Trainings passt das Modell ihre Werte an, bis sie dem Transformer helfen, mit Sprache umzugehen.

4. Woher die Zahlen kommen

Niemand tippt die Werte der Embedding-Matrix von Hand ein. Sie werden im Training gelernt. Zu Beginn enthalten die Vektoren Werte ohne jede sprachliche Information. Dann liest das Modell riesige Textmengen und übt, das nächste Token vorherzusagen. Bei einem Prompt wie "I love cats because they are ___" gibt es einen Tipp ab.

Liegt der Tipp daneben, fließt der Fehler per Backpropagation rückwärts durch das Netz. Die Embedding-Vektoren werden zusammen mit allen anderen Gewichten aktualisiert. Nach dem Training enthält die Matrix Repräsentationen, auf die sich das Modell zu verlassen gelernt hat.

5. Was ein Embedding darstellt

Nehmen wir einen Vektor für "cats":

cats → [0.8, 0.1, -0.6, 0.5]

Es liegt nahe, jede Zahl als benannte Eigenschaft zu lesen, etwa so:

0.8 → animal
0.1 → size
-0.6 → shape
0.5 → plural

Im Allgemeinen funktionieren LLM-Embeddings so nicht. Die Bedeutung ist über alle Dimensionen gleichzeitig verteilt. Eine einzelne Dimension entspricht selten einem einzelnen Begriff, den ein Mensch benennen könnte. Die Repräsentation ist der ganze Vektor.

6. Echte Embedding-Matrizen sind riesig

Skalieren wir nun vom Spielzeugbeispiel auf ein realistisches Modell mit diesen Dimensionen:

Vocabulary size = 50,000
Embedding dimension = 4,096

Die Embedding-Matrix hat dann rund 205 Millionen Parameter, und das ist eine Menge. Was wie eine schlichte Lookup-Tabelle aussieht, kann einen überraschend großen Anteil der Modellgewichte ausmachen.

7. Was als Nächstes passiert

Sobald "I love cats" zu einer Reihe von Embedding-Vektoren geworden ist, wandern diese in den Transformer. So sieht der Ablauf aus:

"I love cats"
               │
               ▼
          Tokenizer
               │
               ▼
        [10, 25, 47]
               │
               ▼
       Embedding Layer
               │
               ▼
      [vector, vector, vector]
               │
               ▼
          Transformer
               │
               ▼
       Next-token prediction

Das Embedding ist die Brücke zwischen diskreten Tokens und den kontinuierlichen numerischen Repräsentationen, mit denen das neuronale Netz arbeitet.

8. Dieselbe Idee in Python

Ein paar Zeilen PyTorch genügen, um es zu zeigen:

import torch
import torch.nn as nn
# Vocabulary contains 50 tokens
# Each token is represented by 4 numbers
embedding = nn.Embedding(
    num_embeddings=50,
    embedding_dim=4
)
# Token IDs for "I love cats"
tokens = torch.tensor([10, 25, 47])
# Look up their embeddings
vectors = embedding(tokens)
print(vectors)
print(vectors.shape)

Die Ausgabe sieht ungefähr so aus:

tensor([
    [ 0.31, -0.21,  0.91,  0.42],
    [-0.52,  0.73,  0.19, -0.12],
    [ 0.79,  0.08, -0.61,  0.54]
])

Und die Form bestätigt drei Tokens mit jeweils vier Zahlen:

torch.Size([3, 4])

Der Embedding-Layer ist im Grunde eine gelernte Lookup-Tabelle. Setzt man die Teile zusammen, sieht die Pipeline so aus:

Text
  ↓
Tokenizer
  ↓
Token IDs
  ↓
Embedding lookup
  ↓
Vectors

Transformer

Der Tokenizer stellt fest, welche Tokens vorkommen. Der Embedding-Layer wandelt ihre IDs in gelernte numerische Repräsentationen um. Der Transformer nimmt diese Repräsentationen, erschließt den Kontext und trifft Vorhersagen.

Wenn Ihnen das nächste Mal diese Zeile in einer Modelldefinition begegnet:

nn.Embedding(vocab_size, embedding_dim)

lesen Sie sie als Anweisung, eine Tabelle mit vocab_size Zeilen zu bauen, in der jedes Token einen eigenen lernbaren Vektor der Länge embedding_dim erhält.