3. Embeddings de Tokens

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Embeddings de Tokens

Após tokenizar os dados de texto, o próximo passo crítico ao preparar dados para treinar modelos de linguagem de grande porte (LLMs) como o GPT é criar embeddings de tokens. Embeddings de tokens transformam tokens discretos (como palavras ou subwords) em vetores numéricos contínuos que o modelo pode processar e aprender. Esta explicação detalha embeddings de tokens, sua inicialização, uso e o papel dos embeddings posicionais em melhorar a compreensão de sequências de tokens pelo modelo.

Tip

O objetivo desta terceira fase é muito simples: Atribuir a cada um dos tokens anteriores no vocabulário um vetor com as dimensões desejadas para treinar o modelo. Cada palavra no vocabulário será um ponto em um espaço de X dimensões.
Observe que inicialmente a posição de cada palavra no espaço é apenas inicializada “aleatoriamente” e essas posições são parâmetros treináveis (serão aprimorados durante o treinamento).

Além disso, durante o embedding de tokens outra camada de embeddings é criada que representa (neste caso) a posição absoluta da palavra na frase de treinamento. Dessa forma, uma palavra em posições diferentes na frase terá uma representação (significado) diferente.

O que são embeddings de tokens?

Embeddings de Tokens são representações numéricas de tokens em um espaço vetorial contínuo. Cada token no vocabulário está associado a um vetor único de dimensões fixas. Esses vetores capturam informações semânticas e sintáticas sobre os tokens, permitindo que o modelo entenda relações e padrões nos dados.

  • Tamanho do vocabulário: O número total de tokens únicos (por exemplo, palavras, subwords) no vocabulário do modelo.
  • Dimensões do embedding: O número de valores numéricos (dimensões) em cada vetor de token. Dimensões maiores podem captar informações mais sutis, mas exigem mais recursos computacionais.

Exemplo:

  • Tamanho do vocabulário: 6 tokens [1, 2, 3, 4, 5, 6]
  • Dimensões do embedding: 3 (x, y, z)

Inicializando Embeddings de Tokens

No início do treinamento, os embeddings de tokens são tipicamente inicializados com pequenos valores aleatórios. Esses valores iniciais são ajustados (fine-tuned) durante o treinamento para representar melhor os significados dos tokens com base nos dados de treinamento.

Exemplo 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)

Não recebi o conteúdo do arquivo. Por favor cole aqui o conteúdo de src/AI/AI-llm-architecture/3.-token-embeddings.md que você quer traduzido, e eu retornarei a tradução para Português mantendo exatamente a mesma sintaxe Markdown/HTML e as regras que você especificou.

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)

Explicação:

  • Cada linha corresponde a um token no vocabulário.
  • Cada coluna representa uma dimensão no vetor de embedding.
  • Por exemplo, o token no índice 3 tem um vetor de embedding [-0.4015, 0.9666, -1.1481].

Acessando o Embedding de um Token:

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

Por favor, forneça o conteúdo do arquivo src/AI/AI-llm-architecture/3.-token-embeddings.md para que eu possa traduzir para o português mantendo exatamente a mesma sintaxe markdown/HTML.

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

Interpretação:

  • O token no índice 3 é representado pelo vetor [-0.4015, 0.9666, -1.1481].
  • Esses valores são parâmetros treináveis que o modelo ajustará durante o treinamento para representar melhor o contexto e o significado do token.

Como Embeddings de Tokens Funcionam Durante o Treinamento

Durante o treinamento, cada token nos dados de entrada é convertido em seu vetor de embedding correspondente. Esses vetores são então usados em várias computações dentro do modelo, como mecanismos de atenção e camadas de redes neurais.

Cenário de Exemplo:

  • Tamanho do Batch: 8 (número de amostras processadas simultaneamente)
  • Comprimento Máximo da Sequência: 4 (número de tokens por amostra)
  • Dimensões do Embedding: 256

Estrutura de Dados:

  • Cada batch é representado como um tensor 3D com forma (batch_size, max_length, embedding_dim).
  • Para o nosso exemplo, a forma seria (8, 4, 256).

Visualização:

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

Explicação:

  • Cada token na sequência é representado por um vetor de 256 dimensões.
  • O modelo processa essas incorporações para aprender padrões de linguagem e gerar previsões.

Incorporações Posicionais: Adicionando Contexto às Incorporações de Tokens

Enquanto as incorporações de tokens capturam o significado de tokens individuais, elas não codificam inerentemente a posição dos tokens dentro de uma sequência. Entender a ordem dos tokens é crucial para a compreensão da linguagem. É aí que entram as incorporações posicionais.

Por que as incorporações posicionais são necessárias:

  • A ordem dos tokens importa: Em frases, o significado muitas vezes depende da ordem das palavras. Por exemplo, “O gato sentou no tapete” vs. “O tapete sentou no gato.”
  • Limitação das incorporações: Sem informação posicional, o modelo trata os tokens como um “saco de palavras” (“bag of words”), ignorando sua sequência.

Tipos de incorporações posicionais:

  1. Incorporações posicionais absolutas:
  • Atribuem um vetor de posição único para cada posição na sequência.
  • Exemplo: O primeiro token de qualquer sequência tem a mesma incorporação posicional, o segundo token tem outra, e assim por diante.
  • Usado por: OpenAI’s GPT models.
  1. Incorporações posicionais relativas:
  • Codificam a distância relativa entre tokens em vez de suas posições absolutas.
  • Exemplo: Indicam quão distantes dois tokens estão, independentemente de suas posições absolutas na sequência.
  • Usado por: Modelos como Transformer-XL e algumas variantes do BERT.

Como as incorporações posicionais são integradas:

  • Mesma dimensionalidade: As incorporações posicionais têm a mesma dimensionalidade que as incorporações de tokens.
  • Adição: Elas são somadas às incorporações de tokens, combinando a identidade do token com a informação posicional sem aumentar a dimensionalidade total.

Exemplo de Adição de Incorporações Posicionais:

Suponha que um vetor de incorporação de token seja [0.5, -0.2, 0.1] e seu vetor de incorporação posicional seja [0.1, 0.3, -0.1]. A incorporação combinada usada pelo modelo seria:

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

Benefícios dos Embeddings Posicionais:

  • Consciência Contextual: O modelo pode diferenciar tokens com base em suas posições.
  • Compreensão de Sequência: Permite que o modelo entenda gramática, sintaxe e significados dependentes do contexto.

Positional Embeddings in Modern LLMs

Rotary Positional Embeddings (RoPE)

RoPE codifica a posição aplicando uma rotação dependente da posição a pares de dimensões nos vetores de query/key, transformando posições absolutas em diferenças de fase relativas. Isso fornece informação de posição relativa mantendo a dimensionalidade dos embeddings inalterada e é amplamente usado em LLMs somente-decodificador recentes.

Para como token e positional embeddings são combinados dentro do modelo, veja the LLM architecture page.

Extending Context Windows in RoPE-Based Models

Trabalhos recentes mostram que o comprimento do contexto é frequentemente limitado pelo esquema de codificação posicional em vez da própria matriz de embeddings de tokens.

  • Position Interpolation (PI): Reescala os índices de posição para que sequências mais longas mapeiem para o intervalo visto durante o treinamento, permitindo extensão com fine-tuning mínimo. Exemplo:
# Position Interpolation (PI) intuition
orig_ctx = 2048
new_ctx = 8192
scaled_pos = pos * (orig_ctx / new_ctx)
  • YaRN: Uma estratégia de extensão RoPE eficiente em termos de computação que modifica o dimensionamento/interpolação do RoPE para extrapolar para contextos mais longos com menos etapas adicionais de treinamento.

Exemplo de Código

A seguir, o exemplo 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])

Referências

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks