Reasoning Models 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 范式转移：以前 scale 训练算力（参数 + 数据），现在 scale 推理算力（reasoning tokens / search / verification）。Snell et al. 2024 (arXiv 2408.03314) 给出 compute-optimal test-time scaling 配方：相同推理 FLOPs 下，best-of-N + PRM beam search + sequential revision 的混合策略比单一 best-of-N 高 >4× 效率；FLOPs-matched 设置下，小模型 + 优化 test-time compute 在某些任务上能匹配/超过 14× 更大的模型。
2. o1 (OpenAI Sep 2024)：用 RL 训练 hidden chain-of-thought，API 只返回 reasoning_tokens 计数而非内容。o3 (Dec 2024) 在 ARC-AGI 上 75.7% (低算力) / 87.5% (高算力 172× 预算)——首次在抽象推理 benchmark 上接近人类。
3. DeepSeek-R1-Zero (arXiv 2501.12948, Jan 2025)：纯 RL 从 base model 直接训，无 SFT cold-start，rule-based reward（答案对/错 + 格式），用 GRPO（无 critic），涌现出 "aha moment"——模型自己学会反思、回溯、验证。
4. DeepSeek-R1：四阶段 pipeline = SFT 冷启动（数千高质 CoT）→ reasoning-oriented RL → rejection sampling + 通用 SFT → 全场景 RL。在 MATH-500、AIME 等数学/代码 benchmark 上对齐 o1。
5. GRPO（DeepSeekMath, arXiv 2402.03300）：去掉 critic value network；对每个 prompt sample $G$ 个回答 $\{o_i\}$，用 group-relative advantage $A_i = (r_i - \text{mean}(\mathbf{r})) / \text{std}(\mathbf{r})$ 替代 GAE。显存降一半 + 训练更稳。
6. PRM vs ORM：ORM（outcome reward）只评 final answer；PRM（process reward，Lightman 2023 "Let's Verify Step by Step"）对每个推理 step 打分，best-of-N 选 trace 上更优。Math-Shepherd (Wang et al. 2023, arXiv 2312.08935) 从中间 step 采样 Monte Carlo completion rollouts（不是 MCTS tree search），用最终答案的 soft/hard estimation 自动标 step label，省去人标。
7. s1 (Muennighoff Feb 2025, arXiv 2501.19393)："Wait" budget forcing——在 </think> 处强行追加 "Wait" 让模型继续思考，1K 样本 SFT + 推理控制超 o1-preview 27% (AIME24)。
8. 易踩坑：CoT ≠ 推理（模型可能 post-hoc 编故事）；self-consistency 在 distribution-shifted 题上崩；PRM 训练易过拟合 step pattern；GRPO 在 long-CoT 上 critic-free 反而是优势（critic 难学）。

§1 为什么这是 2024-2026 最大范式转移

1.1　从 train-time scaling 到 test-time scaling

2020-2023 的 scaling law (Kaplan, Hoffmann/Chinchilla)：性能 ∝ log(参数 × 数据 × FLOPs)——但这是 训练时算力。模型一旦训完，推理时算力是固定的（一次 forward）。

2024 出现两个 anomaly：

• OpenAI o1：花更多 inference tokens 思考 → 性能持续提升，呈现 log-linear scaling（OpenAI 公开的 figure：accuracy vs reasoning compute 是直线）
• Snell et al. 2024：固定 inference/test-time compute 预算下用 compute-optimal scaling（best-of-N + PRM beam search + sequential revision 混合），可让小模型在 FLOPs-matched 设置下 匹配甚至超过 14× 更大模型——前提是 base model 在该任务上已有 non-trivial success rate

• System 1（快）：一次 greedy decode = 一条路径
• System 2（慢）：multiple paths + verifier + backtrack = 树搜索（Tree-of-Thought）或长 CoT（o1）

把 LLM 当成 policy + value 的组合（像 AlphaZero），推理是 MCTS-like 的搜索过程。

1.2　Reasoning Model 的核心组件

       问题 prompt
           │
           ↓
   ┌───────────────────────────┐
   │   Policy LLM (sampler)    │ ← 生成 candidate reasoning traces
   │   - greedy / temperature  │
   │   - long CoT (o1, R1)     │
   │   - tree expansion (ToT)  │
   └───────────────────────────┘
           │  N traces
           ↓
   ┌───────────────────────────┐
   │  Verifier / Reward Model  │
   │  - ORM (outcome only)     │
   │  - PRM (per-step)         │
   │  - rule-based (math/code) │
   └───────────────────────────┘
           │
           ↓
   ┌───────────────────────────┐
   │  Aggregator               │
   │  - majority vote (SC)     │
   │  - best-of-N (verifier)   │
   │  - beam search (PRM)      │
   │  - MCTS (rStar)           │
   └───────────────────────────┘
           │
           ↓
       最终答案

不同 reasoning model 路线本质上是在这三个组件上做选择：

• o1 / R1：把 search 内化到 policy 里（long CoT 单次生成，policy 自己反思）
• ToT / rStar：外部显式 search（MCTS / BFS / beam）
• Best-of-N + PRM：sampling + verifier（最朴素的 test-time scaling）

§2 CoT 演进：从 Wei 2022 到 o1

2.1　Chain-of-Thought (Wei et al., NeurIPS 2022, arXiv 2201.11903)

核心发现：few-shot prompt 给模型展示 "step-by-step reasoning"，性能在大模型上（>62B PaLM）出现 emergent jump，GSM8K 从 18% → 57%。

Q: Roger has 5 tennis balls. He buys 2 more cans of tennis balls. Each can has 3 tennis balls. How many tennis balls does he have now?
A: Roger started with 5 balls. 2 cans of 3 balls each is 6 balls. 5 + 6 = 11.
The answer is 11.

关键点：

• 不是 fine-tune——纯 prompting，base model 已有能力
• emergence：小模型用 CoT 反而变差（噪声大于信号）
• 后续 Kojima et al. 2022 "Let's think step by step" 发现 zero-shot CoT 也能触发

2.2　Self-Consistency (Wang et al. 2022, arXiv 2203.11171)

观察：CoT decoding 是 stochastic（temperature > 0），同一题 sample 多次会得到不同推理路径，但正确答案往往更多次出现（如果模型能力足够）。

算法：

1. 对同一 prompt sample $N$ 条 CoT
2. 提取每条的 final answer
3. 多数投票 选 majority answer

$$\hat{y} = \arg\max_{y \in \mathcal{Y}} \sum_{i=1}^{N} \mathbb{1}[\text{extract}(\text{trace}_i) = y]$$

效果：GSM8K +17.9%（Wang et al. 报告的 PaLM-540B 数字）。

2.3　Tree of Thoughts (Yao et al., NeurIPS 2023, arXiv 2305.10601)

把 CoT 从 chain 升级成 tree：每个节点是一个 "thought"（一步推理），从根节点 BFS/DFS 展开多个候选 child，LLM 自己评分（"is this step promising?"），保留 top-k。

          root (problem)
           │
   ┌───────┼───────┐
  step1a  step1b  step1c        ← sample k thoughts
   │       ✗       ✗            ← LLM evaluator score
   │       prune  prune
   ├──────┼──────┐
 step2a step2b step2c           ← expand surviving node

Game of 24 (用 4 个数字 + 四则运算得到 24)：

• GPT-4 CoT: 4% 成功率
• GPT-4 ToT (b=5, depth=3): 74%——巨大跳变

2.4　从 ToT 到 long-CoT (o1 / R1 路线)

ToT 需要外部搜索框架（递归 prompt + state management）。o1 / R1 走另一条路：把 search 训练进 policy 里——单次长 CoT，但模型自己学会：

• "wait, let me reconsider..."
• "actually that's wrong, the correct way is..."
• "let me verify by trying a different approach"

这些回溯 / 反思 token 在 base model 里很罕见，靠 RL 反复采样 + reward 信号 才能放大成稳定行为。R1-Zero 报告的 "aha moment" 就是这种行为在 RL 训练中突然涌现的时刻。

§3 PRM vs ORM：reasoning verifier 的两条路线

3.1　定义

3.2　PRM800K (Lightman et al. 2023, arXiv 2305.20050)

OpenAI 在 MATH 数据集上人工标了 80 万个 step-level 标签：每个 step 是 positive / neutral / negative。

训练目标（per-step classification）：

$$\mathcal{L}_\text{PRM} = -\sum_{t=1}^{T} \log p_\phi(\ell_t \mid s_{\leq t})$$

其中 $\ell_t \in \{+, 0, -\}$，$s_{\leq t}$ 是前 $t$ 步推理。

推理时把 PRM 当 verifier：

$$\text{score}(\text{trace}) = \prod_{t} p_\phi(\ell_t = +\mid s_{\leq t}) \quad \text{或} \quad \min_t p_\phi(\ell_t = +\mid s_{\leq t})$$

（前者乘积形式更标准；min 形式更悲观但抓最弱步）

3.3　Math-Shepherd（Wang et al. 2023, arXiv 2312.08935）—— 自动标 step label

人标贵，怎么 scale？Math-Shepherd 思路：用 MCTS rollout 估每个 step 的"潜在正确率"。

对每个 step s_t（部分推理）：
  从 s_t 出发 rollout K 条 completion
  count 多少条最终 answer 正确
  reward_t = (正确数) / K

直觉：如果一个 step 是好的，从它出发往下走应该容易得到正确答案；如果是坏的，怎么走都错。

训练 PRM 用 Math-Shepherd 标签：MSE 回归或 BCE 分类。Mistral-7B 在 GSM8K 上 77.9% → 84.1%，无需人标。

3.4　Generative PRM 与 Critic LM

2024 后流行 "generative verifier"：把 PRM 当 next-token-prediction（"is this step correct? yes/no"），直接复用 LLM 架构，不用单独 reward head。代表作：Generative Verifiers (Zhang et al. 2024, arXiv 2408.15240)。优势：能利用 in-context reasoning 评分，比 scalar head PRM 更准。

§4 Best-of-N + Verifier：最朴素的 test-time scaling

4.1　公式

给定 prompt $x$、policy $\pi$、verifier $V$、采样数 $N$：

$$i^{*} = \arg\max_{i \in [N]} V(\text{trace}_i), \quad \text{trace}_i \sim \pi(\cdot \mid x); \quad \hat{y} = \text{extract}(\text{trace}_{i^{*}})$$

理论极限（"oracle BoN"，假设有完美 verifier）：

$$\text{pass}@N = 1 - (1 - \text{pass}@1)^N$$

实际：verifier 不完美，BoN 的 saturation curve 远低于 oracle。Snell 2024 发现：

• 在 简单题 上 BoN 很快饱和（N=4 之后边际收益小）
• 在 难题 上 BoN 持续涨直到 N=64 / 128
• compute-optimal：题难 → 加 N；题易 → greedy

4.2　Best-of-N + PRM 代码

import torch
from typing import Callable

def best_of_n_prm(
    policy_sample: Callable,          # prompt -> (trace, step_list)
    prm_score: Callable,              # step_list -> scalar in [0, 1]
    prompt: str,
    n: int = 16,
    aggregation: str = "min",         # "min" | "prod" | "mean"
) -> tuple[str, float]:
    """
    Best-of-N with process reward model verifier.
    Returns (best_trace, best_score). Note: in `prod` mode, `best_score`
    is the cumulative log-product (negative); compare scores within the same
    aggregation mode only.
    """
    best_trace, best_score = None, -float("inf")
    for _ in range(n):
        trace, steps = policy_sample(prompt)
        step_probs = [prm_score(steps[: t + 1]) for t in range(len(steps))]
        if aggregation == "min":
            score = min(step_probs)
        elif aggregation == "prod":
            # log-sum 避免数值下溢
            score = sum(torch.log(torch.tensor(p) + 1e-9) for p in step_probs).item()
        elif aggregation == "mean":
            score = sum(step_probs) / len(step_probs)
        else:
            raise ValueError(aggregation)
        if score > best_score:
            best_score, best_trace = score, trace
    return best_trace, best_score

4.3　Self-Consistency 代码

from collections import Counter
from typing import Callable
import re

def _extract_braced(s: str, open_idx: int) -> str | None:
    """从 `\boxed{` 后第一个 `{` 起，按平衡括号提取内层（支持嵌套 LaTeX）。"""
    if open_idx >= len(s) or s[open_idx] != "{":
        return None
    depth = 0
    for i in range(open_idx, len(s)):
        if s[i] == "{": depth += 1
        elif s[i] == "}":
            depth -= 1
            if depth == 0:
                return s[open_idx + 1:i]
    return None  # 未闭合

def extract_answer(trace: str) -> str:
    """从 trace 提取 final answer。注意：生产里要做更全的规范化（单位、分数→小数、LaTeX 化简等）。"""
    # 用平衡括号匹配 `\boxed{...}`，避免 `\boxed{\frac{1}{2}}` 被截成 `\frac{1`
    pos = trace.find(r"\boxed")
    if pos != -1:
        inner = _extract_braced(trace, pos + len(r"\boxed"))
        if inner is not None:
            return inner.replace(",", "").replace("$", "").strip()
    m = re.search(r"answer is[:\s]+([^.\n]+)", trace, re.IGNORECASE)
    if m:
        return m.group(1).strip().replace(",", "").replace("$", "").strip()
    return ""

def self_consistency(
    policy_sample: Callable,
    prompt: str,
    n: int = 40,
    temperature: float = 0.7,
) -> tuple[str, dict]:
    """Self-Consistency: sample N traces, majority vote on extracted answers."""
    answers = []
    for _ in range(n):
        trace = policy_sample(prompt, temperature=temperature)
        ans = extract_answer(trace)
        if ans:                            # 跳过解析失败
            answers.append(ans)
    if not answers:
        return "", {}
    counts = Counter(answers)
    return counts.most_common(1)[0][0], dict(counts)

§5 RL 路线：PPO → GRPO

