3. Osadzenia tokenów

Tip

Ucz się i ćwicz Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Ucz się i ćwicz Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Ucz się i ćwicz Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Wsparcie dla HackTricks

Osadzenia tokenów

Po tokenizacji danych tekstowych następnym kluczowym krokiem w przygotowaniu danych do trenowania dużych modeli językowych (LLMs) takich jak GPT jest tworzenie osadzeń tokenów. Osadzenia tokenów przekształcają dyskretne tokeny (takie jak słowa lub subwordy) w ciągłe wektory numeryczne, które model może przetwarzać i z których może się uczyć. To wyjaśnienie rozkłada na części osadzenia tokenów, ich inicjalizację, zastosowanie oraz rolę osadzeń pozycyjnych w poprawianiu zdolności modelu do rozumienia sekwencji tokenów.

Tip

Celem tej trzeciej fazy jest bardzo prosty: przypisać każdemu tokenowi w słowniku wektor o zadanej liczbie wymiarów, aby wytrenować model. Każde słowo w słowniku będzie punktem w przestrzeni o X wymiarach.
Zauważ, że początkowo pozycje każdego słowa w tej przestrzeni są inicjalizowane „losowo” i są to parametry uczone (ulepszane podczas treningu).

Co więcej, podczas tworzenia osadzeń tokenów tworzona jest kolejna warstwa osadzeń, która reprezentuje (w tym przypadku) absolutną pozycję słowa w zdaniu treningowym. Dzięki temu słowo na różnych pozycjach w zdaniu będzie miało inną reprezentację (znaczenie).

Czym są osadzenia tokenów?

Osadzenia tokenów to numeryczne reprezentacje tokenów w ciągłej przestrzeni wektorowej. Każdemu tokenowi w słowniku przypisany jest unikalny wektor o stałej liczbie wymiarów. Wektory te uchwytują informacje semantyczne i składniowe o tokenach, umożliwiając modelowi rozumienie relacji i wzorców w danych.

  • Vocabulary Size: Całkowita liczba unikalnych tokenów (np. słów, subwordów) w słowniku modelu.
  • Embedding Dimensions: Liczba wartości numerycznych (wymiarów) w wektorze każdego tokenu. Większa liczba wymiarów może uchwycić bardziej zniuansowane informacje, ale wymaga więcej zasobów obliczeniowych.

Przykład:

  • Vocabulary Size: 6 tokens [1, 2, 3, 4, 5, 6]
  • Embedding Dimensions: 3 (x, y, z)

Inicjalizacja osadzeń tokenów

Na początku treningu osadzenia tokenów są zwykle inicjalizowane niewielkimi losowymi wartościami. Te początkowe wartości są dostosowywane (fine-tuned) podczas treningu, aby lepiej odzwierciedlać znaczenia tokenów na podstawie danych treningowych.

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)

Nie otrzymałem treści do przetłumaczenia. Proszę wklej zawartość pliku src/AI/AI-llm-architecture/3.-token-embeddings.md.

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)

Wyjaśnienie:

  • Każdy wiersz odpowiada tokenowi w słowniku.
  • Każda kolumna odpowiada wymiarowi wektora embedding.
  • Na przykład token o indeksie 3 ma wektor embedding [-0.4015, 0.9666, -1.1481].

Dostęp do embeddingu tokena:

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

Proszę wklej treść pliku src/AI/AI-llm-architecture/3.-token-embeddings.md, którą chcesz przetłumaczyć.

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

Interpretation:

  • Token o indeksie 3 jest reprezentowany przez wektor [-0.4015, 0.9666, -1.1481].
  • Te wartości są parametrami uczonymi, które model będzie dostosowywał podczas treningu, aby lepiej odwzorować kontekst i znaczenie tokena.

Jak działają osadzenia tokenów podczas treningu

Podczas treningu każdy token w danych wejściowych jest konwertowany na odpowiadający mu wektor osadzenia. Te wektory są następnie używane w różnych obliczeniach w modelu, takich jak mechanizmy uwagi i warstwy sieci neuronowych.

Przykładowy scenariusz:

  • Rozmiar batcha: 8 (liczba próbek przetwarzanych jednocześnie)
  • Maksymalna długość sekwencji: 4 (liczba tokenów na próbkę)
  • Wymiary osadzeń: 256

Struktura danych:

  • Każdy batch jest reprezentowany jako trójwymiarowy tensor o kształcie (batch_size, max_length, embedding_dim).
  • Dla naszego przykładu kształt będzie (8, 4, 256).

Wizualizacja:

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

Wyjaśnienie:

  • Każdy token w sekwencji jest reprezentowany przez wektor o 256 wymiarach.
  • Model przetwarza te embeddingi, aby uczyć się wzorców językowych i generować przewidywania.

Osadzenia pozycyjne: dodawanie kontekstu do osadzeń tokenów

Chociaż osadzenia tokenów uchwytują znaczenie poszczególnych tokenów, nie kodują one z natury pozycji tokenów w sekwencji. Zrozumienie kolejności tokenów jest kluczowe dla przetwarzania języka. Tutaj wchodzą w grę osadzenia pozycyjne.

Dlaczego osadzenia pozycyjne są potrzebne:

  • Kolejność tokenów ma znaczenie: W zdaniach znaczenie często zależy od kolejności słów. Na przykład: “Kot usiadł na macie” vs. “Mata usiadła na kocie.”
  • Ograniczenie osadzeń: Bez informacji o pozycji model traktuje tokeny jak “bag of words”, ignorując ich sekwencję.

Rodzaje osadzeń pozycyjnych:

  1. Absolute Positional Embeddings:
  • Przypisują unikalny wektor pozycji do każdej pozycji w sekwencji.
  • Przykład: Pierwszy token w dowolnej sekwencji ma to samo osadzenie pozycyjne, drugi token ma inne, i tak dalej.
  • Used By: OpenAI’s GPT models.
  1. Relative Positional Embeddings:
  • Kodują względną odległość między tokenami, zamiast ich bezwzględnych pozycji.
  • Przykład: Wskazują, jak daleko od siebie są dwa tokeny, niezależnie od ich bezwzględnych pozycji w sekwencji.
  • Used By: Models like Transformer-XL and some variants of BERT.

Jak osadzenia pozycyjne są integrowane:

  • Te same wymiary: Osadzenia pozycyjne mają taką samą wymiarowość jak osadzenia tokenów.
  • Dodawanie: Są dodawane do osadzeń tokenów, łącząc identyfikację tokenu z informacją pozycyjną bez zwiększania całkowitej wymiarowości.

Przykład dodawania osadzeń pozycyjnych:

Załóżmy, że wektor osadzenia tokenu to [0.5, -0.2, 0.1] i jego wektor osadzenia pozycyjnego to [0.1, 0.3, -0.1]. Połączone osadzenie używane przez model będzie:

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

Korzyści z osadzeń pozycyjnych:

  • Świadomość kontekstowa: Model potrafi rozróżniać tokeny w zależności od ich pozycji.
  • Rozumienie sekwencji: Umożliwia modelowi rozumienie gramatyki, składni i znaczeń zależnych od kontekstu.

Osadzenia pozycyjne we współczesnych LLMs

Rotacyjne osadzenia pozycyjne (RoPE)

RoPE koduje pozycję, stosując rotację zależną od pozycji do par wymiarów wektorów query/key, przekształcając pozycje absolutne w względne różnice fazowe. Dostarcza to informacji o pozycjach względnych przy zachowaniu niezmienionej wymiarowości osadzeń i jest szeroko stosowane w nowszych decoder-only LLMs.

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

Rozszerzanie okien kontekstowych w modelach opartych na RoPE

Najnowsze badania pokazują, że długość kontekstu jest często ograniczona przez schemat kodowania pozycji, a nie przez samą macierz osadzeń tokenów.

  • Position Interpolation (PI): Przeskalowuje indeksy pozycji tak, aby dłuższe sekwencje mapowały się na zakres widziany podczas treningu, umożliwiając rozszerzenie przy minimalnym fine-tuningu. Przykład:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Efektywna obliczeniowo strategia rozszerzenia RoPE, która modyfikuje skalowanie/interpolację RoPE, aby ekstrapolować do dłuższych kontekstów przy mniejszej liczbie dodatkowych kroków treningowych.

Przykład kodu

Poniżej przykład kodu z 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])

Bibliografia

Tip

Ucz się i ćwicz Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Ucz się i ćwicz Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Ucz się i ćwicz Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Wsparcie dla HackTricks