Масштабирование рассуждений LLM¶

~8 минут чтения

URL: Sebastian Raschka, arXiv, OpenReview, Adaline Labs, GitHub Тип: reasoning-scaling / o1 / o3 / test-time-compute / mcts / deepseek-r1 Дата: Февраль 2026 Сбор: Ralph Research ФАЗА 5

Предварительно: Реализация внимания с нуля

Зачем это нужно¶

Обычный способ улучшить LLM -- увеличить модель (больше параметров = лучше). Test-Time Scaling (TTS) переворачивает подход: вместо огромной модели, маленькой модели дают больше "времени на размышление" при инференсе. o1 решает AIME 2024 на 74% (vs 13% у GPT-4o), потому что генерирует длинные цепочки рассуждений и проверяет себя на каждом шаге. DeepSeek R1 показал, что reasoning можно получить чистым RL без человеческих аннотаций -- и выложил модель под MIT лицензией. Ключевой вопрос 2026: как оптимально распределить compute между тренировкой и инференсом.

Part 1: Overview¶

Executive Summary¶

Key Insight:

"Inference-time scaling has become one of the most effective ways to improve answer quality in deployed LLMs." Test-Time Scaling (TTS) decouples reasoning quality from parameter count by allocating more compute during inference. o1/o3 models and DeepSeek R1 represent the new paradigm where "thinking time" matters as much as model size.

2026 Reasoning Scaling Landscape:

Method	Compute At	Model Examples	Key Technique
o1/o3	Test-time	OpenAI o1, o3	Chain-of-thought scaling
DeepSeek R1	Train + test	DeepSeek R1	Pure RL + TTS
MCTS-based	Test-time	Research models	Tree search
Best-of-N	Test-time	Many models	Sampling + verifier

Part 2: Test-Time Scaling (TTS) Paradigm¶

Core Concept¶

Traditional: Bigger model = better reasoning TTS Paradigm: More inference compute = better reasoning

	Traditional Scaling	Test-Time Scaling
Что растет	Размер модели	Compute при инференсе
Инференс	Фиксированный	Адаптивный к сложности
Модель	Должна быть огромной	Может быть компактной
Философия	"Больше параметров = умнее"	"Больше думаешь = умнее"

TTS Trade-off¶

\[\text{Total Compute} = C_{\text{train}} + C_{\text{inference}}\]

TTS shifts compute from training to inference: - Smaller models with more inference steps - Adaptive compute based on problem difficulty - Better ROI for variable difficulty workloads

Part 3: OpenAI o1/o3 Architecture¶

Overview¶

Model	Release	Focus	Key Innovation
o1	2024	Reasoning	Chain-of-thought scaling
o3	2025	Advanced reasoning	TTS + reflective generation

o1/o3 Mechanism¶

graph TD
    IN["Input: Problem"] --> GEN["Generate Reasoning Chain<br/>- Несколько шагов рассуждений<br/>- Self-correction на лету<br/>- Длина зависит от сложности"]
    GEN --> VER["Verify Intermediate Steps<br/>- Логическая консистентность<br/>- Раннее обнаружение ошибок"]
    VER -->|"Ошибка найдена"| GEN
    VER -->|"Все верно"| OUT["Output: Final Answer<br/>(reasoning скрыт от пользователя)"]

    style IN fill:#e8eaf6,stroke:#3f51b5
    style GEN fill:#fff3e0,stroke:#ef6c00
    style VER fill:#f3e5f5,stroke:#9c27b0
    style OUT fill:#e8f5e9,stroke:#4caf50

Ключевой принцип: больше compute для сложных задач, меньше -- для простых.

o1/o3 Performance¶

Benchmark	GPT-4o	o1	o3
AIME 2024	13.4%	74.4%	96.4%
Codeforces	11^th %ile	89^th %ile	98^th %ile
GPQA Diamond	53.6%	78.0%	87.7%
SWE-Bench	33.0%	48.9%	72.8%

Part 4: DeepSeek R1¶

Overview¶

Aspect	Details
Developer	DeepSeek
Release	2025
Training	Pure RL (no human reasoning traces)
License	MIT

DeepSeek R1 Training¶

Traditional Reasoning Models: Labeled reasoning traces → SFT → RLHF. Нужны дорогие аннотации цепочек рассуждений.

DeepSeek R1: Base Model → Pure RL → Emergent Reasoning. Три ключевых отличия:

Не нужны аннотированные reasoning traces -- только reward signal
Reasoning возникает сам из RL-оптимизации (emergent behavior)
Дистилляция в маленькие модели сохраняет ~75-90% качества

DeepSeek R1 Capabilities¶

Capability	Description
Self-correction	Catches and fixes own errors
Long-horizon reasoning	Multi-step problem solving
Code reasoning	Programming + logic combined
Distillation	Transfer to smaller models

DeepSeek R1 Distillation¶

Model	Size	Performance Retention
DeepSeek-R1	671B (MoE)	100%
DeepSeek-R1-Distill-Qwen-32B	32B	~90%
DeepSeek-R1-Distill-Llama-8B	8B	~75%