5.1　Vanilla PPO 回顾（Schulman et al. 2017）

对每个 token $t$，policy gradient with clipping：

$$\mathcal{L}_\text{PPO} = -\mathbb{E}_t \left[ \min\!\left( \rho_t A_t,\; \text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) A_t \right) \right]$$

其中

• $\rho_t = \pi_\theta(o_t \mid s_t) / \pi_{\theta_\text{old}}(o_t \mid s_t)$ 是 importance ratio
• $A_t$ 是 advantage，常用 GAE-$\lambda$：$A_t = \sum_{l\geq 0} (\gamma\lambda)^l \delta_{t+l}$，$\delta_t = r_t + \gamma V_\psi(s_{t+1}) - V_\psi(s_t)$

痛点：

1. 需要训一个 value network $V_\psi$（critic），通常和 policy 同等大小——显存翻倍
2. Critic 训练在 long-CoT 上很难收敛（reward 极度稀疏，只有最终答案对错）
3. GAE 需要 token-level value 估计；long-CoT (4K+ tokens) 上每个 token 的 value 噪声很大

5.2　GRPO（Shao et al. 2024, DeepSeekMath, arXiv 2402.03300）

核心想法：用 group statistics 替代 critic。

算法：

1. 对每个 prompt $x$，从 $\pi_{\theta_\text{old}}$ 采样 $G$ 个 completion $\{o_1, \dots, o_G\}$（通常 $G = 16$ 或 $64$）
2. 用 reward model 给每个 completion 打分 $\{r_1, \dots, r_G\}$
3. Group-relative advantage（trace-level，不是 token-level）：

$$\boxed{\;A_i = \frac{r_i - \text{mean}(\mathbf{r})}{\text{std}(\mathbf{r}) + \epsilon}\;}$$

1. 把 trace-level $A_i$ 广播给该 trace 的所有 token：$A_t = A_i \;\forall t \in o_i$
2. 用 PPO clipping objective 更新 policy（同上公式，但 $A_t$ 来自步骤 3-4）；DeepSeekMath/R1 同时加 KL 正则 $\beta \cdot \mathrm{KL}(\pi_\theta \,\|\, \pi_\text{ref})$。实践中用 Schulman 的 unbiased k3 估计 $\widehat{\mathrm{KL}}_t = e^{\log\pi_\text{ref}(o_t|s_t) - \log\pi_\theta(o_t|s_t)} - (\log\pi_\text{ref}(o_t|s_t) - \log\pi_\theta(o_t|s_t)) - 1$ 对每个 token 取值（恒 $\geq 0$），再 mask + 平均

• 同 prompt 同源：$G$ 个 completion 共享 prompt 难度，差异完全来自 policy 输出；mean 自动减掉 prompt-specific baseline，等价做了 control variate
• 无需 value network：直接省一半显存 + 一倍计算；critic 在 long-CoT 上本来就难学（reward 稀疏 + episode 长）
• 稳定性来自 group size $G$：$G$ 越大，advantage 估计方差越小；DeepSeek-R1 用 $G \approx 16$

5.3　GRPO advantage 计算代码

import torch

