LLM Engineering

🧱 01. Архитектура Transformer

Properties3
descriptionФундамент LLM — self-attention, encoder/decoder, RoPE, MoE, KV Cache и scaling laws
tagsфундамент, llm
aliases01-transformer-architecture

время чтения ~7 мин.

🧱 01. Архитектура Transformer

📌 1. Почему Transformer

До 2017 года доминировали RNN/LSTM/GRU. Проблемы:

  • Последовательная обработка (Sequential processing) — обрабатывают токены по одному, O(n) шагов
  • Исчезающие градиенты (Vanishing gradients) — длинные зависимости забываются
  • Параллелизм — невозможен на уровне последовательности

Определение

Transformer (Vaswani et al., «Attention Is All You Need», 2017) — архитектура на основе self-attention: каждый токен видит все остальные за O(1) шагов, полный параллелизм по последовательности, прямой путь градиентов к любому токену.

📌 2. Архитектура: Encoder-Decoder

Input → [Tokenize] → [Embedding + Positional] → ENCODER (×N)
                                                    ↓
                                                Encoded rep.
                                                    ↓
Output ← [Tokenize⁻¹] ← DECODER (×N) ← [Shifted Output] ← ┘

flowchart LR
    Input["Input"] --> Tokenize["Tokenize"]
    Tokenize --> Embed["Embedding + Positional"]
    Embed --> Encoder["ENCODER ×N"]
    Encoder --> EncRep["Encoded rep."]
    EncRep --> Decoder["DECODER ×N"]
    Shifted["Shifted Output"] --> Decoder
    Decoder --> Detokenize["Tokenize⁻¹"]
    Detokenize --> Output["Output"]

🔹 Энкодер (Encoder, BERT-style)

  • Вход: вся последовательность токенов
  • Multi-Head Self-Attention — каждый токен «смотрит» на все остальные
  • Feed-Forward Network (FFN) — два линейных слоя с ReLU/GELU
  • Residual connections + LayerNorm — стабилизация обучения
  • Выход: contextualized embeddings (каждый токен имеет контекст)

🔹 Декодер (Decoder, GPT-style)

  • Вход: сгенерированные токены (auto-regressive)
  • Masked Self-Attention — токен видит только предыдущие (causal mask)
  • Cross-Attention — смотрит на output энкодера (в encoder-decoder моделях)
  • FFN + Residual + LayerNorm
  • Выход: распределение вероятностей следующего токена

📌 3. Self-Attention — ядро

На собеседовании

Формула attention — must know: Attention(Q, K, V) = softmax(Q·Kᵀ / √d_k) · V. Объясните роль Q/K/V и зачем делить на √d_k.

⚙️ Формула

Attention(Q, K, V) = softmax(Q·Kᵀ / √d_k) · V

Где:

  • Q (Query) — «что я ищу» — линейная проекция входа: Q = X·W_Q
  • K (Key) — «что я предлагаю» — K = X·W_K
  • V (Value) — «что я знаю» — V = X·W_V
  • d_k — размерность key (для масштабирования, чтобы softmax не насыщался)
  • √d_k — стабилизирует градиенты при больших d_k

💡 Интуиция

Каждый токен создаёт 3 вектора: запрос, ключ, значение.

  • Q·Kᵀ — «насколько я (токен) релевантен каждому другому токену?»
  • softmax — нормализует в веса (сумма = 1)
  • ·V — взвешенная сумма значений → новое представление токена с учётом контекста

⚙️ Multi-Head Attention

Вместо одного attention — h параллельных head (обычно 8–96). Каждый head обучается смотреть на разные аспекты (синтаксис, семантика, позиция).

Multi-Head(Q,K,V) = Concat(head_1, ..., head_h) · W_O
где head_i = Attention(Q·W_Q^i, K·W_K^i, V·W_V^i)

Размерность: d_model разделяется на h голов → каждая голова работает с d_model/h.

📌 4. Positional Encoding (позиционное кодирование)

Self-attention не чувствителен к порядку — нужен способ сообщить позицию.

🔹 Синусоидальное (Sinusoidal, оригинальный Transformer)

PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
  • Каждый токен получает уникальный «позиционный fingerprint»
  • Может экстраполировать на позиции длиннее обученных

🔹 Обучаемые позиционные эмбеддинги (Learned Positional Embeddings, GPT, BERT)

  • Просто обучаемая матрица [max_len × d_model]
  • Проще, но не экстраполирует за max_len

🔹 RoPE (Rotary Position Embedding) — современный стандарт

  • Позиция кодируется поворотом векторов Q и K
  • Относительная позиция: Q·Kᵀ зависит только от |pos_q - pos_k|
  • Лучшая экстраполяция на длинные контексты
  • Используется в: Llama, GLM, DeepSeek, Mistral

🔹 ALiBi (Attention with Linear Biases)

  • Нет positional encoding — вместо этого bias в attention scores
  • bias = -m · |i - j| (штраф за расстояние)
  • Тоже экстраполирует хорошо

📌 5. Feed-Forward Network (FFN)

FFN(x) = Linear₂(GELU(Linear₁(x)))
  • Расширение: d_model → 4×d_model → d_model
  • Иногда больше: d_model → 8×d_model (GLM-5.2 и др.)
  • SwiGLU (современный стандарт): FFN(x) = (Swish(x·W₁) ⊙ x·W₃)·W₂
    • Использует gating — дополнительный обучаемый «вентиль»
    • Лучше обычного FFN при том же количестве параметров

📌 6. LayerNorm и Residual Connections

🔹 Residual (Skip Connection)

output = LayerNorm(x + Sublayer(x))
  • Градиент может течь напрямую через сложение
  • Позволяет строить глубокие модели (96 слоёв у GPT-3)
  • Pre-LN vs Post-LN: Pre-LN (нормализация до sublayer) стабильнее при обучении

🔹 RMSNorm (Root Mean Square Normalization)

  • Упрощённый LayerNorm — без вычитания среднего
  • RMSNorm(x) = x / RMS(x) · γ где RMS(x) = √(mean(x²))
  • Быстрее, работает не хуже
  • Используется в: Llama, GLM, Mistral

📌 7. Современные Decoder-only модели

Почти все production LLM (GPT, Claude, Llama, GLM, DeepSeek) — decoder-only.

Почему не encoder-decoder?

  • Проще (один стек слоёв)
  • Лучше масштабируется
  • Auto-regressive generation = естественно для текста
  • Encoder-decoder нужен для seq2seq (перевод, суммаризация) — но decoder-only тоже справляется

⚙️ Типичная архитектура (Llama/GLM-style)

[Token Embedding]
→ [RoPE Positional]
→ ×N:
    [RMSNorm] → [Multi-Head Attention (causal)] → [Residual]
    [RMSNorm] → [SwiGLU FFN] → [Residual]
→ [RMSNorm]
→ [Linear projection → vocab_size]
→ [Softmax → probabilities]

⚙️ Ключевые гиперпараметры

  • d_model — размерность скрытого состояния (4096–16384)
  • n_layers — количество слоёв (32–120)
  • n_heads — количество attention голов (32–96)
  • d_ff — размер FFN (4×–8× d_model)
  • vocab_size — размер словаря (32000–256000)
  • n_ctx — максимальный контекст (4K–1M)

📌 8. MoE (Mixture of Experts)

Вместо одного FFN — множество FFN (экспертов), router выбирает 1-2 на токен.

Router(x) → top-k experts → sum(expert_i(x) · gate_i)
  • Преимущества: больше параметров без роста вычислений (sparse activation)
  • DeepSeek-V3: 671B параметров, но только 37B активных на токен
  • GLM-5.2: предположительно dense, не MoE
  • Trade-off: больше VRAM нужно для всех экспертов, но меньше FLOPs на инференсе

🔹 Expert Routing (маршрутизация экспертов)

  • Token routing: каждый токен → top-k экспертов
  • Expert load balancing: нужно балансировать нагрузку (иначе одни эксперты перегружены)
  • Shared experts: часть экспертов всегда активна (DeepSeek-V3)

📌 9. KV Cache

Важно

KV Cache — главный потребитель памяти при inference. Для Llama-70B с контекстом 128K и fp16 кэш может занимать ~80 GB на один запрос.

При auto-regressive generation каждый новый токен требует пересчёта attention для всех предыдущих. KV Cache — кэширование Key и Value матриц предыдущих токенов.

Без кэша: генерация токена N = O(N²) вычислений attention
С кэшем:  генерация токена N = O(N) — только новый токен

💾 Память KV Cache

  • Размер: 2 × n_layers × n_heads × d_head × seq_len × batch × dtype_bytes
  • Для Llama-70B (80 слоёв, 64 головы, 128 d_head, 128K контекст, fp16):
    • 2 × 80 × 64 × 128 × 131072 × 2 = ~80 GB на один запрос!

⚙️ Оптимизации

  • PagedAttention (vLLM) — KV Cache в страницах (как virtual memory)
  • KV Cache Quantization — int8/int4 вместо fp16
  • KV Cache Offloading — в CPU RAM при нехватке GPU
  • Sliding Window — кэш только последних N токенов (Mistral)

📌 10. Scaling Laws (законы масштабирования)

Chinchilla (Hoffmann et al., 2022): для оптимального обучения модели с N параметрами нужно ~20N токенов.

  • GPT-3 (175B) обучался на 300B токенов — недообучен (должно быть 3.5T)
  • Chinchilla (70B) на 1.4T токенов — лучше при меньшем размере
  • Современные модели: Llama-3 (70B) на 15T токенов — переобучены по Chinchilla, но это намеренно (лучше inference)

Правило: compute-optimal = 20 tokens per parameter. Но если inference дороже training — можно переобучить.

📌 11. Контекстное окно

💡 Как модели понимают длинные тексты

1. RoPE extrapolation / interpolation

  • Interpolation: сжимаем позиции в диапазон [0, max_len]
  • Extension (NTK, YaRN): модифицируем частоты RoPE для экстраполяции
  • Llama-3, GLM-5.2: используют YaRN или подобное для 128K-1M контекста

2. Sparse Attention

  • Не все токены attend на все — только локальное окно + глобальные токены
  • Longformer, BigBird — ранние варианты
  • Modern: Grouped-Query Attention (GQA) — группы head делят KV

3. Ring Attention / Sequence Parallelism

  • Разделение контекста между GPU
  • Каждый GPU обрабатывает свой chunk + передаёт KV по кольцу

📌 12. Глоссарий (для собеседований)

ТерминЗначение
Авторегрессия (Auto-regressive)Каждый токен генерируется на основе предыдущих
Причинная маска (Causal mask)Матрица, запрещающая токену видеть будущие токены
d_modelРазмерность скрытого состояния модели
Эмбеддинг (Embedding)Векторное представление токена
FFNFeed-Forward Network — двухслойная сеть после attention
Fine-tuning (дообучение)Дообучение модели на специфичных данных
GQAGrouped-Query Attention — группы head делят KV (экономия памяти)
Inference (инференс)Использование обученной модели для генерации
KV CacheКэш Key/Value матриц для ускорения auto-regressive generation
Multi-Head (мультиголовое внимание)Несколько параллельных attention механизмов
Pre-training (предобучение)Обучение на большом корпусе текста
RoPERotary Position Embedding — позиционное кодирование поворотом
SwiGLUGated FFN с Swish активацией — современный стандарт
Токен (Token)Единица текста (~0.75 слова для английского, ~1.6 символа для русского)

Вид графа

Недавние заметки