LLM Architecture Comparison: GPT-2 vs GPT-4, LLaMA, Mistral, Qwen — что внутри и чем отличаются | LLM Tricks

Введение: почему архитектура LLM важна?

Вы скачиваете модель из Hugging Face и видите: GPT-2, LLaMA 3, Mistral, Qwen 2.5, Gemma, Phi-3. Все они — большие языковые модели. Но все ли они одинаковые?

Нет. За последние 4 года появилось несколько архитектурных подходов, и каждый имеет свои преимущества и недостатки. Понимание различий помогает:

Выбрать правильную модель для задачи
Настроить параметры эффективно
Понять, почему одна модель лучше другой в конкретном сценарии

В этой статье сравниваем основные архитектуры LLM: от классического GPT-2 до современных Mix-of-Experts.

Общая архитектура: Transformer Decoder-Only

Большинство современных LLM используют decoder-only трансформер — ту же базовую архитектуру, что и GPT-1/GPT-2.

Input tokens → [Embedding] → [Layer 1] → [Layer 2] → ... → [Layer N] → [LM Head] → Output probabilities
                 │              │           │                │
                 └─────────── Self-Attention + FFN ──────────┘

Каждый слой содержит:

Self-Attention — токены "общаются" друг с другом
Feed-Forward Network (FFN) — обработка информации
Layer Normalization — стабилизация обучения
Residual Connections — связь между слоями

# Базовый блок decoder-only трансформера
def transformer_block(x, attention, ffn, norm1, norm2):
    # Pre-Norm архитектура (современный стандарт)
    x = x + attention(norm1(x))   # Attention residual
    x = x + ffn(norm2(x))         # FFN residual
    return x

GPT-2 (2019): Классическая архитектура

GPT-2 Architecture:
  - Layers: 12 (small) / 48 (large)
  - Hidden size: 768 / 1600
  - Attention heads: 12 / 40
  - Parameters: 117M / 1.5B
  - Context window: 1024
  - Activation: GELU
  - Norm: LayerNorm (post-norm)

# GPT-2 использует Post-Normalization
def gpt2_block(x, attention, ffn, norm1, norm2):
    # Post-Norm: нормализация ПОСЛЕ операции
    x = x + attention(x)
    x = norm1(x)
    
    x = x + ffn(x)
    x = norm2(x)
    return x

Post-Norm vs Pre-Norm:

Post-Norm (GPT-2, оригинальный Transformer):
  x → Attention → + → LayerNorm → FFN → + → LayerNorm → Output

Pre-Norm (GPT-3, LLaMA, Mistral, Qwen):
  x → LayerNorm → Attention → + → LayerNorm → FFN → + → Output

Pre-Norm лучше для глубоких сетей:
  - Градиенты стабильнее
  - Легче обучать 96+ слоёв
  - Меньше проблем с exploding gradients

Эволюция архитектур

1. GPT-2 (2019): Основа всего

GPT-2 Large (1.5B):
  - Architecture: Decoder-only Transformer
  - Layers: 48
  - Hidden: 1600
  - Heads: 40
  - Context: 1024 tokens
  - Activation: GELU
  - Norm: Post-LayerNorm
  - Attention: Causal (masked)
  - Parameters: 1.5B

Ограничения GPT-2:

Маленькое контекстное окно (1024)
Post-Norm нестабилен при глубине
Нет rotary embeddings
Стандартный FFN (увеличивает dim в 4x)

2. GPT-3 (2020): Масштабирование

GPT-3:
  - Та же архитектура, что GPT-2
  - Но: Pre-Norm, больше данных, больше параметров (175B)
  - Context: 2048-8192 (зависит от версии)
  - Key изменение: Pre-Norm для стабильности

GPT-3 не ввёл новых архитектурных идей, но показал: scale is all you need.

3. LLaMA (2023): Оптимизации для эффективности

LLaMA Architecture Changes:
  1. Pre-Norm (SwiGLU activation вместо GELU)
  2. Rotary Positional Embeddings (RoPE)
  3. RMSNorm вместо LayerNorm
  4. Grouped Query Attention (GQA) для LLaMA-70B

SwiGLU вместо GELU:

# GELU (GPT-2, стандартный FFN)
def gelu_ffn(x):
    hidden = x @ W1 + b1
    hidden = gelu(hidden)  # GELU activation
    return hidden @ W2 + b2

# SwiGLU (LLaMA, Mistral, Qwen)
def swiglu_ffn(x):
    hidden1 = x @ W1 + b1  # projection
    hidden2 = x @ W3 + b3  # projection (gate)
    hidden = swish(hidden1) * hidden2  # SwiGLU: activation1 * activation2
    return hidden @ W2 + b2

# SwiGLU лучше GELU:
#   - Более информативный gate (управляет потоком информации)
#   - 30-50% лучше качество при том же числе параметров
#   - Стандарт для современных LLM

RMSNorm вместо LayerNorm:

# LayerNorm (стандартный)
def layer_norm(x):
    mean = x.mean(dim=-1)
    var = x.var(dim=-1)
    return (x - mean) / sqrt(var + eps) * gamma + beta

