3. Token-Einbettungen

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Token-Einbettungen

Nach der Tokenisierung der Textdaten ist der nächste kritische Schritt bei der Vorbereitung der Daten für das Training von large language models (LLMs) wie GPT das Erstellen von Token-Einbettungen. Token-Einbettungen verwandeln diskrete Tokens (z. B. Wörter oder Subwords) in kontinuierliche numerische Vektoren, die das Modell verarbeiten und aus denen es lernen kann. Diese Erklärung zerlegt Token-Einbettungen, ihre Initialisierung, Verwendung und die Rolle von Positions-Einbettungen zur Verbesserung des Modellverständnisses von Token-Sequenzen.

Tip

Das Ziel dieser dritten Phase ist ganz einfach: Weise jedem der vorherigen Tokens im Vokabular einen Vektor der gewünschten Dimensionen zu, um das Modell zu trainieren. Jedes Wort im Vokabular wird ein Punkt in einem Raum mit X Dimensionen sein.
Beachte, dass die Position jedes Wortes im Raum anfangs nur “zufällig” initialisiert ist und diese Positionen trainierbare Parameter sind (während des Trainings verbessert werden).

Darüber hinaus wird während der Token-Einbettung eine weitere Ebene von Einbettungen erstellt, die (in diesem Fall) die absolute Position des Wortes im Trainingssatz repräsentiert. Auf diese Weise hat ein Wort in verschiedenen Positionen im Satz eine unterschiedliche Repräsentation (Bedeutung).

Was sind Token-Einbettungen?

Token-Einbettungen sind numerische Repräsentationen von Tokens in einem kontinuierlichen Vektorraum. Jedem Token im Vokabular ist ein eindeutiger Vektor fester Dimensionen zugeordnet. Diese Vektoren erfassen semantische und syntaktische Informationen über die Tokens und ermöglichen es dem Modell, Beziehungen und Muster in den Daten zu verstehen.

  • Vokabulargröße: Die Gesamtanzahl eindeutiger Tokens (z. B. Wörter, Subwords) im Vokabular des Modells.
  • Embedding-Dimensionen: Die Anzahl numerischer Werte (Dimensionen) in jedem Token-Vektor. Höhere Dimensionen können nuanciertere Informationen erfassen, erfordern aber mehr Rechenressourcen.

Beispiel:

  • Vokabulargröße: 6 tokens [1, 2, 3, 4, 5, 6]
  • Embedding-Dimensionen: 3 (x, y, z)

Initialisierung von Token-Einbettungen

Zu Beginn des Trainings werden Token-Einbettungen typischerweise mit kleinen zufälligen Werten initialisiert. Diese Anfangswerte werden während des Trainings angepasst (feinabgestimmt), um die Bedeutungen der Tokens basierend auf den Trainingsdaten besser zu repräsentieren.

PyTorch Beispiel:

import torch

# Set a random seed for reproducibility
torch.manual_seed(123)

# Create an embedding layer with 6 tokens and 3 dimensions
embedding_layer = torch.nn.Embedding(6, 3)

# Display the initial weights (embeddings)
print(embedding_layer.weight)

Ich habe keinen Inhalt erhalten. Bitte füge den Text aus src/AI/AI-llm-architecture/3.-token-embeddings.md ein, dann übersetze ich ihn ins Deutsche.

luaCopy codeParameter containing:
tensor([[ 0.3374, -0.1778, -0.1690],
[ 0.9178,  1.5810,  1.3010],
[ 1.2753, -0.2010, -0.1606],
[-0.4015,  0.9666, -1.1481],
[-1.1589,  0.3255, -0.6315],
[-2.8400, -0.7849, -1.4096]], requires_grad=True)

Erklärung:

  • Jede Zeile entspricht einem Token im Vokabular.
  • Jede Spalte entspricht einer Dimension im Einbettungsvektor.
  • Zum Beispiel hat das Token an Index 3 den Einbettungsvektor [-0.4015, 0.9666, -1.1481].

Zugriff auf die Einbettung eines Tokens:

# Retrieve the embedding for the token at index 3
token_index = torch.tensor([3])
print(embedding_layer(token_index))

Ich habe den Inhalt von src/AI/AI-llm-architecture/3.-token-embeddings.md nicht erhalten. Bitte füge hier den Markdown‑Text der Datei ein (oder lade ihn hoch). Ich werde ihn dann gemäß deinen Vorgaben ins Deutsche übersetzen und dabei Markdown/HTML/Links/Paths/Tags unverändert lassen.

tensor([[-0.4015,  0.9666, -1.1481]], grad_fn=<EmbeddingBackward0>)

Interpretation:

  • Das Token an Index 3 wird durch den Vektor [-0.4015, 0.9666, -1.1481] repräsentiert.
  • Diese Werte sind trainierbare Parameter, die das Modell während des Trainings anpasst, um den Kontext und die Bedeutung des Tokens besser abzubilden.

Wie Token-Embeddings während des Trainings funktionieren

Während des Trainings wird jedes Token in den Eingabedaten in seinen entsprechenden Embedding-Vektor umgewandelt. Diese Vektoren werden dann in verschiedenen Berechnungen innerhalb des Modells verwendet, wie z. B. Attention-Mechanismen und neuronalen Netzwerkschichten.

Beispielszenario:

  • Batch-Größe: 8 (Anzahl der gleichzeitig verarbeiteten Beispiele)
  • Maximale Sequenzlänge: 4 (Anzahl der Tokens pro Beispiel)
  • Embedding-Dimensionen: 256

Datenstruktur:

  • Jeder Batch wird als 3D-Tensor mit der Form (batch_size, max_length, embedding_dim) dargestellt.
  • Für unser Beispiel wäre die Form (8, 4, 256).

Visualisierung:

cssCopy codeBatch
┌─────────────┐
│ Sample 1    │
│ ┌─────┐     │
│ │Token│ → [x₁₁, x₁₂, ..., x₁₂₅₆]
│ │ 1   │     │
│ │...  │     │
│ │Token│     │
│ │ 4   │     │
│ └─────┘     │
│ Sample 2    │
│ ┌─────┐     │
│ │Token│ → [x₂₁, x₂₂, ..., x₂₂₅₆]
│ │ 1   │     │
│ │...  │     │
│ │Token│     │
│ │ 4   │     │
│ └─────┘     │
│ ...         │
│ Sample 8    │
│ ┌─────┐     │
│ │Token│ → [x₈₁, x₈₂, ..., x₈₂₅₆]
│ │ 1   │     │
│ │...  │     │
│ │Token│     │
│ │ 4   │     │
│ └─────┘     │
└─────────────┘

Erklärung:

  • Jedes Token in der Sequenz wird durch einen 256-dimensionalen Vektor dargestellt.
  • Das Modell verarbeitet diese Embeddings, um Sprachmuster zu lernen und Vorhersagen zu erzeugen.

Positions-Embeddings: Kontext zu Token-Embeddings hinzufügen

Während Token-Embeddings die Bedeutung einzelner Tokens erfassen, kodieren sie nicht automatisch die Position der Tokens innerhalb einer Sequenz. Das Verstehen der Reihenfolge der Tokens ist entscheidend für das Sprachverständnis. Hier kommen Positions-Embeddings ins Spiel.

Warum Positions-Embeddings nötig sind:

  • Reihenfolge der Tokens ist wichtig: In Sätzen hängt die Bedeutung oft von der Wortreihenfolge ab. Zum Beispiel “Die Katze saß auf der Matte” vs. “Die Matte saß auf der Katze.”
  • Einschränkung der Embeddings: Ohne Positionsinformationen behandelt das Modell Tokens wie eine “bag of words” und ignoriert ihre Reihenfolge.

