Последовательное рассуждение это тупик масштабирования. Каждый дополнительный токен 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, но и шириной параллелизма, и обучение этой адаптивности станет следующим конкурентным преимуществом.