ReJump: типы действий в рассуждениях LLM и баланс разведки-использования

Когда LLM рассуждает, она делает три типа действий:

1. calc (вычисление) — генерирует новый промежуточный шаг, двигается вперёд
2. verify (проверка) — возвращается к уже найденному шагу, чтобы проверить правильность
3. backtrack (откат) — понимает что зашла в тупик, возвращается назад и пробует другой путь

Jump distance (расстояние прыжка) — сколько шагов по дереву между двумя последовательными попытками решения. Если модель нашла "12 + 11 = 23", потом "23 + 1 = 24" — расстояние маленькое (exploitation, углубление в один путь). Если нашла "12 + 11 = 23", потом откатилась к началу и попробовала "12 × 3 = 36" — расстояние большое (exploration, пробует разные ветки).

Exploration (разведка) — модель пробует много разных подходов, высокий jump distance.

Exploitation (использование) — модель углубляется в один подход, низкий jump distance.

1. Модели с одинаковой точностью думают по-разному

На одной задаче Game of 24 три модели дали правильный ответ, но: - Claude 3.7 Sonnet: линейный путь, ноль проверок, принял первый найденный ответ - Grok 3 Mini Beta: линейный путь, но после нахождения ответа проверил его - DeepSeek-R1: попробовал несколько веток, откатывался назад, проверял промежуточные шаги

2. Разные задачи требуют разного баланса exploration-exploitation

Исследователи обучили XGBoost предсказывать правильность решения по метрикам рассуждений. Оказалось: - Для Game of 24 (комбинаторная задача) самый важный фактор — высокий jump distance (exploration). Нужно пробовать много комбинаций. - Для MATH-500 (последовательная математика) самый важный — высокий success rate (exploitation). Нужна точность на каждом шаге, а не разнообразие путей.

3. LRM vs обычные LLM