Part 5: Search Methods (MCTS, Tree Search)¶

Monte Carlo Tree Search (MCTS)¶

State: текущее частичное решение / цепочка рассуждений. Action: следующий токен / шаг мысли.

Четыре фазы MCTS:

Selection -- выбрать перспективный узел (UCB)
Expansion -- добавить дочерние узлы (новые ветви рассуждений)
Simulation -- rollout до терминального состояния
Backpropagation -- обновить оценки узлов

Upper Confidence Bound (UCB)

\[\text{UCB}(v) = Q(v) + c \cdot \sqrt{\frac{\ln N}{n(v)}}\]

Где \(Q(v)\) -- средний reward узла, \(N\) -- число посещений родителя, \(n(v)\) -- число посещений узла, \(c\) -- exploration constant. Баланс exploitation (высокий \(Q\)) и exploration (малый \(n\)).

Search Methods Comparison¶

Method	Exploration	Compute	Best For
MCTS	Balanced	High	Complex reasoning
Best-of-N	Random	Medium	Verifiable tasks
Beam Search	Greedy	Low	Translation
BFS	Exhaustive	Very High	Short problems
DFS	Deep	Variable	Hierarchical tasks

Forest-of-Thought (ICML 2025)¶

Ключевая идея: несколько деревьев рассуждений + sparse activation.

Генерировать N деревьев рассуждений параллельно
Sparse activation: использовать только перспективные пути (отсечь тупиковые)
Агрегация результатов из разных деревьев для финального ответа

Эффективность: \(O(N \times \text{depth}) \rightarrow O(k \times \text{depth})\), где \(k \ll N\). Точность выше single-tree подходов.

Part 6: Best-of-N with Verifiers¶

Best-of-N Mechanism¶

graph TD
    IN["Input: Problem"] --> GEN["Генерация N кандидатов<br/>s_1, s_2, ..., s_N (параллельно)"]
    GEN --> SCORE["Оценка верификатором<br/>V(s_1), V(s_2), ..., V(s_N)"]
    SCORE --> OUT["Output: argmax_i V(s_i)<br/>Лучшее решение по оценке"]

    style IN fill:#e8eaf6,stroke:#3f51b5
    style GEN fill:#fff3e0,stroke:#ef6c00
    style SCORE fill:#f3e5f5,stroke:#9c27b0
    style OUT fill:#e8f5e9,stroke:#4caf50

Compute: \(O(N \times C_{\text{gen}} + N \times C_{\text{verify}})\) -- линейно от числа кандидатов.

Verifier Types¶

Verifier	Description	Training
ORM	Outcome Reward Model	Final answer correctness
PRM	Process Reward Model	Step-by-step verification
LLM-as-Judge	Another LLM evaluates	Prompt-based

PRM vs ORM¶

Aspect	ORM	PRM
Granularity	Final answer	Each step
Training data	Answer labels	Step annotations
Compute	Lower	Higher
Accuracy	Good for verifiable	Better for reasoning

Part 7: Compute-Optimal TTS¶

Strategy Selection¶

\[\text{Optimal Strategy} = f(\text{Policy Model}, \text{PRM}, \text{Problem Difficulty})\]

Research shows: - Easy problems: Best-of-N efficient - Hard problems: Tree search better - Model size matters: Larger models benefit more from TTS

Compute Allocation¶

Problem Difficulty	Recommended Strategy	N (samples)
Easy	Best-of-N	4-8
Medium	Best-of-N + PRM	16-32
Hard	MCTS or TTS	64-256

Adaptive Compute¶

Логика: если confidence(output) > threshold -- вернуть ответ (мало compute). Иначе -- увеличить compute (больше samples / глубже поиск) и повторить.

Ключевой инсайт: средний compute ниже, чем при фиксированном TTS, а качество сохраняется -- простые задачи решаются быстро, сложные получают больше ресурсов.

Part 8: Practical Implementation¶

FastTTS (Edge LLMs)¶

Aspect	Details
Focus	Accelerating TTS for edge devices
Innovation	Efficient compute allocation
Trade-off	Slightly lower accuracy for faster inference

Implementation Patterns¶

# Best-of-N with PRM
def best_of_n_with_prm(model, prm, problem, n=16):
    candidates = [model.generate(problem) for _ in range(n)]
    scores = [prm.score(problem, c) for c in candidates]
    return candidates[argmax(scores)]

# Adaptive TTS
def adaptive_tts(model, verifier, problem, max_compute=64):
    for n in [4, 16, 64]:
        candidates = [model.generate(problem) for _ in range(n)]
        best = max(candidates, key=lambda c: verifier.score(c))
        if verifier.confidence(best) > 0.9:
            return best
    return best  # Return best after max compute

Part 9: Comparison Matrix¶

Method Comparison¶

