3. Token Embeddings

Tip

Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprende y practica Hacking en Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks

Token Embeddings

Después de tokenizar los datos de texto, el siguiente paso crítico para preparar los datos para entrenar large language models (LLMs) como GPT es crear token embeddings. Los token embeddings transforman tokens discretos (como palabras o subwords) en vectores numéricos continuos que el modelo puede procesar y aprender. Esta explicación desglosa los token embeddings, su inicialización, uso y el papel de los positional embeddings en mejorar la comprensión por parte del modelo de las secuencias de tokens.

Tip

El objetivo de esta tercera fase es muy simple: Asignar a cada uno de los tokens anteriores en el vocabulario un vector de las dimensiones deseadas para entrenar el modelo. Cada palabra en el vocabulario será un punto en un espacio de X dimensiones.
Ten en cuenta que inicialmente la posición de cada palabra en el espacio se inicializa “aleatoriamente” y estas posiciones son parámetros entrenables (se mejorarán durante el entrenamiento).

Además, durante el token embedding se crea otra capa de embeddings que representa (en este caso) la posición absoluta de la palabra en la frase de entrenamiento. De este modo, una palabra en diferentes posiciones de la frase tendrá una representación (significado) diferente.

What Are Token Embeddings?

Token Embeddings son representaciones numéricas de tokens en un espacio vectorial continuo. A cada token del vocabulario se le asocia un vector único de dimensiones fijas. Estos vectores capturan información semántica y sintáctica sobre los tokens, permitiendo que el modelo entienda relaciones y patrones en los datos.

  • Vocabulary Size: El número total de tokens únicos (p. ej., words, subwords) en el vocabulario del modelo.
  • Embedding Dimensions: El número de valores numéricos (dimensiones) en el vector de cada token. Dimensiones más altas pueden capturar información más matizada pero requieren más recursos computacionales.

Example:

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

Initializing Token Embeddings

Al inicio del entrenamiento, los token embeddings típicamente se inicializan con valores pequeños aleatorios. Estos valores iniciales se ajustan (fine-tuned) durante el entrenamiento para representar mejor los significados de los tokens basándose en los datos de entrenamiento.

Ejemplo en PyTorch:

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)

No se proporcionó el contenido a traducir. Por favor, pega el contenido de src/AI/AI-llm-architecture/3.-token-embeddings.md y lo traduciré al español respetando las instrucciones.

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)

Explicación:

  • Cada fila corresponde a un token en el vocabulario.
  • Cada columna representa una dimensión en el vector de embedding.
  • Por ejemplo, el token con índice 3 tiene un vector de embedding [-0.4015, 0.9666, -1.1481].

Acceso al embedding de un token:

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

No proporcionaste el contenido del archivo. Por favor pega el texto de src/AI/AI-llm-architecture/3.-token-embeddings.md que quieres que traduzca al español.

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

Interpretación:

  • El token en el índice 3 está representado por el vector [-0.4015, 0.9666, -1.1481].
  • Estos valores son parámetros entrenables que el modelo ajustará durante el entrenamiento para representar mejor el contexto y el significado del token.

Cómo funcionan los token embeddings durante el entrenamiento

Durante el entrenamiento, cada token en los datos de entrada se convierte en su vector de embedding correspondiente. Estos vectores se usan luego en varios cálculos dentro del modelo, como los mecanismos de atención y las capas de redes neuronales.

Escenario de ejemplo:

  • Tamaño de batch: 8 (número de muestras procesadas simultáneamente)
  • Longitud máxima de secuencia: 4 (número de tokens por muestra)
  • Dimensiones del embedding: 256

Estructura de datos:

  • Cada batch se representa como un tensor 3D con forma (batch_size, max_length, embedding_dim).
  • Para nuestro ejemplo, la forma sería (8, 4, 256).

Visualización:

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

Explicación:

  • Cada token en la secuencia está representado por un vector de 256 dimensiones.
  • El modelo procesa estos embeddings para aprender patrones del lenguaje y generar predicciones.

Embeddings posicionales: Añadiendo contexto a los embeddings de tokens

Si bien los embeddings de tokens capturan el significado de tokens individuales, no codifican de forma inherente la posición de los tokens dentro de una secuencia. Entender el orden de los tokens es crucial para la comprensión del lenguaje. Aquí es donde entran en juego los embeddings posicionales.

Por qué se necesitan los embeddings posicionales:

  • El orden de los tokens importa: En las oraciones, el significado suele depender del orden de las palabras. Por ejemplo, “El gato se sentó en la alfombra” vs. “La alfombra se sentó en el gato.”
  • Limitación de las embeddings: Sin información posicional, el modelo trata los tokens como una «bolsa de palabras», ignorando su secuencia.

Tipos de embeddings posicionales:

  1. Embeddings posicionales absolutas:
  • Asignan un vector de posición único a cada posición en la secuencia.
  • Ejemplo: El primer token en cualquier secuencia tiene la misma embedding posicional, el segundo token tiene otra, y así sucesivamente.
  • Usado por: los modelos GPT de OpenAI.
  1. Embeddings posicionales relativas:
  • Codifican la distancia relativa entre tokens en lugar de sus posiciones absolutas.
  • Ejemplo: Indican qué tan separados están dos tokens, independientemente de sus posiciones absolutas en la secuencia.
  • Usado por: modelos como Transformer-XL y algunas variantes de BERT.

Cómo se integran los embeddings posicionales:

  • Mismas dimensiones: Los embeddings posicionales tienen la misma dimensionalidad que los embeddings de tokens.
  • Adición: Se suman a los embeddings de tokens, combinando la identidad del token con la información posicional sin aumentar la dimensionalidad total.

Ejemplo de suma de embeddings posicionales:

Supongamos que un vector de embedding de token es [0.5, -0.2, 0.1] y su vector de embedding posicional es [0.1, 0.3, -0.1]. El embedding combinado que usaría el modelo sería:

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

Beneficios de las embeddings posicionales:

  • Conciencia contextual: El modelo puede diferenciar entre tokens según sus posiciones.
  • Comprensión de la secuencia: Permite al modelo entender la gramática, la sintaxis y los significados dependientes del contexto.

Embeddings posicionales en LLMs modernos

Rotary Positional Embeddings (RoPE)

RoPE codifica la posición aplicando una rotación dependiente de la posición a pares de dimensiones en los vectores query/key, convirtiendo posiciones absolutas en diferencias de fase relativas. Esto proporciona información de posición relativa manteniendo la dimensionalidad de los embeddings sin cambios y es ampliamente usado en los decoder-only LLMs recientes.

Para ver cómo se combinan los embeddings de token y posicionales dentro del modelo, ver the LLM architecture page.

Extender las ventanas de contexto en modelos basados en RoPE

Trabajos recientes muestran que la longitud de contexto a menudo está limitada por el esquema de codificación posicional en lugar de la token embedding matrix en sí.

  • Position Interpolation (PI): Reescala los índices de posición para que secuencias más largas se mapeen en el rango visto durante el entrenamiento, permitiendo la extensión con ajuste fino mínimo. Ejemplo:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Una estrategia de extensión RoPE eficiente en cómputo que modifica RoPE scaling/interpolation para extrapolar a contextos más largos con menos pasos de entrenamiento adicionales.

Ejemplo de código

A continuación, el ejemplo de código 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])

Referencias

Tip

Aprende y practica Hacking en AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprende y practica Hacking en GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprende y practica Hacking en Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Apoya a HackTricks