Arten von Positions-Embeddings:

  1. Absolute Positions-Embeddings:
  • Weisen jeder Position in der Sequenz einen eindeutigen Positionsvektor zu.
  • Beispiel: Das erste Token in jeder Sequenz hat dasselbe Positions-Embedding, das zweite Token hat ein anderes, und so weiter.
  • Verwendet von: OpenAI’s GPT models.
  1. Relative Positions-Embeddings:
  • Kodieren den relativen Abstand zwischen Tokens statt deren absoluter Positionen.
  • Beispiel: Geben an, wie weit zwei Tokens voneinander entfernt sind, unabhängig von ihren absoluten Positionen in der Sequenz.
  • Verwendet von: Modelle wie Transformer-XL und einige Varianten von BERT.

Wie Positions-Embeddings integriert werden:

  • Gleiche Dimensionen: Positions-Embeddings haben dieselbe Dimensionalität wie Token-Embeddings.
  • Addition: Sie werden zu den Token-Embeddings addiert und kombinieren Token-Identität mit Positionsinformationen, ohne die Gesamtdimensionalität zu erhöhen.

Beispiel für das Hinzufügen von Positions-Embeddings:

Angenommen, ein Token-Embedding-Vektor ist [0.5, -0.2, 0.1] und sein Positions-Embedding-Vektor ist [0.1, 0.3, -0.1]. Das kombinierte Embedding, das vom Modell verwendet wird, wäre:

Combined Embedding = Token Embedding + Positional Embedding
= [0.5 + 0.1, -0.2 + 0.3, 0.1 + (-0.1)]
= [0.6, 0.1, 0.0]

Vorteile von Positional Embeddings:

  • Contextual Awareness: Das Modell kann tokens anhand ihrer Position unterscheiden.
  • Sequence Understanding: Ermöglicht dem Modell, Grammatik, Syntax und kontextabhängige Bedeutungen zu erfassen.

Positional Embeddings in modernen LLMs

Rotary Positional Embeddings (RoPE)

RoPE kodiert Position, indem es eine positionsabhängige Rotation auf Paare von Dimensionen in den query/key vectors anwendet und so absolute Positionen in relative Phasendifferenzen verwandelt. Das liefert relative Positionsinformationen, während die Embedding-Dimensionalität unverändert bleibt, und wird häufig in aktuellen decoder-only LLMs verwendet.

For how token and positional embeddings are combined inside the model, see the LLM architecture page.

Extending Context Windows in RoPE-Based Models

Aktuelle Arbeiten zeigen, dass die Kontextlänge oft durch das positional encoding scheme begrenzt ist, und nicht durch die token embedding matrix selbst.

  • Position Interpolation (PI): Skaliert Positionsindizes neu, sodass längere Sequenzen in den während des Trainings gesehenen Bereich abgebildet werden, was eine Erweiterung mit minimalem fine-tuning ermöglicht. Beispiel:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Eine rechen-effiziente RoPE-Erweiterungsstrategie, die die RoPE-Skalierung/Interpolation so anpasst, dass auf längere Kontexte extrapoliert werden kann, mit weniger zusätzlichen Trainingsschritten.

Code-Beispiel

Im Folgenden das Code-Beispiel aus https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb:

# Use previous code...

# Create dimensional emdeddings
"""
BPE uses a vocabulary of 50257 words
Let's supose we want to use 256 dimensions (instead of the millions used by LLMs)
"""

vocab_size = 50257
output_dim = 256
token_embedding_layer = torch.nn.Embedding(vocab_size, output_dim)

## Generate the dataloader like before
max_length = 4
dataloader = create_dataloader_v1(
raw_text, batch_size=8, max_length=max_length,
stride=max_length, shuffle=False
)
data_iter = iter(dataloader)
inputs, targets = next(data_iter)

# Apply embeddings
token_embeddings = token_embedding_layer(inputs)
print(token_embeddings.shape)
torch.Size([8, 4, 256]) # 8 x 4 x 256

# Generate absolute embeddings
context_length = max_length
pos_embedding_layer = torch.nn.Embedding(context_length, output_dim)

pos_embeddings = pos_embedding_layer(torch.arange(max_length))

input_embeddings = token_embeddings + pos_embeddings
print(input_embeddings.shape) # torch.Size([8, 4, 256])

Referenzen

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks