DeepSeek-R1 и «момент озарения»

Зачем это нужно

В сентябре 2024 года OpenAI показала o1 — модель, которая перед ответом долго «думает» и решает олимпиадные задачи намного лучше обычных чат-ботов. Как её обучали, не рассказали. Сообщество гадало: процессные модели награды, поиск по дереву вроде AlphaGo, тонны размеченных людьми рассуждений?

20 января 2025 года DeepSeek ответила статьёй и открытыми весами. Ответ оказался почти обидно простым: возьмите сильную базовую модель, дайте ей задачи, ответ которых можно проверить программой, и запустите GRPO из прошлого урока. Длинные рассуждениярассуждениеEN reasoning⚠️ В китайском одно слово («туйли») означает и «рассуждение» (reasoning), и «инференс» (inference). Смысл определяется по контексту. «Модель туйли» — reasoning-модель, «ускорение туйли» — ускорение инференса., самопроверка и поиск альтернатив появятся сами. Эту модель назвали DeepSeek-R1-Zero — «Zero», потому что до RL она не видела ни одного примера рассуждения (как AlphaGo Zero не видела партий людей).

В этом уроке — механика: что именно оптимизировали, почему растёт длина, что известно об «озарении» сегодня и зачем полному R1 понадобились ещё три этапа. Постраничное чтение статьи — в треке «Китайская линза»; здесь не будем его повторять.

RLVR: награда, которую проверяет программа

Из урока 6.3.2 вы знаете главную беду нейросетевой reward model — взлом наградывзлом награды (reward hacking)EN reward hackingПолитика находит способ получить высокую награду, не делая того, что задумали люди.. Политика, которую тысячи шагов оптимизируют против RM, находит её «дыры». DeepSeek сделали ставку на награду, которую считает программа. Это проверяемое вознаграждениепроверяемое вознаграждениеEN verifiable reward (RLVR), а подход называют RLVR (RL with Verifiable Rewards).

Задача	Как проверить	Пример награды
Математика с числовым ответом	извлечь ответ из \boxed{} (LaTeX-рамка вокруг итогового ответа) и сравнить с эталоном	1 / 0
Код	скомпилировать и прогнать тесты	доля пройденных тестов или 1 / 0
Логические головоломки, Countdown	проверить решение подстановкой	1 / 0
Формат	регулярное выражение по тегам <think>…</think>	1 / 0 или небольшой бонус
Эссе, перевод, диалог	программно никак	нужна RM или судья-LLM

Последняя строка — граница метода. RLVR блестяще работает там, где есть проверщик, и почти бесполезен там, где его нет. Поэтому в полном R1 для «непроверяемых» задач всё равно вернулись reward model — но аккуратно и ненадолго (см. ниже).

Рецепт R1-Zero

Четыре ингредиента:

1. База: DeepSeek-V3-Base (671B параметров, 37B активных) — без SFT и без инструкций.
2. Шаблон: «A conversation between User and Assistant… The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning process and answer are enclosed within <think> </think> and <answer> </answer> tags… User: prompt. Assistant:». И всё. Ни слова про «проверяй себя»: авторы хотели увидеть, к чему модель придёт сама.
3. Алгоритм: GRPO.
4. Награды (обе правиловыеправиловая наградаEN rule-based rewardНаграду считает программа (сверка ответа, запуск тестов, проверка формата), а не нейросеть. Её трудно «взломать».): за точность ответа и за формат — рассуждение внутри <think>. Нейросетевую RM, ни итоговую, ни процессную, сознательно не использовали.

flowchart LR
D["Задачи с эталонным ответом"] --> P["Шаблон: think, затем answer"]
P --> M["Политика: старт с V3-Base"]
M -->|"16 ответов на задачу"| R["Правила: формат + точность"]
R -->|"награды"| A["GRPO: преимущества по группе"]
A -->|"обновление"| M
M -.->|"каждые 400 шагов"| REF["Новая референсная модель"]

Цикл обучения R1-Zero

В рецензированной версии статьи (Nature, раздел Methods) раскрыты гиперпараметры. Их полезно знать как ориентир для своих экспериментов:

Параметр	Значение в R1-Zero
Ответов на задачу $G$	16
Задач на шаг	32 (батч 512 ответов)
Learning rate	$3 \cdot 10^{-6}$
KL-коэффициент $\beta$	0.001
Температура сэмплирования	1.0
Максимальная длина ответа	32 768 токенов до шага 8.2k, затем 65 536
Всего шагов	10 400 (1.6 эпохи по данным)
Референсная модель	заменяется текущей политикой каждые 400 шагов
Обновления	8192 ответа делят на 16 мини-батчей, одна эпоха

Обратите внимание на две детали. $\beta = 0.001$ — в 40 раз меньше, чем в DeepSeekMath: модели разрешают далеко уйти от исходной. А референс ещё и регулярно «подтягивают» к текущей политике — KL работает как поводок на коротком отрезке пути, а не как якорь в начальной точке.

Что происходило при обучении

Точность. На AIME 2024 pass@1 вырос с 15.6% до 71.0% (arXiv-версия статьи), а в Nature-версии, после продолжения обучения, — до 77.9%. При голосовании большинством — 86.7%, выше среднего участника олимпиады.

Длина. Средняя длина ответа на обучающих задачах устойчиво росла: от сотен токенов до многих тысяч. На шаге 8.2k, когда лимит длины подняли с 32 768 до 65 536, длина и точность сделали скачок. Модель сама начала тратить больше вычислений на трудные задачи — никто её этому прямо не учил.

Слова. В Nature-версии посчитали частоту «рефлексивных» слов (wait, mistake, however, verify, check…). Слово «wait» почти отсутствовало в начале обучения, изредка появлялось между шагами 4000 и 7000 и резко участилось после шага 8000.

Почему растёт длина, если за неё не платят

Награда в R1-Zero вообще не смотрит на рассуждение: ответ <think></think><answer>42</answer> получает максимум, если 42 верно. Почему же рассуждения удлиняются?

Вспомните групповое преимущество. Пусть на трудной задаче короткие ответы «наугад» верны в 20% случаев, а длинные — с выкладками и перепроверкой — в 60%. В группе из 16 ответов длинные чаще оказываются среди верных, получают $A > 0$, и их вероятность растёт. Вместе с ними растёт и всё, что с ними коррелирует: слова «подожди», «проверим», возвраты к началу. Длина — побочный продукт точности.

Есть и вторая, менее романтичная причина. Множитель $1/\vert o_i \vert$ в GRPO наказывает каждый токен длинного неверного ответа слабее, чем короткого (вы видели это в коде урока 6.4.1). Значит, часть роста длины — артефакт формулы. Его разберём в уроке 6.4.3.

Увидеть самому

В практикуме 6.4.5 вы обучите на CPU крошечную модель тем же способом. У неё длина ответа вырастет с 4 до 8 токенов, а доля ответов «с рассуждением» — с 27% до 98%. И вы увидите, при каком условии этого не происходит.

«Момент озарения» — что мы знаем сегодня

В статье есть знаменитая таблица: промежуточная версия R1-Zero посреди решения пишет «Wait, wait. Wait. That’s an aha moment I can flag here» и начинает пересматривать подход. Авторы назвали это «момент озарения»«момент озарения»EN aha momentЭффект из статьи DeepSeek-R1: модель при RL-обучении сама начинает перепроверять свои рассуждения. — и для модели, и для себя.

Это наблюдение вызвало волну проверок. Три вывода, которые стоит знать:

1. Зачатки рефлексии есть уже в базе. Sea AI Lab (2025) нашли слова «Aha», «wait», «verify» в ответах DeepSeek-V3-Base до всякого RL. RL не изобрёл самопроверку — он сделал её частой.
2. RL затачивает, а не расширяет. Ещё в DeepSeekMath (2024) авторы заметили: после RL растёт maj@K (точность голосования большинством из K ответов), но не pass@K (есть ли среди K ответов хоть один верный); обе метрики разобраны ниже. Группа LeapLab из Университета Цинхуа (2025) проверила это на многих моделях: при $k = 1$ RL-модель лучше базы, но при $k$ в десятки и сотни базовая модель догоняет и обгоняет RL-версию. RL повышает вероятность решений, которые база и так иногда находила, и при этом «забывает» редкие пути.
3. Без зачатка нет и роста. Авторы TinyZero, воспроизведя R1-Zero на задаче Countdown, пишут, что 3B-модель учится самопроверке и поиску, а 0.5B — не учится рассуждать вовсе.

Аккуратная формулировка: RL усиливает и закрепляет поведение, которое у базовой модели уже было в зачатке. Результат R1 это не отменяет: превратить редкое поведение в устойчивое — огромная работа. Но «рождение из ничего» — скорее метафора. Отсюда же главный практический урок: сила RL ограничена силой базы.

Как читать метрики: pass@k и голосование

В отчётах о reasoning-моделях постоянно встречаются pass@1, pass@k и cons@64. Разберёмся, что это (подробнее об оценке — в модуле 7.3, а вывод формулы pass@k — в уроке 7.3.2).

• pass@1 в статье R1 — не «один жадный ответ», а средняя доля верных среди $k$ сэмплов с температурой 0.6. Жадное декодирование у длинных рассуждений зацикливается.
• pass@k — вероятность, что среди $k$ попыток есть хотя бы одна верная. Оценивают по $n \ge k$ сэмплам, из которых $c$ верных:

$$\text{pass@}k = 1 - \frac{\binom{n - c}{k}}{\binom{n}{k}}$$

Что написано: $\binom{n-c}{k} / \binom{n}{k}$ — вероятность, что все $k$ случайно выбранных сэмплов окажутся из $n - c$ неверных. Вычитаем из единицы.

• cons@k (maj@k) — самосогласованностьсамосогласованность (голосование большинством)EN self-consistency (majority voting)Сгенерировать N ответов и выбрать самый частый итоговый. В отчётах — maj@k или cons@k.: сгенерировать $k$ ответов и выбрать самый частый итоговый.

import math
import random
from collections import Counter


def pass_at_k(n, c, k):
    """Несмещённая оценка pass@k: из n сэмплов c верных; вероятность, что среди k случайных есть верный."""
    if n - c < k:
        return 1.0
    return 1.0 - math.comb(n - c, k) / math.comb(n, k)


print("16 сэмплов, 4 верных:", {k: round(pass_at_k(16, 4, k), 3) for k in [1, 2, 4, 8]})

# Голосование большинством: когда оно помогает, а когда вредит
random.seed(0)


def majority_accuracy(answer_probs, correct, k, trials=2000):
    answers, weights = zip(*answer_probs.items())
    wins = 0
    for _ in range(trials):
        votes = Counter(random.choices(answers, weights, k=k))   # k ответов модели с заданными вероятностями
        wins += votes.most_common(1)[0][0] == correct           # самый частый ответ совпал с верным?
    return wins / trials


spread = {"42": 0.4, "41": 0.1, "43": 0.1, "24": 0.1, "40": 0.1, "44": 0.1, "12": 0.1}  # ошибки разные
trap = {"42": 0.3, "24": 0.5, "41": 0.2}  # одна «популярная» ошибка
for name, dist in [("ошибки разные", spread), ("ловушка", trap)]:
    print(f"{name:14s} pass@1 = {dist['42']:.2f}", {k: majority_accuracy(dist, "42", k) for k in [1, 5, 16, 64]})

# Игрушечная иллюстрация вывода LeapLab: RL «затачивает» то, что база уже умела
probs_base = [0.0, 0.0, 0.02, 0.05, 0.1, 0.2, 0.4, 0.6] * 50  # 400 задач с разной трудностью
probs_rl = [min(1.0, 3 * p) if p >= 0.1 else p / 4 for p in probs_base]
for name, probs in [("база", probs_base), ("после RL", probs_rl)]:
    row = {k: round(sum(1 - (1 - p) ** k for p in probs) / len(probs), 3) for k in [1, 8, 64, 256]}
    print(f"{name:9s} pass@k:", row)

Вывод:

16 сэмплов, 4 верных: {1: 0.25, 2: 0.45, 4: 0.728, 8: 0.962}
ошибки разные  pass@1 = 0.40 {1: 0.392, 5: 0.587, 16: 0.879, 64: 0.999}
ловушка        pass@1 = 0.30 {1: 0.311, 5: 0.258, 16: 0.175, 64: 0.033}
база      pass@k: {1: 0.171, 8: 0.484, 64: 0.711, 256: 0.749}
после RL  pass@k: {1: 0.365, 8: 0.51, 64: 0.603, 256: 0.71}

Три урока из этих чисел:

• Голосование превращает 40% верных ответов почти в 100% — если ошибки разбросаны. Если же у модели есть одна «любимая» ошибка, которая чаще верного ответа, голосование уверенно выбирает её: 30% превращаются в 3%.
• pass@k растёт с $k$ очень быстро: 4 верных из 16 — это уже 73% при четырёх попытках.
• В игрушечном примере «RL» вдвое поднял pass@1 (0.17 → 0.37), но при $k = 64$ база уже лучше (0.71 против 0.60). Это не настоящие модели, а схема того, что LeapLab измерили на реальных: RL усиливает частые решения и теряет редкие.

🖥 На вашей машине (4×GPU)

Два опыта этого урока на CPU невозможны, а на ваших картах — задача на вечер или ночь. Оба строятся на коде Countdown из практикума 6.4.5: пройдите его часть 2 сначала.

1. Свой маленький R1-Zero. Замените в train_grpo_countdown.py Instruct-модель на базовую Qwen/Qwen2.5-3B — так делали авторы TinyZero. Роли ассистента у base-модели нет, поэтому prompt в датасете передавайте строкой, а не списком сообщений: TRL подаст его как есть, без chat-шаблона.

• Память (оценка). Полное обучение 3B с Adam — около 49 ГБ, одной карте не по силам. Схема из практикума 6.4.5: GPU 0 — сервер vLLM для генерации, GPU 1–3 — обучение с DeepSpeed ZeRO-3 (около 16 ГБ состояния на карту плюс активации).
• Время (оценка, не замер). С ответами до 1024 токенов — порядка минуты на шаг, сотни шагов — ночь. Запускайте в tmux (программа-«оболочка» для терминала: обучение не прервётся, если закрыть окно или потерять связь; шпаргалка — в уроке 4.6.5).
• На что смотреть. Кривая completions/mean_length — растёт ли длина без всякой награды за неё? Раз в 50 шагов сохраняйте примеры ответов (log_completions=True) и считайте долю ответов со словами «wait», «let me check», «подожди», «проверим» — мини-версия подсчёта «рефлексивных» слов из Nature-версии статьи. Контроль — Qwen/Qwen2.5-0.5B на одной карте: авторы TinyZero пишут, что 0.5B рассуждать не учится. Проверьте сами.

2. Затачивает ли RL? pass@k на своей модели. Возьмите 200 новых задач Countdown и для базы и RL-чекпоинта сгенерируйте по 64 ответа на задачу. Посчитайте pass@k функцией pass_at_k выше для $k$ = 1, 4, 16, 64:

from vllm import LLM, SamplingParams
from countdown_rewards import PROMPT, correctness_reward, make_countdown   # код из практикума 6.4.5

tasks = make_countdown(200, seed=1)                 # другой seed, чем при обучении
prompts = [PROMPT.format(nums=t["nums"], target=t["target"]) for t in tasks]
llm = LLM(model="путь/к/чекпоинту")                 # второй запуск — model="Qwen/Qwen2.5-3B"
outs = llm.generate(prompts, SamplingParams(n=64, temperature=0.6, max_tokens=1024))
c = [sum(correctness_reward([o.text for o in out.outputs], [t["nums"]] * 64, [t["target"]] * 64))
     for out, t in zip(outs, tasks)]                # число верных из 64 для каждой задачи

Это 12 800 ответов на модель — на одной карте, по оценке, десятки минут. Запустите базу и чекпоинт одновременно на разных картах (CUDA_VISIBLE_DEVICES=0 и =1). Пересекаются ли кривые pass@k при больших $k$, как у LeapLab?

Подробнее о машине — на странице «Ваша лаборатория».

Полный R1: четыре этапа

R1-Zero решает задачи, но читать его неприятно: рассуждения сумбурные, а языки перемешаны — модель может перейти с английского на китайский посреди фразы (V3-Base училась на многих языках, больше всего на английском и китайском). К тому же R1-Zero умеет только то, что проверяется правилами. Полный R1 исправляет это четырьмя этапами:

flowchart TD
B["DeepSeek-V3-Base"] --> S1["Этап 1: SFT на тысячах длинных CoT — холодный старт"]
S1 --> S2["Этап 2: RL на рассуждения: правила + награда за язык"]
S2 -->|"генератор данных"| S3["Этап 3: Отбор с отклонением: ~600K рассуждений + ~200K прочих"]
B --> S3b["SFT базовой V3 на ~800K примеров"]
S3 --> S3b
S3b --> S4["Этап 4: RL для всех сценариев: правила + RM полезности и безопасности"]
S4 --> R["DeepSeek-R1"]

Конвейер DeepSeek-R1: два этапа SFT и два этапа RL

Этап	Какую проблему решает
1. Холодный стартданные холодного стартаEN cold-start dataНебольшой набор качественных длинных рассуждений для SFT перед RL — так в DeepSeek-R1 исправили нечитаемость R1-Zero.: SFT на тысячах читаемых длинных рассуждений	хаос и нечитаемость R1-Zero; заодно RL стартует с лучшей точки
2. RL на рассуждения + награда за языковую согласованностьнаграда за языковую согласованностьEN language consistency rewardДоля слов целевого языка в рассуждении. В R1 её прибавляют к награде за точность.	смешение языковсмешение языковEN language mixingМодель переключается между языками внутри одного рассуждения. Типичная проблема R1-Zero.; награда — доля слов целевого языка в рассуждении
3. отбор с отклонениемотбор с отклонением (rejection sampling)EN rejection samplingСгенерировать много ответов и оставить только прошедшие проверку. В пост-трейнинге — способ собрать SFT-данные из RL-модели. + SFT с базы V3	RL-чекпоинт генерирует решения, остаются верные и читаемые; добавляют письмо, перевод, фактические вопросы
4. RL для всех сценариев	для задач без проверщика — reward model полезности (смотрит только итоговое резюме) и безопасности (смотрит всё)

Две детали из Nature-версии показывают, как аккуратно обращаются с нейросетевыми наградами. Во втором RL-этапе данные с preference-наградами добавляли только в последние 400 шагов из 1700: авторы прямо пишут, что более долгое обучение на модельной награде ведёт к reward hacking. А в первом RL-этапе клиппинг поставили $\varepsilon = 10$ — гораздо шире привычных 0.2: слишком узкий клиппинг «обрезает» градиент у множества токенов. К этой теме вернёмся в уроке о вариантах GRPO.

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

Nature и что изменилось в индустрии

Рецензирование. Статья поступила в Nature 14 февраля 2025 года, принята 17 июля и опубликована 17 сентября 2025 года (том 645) — с открытым доступом и опубликованными отзывами рецензентов. Для флагманской LLM это редкость: обычно лаборатории ограничиваются препринтом или блогом. Среди восьми рецензентов — исследователи Hugging Face Льюис Танстолл и Эдвард Бичинг. По сравнению с препринтом в Nature-версии появились гиперпараметры RL, анализ рефлексивных слов, выложенные образцы данных для отбора с отклонением и RL-промптов, подробнее разобраны reward hacking и ограничения.

Что изменилось после релиза:

1. RLVR стал стандартным этапом пост-трейнинга. За 2025 год свои reasoning-модели с RL на проверяемых задачах выпустили Moonshot (Kimi k1.5 — в тот же день, что и R1), Alibaba (Qwen3 с гибридным мышлением), ByteDance (Seed1.5-Thinking), MiniMax (M1), Zhipu (GLM-4.5).
2. Волна открытых воспроизведений — TinyZero, Open-R1 от Hugging Face и десятки других. Они быстро нашли слабые места GRPO и предложили исправления: Dr. GRPO, DAPO и другие (урок 6.4.3).
3. Инфраструктура RL стала продуктом. verl (ByteDance), OpenRLHF, slime (Zhipu), AReaL (Ant Group), ROLL (Alibaba) — открытые фреймворки, где генерация на vLLM или SGLang склеена с обучением на FSDP или Megatron.
4. Дистилляция рассуждений стала обычным способом сделать маленькую reasoning-модель: веса R1 под MIT, и README прямо разрешает использовать их для обучения других моделей (урок 6.4.4).
5. Спор о том, что именно делает RL, — от «озарения» к аккуратным измерениям pass@k.

Китайский угол: один рецепт — вся экосистема

Почему R1 так быстро разошёлся по Китаю. Четыре из шести дистиллированных версий R1 построены на открытых Qwen2.5 (ещё две — на Llama): сильная база одной китайской лаборатории и рецепт рассуждений другой усилили друг друга. Открытые фреймворки для повторения рецепта тоже во многом китайские: verl (ByteDance), slime (Zhipu), AReaL (Ant Group), ROLL (Alibaba), EasyR1 (автор LLaMA-Factory). На них в 2025 году воспроизводили R1-Zero многие команды — от университетов до стартапов.

Критика тоже китайская. Самая цитируемая проверка тезиса «RL учит модель новому» — работа LeapLab из Университета Цинхуа (апрель 2025). Её вывод спорят и уточняют до сих пор, но pass@k при больших $k$ стал частой проверкой в статьях о RLVR.

Термины в китайских разборах (например, unlock-deepseek от Datawhale). RL по-китайски — буквально «обучение с усилением». Проверяемая награда, длинная цепочка рассуждений («длинная цепь мышления»), холодный старт, отбор с отклонением и смешение языков называются дословно. Для «момента озарения» (aha moment) взято буддийское слово «внезапное просветление».

Проверь себя

Проверь себя6 вопросов·

1 Награда R1-Zero не зависит от длины рассуждения. Почему длина всё равно растёт?

Авторы добавили бонус за каждые 1000 токеновДлинные ответы с перепроверкой чаще верны на трудных задачах, получают положительное преимущество, и их паттерны усиливаются; часть роста добавляет нормировка $1/|o_i|$ в GRPOМодель копирует длинные рассуждения из SFT-данныхТак устроен шаблон: он требует не менее 1000 токенов

2 Из 16 сэмплов верны 4. Чему равна несмещённая оценка pass@4? Округлите до двух знаков.

3 Какие утверждения о гиперпараметрах R1-Zero (по Nature-версии) верны?Можно выбрать несколько ответов

На каждую задачу генерировали 16 ответовKL-коэффициент $\beta = 0.001$ — намного меньше, чем в DeepSeekMathРеференсную модель периодически заменяли текущей политикойНаграду давала процессная модель вознаграждения (PRM)

4 Модель отвечает верно в 30% случаев, а одну и ту же неверную версию выдаёт в 50%. К какому числу стремится точность голосования большинством при очень большом числе сэмплов? Ответ — доля от 0 до 1.

5 Что в первую очередь показала работа LeapLab (Цинхуа) о pass@k?

RL-модели лучше базовых при любом $k$При малых $k$ RL-модель лучше, а при больших база догоняет и обгоняет: RL в основном затачивает уже имеющиеся решенияБазовые модели вообще не решают задач AIMEpass@k нельзя оценить по сэмплам

6 Какие этапы полного R1 направлены против нечитаемости и смешения языков R1-Zero?Можно выбрать несколько ответов

SFT на cold-start данных с читаемыми рассуждениямиНаграда за языковую согласованность на этапе RLФильтрация ответов со смешением языков при отборе с отклонениемУвеличение KL-коэффициента до 0.04

Проверить ответы

Итоги

• RLVR: награду считает программа — сверка ответа, тесты, формат. Взломать её гораздо труднее, чем нейросетевую RM, но работает она только там, где есть проверщик.
• R1-Zero = V3-Base + минимальный шаблон + GRPO + награды за точность и формат. AIME 2024: 15.6% → 71.0% (77.9% в Nature-версии).
• Длина рассуждений растёт как побочный продукт точности; «момент озарения» — усиление поведения, которое в базе уже было в зачатке. Сила RL ограничена силой базы.
• pass@1, pass@k, maj@k — разные метрики; голосование помогает, только когда верный ответ — самый частый.
• Полный R1 = холодный старт → RL с наградой за язык → отбор с отклонением и SFT → RL для всех сценариев.

Дальше: что сообщество исправило в GRPO за 2025 год — DAPO, Dr. GRPO, GSPO, CISPO, подход Kimi k1.5 и борьба с коллапсом энтропии.