def grpo_advantage(rewards: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
    """
    Group-relative advantage estimation.

    Args:
        rewards: [G] tensor of trace-level rewards (one prompt's group).
        eps: numerical stability.

    Returns:
        advantages: [G] tensor, mean ≈ 0, std ≈ 1.
    """
    mu = rewards.mean()
    sigma = rewards.std(unbiased=False)        # 用 biased std（除 G 而非 G-1）
    return (rewards - mu) / (sigma + eps)


def grpo_loss(
    log_probs_new: torch.Tensor,               # [G, T] new policy log p
    log_probs_old: torch.Tensor,               # [G, T] old policy log p (detached)
    log_probs_ref: torch.Tensor,               # [G, T] reference policy log p
    rewards: torch.Tensor,                     # [G] trace-level
    mask: torch.Tensor,                        # [G, T] valid token mask
    clip_eps: float = 0.2,
    kl_beta: float = 0.04,
) -> torch.Tensor:
    """Single-prompt GRPO loss (group size = G traces).
    要求 `log_probs_old` 和 `log_probs_ref` 都是 detached（无梯度）；
    若调用方传入带梯度 tensor，会把梯度错误地传进 old/reference policy。
    """
    adv = grpo_advantage(rewards)              # [G]
    adv = adv.unsqueeze(-1)                    # [G, 1] broadcast to tokens

    # 防御性 detach：即使调用方忘了，old / ref policy 也不会被反传
    log_probs_old = log_probs_old.detach()
    log_probs_ref = log_probs_ref.detach()

    # PPO clipping
    ratio = torch.exp(log_probs_new - log_probs_old)        # [G, T]
    surr1 = ratio * adv
    surr2 = torch.clamp(ratio, 1 - clip_eps, 1 + clip_eps) * adv
    pg_loss = -torch.min(surr1, surr2)                       # [G, T]

    # KL 正则：约束 policy 不漂离 reference 太远
    # DeepSeekMath/R1 用 Schulman 的 unbiased k3 估计：
    #   KL ≈ exp(log_ref - log_new) - (log_ref - log_new) - 1   ≥ 0
    # 这是 KL(π_θ || π_ref) 的样本无偏估计，且总是非负，比 raw log-ratio 稳得多
    log_diff = log_probs_ref - log_probs_new               # [G, T]
    kl = torch.exp(log_diff) - log_diff - 1.0              # [G, T], ≥ 0
    loss = pg_loss + kl_beta * kl                          # [G, T]

    # Masked mean over valid tokens
    return (loss * mask).sum() / mask.sum().clamp_min(1.0)

• log_probs_old 必须 detach（不参与梯度），否则和 ratio 形成奇怪的梯度路径
• std 用 biased 还是 unbiased 影响小但要一致（DeepSeek 公开版用 biased）
• 当 $G$ 个 rewards 全相同（如全错或全对），std = 0，且 $r_i - \mu \equiv 0$，加 eps 后 advantage = 0 → policy-gradient 项归零；但 KL 正则项仍存在，总 loss 退化成 kl_beta * KL（仍会把 policy 拉回 reference）。生产里通常 skip 这种 prompt（data filtering）以避免无信号更新，或者 clamp std 下限（如 0.1）
• Mask 必须 cover 所有 padding token，否则 padded log-prob 会污染 loss

5.4　GRPO 为什么 sample efficient（L3 高频题）

观察：R1 论文公开的 ~80 万样本（≈ 600k reasoning + 200k non-reasoning）是 Stage 3 rejection sampling + SFT 数据，不是 RL prompt 数；R1 Stage 2 reasoning RL 的 prompt 总量论文未严格公开，但整体训练计算量（~147K H800-hours）仍比同期 RLHF (InstructGPT 几百万人类偏好 pair) 显著小，GRPO 是核心算法贡献。

根因（不止是"省 critic"）：

1. Trace-level reward 与 trace-level credit 自然对齐：GRPO 直接把 trace reward 当 advantage 给所有 token；不需要 critic 做 per-token credit assignment。在 reward 完全只看 final answer 的设定下，这就是 sequence-level Monte-Carlo return 的标准 policy-gradient 估计（不是"最优"，但 trace-level 比 critic 在 long-CoT 上的 noisy per-token V 更稳）
2. 同 prompt 内的 contrast 自动消除 prompt-level noise：advantage = $(r - \mu) / \sigma$ 让 advantage 分布稳定，policy update 更新方向更准；等价于在每个 prompt 内做了 paired comparison
3. PPO clipping 限制单步更新幅度：和 $G$ 一起保证不会因某个 prompt outlier reward 把 policy 推飞
4. Rule-based reward 难以被 RM-hacking：r1 用规则 reward（答案正则匹配 + 格式 <think></think>），没有 learned RM 可被 over-optimization；advantage 主要反映"是否答对"。注意规则 reward 并非完全不可 hack——policy 仍可能利用正则漏洞、格式 trick 或测试集泄露——但避开了 learned-RM 漂出训练分布的主要 failure mode

R1 训练 GPU 小时 ≈ 147K H800-hours（DeepSeek 公开数）——比 GPT-4 训练量小两个数量级，是 GRPO + 数据精炼 + 规则 reward 联合作用的结果。

§6 DeepSeek-R1-Zero / R1 全流程

6.1　R1-Zero：纯 RL 不要 SFT 的极端实验

唯一假设：base model（DeepSeek-V3-Base, 671B MoE）已具备基础语言 + 数学能力。

训练：

• Reward = accuracy_reward + format_reward（rule-based，无 RM）

  • accuracy_reward：答案能否被自动 extract + match ground truth
  • format_reward：是否用 <think>...</think> 包围推理过程
• 算法：GRPO，$G = 16$，KL $\beta = 0.001$
• 数据：数学（MATH, AIME, 等）+ 代码（LeetCode-like 可执行评测）

涌现行为（"aha moment"，DeepSeek-R1 paper Fig 3）：

• 训练几 K steps 后，CoT 长度自发增长（200 token → 数千 token）
• 出现 "Wait, let me reconsider..."、"Actually that's wrong"、"Let me verify by..." 等 self-reflection 句式
• 在 AIME 2024 上 pass@1 从 base 的 15.6% → 71.0%（远超 GPT-4o-0513 的 9.3%）

问题：R1-Zero 的输出有 可读性问题 —— 推理过程语言混杂（中英文 + 数学符号乱跳）、有时候不分段、人类读不懂。所以 R1 加了后续阶段。

6.2　R1 完整 4 阶段 pipeline

核心 insight：

• Stage 1 = readability injection，不是为了 reasoning（reasoning 来自 RL）
• Stage 3 = generalization injection，把数学/代码 RL 学到的推理能力 transfer 到非可验证领域（写作、对话、QA）
• Stage 4 = safety + helpfulness alignment，等价于 RLHF 收尾

6.3　R1-Distill：把 R1 蒸到小模型

DeepSeek 用 Stage 3 数据（60 万 reasoning 样本）对 Qwen2.5-{1.5B, 7B, 14B, 32B} 和 Llama3-{8B, 70B} 做 纯 SFT（无 RL），得到 R1-Distill 系列。

关键发现（论文 Table 5）：

• DeepSeek-R1-Distill-Qwen-32B 在 AIME 2024 上 72.6 vs o1-mini 63.6——SFT 蒸馏的小模型超过 o1-mini
• 1.5B 模型在 MATH-500 上 83.9，远超原 Qwen2.5-Math-1.5B 的 51.0
• 论文公开版 R1-Distill 只做了 SFT，没有再叠 RL；作者明确指出"incorporating RL could substantially boost performance"——所以"distill 后能否 RL 出更多"是未结论的开放问题，而不是"做不到"

• DeepSeek-R1-Distill-Qwen-32B (SFT only) > DeepSeek-Qwen-32B-RL (直接 RL from scratch on Qwen)
• 原因：小模型 base 太弱，纯 RL 难涌现 reasoning；用大模型 R1 生成的 reasoning trace 做 SFT 等价于 distillation through demonstrations，把"reasoning 行为模式"直接复制过来。
• Implication：reasoning 能力的涌现需要大 base + 强 RL；小模型上靠蒸馏复制是最经济路线。

§7 Test-Time Scaling：Snell 2024 与 s1 budget forcing

7.1　Snell et al. 2024（arXiv 2408.03314）核心结论

题目：固定 inference FLOPs，怎么分配最优？

实验设置：

• 同一 base model（PaLM-2 系列）
• 不同 test-time 策略：BoN、majority vote、ToT-like beam search、PRM beam search、sequential revision（让模型看自己的回答再改）
• compute-optimal：每个 prompt 根据难度动态选策略（简单题 greedy，难题 beam search + PRM）

核心 finding：

• 在固定预算下，optimal test-time scaling > 14× 模型 scaling（在某些 MATH 子集上）
• 简单题：majority vote / BoN 4-8 即可
• 难题：PRM-guided sequential revision + beam search 收益最大

$$\text{Compute}_\text{optimal}(x) = \arg\min_{(\theta, N)} \mathbb{E}[L(\pi_\theta(x; N))] \;\text{s.t.}\; \text{FLOPs}(\theta, N) \leq B$$

• $\theta$ = 模型规模，$N$ = test-time samples / beam width
• 论文给的实际经验：在 base model 能 pass@1 > 30% 的题上，加 N 比加参数更划算

7.2　s1: Simple Test-Time Scaling（Muennighoff et al. Feb 2025, arXiv 2501.19393）

最简单的 reasoning model：1000 条样本 SFT + budget forcing 推理控制。

数据（s1K，1000 条）：

• 来自三个 criteria 筛选：difficulty、diversity、quality
• 每条样本：question + reasoning trace（用 Gemini Thinking 生成）+ answer

训练：Qwen2.5-32B-Instruct 上做 26 分钟 SFT（16×H100，1 epoch）——堪称史上最便宜 reasoning model。

推理 trick：budget forcing

模型生成：
<think>
[推理 token...]
[模型试图输出 </think>，但当前 token 数 < target_budget]
[强行替换 </think> 为 "Wait"]
[模型继续推理...]
...
[当 token 数 >= target_budget 或自然结束]
</think>
答案：...

效果：在 AIME 2024 上 s1-32B（用 budget forcing）= 56.7%，超过 o1-preview 的 44.6%。

• SFT 让 base model 学会了 <think>...</think> 格式，但 reasoning 长度有 distribution（短题短推理）
• 强行注入 "Wait" 让模型停在 </think> 的 boundary，激活其 in-context 的"反思"能力
• 等价于 forcing 模型留在 "thinking mode" 多 sample 几条推理路径
• 失败案例：base model 完全没见过反思 pattern 时，"Wait" 后面接的内容是 garbage——s1 的 1K SFT 数据已经隐含了反思 pattern

7.3　Sequential vs Parallel test-time compute

Snell 2024 报告：对简单题 parallel 更划算，对难题 sequential 显著更好。

§8 MCTS for Reasoning：rStar 系列

8.1　PUCT 公式（AlphaGo / AlphaZero 起源）

在节点 $s$，对每个 action $a$，PUCT score：

$$\boxed{\;U(s, a) = Q(s, a) + c_\text{puct} \cdot \pi(a \mid s) \cdot \frac{\sqrt{N(s)}}{1 + N(s, a)}\;}$$

• $Q(s, a)$ = 当前 $(s, a)$ 的平均 value（exploitation）
• $\pi(a \mid s)$ = policy prior（来自 policy network）
• $N(s)$ = node $s$ 的总访问次数
• $N(s, a)$ = action $a$ 被选过几次
• $c_\text{puct}$ = exploration constant（典型 1.0-2.0）

直觉：访问次数少的 + policy 看好的 + 当前 value 高的 action 被偏好。

8.2　rStar (Microsoft Research, arXiv 2408.06195) 关键 idea

把 LLM 当 policy + value 套进 MCTS：

• State：当前部分推理 $s_{
• Action：下一步要做什么（rStar 定义了 5 种 reasoning action：propose one-step, propose sub-question, generate full CoT, decompose, rephrase）
• Reward：终止节点用 mutual consistency check（另一个 LLM verify）

rStar-Math (arXiv 2501.04519) 进一步：用 MCTS rollout 自动标 process label（类似 Math-Shepherd 思路），训出 process preference model (PPM)，policy + PPM 反复 self-evolve 四轮。Qwen2.5-Math-7B 在 MATH 上从 58.8 → 90.0，逼近 o1-preview。

8.3　简化 MCTS for reasoning 伪代码

import math
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class MCTSNode:
    state: str                          # 部分推理 trace
    parent: Optional["MCTSNode"] = None
    prior: float = 0.0                  # policy network prob
    visit_count: int = 0
    value_sum: float = 0.0
    children: dict[str, "MCTSNode"] = field(default_factory=dict)
    is_terminal: bool = False

    @property
    def q_value(self) -> float:
        return self.value_sum / self.visit_count if self.visit_count > 0 else 0.0

def puct_score(node: MCTSNode, parent_visits: int, c_puct: float = 1.5) -> float:
    """PUCT: Q + c * P * sqrt(N_parent) / (1 + N)"""
    return node.q_value + c_puct * node.prior * math.sqrt(parent_visits) / (1 + node.visit_count)

def select(root: MCTSNode) -> MCTSNode:
    """Traverse tree by PUCT until reaching a leaf."""
    node = root
    while node.children and not node.is_terminal:
        node = max(node.children.values(),
                   key=lambda c: puct_score(c, node.visit_count))
    return node

def expand(node: MCTSNode, policy_lm, k: int = 4):
    """Sample k next-step candidates from policy LM."""
    if node.is_terminal:
        return
    candidates = policy_lm.sample_next_steps(node.state, k=k)   # list of (step_text, prior)
    for step_text, prior in candidates:
        new_state = node.state + "\n" + step_text
        is_term = step_text.startswith("Final answer:")
        node.children[step_text] = MCTSNode(
            state=new_state, parent=node, prior=prior, is_terminal=is_term,
        )

def rollout(node: MCTSNode, policy_lm, verifier) -> float:
    """Simulate from node to terminal; return reward."""
    if node.is_terminal:
        return verifier(node.state)
    state = node.state
    while len(state) < 4096:
        step = policy_lm.sample_next_step(state, temperature=1.0)
        state += "\n" + step
        if step.startswith("Final answer:"):
            break
    return verifier(state)   # ORM or PRM final score

def backup(node: MCTSNode, reward: float):
    """Propagate reward up the path."""
    while node is not None:
        node.visit_count += 1
        node.value_sum += reward
        node = node.parent

def mcts_search(prompt: str, policy_lm, verifier, n_simulations: int = 100, k: int = 4) -> str:
    """Standard MCTS for reasoning."""
    root = MCTSNode(state=prompt)
    # 首轮先 expand 根节点，保证 root.children 非空
    expand(root, policy_lm, k=k)
    for _ in range(n_simulations):
        leaf = select(root)
        if leaf.visit_count > 0 and not leaf.is_terminal:
            expand(leaf, policy_lm, k=k)
            if leaf.children:
                leaf = max(leaf.children.values(),
                           key=lambda c: c.prior)        # 先选 prior 最高
        reward = rollout(leaf, policy_lm, verifier)
        backup(leaf, reward)
    if not root.children:
        return root.state                                 # safety guard
    # 沿 visit_count 最高路径下行，直到 terminal 或 leaf（叶子未 expand）
    # 这样返回的是完整 trace 而非仅第一层 child；如果中间层最强路径未到 terminal，
    # 也至少返回该路径上当前已 expand 的最深 state
    node = root
    while node.children and not node.is_terminal:
        node = max(node.children.values(), key=lambda c: c.visit_count)
    return node.state

8.4　PRM-Guided Beam Search（更轻量替代）

不做完整 MCTS，只保留 top-$b$ 个 partial trace，每步用 PRM 评分：

import math

def prm_beam_search(
    policy_lm,
    prm,
    prompt: str,
    beam_width: int = 4,
    expansion: int = 4,
    max_steps: int = 16,
) -> str:
    """PRM-guided step-level beam search."""
    # (cumulative_log_score, partial_trace, is_done)
    beams = [(0.0, prompt, False)]
    for _ in range(max_steps):
        new_beams = []
        for score, trace, done in beams:
            if done:
                new_beams.append((score, trace, True))
                continue
            # 从当前 trace expand expansion 个候选 step
            candidates = policy_lm.sample_next_steps(trace, k=expansion, temperature=0.8)
            for step, _ in candidates:
                new_trace = trace + "\n" + step
                step_prob = prm.score_step(new_trace)        # in [0, 1]
                # 累加 log 概率（数值稳定）
                new_score = score + math.log(step_prob + 1e-6)
                is_terminal = step.startswith("Final answer:")
                new_beams.append((new_score, new_trace, is_terminal))
        # 防御性 edge case：若所有 beam 都 expand 出空候选，避免 max(empty)
        if not new_beams:
            break
        # 按累积 log-score 选 top-b
        beams = sorted(new_beams, key=lambda x: x[0], reverse=True)[:beam_width]
        if all(b[2] for b in beams):
            break
    # 返回最高分的 trace（空 beam 时回退到初始 prompt）
    return max(beams, key=lambda x: x[0])[1] if beams else prompt

§9 Reasoning Model 全景对比

9.1　主流 reasoning model 对比表（截至 2026）

9.2　选型决策树（面试常问）

任务领域？
├── 数学/竞赛（AIME / IMO） ─→ R1 / R1-Distill-32B / o1 / s1-32B
├── 形式化定理证明（Lean / Coq） ─→ DeepSeek-Prover-V2
├── 代码（Codeforces / SWE-bench） ─→ o1-pro / R1 / Claude 3.7 + thinking
├── 通用 reasoning（agent / chain task） ─→ Claude 3.7 / Gemini 2 Thinking / R1
├── 小模型部署（边缘 / 移动） ─→ R1-Distill-1.5B-7B
└── ARC-AGI / 抽象推理 ─→ o3（高算力档）

部署预算？
├── 高（CoT 几千 token / 题）─→ o1, o3, R1, Claude 3.7-extended
├── 中（CoT 1-2K token）─→ s1-32B, R1-Distill-32B
└── 低（greedy 或 BoN=8）─→ R1-Distill-1.5B + best-of-N with verifier

9.3　CoT 是否真的反映推理？（深题）

经典争议：Attention is not Explanation (Jain & Wallace 2019) 在 CoT 上的 echo——模型展示的 reasoning 是否真实反映其内部计算？

证据：

• 支持真实：Anthropic Sleeper Agents 实验 (Hubinger et al. 2024) 显示 CoT 内容会影响下游 action（不是纯 post-hoc rationalization）
• 支持非真实：Turpin et al. 2023 "Language Models Don't Always Say What They Think" 发现给 biased exemplar 后，模型 CoT 给出 plausible 但错误的 reasoning（biased 但 CoT 没提 bias）
• R1-Zero 的 "aha moment" 是有限证据：行为变化（更长 + 更多反思）确实和性能涨同步，但仍可能是 surface pattern

面试时务必给 balanced view：CoT 是有用 + 部分可信的；但不能当 100% explanation。

§10 25 高频面试题（L1 必会 / L2 进阶 / L3 顶级 lab）

按 gpt-5.5 xhigh 模拟的顶级 lab interviewer 视角排序。

L1 必会题（任何 LLM 岗都会问）

L2 进阶题（reasoning 方向 / research 岗）

L3 高级题（顶级 lab / 研究方向）

§A 附录：核心 paper 时间线 + 一句话总结

按时间倒序：

1. DeepSeek-R1 (2501.12948) —— 涵盖 GRPO + 4 阶段 + R1-Zero "aha moment"
2. DeepSeekMath (2402.03300) —— GRPO 算法原始论文
3. Let's Verify Step by Step (2305.20050) —— PRM 基础
4. Snell et al. (2408.03314) —— test-time compute scaling 范式

读完这 4 篇 + 本 cheat sheet，reasoning model 面试题目应能 80%+ 覆盖。