3. Embedding dei token

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

Embedding dei token

Dopo aver tokenizzato i dati testuali, il passo successivo cruciale nella preparazione dei dati per l’addestramento di large language models (LLMs) come GPT è creare gli embedding dei token. Gli embedding dei token trasformano token discreti (come parole o subword) in vettori numerici continui che il modello può processare e da cui può apprendere. Questa spiegazione analizza gli embedding dei token, la loro inizializzazione, il loro utilizzo e il ruolo degli embedding posizionali nel migliorare la comprensione delle sequenze di token da parte del modello.

Tip

Lo scopo di questa terza fase è molto semplice: Assegnare a ciascuno dei token del vocabolario un vettore con le dimensioni desiderate per addestrare il modello. Ogni parola nel vocabolario sarà un punto in uno spazio di X dimensioni.
Nota che inizialmente la posizione di ogni parola nello spazio è semplicemente inizializzata “casualmente” e queste posizioni sono parametri addestrabili (verranno migliorate durante l’addestramento).

Inoltre, durante l’embedding dei token viene creato un ulteriore livello di embedding che rappresenta (in questo caso) la posizione assoluta della parola nella frase di addestramento. In questo modo una parola in posizioni diverse nella frase avrà una rappresentazione (significato) differente.

Cosa sono gli embedding dei token?

Gli embedding dei token sono rappresentazioni numeriche dei token in uno spazio vettoriale continuo. A ogni token del vocabolario è associato un vettore unico a dimensione fissa. Questi vettori catturano informazioni semantiche e sintattiche sui token, permettendo al modello di comprendere relazioni e pattern nei dati.

  • Dimensione del vocabolario: Il numero totale di token unici (es. parole, subword) nel vocabolario del modello.
  • Dimensioni dell’embedding: Il numero di valori numerici (dimensioni) nel vettore di ciascun token. Dimensioni maggiori possono catturare informazioni più sfumate ma richiedono più risorse computazionali.

Esempio:

  • Dimensione del vocabolario: 6 token [1, 2, 3, 4, 5, 6]
  • Dimensioni dell’embedding: 3 (x, y, z)

Inizializzazione degli embedding dei token

All’inizio dell’addestramento, gli embedding dei token vengono tipicamente inizializzati con piccoli valori casuali. Questi valori iniziali vengono aggiustati (ottimizzati) durante l’addestramento per rappresentare meglio il significato dei token in base ai dati di addestramento.

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)

Non hai fornito il contenuto da tradurre. Incolla qui il testo del file src/AI/AI-llm-architecture/3.-token-embeddings.md e procederò con la traduzione mantenendo inalterati tag, link, percorsi e codice.

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)

Spiegazione:

  • Ogni riga corrisponde a un token nel vocabolario.
  • Ogni colonna rappresenta una dimensione nel vettore di embedding.
  • Per esempio, il token all’indice 3 ha un vettore di embedding [-0.4015, 0.9666, -1.1481].

Accesso all’embedding di un token:

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

Output:

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

Interpretazione:

  • Il token all’indice 3 è rappresentato dal vettore [-0.4015, 0.9666, -1.1481].
  • Questi valori sono parametri addestrabili che il modello aggiusterà durante l’addestramento per rappresentare meglio il contesto e il significato del token.

Come funzionano i Token Embeddings durante l’addestramento

Durante l’addestramento, ogni token nei dati di input viene convertito nel corrispondente vettore embedding. Questi vettori vengono poi usati in vari calcoli all’interno del modello, come i meccanismi di attenzione e gli strati delle reti neurali.

Scenario di esempio:

  • Dimensione del batch: 8 (numero di campioni processati simultaneamente)
  • Lunghezza massima della sequenza: 4 (numero di token per campione)
  • Dimensioni dell’embedding: 256

Struttura dei dati:

  • Ogni batch è rappresentato come un tensore 3D con forma (batch_size, max_length, embedding_dim).
  • Per il nostro esempio, la forma sarebbe (8, 4, 256).

Visualizzazione:

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

Spiegazione:

  • Ogni token nella sequenza è rappresentato da un vettore a 256 dimensioni.
  • Il modello elabora questi embedding per apprendere schemi linguistici e generare predizioni.

Embedding posizionali: Aggiungere contesto agli embedding dei token

Mentre gli embedding dei token catturano il significato dei singoli token, non codificano intrinsecamente la posizione dei token all’interno di una sequenza. Comprendere l’ordine dei token è cruciale per la comprensione del linguaggio. Qui entrano in gioco gli embedding posizionali.

Perché gli embedding posizionali sono necessari:

  • L’ordine dei token è importante: Nelle frasi, il significato spesso dipende dall’ordine delle parole. Per esempio, “Il gatto si è seduto sul tappeto” vs. “Il tappeto si è seduto sul gatto.”
  • Limite degli embedding: Senza informazione posizionale, il modello tratta i token come una “bag of words”, ignorandone la sequenza.

Tipi di embedding posizionali:

  1. Embedding posizionali assoluti:
  • Assegnano un vettore di posizione unico a ogni posizione nella sequenza.
  • Esempio: Il primo token in qualsiasi sequenza ha lo stesso embedding posizionale, il secondo token ne ha un altro, e così via.
  • Usati da: OpenAI’s GPT models.
  1. Embedding posizionali relativi:
  • Codificano la distanza relativa tra i token piuttosto che le loro posizioni assolute.
  • Esempio: Indicano quanto sono distanti due token, indipendentemente dalle loro posizioni assolute nella sequenza.
  • Usati da: Modelli come Transformer-XL e alcune varianti di BERT.

Come gli embedding posizionali vengono integrati:

  • Stesse dimensioni: Gli embedding posizionali hanno la stessa dimensionalità degli embedding dei token.
  • Addizione: Vengono sommati agli embedding dei token, combinando l’identità del token con l’informazione posizionale senza aumentare la dimensionalità complessiva.

Esempio di aggiunta degli embedding posizionali:

Supponiamo che un vettore di embedding del token sia [0.5, -0.2, 0.1] e il suo vettore di embedding posizionale sia [0.1, 0.3, -0.1]. L’embedding combinato utilizzato dal modello sarebbe:

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

Vantaggi degli Embedding posizionali:

  • Consapevolezza contestuale: Il modello può distinguere tra token in base alle loro posizioni.
  • Comprensione delle sequenze: Permette al modello di comprendere grammatica, sintassi e significati dipendenti dal contesto.

Embedding posizionali nei moderni LLM

Rotary Positional Embeddings (RoPE)

RoPE codifica la posizione applicando una rotazione dipendente dalla posizione a coppie di dimensioni nei vettori query/key, trasformando posizioni assolute in differenze di fase relative. Questo fornisce informazioni di posizione relative mantenendo invariata la dimensionalità degli embedding ed è ampiamente usato nei recenti LLM decoder-only.

Per come token e embedding posizionali sono combinati all’interno del modello, vedi la pagina sull’architettura LLM.

Estensione delle finestre di contesto nei modelli basati su RoPE

Lavori recenti dimostrano che la lunghezza del contesto è spesso limitata dallo schema di codifica posizionale piuttosto che dalla matrice di embedding dei token stessa.

  • Position Interpolation (PI): Ridimensiona gli indici di posizione in modo che sequenze più lunghe rientrino nell’intervallo visto durante l’addestramento, permettendo l’estensione con fine-tuning minimo. Esempio:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Una strategia di estensione RoPE efficiente dal punto di vista computazionale che modifica lo scaling/interpolation di RoPE per extrapolare a contesti più lunghi con meno passi di addestramento aggiuntivi.

Esempio di codice

Segue l’esempio di codice da 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])

Riferimenti

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks