В последние месяцы всё чаще слышим про «reasoning-модели», способные не просто продолжать текст, а действительно шаг за шагом решать сложнейшие задачи цепочкой рассуждений (chain-of-thought). Впервые такой подход эффектно показали в OpenAI o1, но, к сожалению, подробности там остаются секретными. Недавно же команда DeepSeek наделала шуму с открытыми вариантами R1 и R1-Zero, созданными поверх их собственной большой MoE-модели DeepSeek-V3. В этом посте я не стану углубляться в вопрос «чья модель лучше — o1 или R1». Зато разберу, какие главные технические детали стоят за R1, почему Zero-версия выглядит особо захватывающе, и как именно авторам удалось обучить модель мыслить.

Почему все резко вспомнили про ризонинг?

Меня часто спрашивают:

«А что вообще тут нового? Chain-of-thought промптинг ведь уже несколько лет известен и неплохо работает. Модели давно умеют размышлять и решать задачи, рассуждая по шагам».

Да, сами по себе размышления языковых моделей — это не новинка. Уже давно было ясно, что если перед ответом попросить LLM как следует подумать, то и ответ станет точнее. А вы сами-то сходу умеете перемножать 10-значные числа? Вот-вот, я тоже — только в столбик, «шаг за шагом».

Но в чём же тогда загвоздка? Дело в том, что у предыдущих моделей вроде GPT-4 есть предел: если заставить их думать слишком долго, точность может даже снижаться — из-за галлюцинаций на длинном контексте и пресловутой проблемы «lost in the middle», когда середина промпта попросту теряется.

А вот у последнего поколения моделей (o1, R1 и т.п.) такого ограничения почти нет: эффект от CoT не выходит на насыщение и не упирается в потолок. Чем дольше они размышляют, тем выше становится точность. В OpenAI назвали это «test-time scaling» — то есть компьютом можно теперь не только претрейн закидывать, но и инференс.

Что выложили разработчики DeepSeek?

DeepSeek поделилась сразу 8ю моделями: DeepSeek-R1, DeepSeek-R1-Zero и шесть дистилляций в модели поменьше (Qwen 1.5B, 7B, 14B, 32B, Llama 3-8B и 70B).

R1 и R1-zero построены на базе DeepSeek-V3, крупной Mixture-of-Experts модели:

• Архитектура: типичный трансформер-декодер, но с многоголовым latent attention (MLA) + DeepSeekMoE, и MTP (Multi-Token Prediction) — техника, позволяющая предсказывать сразу несколько будущих токенов.

• Размер: 671 миллиард параметров, но только 37B одновременно активированы для каждого отдельного токена.

По сути, R1 и R1-Zero — это небольшое, прям крошечное, на мой взгляд, дообучение поверх DeepSeek-V3.

В чём главное отличие R1 и R1-Zero версий?

Обе имеют одинаковую архитектуру. Однако их обучение сильно отличается:

• R1-Zero вообще не использует SFT (supervised fine-tuning на чистых текстах). Никаких человеко-размеченных данных. Чистый RL, причём reward они получают через юнит-тесты (для задач на программирование), математические проверки логических задач и прочие очень простые, но устойчивые правила. Авторы называют это «pure reinforcement learning», то есть без human-in-the-loop.

• R1 же обучается в многоэтапном, более классическом режиме для получения «читабельных» цепочек рассуждений и более высоких метрик. При этом ранние чекпоинты R1-zero использовались для генерации части обучающих данных.

DeepSeek-R1-Zero: чистое RL, без датасета и без людей

Давайте сначала разжуём детальнее Zero версию.

Почему без людей? Люди и разметка — это бутылочное горлышко. Зачастую для RLHF нужно нанимать аннотаторов, вручную помечать «это хороший ответ, это плохой», что дорого и медленно. В Zero-версии авторы переходят на автопроверку: если задача — написать фрагмент кода, компилятор сам выдаёт pass/fail, если математическая задача — есть чёткий эталон ответа, если логическая — проверяется тестами. Всё это быстро масштабируется без человека.

GRPO и Aha moment

В качестве алгоритма RL применяется GRPO (Group Relative Policy Optimization) изобретённый этими же авторами, но в прошлой работе «DeepSeekMath». В отличие от классического PPO (от OpenAI, который они судя по всему и продолжают использовать для o1), здесь не нужна reward-модель того же размера, что и обучаемая LLM, а оценка реворда берётся по «группе» сгенерированных ответов. Это серьёзно экономит вычисления и, по словам разработчиков, модель сходится очень быстро: около 4000 (всего 4000!) RL-итераций — уже заметный скачок.

Пишут, что примерно на середине обучения возникает момент озарения — «Aha-moment», когда модель вдруг начинает сама вставлять рефлексию, самопроверку, удлинять Chain-of-Thought до сотен и даже тысяч токенов для решения сложных (и простых, ахах) примеров. Ещё постепенно появляются побочные эффекты такие как «language mixing», когда часть рассуждений идёт, условно, на английском, кусок — на псевдоязыке, ещё часть на китайском.

С точки зрения человеческого читателя это выглядит жутковато, но reward алгоритму наплевать. Главное, что так модель увеличивает точность. Что-то похожее мы уже видели в QuietStar подходе. При этом чем дольше учится — тем больше compute тратит. По мере обучения модель сама решила «дополнять» свою reasoning-цепочку при генерации, и это соответствовало росту точности. При этом для простых задач "думающие" модели так же закидывают читателя простыней текста.

Смотрим на формулу GRPO и стараемся не заплакать

При виде этой формулы хочется заплакать и бросить этот ваш RL для LLM. Но успокойтесь, тут всё проще чем выглядит. Ниже я попробую объяснить суть на пальцах.

Обычно в RL методах для LLM (например PPO) помимо «актора» (самой LLM) обучается ещё и «reward модель», которая оценивает насколько хороши ответы основной модели. Но такой «критик» нередко требует почти таких же размеров, как актор, удваивая затраты памяти и вычислительные ресурсы. Авторам это не подходило: они хотели запустить масштабное RL обучение (в математике, коде, логике), причём на больших моделях. Так и появился GRPO (Group Relative Policy Optimization), который вообще убирает отдельную reward-модель из пайплайна.

Суть GRPO на пальцах

1. Формируем группу. Для каждого вопроса (prompt) старая политика (модель) генерирует не один ответ, а целую группу G ответов.

2. Считаем reward для каждого ответа (скажем, проверяем код автотестами или сравниваем числовой результат в задаче по математике).

3. Вычисляем "относительные" преимущества (advantage). Пусть — reward для i-го ответа. Тогда:

   

   Тот, у кого выше среднего, получает положительный advantage (усиливаем генерацию). У кого ниже — наоборот, штраф.

4. Обновляем политику. Применяем знакомую механику PPO (ratio =), клипируем апдейты (чтобы не улететь), добавляем KL-штраф, чтобы модель не слишком расходилась с изначальным чекпоинтом.

Главное, что теперь вообще не нужна reward-модель. Каждая группа ответов сама формирует baseline (среднюю планку), а модель видит, насколько "этот ответ" лучше/хуже других.

В итоге

• Экономим кучу GPU-памяти: громоздкая reward-модель (иногда размером с саму LLM) больше не нужна.

• Меньше "reward-hacking": модель не пытается «обмануть» модель критика, так как baseline вычисляется прямо из сэмплов.

• Удобнее масштабировать: Авторов DeepSeekMath и DeepSeek-R1 это особо выручило при обучении на сотнях тысяч примеров (математика, код), где проверка "правильности" ответа легко автоматизируется.

Пара слов про датасеты для R1-zero

Здесь нет стандартного набора, тут скорее мешок задач из бенчмарков (какие хитрые!). Сами авторы не раскрывают всё детально. Говорят лишь, что «берём coding, math, logic» и добавляем «синтетические цепочки», где проверка результата легко автоматизируется. Похоже, они банально взяли train-части от кучи бенчмарков MATH, CodeForces, MMLU, GPQA и т.д., плюс ещё что-то синтетическое и автоверифицируемое нагенерили.

Читабельность ризонинга падает по мере обучения

Да, CoT в R1-Zero местами совсем кривой: модель мешает языки, вставляет «левые» куски кода. Человек читает и не понимает половину «логики». Но RL говорит: «Главное — результат правильный, остальное неважно». По сути, модель может «придумать» новый язык для рассуждений, выходящий за рамки человеческой грамматики. Это напоминает «QuietStar»: LLM генерит кучу токенов, часть может выглядеть абсурдно, но всё равно улучшает правильность итогового ответа. Видимо, настоящая «мысль» идёт в скрытых слоях, а то, что мы видим в тексте — это лишь побочный продукт.

Чтобы «исправить» эту дикость и нечитаемость формата, авторы в итоге отказываются от идеи “голого RL” и возвращаются к более стандартному многоэтапному обучению и создают R1.

DeepSeek-R1: обучение в несколько этапов

Если DeepSeek-R1-Zero училась чисто на RL без всякого супервайз-старта, то DeepSeek-R1 пошла классическим путём «SFT + RL + дообучение», но со своими нюансами. Ниже разберём этот пайплайн подробно — от сбора данных до того, что случилось с версией Zero.

1. Cold-start датасет

   • В DeepSeek-R1 первым делом решили избежать «нестабильного старта» RL, когда модель, не знающая даже элементарных шаблонов рассуждения, начинает сходиться медленнее или выдавать хаотические цепочки. Поэтому собрали небольшой «cold-start» корпус: несколько тысяч задач с подробно расписанными шагами (Chain-of-Thought).

   • Как собирали:

     • Использовали разные промпты к уже имеющимся моделям (в том числе ранние версии DeepSeek, R1-Zero) на удобочитаемых сэмплах, с запросом «распиши решение более детально».

     • Затем вручную или полуручными правилами (Quality Filter) отсеивали явно неправильные или плохо читаемые цепочки.

     • Формат вывода специально выровняли под человека: «блок рассуждения + финальный краткий ответ».

   • В итоге модель DeepSeek-V3 (базовая MoE-модель) доучивается на этом небольшом наборе (не более 10k-15k примеров по разным подсказкам: математика, логика, частицы кода и т.д.). После этого чекпоинт уже способен выдавать «длинное рассуждение + понятную финальную цепочку» и создаёт основу для последующего RL обучения.

2. Этап «Reasoning-only RL»

   • Второй шаг — это, по сути, тот же подход, что и у R1-Zero, но теперь стартует модель, уже умеющая хоть как-то структурированно мыслить.

   • Упор делается на те области, где проверка результата автоматизируема:
     

     • Математические (MATH, CNMO, AIME и т.п.) — проверяют финальный ответ (правильно/нет).

     • Код: проверяют pass/fail по тестам (LeetCode-стиль, Codeforces).

     • Логические, научные: если есть точное решение или референс, возможно автоматизированное сопоставление.

   • Языковой штраф/Language consistency: чтобы CoT был более читаем, авторы добавили дополнительный (пусть и небольшой) штраф, если модель впадает в абракадабру на смеси языков или не следует Markdown-формату. Варьирование этого штрафа чуть понижает точность, зато повышает «human-readability».

   • RL продолжают до сходимости, это несколько десятков тысяч итераций. Как и у R1-Zero, в середине обучения часто наступает «aha moment» — модель увеличивает длину цепочки, начинает вставлять самопроверку и «разговор с собой». Благодаря тому, что здесь изначальный чекпоинт уже знал, как выглядит «красивое» рассуждение, итог заметно лучше, чем у Zero.

3. Rejection Sampling + новое SFT

   • После того как RL сошёлся на чистом reasoning (математика, код и т.д.), разработчики ещё раз генерируют синтетический датасет — много ответов из полученной RL-модели (уже умеющей размашисто рассуждать).

   • Отбраковывают ответы, где модель ошиблась (через те же автотесты или доп. проверки), и оставляют правильно решённые цепочки.

   • При этом добавляют и «некоторые другие» области (письменные задания, QA, формальная валидация и т.п.) из более широкого SFT набора DeepSeek-V3, чтобы модель не потеряла общие навыки за время узкого RL на math/code.

   • Суммарно получается новый крупный датасет 600k + 200k, где большая часть — это «reasoning» с подтверждённой правильностью, а часть — «некоторые другие» типы запросов (factual QA, writing, style). На этом всем снова делают supervised fine-tuning базовой DeepSeek-V3. Фактически мы получаем обновлённую версию модели, которая собрала «лучшую выборку» рассуждений из RL-чекпоинта и объединила их с другими сценариями.

4. Финальное RL на все сценарии

   • Дальше авторы еще раз запускают RL, теперь не только на задачах math/coding, но и на «общих» промптах, где Reward уже задаётся обученным preference-модулем (частично — от DeepSeek, частично — от моделей-оценщиков). На математических/кодовых задачах всё по-прежнему: форматный реверс, pass/fail и т.д. На «общих» — есть reward-модель, следящая за полезностью и безопасностью (helpfulness / harmlessness).

Так и формируется финальный чекпоинт DeepSeek-R1, открытый сообществу. Да, этапы выглядят запутанно, и превращаются в постоянное чередование RL и SFT + генерация синтетики. Чтобы лучше осознать, что же тут происходит, посмотрите на схему от SirrahChan, тут всё выглядит гораздо проще.

Дистилляции

Респект авторам, они не пожмотились обучить и выложить ещё и дистилляции R1 в более маленькие модели от других исследовательских групп. Всего они выложили 6 версий: Qwen 1.5B, 7B, 14B, 32B, Llama 3-8B и 70B.

1. Они берут большую модель R1, генерят кучу reasoning-трейсов и ответов.

2. Файнтюнят модели поменьше на этих трейсах.

Авторы говорят, что «Distillation в данном случае лучше, чем RL». И модели сходятся к точности выше, чем если их учить до сходимости также как R1. Видимо, потому что «паттерны рассуждения» не возникают сами по себе в маленькой модели — ей сложнее открывать сложный CoT и рефлексию или “Aha-moment”. Опять вспоминаем про эмерджетные свойства крупных LLM.

Заключение

Итак, DeepSeek представили две новые reasoning-модели: R1-Zero — полностью RL без участия человека, и R1 — с небольшим блоком SFT и многоэтапным обучением для улучшения читаемости и метрик. Это — прямое продолжение большой волны «reasoning-моделей». Отличие от OpenAI o1/o3 в том, что R1(-Zero) открыты, и в их техрепорте детально расписан подход (архитектура, GRPO, наборы задач, синтетические цепочки). Прорыв в том, что Zero убирает «human in the loop», и модель сама фактически создаёт собственный язык, пусть и малочитабельный, но эффективный для решения задач.

Похоже, что R1-Zero действительно открывает дверь к быстрому RL-обучению reasoning без узкого места в виде human feedback \ human annotation.

В любом случае, я буду следить за развитием темы. Если и вам тоже всё это интересно, то заходите в мой телеграм-канал AbstractDL.

Полезные ссылки

• DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (оригинальная статья)

• Разбор DeepSeek-R1 от Jay Alammar

• Туториал по воспроизведению DeepSeek-R1-mini

• HuggingFace чекпоинты

• DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models (разбор статьи)