Модели, обученные на reasoning (DeepSeek-R1, QwQ-32B), показывают больше deliberate behaviors (осознанных действий): чаще делают verify и backtrack, генерируют больше разных решений (#solution выше). Обычные модели с Chain-of-Thought промптом идут более линейно.

4. Distillation сохраняет стиль рассуждений

Distilled модели (обученные на выходах учителя) копируют не только точность, но и reasoning behavior учителя — похожий exploration-exploitation баланс, verification rate.

Сам инструмент ReJump требует LLM API для парсинга reasoning traces, но принципы можно применить через текстовые инструкции.

Задача: Придумать концепцию для подкаста про российский стартап-рынок, которая зайдёт аудитории Telegram-каналов про венчур и технологии.

Промпт:

Задача: {концепция подкаста про российские стартапы}

Требования к процессу рассуждений:
1. Сгенерируй 5-7 РАЗНЫХ подходов к концепции (exploration)
2. Для каждого подхода сделай 2-3 шага развития идеи
3. Если подход кажется слабым — явно скажи "откатываюсь" и пробуй другое направление (backtracking)
4. Не углубляйся в один вариант больше чем на 3 шага — переключайся на следующий
5. После генерации всех вариантов — вернись к каждому и проверь: "Почему это зайдёт аудитории?" (verification)

Покажи процесс: какой подход пробуешь, когда откатываешься, когда проверяешь.

Результат: Модель покажет несколько разных концепций (например: "интервью с фаундерами", "разбор failed кейсов", "венчурный инвестор в роли детектива", "сравнение US vs RU практик"), явно откатится от слабых идей, вернётся к сильным для проверки гипотез.

Задача: Рассчитать unit-экономику SaaS-сервиса: CAC 15000₽, ARPU 3000₽/мес, churn 5%/мес. Когда окупится когорта?

Промпт:

Задача: {расчёт окупаемости когорты}

Требования к процессу рассуждений:
1. Иди по ОДНОМУ пути решения, шаг за шагом (exploitation)
2. После каждого шага — проверь: "Правильно ли я посчитал? Какие единицы измерения?" (verification)
3. Если обнаружил ошибку — откатись к ошибочному шагу, исправь, продолжи (backtracking при необходимости)
4. НЕ пробуй альтернативные методы, фокусируйся на точности текущего
5. Остановись сразу после получения правильного ответа (no overthinking)

Покажи каждый шаг и проверку.

Результат: Модель последовательно рассчитает LTV, затем LTV/CAC, проверит каждый шаг (единицы измерения, формулы), даст точный ответ без лишних вариаций.

Задача: {твоя задача}

Настройки рассуждений:
- Exploration level: {низкий/средний/высокий}
  * Низкий: иди по одному пути, не отвлекайся
  * Средний: попробуй 2-3 разных подхода
  * Высокий: генерируй 5+ разных вариантов, активно переключайся

- Verification: {каждый шаг / только финал / без проверки}
  * Каждый шаг: после каждого промежуточного результата проверяй правильность
  * Только финал: проверь только итоговый ответ
  * Без проверки: просто выдай решение

- Backtracking: {агрессивный / умеренный / избегай}
  * Агрессивный: при малейших сомнениях откатывайся и пробуй иначе
  * Умеренный: откатывайся только при явных ошибках
  * Избегай: доводи начатый путь до конца

- Stop condition: {первое правильное решение / все варианты / глубина N}

Покажи процесс: что пробуешь, когда проверяешь, когда откатываешься.

Как заполнять: - {твоя задача} — конкретная задача - Exploration level — зависит от задачи: комбинаторика/brainstorming = высокий, математика/логика = низкий - Verification — если нужна точность = каждый шаг, если скорость = только финал - Backtracking — если дорогой cost ошибки = агрессивный, если дёшево попробовать разное = умеренный - Stop condition — если нужно одно решение = первое правильное, если нужны варианты = все варианты

1. LLM не различает "типы действий" по умолчанию

Модель генерирует текст последовательно, не понимая "сейчас я проверяю" vs "сейчас я генерирую новое". Явная инструкция "после каждого шага проверяй" или "если застрял, откатись" создаёт структуру, которая меняет поведение.

2. Разные задачи действительно требуют разного подхода

Если задача комбинаторная (Game of 24, brainstorming, поиск багов) — высокий exploration помогает, модель не застревает на первом неправильном пути. Если задача последовательная (математика, логические выводы) — высокий exploitation помогает, модель не распыляется.

3. Verification экономит токены на длинных reasoning traces

Модель без проверки может пройти 50 шагов по неправильному пути. Модель с проверкой "каждые 5 шагов вернись и проверь логику" поймает ошибку раньше.

Рычаги управления:

⚠️ Нет гарантии выполнения: Текстовые инструкции "делай exploration" не дают точного контроля как программный код. Модель может интерпретировать по-своему.

⚠️ Токены: Высокий exploration = длинные reasoning traces = дороже. На GPT-4/Claude может быть неподъёмно для сложных задач.

⚠️ Работает не на всех моделях: Слабые модели (< GPT-3.5 уровня) плохо следуют сложным инструкциям о процессе рассуждений. Это для frontier models (GPT-4, Claude 3+, DeepSeek, QwQ).

⚠️ Сам инструмент ReJump недоступен без кода: Для построения дерева, подсчёта метрик, визуализации нужен LLM API (Gemini 2.5 Pro) + код для парсинга. Обычный юзер может применить только принципы через текст, но не измерить "jump distance = 4.2" или "verification rate = 0.3".

⚠️ Не заменяет структурированные методы: Если нужен гарантированный exploration — лучше Tree-of-Thoughts или Best-of-N sampling. Текстовая инструкция "попробуй 5 вариантов" мягче чем явный branching.

Команда из UW-Madison и Microsoft Research создала LLM-агента ReJump-Extractor на базе Gemini 2.5 Pro, который парсит reasoning traces (текст рассуждений модели) в два слоя: tree layer (дерево промежуточных шагов, каждый узел = подзадача + её решение) и jump layer (последовательность переходов между узлами с типами: calc/verify/backtrack).

Проверили надёжность на 82 вручную размеченных примерах Game of 24 (similarity с ground truth > 0.94) и human evaluation на MATH-500 (80%+ accuracy после одного прогона, 90%+ после трёх попыток extraction).

Протестировали 5 frontier моделей (DeepSeek-R1, QwQ-32B, Grok 3 Mini Beta, Phi-4-reasoning-plus, Claude 3.7 Sonnet) на MATH-500 (математические задачи школьного уровня, обычно 1-2 пути решения) и Game of 24 (комбинаторная задача: составь 24 из четырёх чисел через +−×÷, много путей). Для каждого reasoning trace построили ReJump и посчитали метрики.

Почему результаты получились такими: На Game of 24 все модели показали высокий #solution (много попыток) и высокий jump distance (exploration), потому что задача комбинаторная — нужно пробовать разные комбинации операций. На MATH-500 наоборот — низкий #solution и низкий jump distance (exploitation), потому что задачи имеют чёткую последовательность шагов, и блуждание между ветками вредит.

Удивительное: Даже при одинаковой final accuracy модели показывают радикально разное reasoning behavior. DeepSeek-R1 делает 0.15-0.20 verification rate (каждый 5-7 переход — проверка), Claude 3.7 Sonnet делает ~0.05 (почти не проверяет). Phi-4-reasoning-plus на Game of 24 делает самый высокий exploration (jump distance), но не самый высокий accuracy — exploration помогает, но не гарантирует.

Инсайт для практики: Если твоя задача как Game of 24 (нужно найти редкую комбинацию из множества вариантов) — проси модель "попробуй разные подходы, откатывайся если не работает". Если как MATH-500 (последовательная цепочка шагов) — проси "иди по одному пути, тщательно проверяя каждый шаг". Универсального "лучшего стиля" нет, зависит от структуры задачи.

Добавь в промпт:

После каждого действия выводи:
- [CALC] — если генерируешь новый шаг
- [VERIFY] — если проверяешь уже найденное
- [BACKTRACK] — если откатываешься назад

Это создаёт transparency: ты видишь не только что модель думает, но и какой тип действия она делает. Помогает отлаживать когда модель уходит не туда.

Если модель уходит в бесконечный exploration (особенно DeepSeek-R1, QwQ-32B на открытых задачах):

Лимиты:
- Максимум 3 разных подхода (exploration cap)
- Максимум 5 шагов на каждый подход (depth cap)
- После нахождения правильного решения — СТОП, не проверяй дальше (no overthinking)

Это trade-off: меньше diversity, но дешевле и быстрее.

Если нужно высокое качество и готов потратить токены:

Сгенерируй 5 решений для задачи: {задача}

Для каждого решения покажи:
1. Сколько разных подходов попробовал (exploration count)
2. Сколько раз проверял промежуточные шаги (verification count)
3. Сколько раз откатывался назад (backtracking count)

Затем выбери решение с {критерием}:
- Для комбинаторных задач: highest exploration count
- Для точных вычислений: highest verification count
- Для отладки: highest backtracking count (значит модель критично смотрела на решение)

Это аналог ReJump-guided Best-of-N из исследования, но без построения дерева — выбор по явным маркерам процесса.

ReJump: A Tree-Jump Representation for Analyzing and Improving LLM Reasoning (Preprint, 2025)

Yuchen Zeng, Shuibai Zhang, Wonjun Kang, et al. — UW-Madison, Microsoft Research, FuriosaAI, Seoul National University, KRAFTON

Код: https://github.com/UW-Madison-Lee-Lab/ReJump

Упомянутые методы: Tree-of-Thoughts (Yao et al., 2023), Chain-of-Thought prompting (Wei et al., 2022), RL from Verifiable Rewards (Guo et al., 2025)