3. Embeddings de tokens

Tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE) Apprenez et pratiquez le hacking Azure : HackTricks Training Azure Red Team Expert (AzRTE)

Soutenir HackTricks

Embeddings de tokens

Après la tokenisation des données textuelles, l’étape suivante et cruciale pour préparer les données en vue d’entraîner des large language models (LLMs) comme GPT est la création des embeddings de tokens. Les embeddings de tokens transforment des tokens discrets (comme des mots ou des sous-mots) en vecteurs numériques continus que le modèle peut traiter et apprendre. Cette explication décompose les embeddings de tokens, leur initialisation, leur utilisation, et le rôle des positional embeddings pour améliorer la compréhension des séquences de tokens par le modèle.

Tip

L’objectif de cette troisième phase est très simple : Attribuer à chacun des tokens précédents du vocabulaire un vecteur de la dimension désirée pour entraîner le modèle. Chaque mot du vocabulaire sera un point dans un espace de X dimensions.
Notez qu’initialement la position de chaque mot dans l’espace est juste initialisée “aléatoirement” et ces positions sont des paramètres entraînables (seront améliorés durant l’entraînement).

De plus, pendant la création des embeddings de tokens, une autre couche d’embeddings est créée qui représente (dans ce cas) la position absolue du mot dans la phrase d’entraînement. Ainsi, un mot à différentes positions dans la phrase aura une représentation différente (sens).

Qu’est-ce que les embeddings de tokens ?

Embeddings de tokens sont des représentations numériques des tokens dans un espace vectoriel continu. Chaque token du vocabulaire est associé à un vecteur unique de dimension fixe. Ces vecteurs capturent des informations sémantiques et syntaxiques sur les tokens, permettant au modèle de comprendre les relations et les motifs dans les données.

  • Taille du vocabulaire : Le nombre total de tokens uniques (par exemple, mots, sous-mots) dans le vocabulaire du modèle.
  • Dimensions des embeddings : Le nombre de valeurs numériques (dimensions) dans le vecteur de chaque token. Des dimensions plus élevées peuvent capturer des informations plus nuancées mais nécessitent plus de ressources computationnelles.

Exemple :

  • Taille du vocabulaire : 6 tokens [1, 2, 3, 4, 5, 6]
  • Dimensions des embeddings : 3 (x, y, z)

Initialisation des embeddings de tokens

Au début de l’entraînement, les embeddings de tokens sont typiquement initialisés avec de petites valeurs aléatoires. Ces valeurs initiales sont ajustées (fine-tuned) durant l’entraînement pour mieux représenter le sens des tokens en fonction des données d’entraînement.

PyTorch Example:

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)

Sortie :

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)

Explication :

  • Chaque ligne correspond à un token du vocabulaire.
  • Chaque colonne représente une dimension dans le vecteur d’embedding.
  • Par exemple, le token à l’index 3 a un vecteur d’embedding [-0.4015, 0.9666, -1.1481].

Accéder à l’embedding d’un token :

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

Veuillez fournir le contenu du fichier src/AI/AI-llm-architecture/3.-token-embeddings.md à traduire en français.

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

Interprétation :

  • Le token à l’index 3 est représenté par le vecteur [-0.4015, 0.9666, -1.1481].
  • Ces valeurs sont des paramètres entraînables que le modèle ajustera pendant l’entraînement afin de mieux représenter le contexte et la signification du token.

Comment fonctionnent les Token Embeddings pendant l’entraînement

Pendant l’entraînement, chaque token dans les données d’entrée est converti en son vecteur d’embedding correspondant. Ces vecteurs sont ensuite utilisés dans diverses opérations au sein du modèle, comme les mécanismes d’attention et les couches de réseaux de neurones.

Exemple :

  • Taille du lot : 8 (nombre d’échantillons traités simultanément)
  • Longueur maximale de séquence : 4 (nombre de tokens par échantillon)
  • Dimensions de l’embedding : 256