# RMSNorm (LLaMA, упрощённая версия)
def rms_norm(x):
    var = x.pow(2).mean(dim=-1)  # только RMS (без mean)
    return x * rsqrt(var + eps) * gamma

# RMSNorm:
#   - На 20-30% быстрее LayerNorm
#   - Такое же качество
#   - Не вычисляет mean (одна операция меньше)

RoPE (Rotary Positional Embeddings):

# Позиционная кодировка в оригинальном Transformer:
#   pos_encoding[pos][dim] = sin(pos / 10000^(dim/d_model))

# RoPE (LLaMA, современный стандарт):
#   Применяет поворотную матрицу к каждому токену
#   mθ = [[cos(mθ), -sin(mθ)], [sin(mθ), cos(mθ)]]
#
# Преимущества RoPE:
#   - Better extrapolation за пределы обучения
#   - Implicit attention bias (ближние токены сильнее)
#   - Works great with NTK scaling

Grouped Query Attention (GQA):

Multi-Query Attention (MQA):
  - 1 query, 1 key, 1 value head
  - Все query heads делят один key/value
  - Быстро, но теряет качество

Grouped Query Attention (GQA):
  - Группы query heads делят по одному key/value
  - LLaMA-70B: 8 groups (8 KV heads)
  - Баланс между скоростью и качеством

Example:
  LLaMA-7B:    32 query heads, 32 KV heads  (standard)
  LLaMA-70B:   64 query heads, 8 KV heads   (GQA)
  
  Скорость inference с GQA: +30-50% при длинном контексте

4. Mistral (2023-2024): Sliding Window + Sparse Attention

Mistral Architecture Changes:
  1. Sliding Window Attention (SWA)
  2. Grouped Query Attention (GQA)
  3. SwiGLU activation
  4. RMSNorm + Pre-Norm
  5. Context: 8K (Mistral 7B), 32K-128K (Mistral Small/Large)

Sliding Window Attention:

# Стандартный causal attention:
#   attention(i, j) = softmax(Qi @ Kj^T / sqrt(d)) для j < i
#   O(n²) complexity

# Sliding Window Attention (Mistral):
#   attention(i, j) = softmax(Qi @ Kj^T / sqrt(d)) для:
#     - j < i (causal)
#     - j > i - window_size (ограниченное окно)
#   O(n * window_size) complexity

# Для длинных контекстов:
#   n = 32000, window = 4096
#   Standard: 32000² = 1,024,000,000 операций
#   SWA: 32000 * 4096 = 131,072,000 операций
#   Ускорение: ~8x

Sliding Window Attention:

Token:  [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Window:  └─────────── 4096 ───────────┘

Для токена 5000:
  - Смотрит на токены 1004-4096 (окно)
  - Плюс все токены 1-1000 (cross-window attention)
  - Итого: ~5000 токенов контекста вместо 4096

5. Qwen 2.5 (2024): MoE и оптимизации

Qwen 2.5 Architecture:
  - Dense: SwiGLU, RMSNorm, RoPE, GQA
  - MoE версия: 47B active / 236B total params
  - Context: до 131K tokens
  - Vocabulary: 151,643 tokens (лучшая мультиязычность)

Qwen improvements:

Улучшенная токенизация (151K vocab — одна из лучших)
NTK-aware GQA scaling для длинных контекстов
Better data mixing (мультиязычность: EN, ZH, ES, FR, DE, JA, KO, AR...)

6. Gemma 2 (2024): Deep-Stacking + RPO

Gemma 2 Architecture:
  - 27B: 46 layers (deep stacking)
  - 9B: 42 layers
  - Counter-Halving: чередование full и half layers
  - SmoothPlusFloat: improved activation
  - Context: 8K-128K (с NTK scaling)

Counter-Halving:

# Gemma 2 чередует полные и половинные слои:
# Layer 0:  full FFN (dim_ffn = 4 * d_model)
# Layer 1:  half FFN (dim_ffn = 2 * d_model)
# Layer 2:  full FFN
# Layer 3:  half FFN
# ...

# Это даёт:
#   - ~30% меньше параметров при том же качестве
#   - Меньше VRAM для inference
#   - Быстрее training

7. Phi-3 (2024): Маленькие модели с большим качеством

Phi-3 Architecture:
  - Phi-3 Mini: 3.8B params, 4K context
  - Phi-3 Small: 14B params, 128K context
  - Phi-3 Medium: 14B params, 128K context
  - Architecture: Standard decoder-only + GQA + RoPE
  - Key: quality of training data > model size

Phi philosophy:

"Small but mighty" — меньше параметров, но качество больших
Training data curation: synthetic data + high-quality web
Distillation from GPT-4 for reasoning tasks

Сравнительная таблица архитектур

┌─────────────┬──────────┬──────────┬──────────┬──────────┬──────────┐
│ Model       │ Layers   │ Params   │ Context  │ KV Cache │ FFN      │
├─────────────┼──────────┼──────────┼──────────┼──────────┼──────────┤
│ GPT-2       │ 48       │ 1.5B     │ 1K       │ Standard │ GELU     │
│ GPT-3       │ 96       │ 175B     │ 8K       │ Standard │ GELU     │
│ LLaMA 2     │ 32/80    │ 7/70B    │ 4K       │ GQA(70B) │ SwiGLU   │
│ LLaMA 3     │ 32/126   │ 8/70B    │ 8K       │ GQA      │ SwiGLU   │
│ Mistral 7B  │ 32       │ 7B       │ 8K       │ GQA      │ SwiGLU   │
│ Mistral Nemo│ 48       │ 12B      │ 128K     │ GQA      │ SwiGLU   │
│ Qwen 2.5    │ 28/64    │ 0.5/3/7  │ 131K     │ GQA      │ SwiGLU   │
│            │          │ 14/32/72 │          │          │          │
│ Gemma 2     │ 42/46    │ 9/27B    │ 8-128K   │ GQA      │ SwiGLU   │
│ Phi-3       │ 32/40    │ 3.8/14B  │ 4K-128K  │ GQA      │ SwiGLU   │
│ Cohere      │ 40       │ 40B      │ 128K     │ GQA      │ SwiGLU   │
│ Command-R   │          │          │          │          │          │
└─────────────┴──────────┴──────────┴──────────┴──────────┴──────────┘

KV Cache:
  Standard:    1 KV head per query head
  GQA:         Groups of query heads share 1 KV head
  MQA:         All query heads share 1 KV head

Сравнение производительности

Inference Speed (tokens/sec, A100-80GB, BF16)

┌─────────────┬──────────┬──────────┬──────────┐
│ Model       │ BS=1     │ BS=16    │ BS=64    │
├─────────────┼──────────┼──────────┼──────────┤
│ LLaMA 7B    │ ~85      │ ~950     │ ~3200    │
│ LLaMA 70B   │ ~12      │ ~140     │ ~480     │
│ Mistral 7B  │ ~80      │ ~900     │ ~3000    │
│ Qwen 7B     │ ~82      │ ~920     │ ~3100    │
│ Gemma 2 9B  │ ~65      │ ~720     │ ~2400    │
└─────────────┴──────────┴──────────┴──────────┘

BS = Batch Size

Качество (MMLU score, zero-shot)

┌─────────────┬──────────┐
│ Model       │ MMLU     │
├─────────────┼──────────┤
│ LLaMA 3 8B  │ 66.6     │
│ LLaMA 3 70B │ 82.0     │
│ Mistral 7B  │ 65.3     │
│ Mistral NMO │ 72.8     │
│ Qwen 2.5 7B │ 79.0     │
│ Qwen 2.5 32 │ 84.3     │
│ Qwen 2.5 72 │ 86.1     │
│ Gemma 2 9B  │ 74.1     │
│ Gemma 2 27B │ 81.0     │
│ Phi-3 Mini  │ 68.5     │
│ Phi-3 Small │ 77.4     │
└─────────────┴──────────┘

Как выбрать архитектуру?

Для локального деплоя (1-24GB VRAM)

Рекомендации:
  4-8GB:   Phi-3 Mini (3.8B), Qwen 2.5 3B
  8-12GB:  LLaMA 3 8B, Mistral 7B, Qwen 2.5 7B
  12-24GB: Qwen 2.5 14B, Gemma 2 9B (2x quantized)
  
  Формат: GGUF (Q4_K_M или Q5_K_M)
  Сервер: llama.cpp, Ollama, vLLM (with GGUF)

Для серверного деплоя (40-80GB+ VRAM)

Рекомендации:
  40GB:    LLaMA 3 8B (BF16), Qwen 2.5 14B (Q8)
  80GB:    LLaMA 3 70B (AQ4), Qwen 2.5 32B (BF16)
  2x80GB:  LLaMA 3 70B (BF16), Qwen 2.5 72B (Q8)
  
  Формат: BF16, FP8, AWQ, GPTQ
  Сервер: vLLM, TGI, TensorRT-LLM

Для мультиязычности (RU + EN + ...)

Лучшие модели для русского языка:
  1. Qwen 2.5 — лучшая мультиязычность (включая RU)
  2. LLaMA 3 — хороший RU, отличный EN
  3. Mistral Nemo — хороший RU
  4. Gemma 2 — средний RU
  
  Для лучшего RU: fine-tune на русскоязычных данных

Заключение

Архитектура LLM эволюционировала от простого GPT-2 к сложным системам с:

SwiGLU — лучше FFN
RoPE — лучшая позиционная кодировка
RMSNorm — быстрее нормализация
GQA — эффективный KV cache
Sliding Window — длинные контексты
MoE — большие модели с меньшими затратами

Что выбрать в 2026?

Для локального деплоя: Qwen 2.5 7B/14B или LLaMA 3 8B
Для сервера: Qwen 2.5 72B или LLaMA 3 70B
Для мультиязычности: Qwen 2.5
Для reasoning: Gemma 2 27B или Qwen 2.5 32B

Все модели доступны на Hugging Face в формате GGUF для локального использования.