Последовательное рассуждение — это тупик масштабирования. Каждый дополнительный токен reasoning увеличивает задержку линейно, а накопление промежуточных путей exploration приводит к context-rot: модель теряет способность различать полезный сигнал от шумных distractor-токенов в длинном контексте. На задачах, требующих миллионов токенов планирования, пользователи ждут десятки минут — и это только начало проблемы.

Исследователи из UC Berkeley (BAIR Blog) разобрали новую парадигму — Adaptive Parallel Reasoning (APR), где модель сама решает, когда разветвить reasoning на независимые параллельные потоки, сколько нитей запустить, и как синтезировать результаты обратно в единый ответ. Это не форсированный tree-of-thoughts с жёстко заданной структурой, а выученное поведение: модель сама выбирает control flow между сериальным и параллельным мышлением в зависимости от сложности задачи.

Почему последовательность не работает на сложных задачах

Представьте, что модель решает арифметику «25+42» и одновременно пытается найти минимальную планарную область для непрерывного поворота единичного отрезка на 180°. Фреймворк, применяющий одинаковую параллельную структуру к обеим задачам, тратит compute впустую на первую и, скорее всего, использует неверную стратегию декомпозиции для второй.

Проблема не в параллелизации как таковой — она давно известна как решение. Вопрос в адаптивности. BoN (Best of N) запускает одинаковые запросы N раз — это избыточно. Tree-of-Thoughts требует domain-specific heuristics для декомпозиции. APR убирает оба ограничения: модель учится из trial-and-error в RL, обнаруживая паттерны вроде «запустить следующий шаг вместе с self-verification предыдущего» или «параллельно hedging основного подхода с backup» — emergent behaviors, которые сложно спроектировать вручную.

Две школы реализации: engine-modifying vs engine-agnostic

На практике параллельная генерация создаёт проблему при агрегации. Независимые потоки начинаются с одинаковых position IDs, что приводит к encoding overlap при merge KV cache. Плюс, потоки не attend друг к другу — значит, конкатенированный KV cache даёт non-causal attention pattern, которого базовая модель не видела при обучении.

Multiverse (Yang et al., 2025) и родственные работы (Parallel-R1, NPR) модифицируют inference engine. Они копируют KV cache каждого потока и редактируют page table, сшивая non-contiguous memory blocks в единую последовательность. Это позволяет избежать redundant prefill, но создаёт fragility: другой запрос может evict referenced KV cache до завершения synthesis-запроса. Плюс, stitched sequence получает нестандартное позиционное кодирование — модель не pretraining на таком, требуется extensive training с модифицированной attention mask, чтобы синхронизировать training и inference behavior. Multiverse вынужден ограничивать batch size, что снижает throughput.

ThreadWeaver (Lian et al., 2025) идёт противоположным путём: inference engine остаётся нетронутым, оркестрация на стороне клиента. Fork идентичен Multiverse, но join работает иначе — клиент конкатенирует текстовые outputs всех branches в одну contiguous sequence, затем engine выполняет второй prefill для генерации KV cache финального шага. Префилл значительно дешевле декодинга, поэтому computational redundancy приемлема. Главный бонус: второй prefill использует causal attention (потоки видят друг друга), что совместимо со стандартной autoregressive подготовкой модели. Engine-agnostic дизайн означает, что метод работает с любым inference engine и получает выгоду от будущих улучшений движка.

Как обучить модель параллельному мышлению

Демонстраций через instruction-following недостаточно — базовые модели не умеют спонтанно генерировать параллельные потоки. SFT учит синтаксису (как структурировать запросы со специальными токенами), но есть дебаты: Parallel-R1 и NPR утверждают, что SFT-демонстрации просто индуцируют format following, а не фундаментальную reasoning capability.

Настоящая проблема — incentive. Если награждать только за accuracy, параллелизация не emerges стабильно. Если награждать за количество потоков — модель спамят короткими бесполезными ветками. Parallel-R1 попробовал alternating-schedule (награждать структуру только 20% времени): использование параллелизма выросло с 13.6% до 63%, но accuracy почти не изменилась.

Решение — Pareto-optimal reward. ThreadWeaver определяет parallelization reward как 1 - L_critical / L_total, где L_critical — длина критического пути (самой длинной causally-dependent последовательности токенов), а L_total — общее количество сгенерированных токенов. Для сериальной траектории это 0; чем больше критический путь становится малой долей от общего compute, тем выше награда. Ключевой принцип: параллелизация награждается только при корректном ответе. Формально, R = 1(Correctness) + 1(Correctness) × parallelization_metric. Если модель не может решить задачу, мы не хотим навязывать ей constraints на структуру — сначала accuracy, потом эффективность.

Тренировочная инфраструктура использует prefix-tree (trie) организацию данных. Параллельную траекторию разворачивают в единую последовательность, применяя ancestor-only attention mask: каждая thread condition-на только prompt+subtasks, без visibility на sibling threads или финальный conclusion. Это имитирует inference behavior в training time, позволяя одному batch-у обрабатывать всю разветвленную структуру.

Результаты и открытые вопросы

Сравнение методов осложняется различиями в setup. Multiverse использует Qwen2.5 32B для SFT на graduate-level задачах (s1k dataset содержит задачи уровня магистратуры по математике и естественным наукам) — это необходимо для capturing сложной reasoning структуры в solution trajectories. RL-методы работают с 4B–8B non-CoT instruct моделями из-за compute constraints: RL требует многократных rollout, что делает большие модели prohibitively expensive для experimentation.