Structure des données :

  • Chaque batch est représenté comme un tenseur 3D de forme (batch_size, max_length, embedding_dim).
  • Pour notre exemple, la forme serait (8, 4, 256).

Visualisation :

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   │     │
│ └─────┘     │
└─────────────┘

Explication :

  • Chaque token dans la séquence est représenté par un vecteur à 256 dimensions.
  • Le modèle traite ces embeddings pour apprendre les motifs linguistiques et générer des prédictions.

Positional Embeddings : ajouter du contexte aux token embeddings

Tandis que les token embeddings captent le sens des tokens individuels, ils n’encodent pas intrinsèquement la position des tokens dans une séquence. Comprendre l’ordre des tokens est crucial pour la compréhension du langage. C’est là que les positional embeddings interviennent.

Pourquoi les Positional Embeddings sont nécessaires :

  • L’ordre des tokens compte : Dans les phrases, le sens dépend souvent de l’ordre des mots. Par exemple, “The cat sat on the mat” vs. “The mat sat on the cat.”
  • Limitation des embeddings : Sans information positionnelle, le modèle traite les tokens comme un “bag of words”, en ignorant leur séquence.

Types de positional embeddings :

  1. Absolute Positional Embeddings :
  • Assigne un vecteur de position unique à chaque position dans la séquence.
  • Exemple : Le premier token de toute séquence a le même positional embedding, le deuxième token en a un autre, etc.
  • Utilisé par : OpenAI’s GPT models.
  1. Relative Positional Embeddings :
  • Encodent la distance relative entre les tokens plutôt que leurs positions absolues.
  • Exemple : Indiquent à quelle distance sont deux tokens, indépendamment de leurs positions absolues dans la séquence.
  • Utilisé par : des modèles comme Transformer-XL et certaines variantes de BERT.

Comment les Positional Embeddings sont intégrés :

  • Même dimensionnalité : Les positional embeddings ont la même dimensionnalité que les token embeddings.
  • Addition : Ils sont ajoutés aux token embeddings, combinant l’identité du token avec l’information positionnelle sans augmenter la dimensionnalité globale.

Exemple d’ajout de positional embeddings :

Supposons qu’un vecteur d’embedding de token soit [0.5, -0.2, 0.1] et que son vecteur de positional embedding soit [0.1, 0.3, -0.1]. L’embedding combiné utilisé par le modèle serait :

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

Avantages des encodages positionnels :

  • Conscience contextuelle : Le modèle peut différencier les tokens en fonction de leur position.
  • Compréhension de séquence : Permet au modèle de comprendre la grammaire, la syntaxe et les significations dépendantes du contexte.

Encodages positionnels dans les LLM modernes

Rotary Positional Embeddings (RoPE)

RoPE encode la position en appliquant une rotation dépendante de la position à des paires de dimensions dans les vecteurs query/key, transformant les positions absolues en différences de phase relatives. Cela fournit une information de position relative tout en conservant la dimensionnalité des embeddings inchangée et est largement utilisé dans les LLM decoder-only récents.

Pour la manière dont les embeddings de tokens et positionnels sont combinés à l’intérieur du modèle, voir the LLM architecture page.

Extending Context Windows in RoPE-Based Models

Des travaux récents montrent que la longueur de contexte est souvent limitée par le schéma d’encodage positionnel plutôt que par la matrice d’embeddings de tokens elle-même.

  • Position Interpolation (PI) : Rééchelonne les indices de position de sorte que les séquences plus longues se mappent dans la plage observée durant l’entraînement, permettant une extension avec un fine-tuning minimal. Exemple:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Une stratégie d’extension RoPE économe en calcul qui modifie la mise à l’échelle/interpolation de RoPE pour extrapoler à des contextes plus longs avec moins d’étapes d’entraînement supplémentaires.

Exemple de code

En suivant l’exemple de code de 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])

Références

Tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE) Apprenez et pratiquez le hacking Azure : HackTricks Training Azure Red Team Expert (AzRTE)

Soutenir HackTricks