Модели рассуждений обучают, а не промптят

Вот мнение, которое я плохо отстаивал на командном обеде в прошлом году и с тех пор верю в него ещё сильнее: если вы представляете reasoning-модель как «обычную LLM, которой сказали думать пошагово», то вы вообще не понимаете, как устроены такие модели, и это непонимание тихо стоит вам денег и точности в продакшене. Reasoning-модели — это не техника промптинга. Это артефакт обучения. Поведение с цепочкой рассуждений, которое делает их сильными в математике и коде, появляется из reinforcement learning с проверяемыми наградами, а не из чего-либо, что вы написали в системном промпте. Я по-настоящему это понял, проходя тот же путь, который Себастьян Рашка разбирает в своём новом 11-часовом курсе по созданию reasoning-модели: загружаем небольшую базовую модель Qwen3, пишем верификатор, запускаем GRPO и смотрим, как трассировки рассуждений становятся длиннее, а точность растёт. Когда вы увидели это в собственном цикле обучения, обратно уже не отмотать.

Давайте обоснуем этот тезис как следует, а потом немного его скорректируем там, где это нужно, ведь есть одно место, где промптинг действительно важен, и делать вид, что его нет, было бы хайпом другого сорта.

Почему модель «просто промптим» не работает

Популярная история выглядит так: в 2022 году исследователи обнаружили, что добавление фразы «Давай подумаем пошагово» к промпту резко повышает точность арифметики, так родился chain-of-thought промптинг. Всё верно, но история умалчивает, что было дальше: лаборатории взяли это поведение и вжгли его в веса с помощью reinforcement learning. Современной reasoning-модели не нужна ваша пошаговая заклинательная формула. Она генерирует развёрнутые трассировки рассуждений по умолчанию, потому что её обучили это делать и награждали за трассировки, которые приводят к правильным ответам.

Это можно проверить самостоятельно за один вечер. Возьмите базовую модель, Qwen3 0.6B подойдёт и работает на одной потребительской видеокарте, и прогоните её на MATH-500 с chain-of-thought промптом и без него. Вы получите скромный прирост. Теперь возьмите RLVR-обученный вариант той же семейства моделей. Разница между двумя условиями будет не прирostом, а обрывом. Ни один системный промпт этот разрыв не закроет. В этом эмпирическое ядро моего тезиса: способность живёт в весах, а веса стали такими благодаря обучению, а не благодаря удачной расстановке токенов на этапе инференса.

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

Верификатор — и есть весь фокус

Когда я работал ML-инженером, та часть RLHF, которая всегда казалась мне слегка проклятой, — это reward model. Вы обучаете отдельную нейросеть имитировать человеческие предпочтения, затем оптимизируете политику против неё, а потом остаток проекта боретесь с reward hacking: политика находит какой-то вырожденный вывод, который высоко оценивается reward-моделью, но бесполезен для живых людей. Это состязательные отношения, заложенные в архитектуру.

Reinforcement learning с проверяемыми наградами, RLVR, обходит эту проблему полностью, и when вы сами пишете верификатор с нуля, вы начинаете ценить, насколько изящен этот ход. Для математики верификатор — это скучная, детерминированная программа: извлечь финальный ответ из вывода модели, нормализовать его (обработать дроби, десятичные числа, эквивалентные записи вроде 1/2 и 0.5) и проверить математическую эквивалентность. Правильный ответ — награда один, неправильный — ноль. Выученной reward-модели, которую можно взломать, здесь нет. Сигнал награды — это ground truth.

Поэтому reasoning-модели сначала научились math и коду. У обеих областей есть дешёвые и надёжные верификаторы: символьные проверяльщики эквивалентности для математики и юнит-тесты для кода. Не нужны разметчики, которые ранжируют ответы; нужна Python-функция, которая возвращает булево значение. Практическое следствие для тех, кто строит доменные reasoning-системы, очевидно: если вы можете написать верификатор для своей области, вы, скорее всего, сможете обучить под неё reasoner. Если не можете, то есть если правильность в вашей области — дело вкуса, как рекламный текст, вы застреваете с RLHF и его головной болью из-за reward hacking.

Узкое место для рассуждений в новой области — это не вычисления и не данные. Это возможность записать, что значит «правильно», в виде программы.

Мне нравится одна деталь в подходе, когда верификатор пишется первым, ещё до обучения: он работает в двух ролях. Тот же грейдер, который оценивает базовую модель на MATH-500 для замеров, становится функцией награды во время RL. Когда вы реализуете его сами, замечаете, сколько тонкой работы он делает: извлечение ответа на самом деле капризное, потому что модели выражают финальные ответы в десятках форматов, и хрупкий экстрактор незаметно портит сигнал награды. Модель, которая написала «следовательно, x = 7», может быть засчитана неверно, если ваше регулярное выражение ищет только ответы в \boxed. Небрежные верификаторы учат небрежным политикам. Этот урок из статей просто так не усвоить.

Что GRPO на самом деле делает с весами

Сам цикл обучения в упрощённой версии «с нуля» удивительно компактен. Group Relative Policy Optimization, алгоритм, популяризированный DeepSeek, отбрасывает критик-сеть, из-за которой PPO так сильно жрёт память. Вместо обучения функции ценности вы генерируете группу ответов на один и тот же промпт, оцениваете их все верификатором и вычисляете преимущество каждого ответа относительно среднего по группе. Ответы лучше среднего по группе получают повышение вероятности токенов, а хуже — понижение.

def grpo_advantages(rewards: torch.Tensor) -> torch.Tensor:
# rewards: [group_size], one per sampled response to the same prompt
mean = rewards.mean()
std = rewards.std().clamp_min(1e-4)
return (rewards - mean) / std  # relative advantage per response
# Training step: maximize advantage-weighted log-probability
def grpo_loss(logprobs: torch.Tensor, advantages: torch.Tensor) -> torch.Tensor:
# logprobs: summed sequence log-prob under the current policy
return -(advantages.detach() * logprobs).mean()

В реальных реализациях добавляется штраф KL, чтобы политика не уплывала слишком далеко от опорной модели, плюс клиппинг, заимствованный из PPO, но скелет выше честно является главной идеей. И вот что завораживает при наблюдении: вы ничего не говорите модели о стиле рассуждений. Вы награждаете только правильные финальные ответы. Тем не менее в ходе обучения длина ответов растёт. Модель начинает делать самокоррекции посреди трассировки, вроде «стоп, давай проверю», потому что трассировки с поведением проверки чаще заканчиваются правильным ответом, а правильный ответ — единственное, за что дают награду. Стиль chain-of-thought — это возникшее решение задачи оптимизации, а не поведение, которое кто-то спроектировал. Поэтому я и говорю, что это обучено, а не промптится: версия этого поведения из эпохи промптов была людьми, имитирующими то, что RL позже открыл самостоятельно.

Здесь спрятана прагматичная инженерная заметка, которую цикл хайпа пропускает: модели 0.6B на приличной видеокарте достаточно, чтобы увидеть эту динамику по-настоящему. Вы получите измеримый прирост на MATH-500 от GRPO на железе, которое стоит несколько долларов в час. Фронтирную модель вы не получите. И это нормально, ведь в этом упражнении смысл не в ней.

Масштабирование на этапе инференса: где вычисления частично заменяют обучение

До любого RL существует семейство техник, которые улучшают ответы при замороженных весах: сэмплируете несколько кандидатов с temperature и top-p, а затем объединяете их. Self-consistency — рабочая лошадка: генерируете k ответов и берёте мажоритарное голосование по финальным ответам. Работает на удивление хорошо, и работает даже на базовых моделях, что является первой трещиной в моём исходном тезисе, которую я признаю: вычисления на инференсе — настоящая, ортогональная ось улучшения.

Но посмотрите, что эти техники на самом деле требуют. Мажоритарное голосование помогает, только если модель уже имеет ненулевую вероятность давать правильные ответы: голосование усиливает сигнал, который уже есть, но не создаёт сигнал на пустом месте. Отбор по скорингу (ранжирование кандидатов по логарифму вероятности последовательности) обладает тем же свойством. А циклы самоулучшения, где модель критикует и правит собственный ответ, оказываются на базовых моделях разочаровывающе слабыми, потому что честная самокритика сама по себе является способностью, которую устанавливает RL. Каждый трюк инференса сочетается с обучением, но ни один не заменяет его. Фронтирные системы комбинируют RL-обученные модели с масштабированием инференса именно потому, что эффекты перемножаются, а не складываются.

Для практиков важна и стоимость. Self-consistency при k=16 стоит в шестнадцать раз дороже по инференсу. Выгодна ли такая сделка, полностью зависит от вашей кривой точность-на-доллар, и единственный честный способ это понять — самим построить график точности MATH-500 от числа кандидатов. Похожий вопрос о размещении вычислений мы разбирали в нашем обзоре flash-моделей и эффективности инференса: повторяющаяся тема в том, что «потратить больше вычислений» имеет как минимум три разных смысла, и они не взаимозаменяемы.

Дистилляция и единственное место, где промптинг выживает

Финальный этап в конвейере «с нуля» — дистилляция: берём длинные трассировки рассуждений сильного (обычно крупного) reasoner и дообучаем на них меньшую модель напрямую, обычным supervised learning. Без RL и без верификатора в цикле. Так создано много дешёвых небольших reasoning-моделей, которые вы реально будете разворачивать. И это скорее подтверждает тезис, чем опровергает его: поведение рассуждения всё равно берётся из обучающих данных, созданных RL-обученной моделью, просто передаётся через градиентный спуск, а не через награду. Способность никогда не внедряется на этапе промпта; её всегда запекает оптимизация.

Так где же мой контртезис даёт сбой? Честно говоря, здесь: промптинг всё ещё важен на периферии, и эта периферия не нулевая. Контроли усилия рассуждения, то есть настройки бюджета размышлений low/medium/high, которые открывают модели текущего поколения, — это рычаги на этапе инференса, которые заметно обменивают точность на задержку и стоимость. Ограничения структурированного вывода, пайплайны с верификатором в цикле и constrained decoding — это техники уровня промптов и обвязки с реальной ценностью, о чём мы писали в нашем материале про constrained decoding. А если вы застряли с базовой моделью и ничего не можете обучить, chain-of-thought промптинг всё равно приносит реальные баллы на эвалах. «Обучено, а не промптится» — это утверждение о том, где способность возникает, а не утверждение, что выборы на этапе инференса не важны.

Почему сборка полезнее чтения

В обычных местах всплыло справедливое возражение: не похоже ли руководство «собери свою reasoning-модель» на гайд «собери свой процессор» — мило, но бесполезно, ведь настоящее обучение требует кластеров и проприетарных данных? Думаю, это упускает смысл упражнения, и то же я скажу про классический туториал «напиши свою оболочку», который мы хвалили в статье Что написание шелла учит вас об Unix именно по этой причине. Никто не пишет шелл, чтобы заменить bash. Вы его пишете, потому что fork, exec, пайпы и обработка сигналов перестают быть абстракциями, которые вы просто запомнили, и становятся механизмом, который вы подержали в руках.

То же и здесь. Вещи, которые навсегда изменили то, как я работаю с reasoning-моделями, пришли из деталей реализации, а не из статей:

• Написание верификатора научило меня, что качество награды — это задача программной инженерии: граничные случаи нормализации незаметно искажают обучение, а утверждение «награда — это ground truth» настолько верно, насколько хорош ваш экстрактор ответов.
• Реализация скоринга по логарифму вероятности последовательности (с возней с численной стабильностью, которую это влечёт) расшифровала половину функций потерь из литературы по post-training. Все они сводятся к сравнению того, насколько вероятны ответы при разных политиках.
• Наблюдение за ростом длины ответов в ходе GRPO без всяких промптов убило мою последнюю остаточную веру в то, что стиль рассуждения — поверхностное поведение. Это то, что оптимизация находит, когда единственная цель — правильность.
• Построение графика точности от числа кандидатов для self-consistency дало мне реальную интуицию насчёт трейдоффа точность-на-доллар, которой не давала ни одна таблица бенчмарков.

Страх перед вычислениями также преувеличен для учебных целей. Ранние части — загрузка базовой модели, потоковая генерация с KV-кэшем, написание верификатора, прогон MATH-500 — подходят для CPU и ноутбука или очень близки к этому. GRPO-обучение требует GPU, но одной, и арендованная по часам она дешевле большинства учебников. Чего вы не воспроизведёте дома, так это масштаба, а масштаб — это действительно другая дисциплина. Это один из мифов про инференс-движок DeepSeek, которые мы проверяли: стек обслуживания фронтирной лаборатории решает проблемы, которых просто не существует на масштабе туториала, и наоборот.

Практический вывод

Если вынести из всего этого одну вещь, то вот она: мировоззрение, ориентированное на верификатор. Современный стек reasoning выглядит так: базовая модель, программа, которая определяет, что значит «правильно», RL-алгоритм, который оптимизирует против неё, и техники инференса, которые умножают результат. Промптинг сидит на самом краю этой системы и управляет способностью, которую создало обучение. Команды, которые это понимают, вкладывают усилия туда, где они накапливаются: в лучшие верификаторы, лучший дизайн наград и лучшие циклы оценки, вроде тех, которых, как мы считаем, не хватает большинству AI-бенчмарков, которые не замечают реальной работы. Команды, которые не понимают, продолжают крутить системные промпты и гадать, почему точность упёрлась в потолок.

Мой тезис с обеденного стола выдерживает одну оговорку: reasoning-модели обучаются, а не промптятся, но обвязка, которую вы строите вокруг них, включая промпты, определяет, сколько из этой обученной способности вы реально снимете. Соберите маленькую версию сами когда-нибудь. Одиннадцать часов программирования по курсу — недорогая цена за то, чтобы больше никогда не путаться в этом вопросе.