Каждая работа оптимизирует немного разные objectives и использует разные метрики — это отвлечённая проблема benchmarking в молодой области. Некоторые измеряют wall-clock time, другие — total token count, третьи — критический путь. Без стандартизированного evaluation framework прямое сравнение чисел из разных papers затруднительно.

Открытые вопросы касаются фундаментальной природы параллелизма. Parallel-R1 показывает, что diversity, индуцированная параллельной структурой во время RL, может быть важнее самого параллелизма при inference. Это наводит на мысль, что APR работает скорее как training-time exploration scaffold, а не inference-time technique. Кроме того, модели стабильно коллапсируют обратно к сериальному reasoning, когда parallelization rewards ослабляются — после 200 шагов без награды за параллелизм модель возвращается к последовательному поведению. Это training stability issue, reward design issue, или свидетельство того, что параллельная структура конфликтует с autoregressive prior из pretraining?

Engine-agnostic дизайн означает, что метод работает с любым inference engine и получает выгоду от будущих улучшений движка.

KV cache management: RadixAttention и prefix sharing

При параллельной генерации возникает проблема эффективного управления KV cache. Каждый поток начинается с общего prefix sequence (списка подзадач), и без оптимизации каждый поток должен префиллить и пересчитывать KV cache для этого prefix. Это избыточность.

SGLang's RadixAttention решает эту проблему, организуя множественные запросы в radix tree (prefix tree) — структуру данных, где последовательности элементов переменной длины хранятся вместо единичных элементов. Таким образом, единственные новые KV cache entries происходят от независимой генерации потоков. Общий prefix вычисляется один раз и разделяется между всеми branches.

Multiverse идёт дальше, переиспользуя KV cache независимых потоков во время synthesis stage. Они копируют KV cache каждого потока и редактируют page table, сшивая non-contiguous memory blocks в единую KV cache последовательность. Это позволяет избежать redundant prefill второго шага. Однако такой подход создаёт fragility: если другой запрос приходит и evict referenced KV cache до завершения synthesis request, система вынуждена остановиться и пере-префиллить предыдущий thread request. Multiverse решает это ограничением batch size, что снижает throughput.

Практический смысл для инженеров

Для deployment APR означает сдвиг от static batching к dynamic compute allocation. Вместо фиксированного max_tokens на запрос, система должна отслеживать critical path и балансировать между exploration (параллельные ветки) и exploitation (синтез результата). Engine-agnostic подходы типа ThreadWeaver проще внедрить — они не требуют кастомных inference engine модификаций, работают через стандартный API с client-side orchestration.

Стоит обратить внимание на RadixAttention — эту оптимизацию можно применять уже сегодня даже без полной реализации APR. Если ваш сервис обрабатывает batch запросов с общим system prompt или few-shot примерами, radix tree сократит префилл на 40–60%. SGLang реализует это из коробки; vLLM и TGI тоже добавляют поддержку prefix caching.

Для исследователей APR открывает новое измерение в scaling laws: если раньше мы масштабировали параметры, данные и sequence length, теперь добавляется четвёртая ось — степень параллелизации reasoning. Оптимальное распределение compute между сериальным и параллельным мышлением, вероятно, зависит от task complexity, и обучение этой адаптивности — следующая граница inference-time scaling.

Часто задаваемые вопросы

Чем APR отличается от Tree-of-Thoughts?

Tree-of-Thoughts использует заранее заданные domain-specific эвристики для декомпозиции задачи на подзадачи. APR не требует ручного дизайна структуры — модель учится декомпозировать из trial-and-error в reinforcement learning, обнаруживая паттерны параллелизации emergent-образом. Плюс APR может выбрать не параллелить вовсе, если задача слишком проста.

Почему модели коллапсируют обратно к сериальному reasoning без параллелизационной награды?

Parallel-R1 показал: если убрать reward за параллелизацию после 200 шагов RL, модель возвращается к последовательному мышлению. Это может отражать конфликт между параллельной структурой и autoregressive prior из pretraining — модель обучалась генерировать токены строго слева направо, и параллельные ветки требуют нетривиального переучивания. Альтернативное объяснение: параллелизация — это learned skill, который требует постоянной подкрепляющей стимуляции, иначе модель откатывается к simpler policy.

Можно ли применить APR к существующим моделям без перетренировки?

Нет. APR требует как минимум SFT на демонстрациях параллельных траекторий (чтобы модель выучила синтаксис специальных токенов fork/join), плюс RL для формирования incentives. Engine-agnostic инференс (ThreadWeaver) не требует модификации движка, но сама модель должна быть обучена генерировать параллельные структуры. Retrofitting к замороженной модели невозможен — это не inference-time trick, а learned capability.

Итог

Adaptive Parallel Reasoning — это не просто «запустить несколько потоков и выбрать лучший». Это парадигма, где модель сама становится архитектором собственного вычислительного графа, динамически решая, когда сериальное мышление достаточно, а когда нужна параллельная exploration. Два конкурирующих подхода (engine-modifying Multiverse vs engine-agnostic ThreadWeaver) отражают фундаментальный trade-off между inference efficiency и deployment simplicity. Для индустрии это означает, что следующие поколения reasoning models будут масштабироваться не только длиной context, но и шириной параллелизма — и обучение этой адаптивности станет следующим конкурентным преимуществом.