Как устроен LLM изнутри

Версия: 1.0.0
Дата: 2026-03-25
Аудитория: Технический специалист без ML-бэкграунда

Содержание

1. Что такое LLM
2. Токены — как текст становится числами
3. Веса — долгосрочная память модели
4. Трансформер — движок предсказания
5. Контекст — рабочая память сессии
6. Как формируется ответ
7. MoE — архитектура с экспертами
8. LoRA — лёгкая донастройка
9. Дистилляция — обучение на чужих ответах
10. DeepSeek — что они сделали
11. Как обучить модель с нуля
12. Обработка больших данных в контексте
13. Тренды 2025–2026

1. Что такое LLM

LLM (Large Language Model) — это программа, которая предсказывает следующий токен на основе предыдущих.

Больше ничего. Вся "интеллектуальность" — следствие того, что для правильного предсказания следующего слова модель вынуждена понять смысл всего предыдущего текста.

Вход:  "Столица России — это"
Модель: [вычисляет вероятности для каждого возможного следующего токена]
Выход: "Москва" (вероятность 0.97), " город" (0.01), "Санкт" (0.005), ...

Модель не "знает" ответ как факт в базе данных. Она воспроизводит статистические паттерны из обучающих данных: после этой фразы в миллионах документов всегда шло "Москва".

2. Токены

Что такое токен

Токен — это кусок текста, не слово и не буква. Обычно частая подстрока.

"программирование" → ["програм", "миро", "вание"]  (3 токена)
"cat"              → ["cat"]                         (1 токен)
"cats"             → ["cats"]                        (1 токен, часто встречается)
"xyzqw"            → ["x", "y", "z", "q", "w"]      (5 токенов, редкая строка)

Как строится словарь токенов — BPE

BPE (Byte Pair Encoding) — алгоритм:

1. Начинаем с отдельных байтов (256 штук)
2. Берём обучающий корпус текста
3. Находим самую частую пару байтов → сливаем в один токен
4. Повторяем 32 000–100 000 раз

Итог: словарь из ~32–100K токенов. Частые слова — один токен. Редкие слова — несколько токенов.

Почему русский дороже английского

Английский язык создавался вместе с интернетом и ML. В обучающих корпусах английского текста в 10–20 раз больше чем русского. BPE выучил английские слова как цельные токены.

"hello"         → 1 токен
"привет"        → 2–3 токена
"автоматизация" → 4–6 токенов

Больше токенов = дольше обрабатывается = дороже. Русский текст в API стоит в 1.5–2x раз больше по токенам чем эквивалентный английский.

Числа как токены

Это важная деталь: каждое число — отдельный токен.

"1234" → токен "1234"
"1235" → токен "1235"

Модель не "знает" что 1234 + 1 = 1235. Она видит две разные строки без математической связи. Именно поэтому LLM плохо считает — числа для неё не числа, а слова.

Решение: перехват математики на Python/Bash (см. раздел 12).

3. Веса

Что такое веса

Веса (weights, параметры) — это миллиарды чисел с плавающей точкой, записанных в матрицы. Это и есть "мозг" модели.

GPT-2:    117M параметров   ← маленькая
Llama 3:  8B параметров     ← средняя
GPT-4:    ~1.8T параметров  ← большая (оценка)

Веса хранятся на диске (~2 байта на параметр в bf16):
- 7B модель = ~14 GB файл
- 70B модель = ~140 GB файл

Что хранится в весах

В весах закодированы ВСЕ знания модели:
- Грамматика всех языков
- Факты о мире (история, наука, география)
- Стиль написания текстов
- Логика и рассуждения
- Код на 50+ языках программирования

Это не база данных с ключами. Это распределённая статистика — паттерны, усвоенные за миллионы шагов обучения.

Как обучаются веса

1. Берём текст: "Париж — столица ___"
2. Модель предсказывает следующее слово
3. Сравниваем с правильным ("Франции")
4. Считаем ошибку (loss)
5. Вычисляем градиент — насколько каждый вес повлиял на ошибку
6. Сдвигаем все веса на крошечную величину в правильную сторону
7. Повторяем триллионы раз

После обучения веса заморожены. Они не меняются во время работы модели. Это как прошивка.

4. Трансформер

Общая схема

Трансформер — это стек одинаковых слоёв. GPT-4 имеет ~120 слоёв. Каждый слой берёт массив векторов (по одному на каждый токен) и возвращает обновлённый массив.

Токены → [Embedding] → [Слой 1] → [Слой 2] → ... → [Слой N] → [Softmax] → Токен

Embedding — конвертация номера токена в вектор (например, 4096 чисел).

Softmax — конвертация финального вектора в вероятности для всего словаря.

Self-Attention — ядро трансформера

Это механизм, позволяющий каждому токену "посмотреть" на все остальные токены и обновить своё значение.

Фраза: "Банк реки был крутым"

Токен "был" смотрит на все остальные и решает:
- "Банк" (0.05 веса) — слабая связь
- "реки" (0.71 веса) — сильная! это не финансовый банк
- "крутым" (0.24 веса) — средняя связь

Итог: вектор "был" обновляется — теперь он знает контекст (физический берег, не банк)

Математически: каждый токен создаёт три вектора:
- Query (Q) — "что я ищу?"
- Key (K) — "что я предлагаю?"
- Value (V) — "что я отдам если меня выберут?"

Внимание = softmax(Q × Kᵀ / √d) × V

Головы внимания (Attention Heads)

В каждом слое не одно внимание, а несколько параллельных (8–64 "головы").

Каждая голова специализируется на своём аспекте:
- Одна следит за синтаксисом (подлежащее↔сказуемое)
- Другая за кореференцией (местоимение↔существительное)
- Третья за семантической близостью слов
- Четвёртая за позицией в предложении

Никто не программировал эти специализации — они возникли сами в процессе обучения.

Causal Mask — ограничение на "смотреть вперёд"

Модель предсказывает следующий токен, значит не должна видеть будущие токены при обучении.

Фраза: "кот сидит на"
Когда обучаем предсказанию "на", токен "на" не должен видеть себя.
Маска обнуляет внимание на все токены правее текущего.

Feed-Forward — слой "памяти фактов"

После attention в каждом слое есть Feed-Forward сеть (2 полносвязных слоя). Считается что именно здесь хранятся конкретные факты, а attention занимается контекстом.

5. Контекст

Что такое контекст

Контекст — это плоский массив токенов, который подаётся в трансформер на каждый запрос. Это рабочая память — существует только в рамках одной сессии.

[SYSTEM токены][HUMAN токены][ASSISTANT токены][TOOL_RESULT токены][HUMAN токены]...

Пример реального контекста:

<|system|>
Ты помощник...
<|user|>
Привет, как дела?
<|assistant|>
Всё хорошо! Чем могу помочь?
<|user|>
Напиши код на Python...

Кто управляет контекстом

Трансформер — тупой предсказатель. Он получает массив токенов и возвращает следующий токен. Всё остальное делает рантайм (inference engine):

• Собирает контекст из system prompt + истории диалога + текущего запроса
• Добавляет результаты вызовов инструментов
• Следит за лимитом (не превысить context window)
• Решает что обрезать если не влезает (обычно старые сообщения)

Context Window — ограничение

Трансформер физически не может обработать больше N токенов за раз (архитектурное ограничение памяти GPU).

GPT-3.5:   4K токенов
GPT-4:     128K токенов
Claude:    200K токенов
Gemini:    1M токенов (2024)

При превышении лимита старые токены выбрасываются. Модель "забывает" начало разговора.

Веса vs Контекст

6. Как формируется ответ

Авторегрессия — токен за токеном

Модель генерирует текст по одному токену:

1. Весь контекст → трансформер → вероятности 100K токенов
2. Выбираем токен (sampling)
3. Добавляем токен в контекст
4. Повторяем с пункта 1
5. Останавливаемся на <|end|> токене

Ответ из 200 слов = ~250 токенов = 250 прогонов через трансформер.

Sampling — как выбирается токен

Не всегда берётся самый вероятный токен. Есть параметры:

Temperature (0.0–2.0):
- 0.0 — всегда самый вероятный (детерминированно, скучно)
- 0.7 — баланс (обычный режим)
- 1.5 — творческий режим (иногда неожиданные слова)

Top-P (0.0–1.0): выбирать только из токенов, которые в сумме дают P вероятности. Отсекает маловероятный "мусор".

Откуда берётся структура ответа

Никакого отдельного алгоритма "сначала введение, потом таблица, потом вывод" нет.

Структура ответа закодирована в весах через обучающие данные: модель видела миллионы технических ответов именно такой структуры и воспроизводит паттерн.

Pre/Post-processing

Вокруг трансформера есть слои обработки:

Запрос пользователя
    ↓
[Pre-processing]
  - Токенизация
  - Сборка контекста (system + история + запрос)
  - Tool definitions (если есть)
    ↓
[Transformer] — генерирует токены
    ↓
[Post-processing]
  - Детокенизация (токены → текст)
  - Парсинг tool calls (если модель вызвала инструмент)
  - Safety filter (опционально)
  - Форматирование ответа
    ↓
Ответ пользователю

7. MoE (Mixture of Experts)

Проблема обычного трансформера

В стандартном трансформере все параметры участвуют в обработке каждого токена. Больше параметров = лучше качество, но дороже вычисления.

Идея MoE

Разделить Feed-Forward слой на N специализированных "экспертов". Для каждого токена активировать только 2–4 из них.

Обычный трансформер:
  токен → [все 100% параметров] → результат

MoE трансформер:
  токен → [Router] → выбирает 2 из 8 экспертов
       → [Эксперт 3] ─┐
       → [Эксперт 7] ─┴→ объединяем → результат

Router — маленькая сеть, которая смотрит на токен и решает каким экспертам его отправить.

Что получается

DeepSeek V3:
  Всего параметров:  671B
  Активных на токен: 37B (6%)

Качество как у 671B модели.
Вычисления как у 37B модели.

Разные эксперты специализируются автоматически: один на коде, другой на математике, третий на диалоге — никто это не программировал.

Минус MoE

Вся модель должна влезать в память (671B весит ~1.3 TB). Нужны серверы с терабайтами RAM. Для одного GPU не подходит. Используется только в датацентрах.

8. LoRA

Зачем нужна

Обучить 70B модель с нуля = миллионы долларов и месяцы GPU-времени.

Но часто нужно не обучать с нуля, а специализировать готовую модель: обучить её отвечать в конкретном стиле, знать специфическую терминологию, следовать особым инструкциям.

Идея LoRA

Вместо изменения исходных весов — добавить маленькие матрицы-адаптеры.

Оригинальный вес W (большая матрица 4096×4096 = 16M чисел)

LoRA добавляет:
  A (4096×8)  — 32K чисел
  B (8×4096)  — 32K чисел

Итоговый вес: W + A×B

Изменяем только A и B. W заморожен.

Ранг r=8 означает промежуточный размер (8 в примере выше). Типично r=4–64.

Что получается

Обучение 70B модели:     ~70B параметров обновляются
LoRA (r=16) для 70B:     ~0.7B параметров обновляются (1%)

Память: в 100x меньше
Время:  в 10-50x быстрее
Качество: близко к полному fine-tuning

Применение

• Обучить модель на корпоративных документах
• Адаптировать под конкретный язык/диалект
• Настроить стиль ответов
• Специализировать под предметную область (медицина, юриспруденция)

Итог — файл адаптера (~100–500 MB) который накладывается на базовую модель. Можно иметь одну базовую модель и десятки LoRA-адаптеров.

9. Дистилляция

Идея

Большая модель (учитель) обучает маленькую модель (ученик) через свои ответы.

Обычное обучение:
  вопрос + [ответ человека] → обновить веса ученика

Дистилляция:
  вопрос → GPT-4 (учитель) → ответ учителя
  вопрос + [ответ учителя] → обновить веса ученика

Зачем это работает лучше

Человеческая разметка:
- Дорого ($5–20 за пример)
- Медленно
- Субъективно и непоследовательно

Учитель-модель:
- Дёшево ($0.01–0.10 за пример через API)
- Быстро (миллион примеров за день)
- Последовательно

Дополнительный эффект: учитель даёт "мягкие вероятности" (не просто правильный ответ, а распределение вероятностей по всем токенам). Ученик учится на более богатом сигнале.

Результаты дистилляции

• Phi-3 (Microsoft, 3.8B) обучена на синтетических "учебниках" — обгоняет многие 7B модели
• Llama 3.2 1B — дистиллирована из Llama 3 70B
• DeepSeek R1 7B — дистиллирована из DeepSeek R1 671B

Главный вывод: маленькая модель + качественная дистилляция > большая модель + плохие данные.

10. DeepSeek

Контекст: китайские санкции

DeepSeek (китайская компания) не имела доступа к NVIDIA H100. Использовали H800 — урезанная версия (отключён NVLink, межчиповая пропускная способность в 2–3x меньше).

Ограничения вынудили их оптимизировать архитектуру. Получилось лучше чем у тех у кого ресурсов было больше.

Ключевые инновации DeepSeek V3 + R1

1. MoE с fine-grained routing

671B параметров, активно 37B. Роутер выбирает 2 из 256 мини-экспертов (не из 8 больших как у GPT-4). Более точная маршрутизация, лучше специализация.

2. MLA (Multi-Head Latent Attention)

KV-cache — главная проблема длинного контекста. На каждый токен нужно хранить Key и Value для всех слоёв. 128K контекст = несколько GB RAM только для кеша.

DeepSeek сжимает KV в маленький латентный вектор:

Обычный KV-cache:  128K токенов × 128 слоёв × 2 × 4096 = огромный
MLA KV-cache:      128K токенов × 128 слоёв × 512 (сжатый) = в 13x меньше

При генерации разворачивает обратно. Качество почти не теряется.

3. GRPO — обучение без людей

Обычный RLHF (Reinforcement Learning from Human Feedback):

Модель → ответ → человек-оценщик → reward signal → обновить модель

Дорого, медленно, субъективно.

GRPO (Group Relative Policy Optimization):

Задача с проверяемым ответом (математика, код)
→ Модель генерирует 8 вариантов решения
→ Автоматически проверяем какие правильные (через Python/тесты)
→ Правильные: +reward, неправильные: -reward
→ Обновляем модель

Людей нет вообще. Модель сама себя учит через самопроверку. DeepSeek-R1 превзошёл OpenAI o1 на математических задачах именно через GRPO.

4. Дистилляция R1 → маленькие модели

DeepSeek R1 (671B) использовался как учитель для обучения:
- DeepSeek R1 7B
- DeepSeek R1 14B
- DeepSeek R1 32B

Маленькие модели воспроизводят "мышление" большой. R1 7B обгоняет некоторые 70B модели на математике.

Итог DeepSeek vs конкуренты

11. Как обучить модель с нуля

Шаг 1: Архитектура

Берём Transformer Decoder (как GPT). Не изобретаем — используем готовый код Llama/Mistral, меняем размер.

Обязательные оптимизации:

Шаг 2: Данные (самый важный шаг)

Закон Chinchilla (DeepMind, 2022): оптимально 20 токенов данных на 1 параметр.

1B модель  → 20B токенов данных
7B модель  → 140B токенов данных
70B модель → 1.4T токенов данных

Качество данных важнее количества.

Пайплайн очистки:

1. Скачать Common Crawl / Wikipedia / книги
2. Дедупликация (MinHash LSH) — убирает 30–60% дублей
3. Качественный фильтр (fastText) — только "книжный" текст
4. Обучить токенизатор на корпусе (BPE, 32–64K токенов)

Шаг 3: Pre-training (основа)

# Псевдокод обучения
for batch in data_loader:
    tokens_input = batch[:, :-1]    # все кроме последнего
    tokens_target = batch[:, 1:]    # все кроме первого (сдвиг на 1)

    logits = model(tokens_input)
    loss = cross_entropy(logits, tokens_target)  # предсказали следующий токен
    loss.backward()
    optimizer.step()

Параметры:
- Learning rate: 3e-4 (cosine decay)
- Batch size: большой (через gradient accumulation)
- Gradient checkpointing: пересчёт активаций вместо хранения (RAM ÷3–5)

Шаг 4: SFT — обучение следовать инструкциям

После pre-training модель умеет продолжать текст, но не отвечать на вопросы.

SFT (Supervised Fine-Tuning) = обучение на примерах {инструкция → ответ}:

Данные: OpenHermes 2.5 (1M примеров, бесплатно)
Формат: <|user|>Напиши стих про кота<|assistant|>Мяукал кот...
Эпохи: 1–3
LR: в 10x меньше чем pre-training

Шаг 5: Выравнивание (alignment)

Вариант A — DPO (проще, рекомендуется):

Direct Preference Optimization. Нужны пары {хороший ответ, плохой ответ} на один вопрос. Прямая оптимизация без отдельной reward-модели.

Вариант B — GRPO (для задач с проверяемым ответом):

Как у DeepSeek — модель генерирует варианты, автоматически проверяем, даём reward.

Вариант C — RLHF (классика, дорого):

Обучить отдельную reward-модель на человеческих оценках, потом PPO. Используют крупные лаборатории.

Шаг 6: Дистилляция (опционально, рекомендуется)

После базового обучения — дополнительно учим на ответах GPT-4/Claude:

for prompt in curated_prompts:
    teacher_answer = gpt4_api(prompt)      # ~$0.01 за ответ
    train_on(prompt, teacher_answer)       # как SFT

100K примеров = ~$1 000 за учителя + несколько дней дообучения.

Железо и стоимость

12. Обработка больших данных

Проблема

Контекст ограничен. 200K токенов = ~150K слов. Для анализа большой кодовой базы или документа — не влезает.

Паттерны решения

Cursor (пагинация)

Обрабатываем файл по N строк:
[1–100] → обработать → сохранить результат
[101–200] → обработать → дополнить результат
...

Map-Reduce

MAP:    разбить на независимые куски → обработать каждый
REDUCE: объединить результаты

Sliding Window (скользящее окно)

Для задач с контекстом (суммаризация, анализ):
[1–1000 токенов]              → обработать → summary_1
[800–1800 токенов]            → обработать → summary_2  (200 токенов перекрытия)
...
[summary_1, summary_2, ...] → финальный синтез

Hierarchical (иерархия)

Уровень 1: суммаризировать каждую главу (по отдельности)
Уровень 2: суммаризировать summaries глав
Уровень 3: финальный анализ всей книги

Перехват математики

LLM плохо считает (числа — просто токены-строки). Решение:

Вместо того чтобы LLM считала в голове — она пишет код, код выполняется, результат возвращается в контекст:

# Модель видит задачу "2847 × 3961"
# Вместо предсказания ответа по статистике:
result = execute_python("print(2847 * 3961)")
# → 11 278 167  (точно, от процессора)

Именно так работают Code Interpreter в ChatGPT, Python tool в Claude.

13. Тренды 2025–2026

Test-Time Compute

Революционная идея: вместо того чтобы делать модель больше, дать ей больше времени думать.

Старая парадигма:  большая модель → сразу хороший ответ
Новая парадигма:   средняя модель → много шагов "рассуждения" → хороший ответ

OpenAI o1/o3, DeepSeek R1 — именно это. Модель генерирует длинную цепочку рассуждений (Chain of Thought) перед финальным ответом. На сложных задачах это работает лучше чем просто большая модель.

SSM / Hybrid архитектуры

Transformer имеет O(n²) сложность по длине контекста. Для 1M токенов это катастрофа.

SSM (State Space Models) — Mamba, RWKV — линейная O(n) сложность. Хуже на коротких задачах, намного лучше на очень длинных.

Гибриды (Jamba, Zamba): часть слоёв — Attention, часть — SSM. Баланс качества и эффективности.

Synthetic Data Dominance

К 2025 стало очевидно: модели, обученные на синтетических данных (сгенерированных другими моделями), часто превосходят обученные на реальных данных.

Phi-3 (3.8B) обгоняет многие 7B модели обученные на реальном интернете — только потому что обучалась на "учебниках" написанных GPT-4.

Quantization — модели для слабого железа

Квантизация (quantization) = хранение весов в меньшей точности:

fp32:  4 байта на параметр  (7B = 28 GB)
fp16:  2 байта на параметр  (7B = 14 GB)
int8:  1 байт на параметр   (7B = 7 GB)
int4:  0.5 байта             (7B = 3.5 GB — влезает в 4 GB GPU!)

GGUF формат + llama.cpp: запуск 7B модели на обычном ноутбуке.

FP8 Training

H100/H800 поддерживают FP8 (8-bit floating point) для обучения. В 2x быстрее bf16 при сопоставимом качестве. DeepSeek V3 обучали на FP8.

Speculative Decoding

Маленькая модель (draft model) угадывает несколько следующих токенов. Большая модель проверяет всё за один прогон.

Draft model: предсказывает токены [1, 2, 3, 4, 5]
Target model: проверяет все 5 сразу (один прогон вместо пяти)
Если угадала k токенов → принимаем их
Если нет → откатываемся до ошибки

Ускорение: 2–4x при том же качестве

Итоговая картина

Текст
  ↓
[Токенизация — BPE]
  ↓
[Embedding — токен → вектор]
  ↓
[Трансформер — N слоёв self-attention + FFN]
  ↓ (каждый слой обогащает векторы контекстом)
[Softmax → вероятности]
  ↓
[Sampling — выбор токена]
  ↓
[Авторегрессия — добавляем в контекст, повторяем]
  ↓
Текст ответа

Где что живёт:
- Знания о мире → в весах (обучены, заморожены)
- Текущий разговор → в контексте (сессия, исчезает)
- Специализация → LoRA-адаптер (накладка на веса)
- Экономия вычислений → MoE (активны только 2–4 из 256 экспертов)
- Мышление → Test-Time Compute (длинный Chain of Thought)

Документ составлен на основе сессии 2026-03-25
Следующее обновление: при появлении новых архитектурных инноваций