Feature	o1/o3	DeepSeek R1	MCTS	Best-of-N
Train compute	High	Medium	Low	Low
Inference compute	Variable	Variable	High	Medium
Needs verifier	Internal	Internal	Yes	Yes
Best for	General	Code/Math	Complex	Verifiable
Open source	No	Yes	Yes	Yes

Performance vs Compute¶

Method	Low Compute	Medium Compute	High Compute
Standard	Baseline	Baseline	Baseline
Best-of-N	+5-10%	+10-15%	+15-20%
MCTS	+5-8%	+15-25%	+20-35%
o1-style TTS	+10-15%	+20-30%	+30-50%

Part 10: Interview-Relevant Numbers¶

Compute Scaling¶

Model	Baseline Tokens	TTS Tokens	Quality Gain
GPT-4o	4K	N/A	Baseline
o1	4K	4K-100K	+30-50%
o3	4K	4K-1M	+50-80%

Best-of-N Efficiency¶

N	Accuracy Gain	Compute Cost
1	Baseline	1x
4	+5-10%	4x
16	+10-15%	16x
64	+15-20%	64x

TTS vs Model Size¶

Strategy	7B Model	70B Model	700B Model
Standard	45%	65%	75%
Best-of-16	55%	75%	82%
TTS (adaptive)	60%	80%	88%

DeepSeek R1 Benchmarks¶

Benchmark	DeepSeek R1	o1	GPT-4o
MATH-500	97.3%	96.4%	76.6%
AIME 2024	79.8%	74.4%	13.4%
Codeforces	96.3%	89.0%	11.0%

Gotchas¶

TTS не всегда помогает

На простых задачах TTS вреден: дополнительный compute не улучшает результат, а только увеличивает latency и стоимость. Best-of-4 на простой задаче даёт +2-3% accuracy при 4x стоимости. Adaptive compute решает проблему: сначала пробуй дёшево, увеличивай только если confidence низкий.

DeepSeek R1 -- это не o1

Часто их объединяют как "reasoning models", но механизмы разные. o1 обучен через SFT на аннотированных reasoning traces + RLHF. DeepSeek R1 -- чистый RL без человеческих аннотаций, reasoning возникает emergently. Практическое следствие: R1 open-source (MIT), o1 закрыт; R1 дистиллируется в маленькие модели с ~75-90% retention.

PRM дорог в обучении

Process Reward Model требует пошаговых аннотаций (каждый шаг рассуждения размечен как верный/неверный). Это в 10-50x дороже разметки финальных ответов для ORM. На практике часто используют ORM + Best-of-N как baseline, а PRM -- только для сложных задач где step-by-step verification критичен.

Interview Q&A¶

Q: Объясните разницу между Test-Time Scaling и обычным Chain-of-Thought промптингом.

Red flag: "Это одно и то же -- модель думает пошагово"

Strong answer: "CoT промптинг -- это техника промпта ('Let's think step by step'), она не меняет количество compute. TTS -- это парадигма, где модель получает адаптивный бюджет compute при инференсе. o1 может сгенерировать 100K токенов внутренних рассуждений на сложную задачу vs 4K у GPT-4o. TTS включает CoT, но также tree search (MCTS), Best-of-N с верификаторами, и adaptive compute allocation."

Q: Как бы вы выбрали стратегию TTS для production системы?

Red flag: "Всегда использовать максимальный compute для лучшего результата"

Strong answer: "Зависит от задачи. Easy: Best-of-N с N=4-8, параллелизуемо и дёшево. Medium: Best-of-N + PRM с N=16-32. Hard: MCTS или o1-style TTS с N=64-256. Ключевое -- adaptive compute: если confidence > 0.9 после первых 4 samples, стоп. Это снижает средний compute на 60-70% vs фиксированного бюджета. Также TTS линейно масштабирует inference cost, нужен ROI анализ."

Q: Почему DeepSeek R1 -- это прорыв?

Strong answer: "Три причины: (1) Reasoning из чистого RL без human reasoning traces -- доказывает что reasoning может быть emergent behavior, не требуя дорогих аннотаций. (2) Дистилляция: 32B модель сохраняет ~90% качества 671B MoE, делая reasoning доступным на consumer hardware. (3) MIT лицензия -- первая open-source reasoning model на уровне o1. На MATH-500 R1 обходит o1 (97.3% vs 96.4%)."

Sources¶

Sebastian Raschka — "Categories of Inference-Time Scaling" (Jan 2026)
arXiv — "Scaling LLM Reasoning via Test-time Policy Evolution" (2601.20379)
arXiv — "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs" (2501.12948)
OpenReview — "Test-Time Scaling with Reflective Generative Model" (o3)
ICML 2025 — "Forest-of-Thought: Scaling Test-Time Compute"
Adaline Labs — "What is Test-time Scaling?"
arXiv — "FastTTS: Accelerating Test-Time Scaling" (2509.00195)
GitHub — "Awesome-Inference-Time-Scaling" (curated papers)
Medium — "How LLM Reasoning Powers the Agentic AI Revolution" (Jan 2026)
Shanghai AI Lab — "Compute-Optimal Test-Time Scaling"