想象你是一位铁匠师傅，想打造一把削铁如泥的宝剑。你不可能一次就成功，而是会经历这样的循环：先打出一把剑，拿去实战砍一砍，哪些地方卷刃了、哪里崩口了，记下来；下一轮锻造时，专门改进这些薄弱环节，再打一把更好的剑；然后再实战检验、再改进……如此循环往复，剑就越来越好。 AI 领域让大模型“学会推理”的专家迭代（Expert Iteration）方法，本质上就是这么一套“铁匠铺哲学”。科学家们不直接教模型怎么解题，而是让模型自己“打铁”——生成大量解题过程，再选出最优秀的那批“宝剑”作为示范，让模型对照着学习改进，然后再生成、再筛选、再学习，如此循环，模型就一步步从“只会瞎猜的小学徒”升级成“解题专家”。 这套方法被称为“专家迭代”，是当前推理模型（比如 OpenAI o1、DeepSeek-R1 这类“想得深再回答”的模型）训练的核心思想之一。它会用强化学习让模型自我博弈——自己出题、自己解题、自己当裁判，在不断的“淘汰与晋级”中逼近最聪明的解题策略。

岗位关联

如果你正在做大模型推理能力的训练优化，掌握专家迭代意味着你拥有了一套无需人工标注、依赖模型自我进化就能持续提升推理水平的“圣杯级”方法论——这几乎是当下推理模型赛道的必修课。

目录
  1. 可视化演示
  2. 思想源流：从围棋大师到数学天才
  3. 采样生成轨迹：让学徒放飞想象力
  4. 筛选优质样本：谁是真正的千里马
  5. 监督微调升华：把好剑法刻进肌肉记忆
  6. 迭代循环评估：铁匠的验收标准
  7. 强化学习进阶：从学徒到自主进化
  8. 工程实战细节：铁匠铺的精益管理
  9. 局限与前景：铁匠的未解之谜
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

展示Expert Iteration自我博弈训练过程：采样生成解题轨迹、筛选优质样本、微调模型、循环迭代提升推理能力。

本节配有交互动效（进入视口后自动加载，约 3KB）。

采样生成阶段 模型对每个问题生成多条解题轨迹 通过温度采样增加轨迹多样性 点击下方步骤切换不同阶段

思想源流：从围棋大师到数学天才

想象一位老厨师在厨房里带徒弟。传统的教法是：老厨师做一道菜，徒弟照着一步步学（这叫模仿学习）。但老厨师发现，最顶尖的厨艺根本不是“照着做”能教出来的——于是他想了个新办法：让徒弟自己尝试各种做法，做出十道菜，老厨师只尝一口，挑出最好吃的那道，让徒弟琢磨“这道菜为什么好吃”，再来十道、再挑……徒弟就在这样一轮轮的“自己动手 + 优中选优”中，超越了老师的菜谱。

这就是专家迭代的“厨房版”。2017 年，DeepMind 在 AlphaGo 的训练中首次将其发扬光大。AlphaGo 先和自己下棋（自我博弈），产生大量棋谱，再从这些棋谱中挑出胜率高的招法来学习，循环迭代，最终超越了所有人类棋手。后来的 AlphaZero 甚至完全不看人类棋谱，只靠自我博弈成为“三栖冠军”（围棋、国际象棋、将棋）。研究者们意识到：这个方法完全可以迁移到语言模型的推理训练上——让大模型自己生成解题过程，自己当裁判筛选优劣，再自己学习。

这和我们熟悉的“模仿学习”（Imitation Learning）有本质区别。模仿学习是“看老师怎么做，我照着做”，上限是老师的水平；专家迭代是“我自己做，从我的作品里挑最好的继续改进”，上限是自己不断突破。就像徒弟如果只模仿老厨师，最多跟老师一样好；但如果在老师的点评下自己反复尝试，就可能做出老师都没想到的新菜式。专家迭代的本质，就是把“生成者”和“评估者”合二为一，让模型成为自己的老师。

想象铁匠每一轮打的剑，都是从自己前一轮的手艺中总结经验——时间一长，每一锤都更有准头。AlphaGo 打败李世石的那一战后，整个 AI 圈意识到：不用人类示范，机器自己和自己较劲，也能成为顶尖高手。

Expert Iteration:πt+1=arg⁡max⁡π  Eτ∼πt[R(τ)]\text{Expert Iteration}: \quad \pi_{t+1} = \arg\max_{\pi} \; \mathbb{E}_{\tau \sim \pi_t}[R(\tau)]
这个公式说的是：下一轮模型 $\pi_{t+1}$ 是在上一轮模型 $\pi_t$ 生成的所有解题轨迹 $\tau$ 中，挑回报 $R(\tau)$ 最高的答案来学习而得的——每一代都比上一代更“精”。
  1. $\pi_{t+1}$（新一轮的模型策略）这是我们训练的目标——比上一轮更会推理的新模型。
    πt+1\pi_{t+1}
  2. $\arg\max$（求“使……最大的那个”）表示我们不是简单平均所有答案，而是“挑最好的那个策略”。
    arg⁡max⁡π\arg\max_{\pi}
  3. $\mathbb{E}_{\tau \sim \pi_t}$（在上一轮模型产生的轨迹上取期望）意思是“让上一轮这个模型大量解题，把所有解法的分布都看过一遍”。
    Eτ∼πt\mathbb{E}_{\tau \sim \pi_t}
  4. $R(\tau)$（轨迹回报）对一条解题路径打的分数——答对了给正分，错了给低分，这就是裁判的评分表。
    R(τ)R(\tau)

采样生成轨迹：让学徒放飞想象力

铁匠打剑不能每把都一个模子。如果学徒每次都按同样的手法打铁，那他永远不知道自己哪里还有改进空间。所以老铁匠会让学徒“大胆试”——今天用不同的火候、明天换不同的捶打角度、后天试试不同的淬火时机，打出十几把各有特点的剑，再一一检验哪把最锋利。

在专家迭代里，这个“让学徒放飞想象力”的步骤叫采样（Sampling）。具体做法是：给定一道数学题或编程题，让模型用解码（Decoding）的方式生成多条不同的解题轨迹。怎么让模型每次生成得不一样呢？关键靠一个叫 温度（Temperature） 的参数。温度高时，模型“思路更发散”，可能走出奇奇怪怪但偶尔惊艳的路线；温度低时，模型“按部就班”，倾向于最保险的回答。

这里有个关键技术点：推理和写作文不一样，正确路径往往藏在“想得深一点”的过程中。为了获得高质量轨迹，工程师会让模型开启 思维链（Chain-of-Thought） 模式，把推理步骤一步步写出来。比如解一道几何题，模型需要先写“设未知数”，再写“根据勾股定理”，再写“化简方程”……每一步都暴露在轨迹中，方便后续筛选。这一阶段的目标是生成一个容量够大的 轨迹池（Trajectory Pool）——池子越大，里面藏着的“黄金答案”就越多。

这就像铁匠铺里摆满了形态各异的剑胚——有的细长、有的厚重、有的弯曲。你不确定哪一把能成神兵，但你知道，打得足够多，总有几把藏着惊喜。采样阶段的核心原则就是：先求数量，再求质量。没有足够多的“草稿”，后面就无从“淘金”。

采样:τ1,τ2,…,τN∼πθ(⋅∣x)\text{采样}: \quad \tau_1, \tau_2, \ldots, \tau_N \sim \pi_{\theta}(\cdot \mid x)
公式的含义是：对同一个问题 $x$，用当前模型 $\pi_{\theta}$ 采样出 $N$ 条不同的解题路径 $\tau_1$ 到 $\tau_N$。就像同一道菜让徒弟做 N 遍，每遍火候不同。
  1. $\tau_1, \tau_2, \ldots, \tau_N$（N 条解题轨迹）每一条都是一次完整的“思考到作答”的完整记录。
    τ1,τ2,…,τN\tau_1, \tau_2, \ldots, \tau_N
  2. $\sim$（服从……分布）表示这些轨迹不是手写的，而是按模型的概率分布随机“长”出来的。
    ∼\sim
  3. $\pi_{\theta}(\cdot \mid x)$（给定题目 $x$ 时的模型策略）$\theta$ 是模型的参数（大脑里的“神经连接”），模型看到题 $x$ 后，会按自己的参数给出各种答案的概率分布。
    πθ(⋅∣x)\pi_{\theta}(\cdot \mid x)

筛选优质样本：谁是真正的千里马

铁匠打出了二十把剑，接下来要做的，就是一把把试斩——砍竹子、斩铁板、试韧性。经不起考验的直接回炉，经得住考验的留下来细细打磨。这一步是整个专家迭代的“试剑大会”，学者们叫它 筛选（Filtering） 或 选择（Selection）。

怎么判断一条解题轨迹好不好？有几种常用的“试剑石”：

第一种是规则验证器（Rule-Based Verifier）。对于数学题，直接把模型的最终答案代入题目检验对错，对了就是好轨迹。对编程题呢，把代码丢进测试用例里跑，跑通全部用例就算通过。这是最硬核的“实战检验”。

第二种是多数投票共识（Majority Voting / Self-Consistency）。让模型对同一道题生成多条答案，如果大多数答案都指向同一个结果，那这个结果大概率是对的。就像让十个学徒分别估价一把剑，八个人说值十两银子，那它大概率真值这个价。

第三种是过程奖励模型（Process Reward Model）。有时最终答案对了，但中间步骤可能“蒙对的”；或者最终答案错了，但前面几步很有启发性。于是训练一个小模型专门对每一步打分，奖励那些“过程也漂亮”的轨迹。现在很多前沿推理模型（如 DeepSeek-R1）也结合了这种思路。

“试剑”环节最妙的地方在于：裁判并不需要是人类。数学题有标准答案，代码题有测试用例，这些都是“铁面无私的自动裁判”。这意味着整个流程可以全自动运转——模型自己出剑、自己试剑、自己收剑入库，人类只需要在旁边搭好擂台即可。

筛选:Dtrain={(τ,y)∣R(τ)≥θthreshold}\text{筛选}: \quad \mathcal{D}_{\text{train}} = \{(\tau, y) \mid R(\tau) \geq \theta_{\text{threshold}}\}
公式说明：只有那些得分 $R(\tau)$ 高于某个分数线 $\theta_{\text{threshold}}$ 的轨迹，才能进入训练集 $\mathcal{D}_{\text{train}}$，即“过不了试剑大会的剑，不许进兵器库”。
  1. $\mathcal{D}_{\text{train}}$（训练数据集）相当于铁匠铺的“精品兵器库”，只存放被筛选出来的优质答案。
    Dtrain\mathcal{D}_{\text{train}}
  2. $(\tau, y)$（轨迹和答案配对）不仅要存模型写的过程 $\tau$，还要存最终答案 $y$，这样模型才知道“好过程带来好结果”。
    (τ,y)(\tau, y)
  3. $R(\tau) \geq \theta_{\text{threshold}}$（分数达标）$R$ 是打分函数（验证器），$\theta_{\text{threshold}}$ 是入选门槛。只有越过门槛的才有资格入库。
    R(τ)≥θthresholdR(\tau) \geq \theta_{\text{threshold}}

监督微调升华：把好剑法刻进肌肉记忆

铁匠选出了十把好剑，接下来不是把它们挂墙上欣赏，而是要让学徒拆解这些剑好在哪——剑刃的弧度、重心的配比、淬火的温度，然后反复模仿练习，直到这些“好剑法”成为学徒的肌肉记忆。下次再打铁时，不用多想，手自然会往正确的方向走。

对应到模型训练，这一步叫监督微调（Supervised Fine-Tuning, SFT）。我们把筛选出来的优质轨迹当作“标准答案”，用经典的交叉熵损失（Cross-Entropy Loss）来训练模型——让模型看到某道题时，学会最大化生成那条优质轨迹的概率。一句话：让好答案越来越容易被模型说出来，坏答案越来越难被说出来。

这个过程不是简单的“背答案”。模型在几万道题、几十万条优质轨迹上微调后，会逐渐归纳出隐藏的“解题风格”——比如先理解题意、再分解子问题、逐步验证中间结果、最后给出结论。这种风格一旦沉淀进模型参数，就会迁移到没见过的题目上，表现为“推理能力提升了”。

微调过后的模型，就像把好剑法练成本能的学徒。此时完成了一轮专家迭代，但故事才刚刚开始——第二轮迭代马上来临：这个“升级版学徒”再次去采样、再次试剑、再次打磨。每一轮，起点都比上一轮高，于是进化不会停止。

LSFT=−E(τ∗,y∗)∼Dtrain[∑t=1Tlog⁡πθ(at∗∣s<t∗,x)]\mathcal{L}_{\text{SFT}} = -\mathbb{E}_{(\tau^*, y^*) \sim \mathcal{D}_{\text{train}}}\left[\sum_{t=1}^{T} \log \pi_{\theta}\left(a_t^* \mid s_{<t}^*, x\right)\right]
这是监督微调的损失函数，意思是：对训练集中每条“黄金轨迹”，让模型每一步都尽量“说”出标准答案中的那个词，所有步骤加起来概率最大、损失最小。
  1. $\mathcal{L}_{\text{SFT}}$（监督微调的损失）衡量模型“说得像不像标准答案”的差距。差距越小，模型越接近专家。
    LSFT\mathcal{L}_{\text{SFT}}
  2. $-\mathbb{E}$（负期望）对训练集里的所有样本取平均，损失要越小越好。
    −E-\mathbb{E}
  3. $\sum_{t=1}^{T} \log \pi_{\theta}$（每个步骤的概率取对数再求和）每一步都是一个“小选择”，把所有步骤的选择概率乘起来（取对数变成相加）就是整条轨迹的得分。
    ∑t=1Tlog⁡πθ\sum_{t=1}^{T} \log \pi_{\theta}
  4. $a_t^* \mid s_{<t}^*$（给定上文，预测标准答案中的下一个词）$a_t^*$ 是第 $t$ 步应该输出的 token，$s_{<t}^*$ 是此前已经输出的内容。
    at∗∣s<t∗a_t^* \mid s_{<t}^*

迭代循环评估：铁匠的验收标准

循环迭代不是“无限打铁”这么简单，老铁匠需要一套验收标准：这把剑到底比上一把好在哪里？是更锋利了，还是更耐用了？如果连续三轮都毫无进步，是不是锻造方法出了问题？在专家迭代中，这套“验收体系”叫评估（Evaluation）。

工程师会准备一个固定的评估基准（Benchmark），比如数学推理界的 GSM8K、MATH，代码界的 HumanEval、MBPP。每一轮新模型训练完，都要在这些基准上重新测一遍，记录分数变化。如果分数稳步上升，说明迭代有效；如果不动了，说明到了瓶颈，需要调整采样策略或筛选标准。

同时要小心一个陷阱：过拟合（Overfitting）。如果每次迭代都用同一批题目做采样源，模型可能把那些题的答案“背”下来，而不是真正学会举一反三。就像学徒反复练同一道菜练到闭眼都能做，但换一道新菜就傻眼。所以好的实践是：每轮迭代换一批新的训练题目，或者动态调整题目难度——先做简单的建立信心，再做中等的提升能力，最后上难题突破上限。

有了“验收标准”，循环迭代才不会变成盲目的原地打转。铁匠的每一轮淬火、每一次试斩、每一版打磨，都是为了在那道刻在墙上的“标准线”上画出一道新刻痕。当新刻痕一次次超过旧刻痕，老铁匠知道，这条路走对了。

评估:Scoret+1=1M∑i=1MI[πt+1(xi)=yi]\text{评估}: \quad \text{Score}_{t+1} = \frac{1}{M}\sum_{i=1}^{M} \mathbb{I}\left[\pi_{t+1}(x_i) = y_i\right]
公式表示在 $M$ 道评测题上统计新模型的正确率——只有“实战得分”不断新高，才算真正进化，而不是自我感觉良好。
  1. $M$（评测题总数）评估不能只看一两道题，要用一批有代表性的题目才靠谱。
    MM
  2. $\mathbb{I}[\cdot]$（指示函数）一个“是/否”开关——答案对了记 1，错了记 0。
    I\mathbb{I}
  3. $\pi_{t+1}(x_i) = y_i$（模型在题目 $x_i$ 上给出正确答案 $y_i$）这是对“推理能力”最直白的检验。
    πt+1(xi)=yi\pi_{t+1}(x_i) = y_i

强化学习进阶：从学徒到自主进化

讲到这儿你可能发现一个疑点：如果每轮都是“采样—筛选—微调”，那模型是怎么学会探索新策略的？单纯模仿自己的好答案，会不会最后变成“自嗨式重复”？

所以现代专家迭代的完全体，往往要结合强化学习（Reinforcement Learning, RL）。想象一位更聪明的铁匠师傅：他不只让学徒模仿好剑，还给学徒设计了一套“奖励机制”——打出好剑奖一块银子，打出废铁扣一块。学徒为了多拿银子，会主动尝试新的打铁角度、新的材料配比——这就是探索。专家迭代帮学徒找到“什么样子算好剑”，强化学习则驱动学徒“不断尝试去打更好的剑”。

在技术实现上，最常用的是 PPO（Proximal Policy Optimization，近端策略优化） 算法。它的核心思路是：让模型当前的策略（怎么解题）跟旧策略做对比，如果新策略在同样题目上得分更高，就加大“往这个方向走”的力度；如果得分没变甚至更差，就保守一点，别走太远。这种“有控制的进步”让训练过程稳定不崩。

强化学习还需要一个奖励信号。在数学题上可以用最终答案正确与否（稀疏奖励），在代码题上可以用测试用例通过率。但有些任务没有标准答案，这时就要训练一个奖励模型（Reward Model, RM） 来给轨迹打分。整个流程串起来是：采样 → 验证器/奖励模型打分 → PPO 更新策略 → 再采样……这与专家迭代的“生成—筛选—学习”骨架同构，只是把“监督微调”升级为“强化学习优化”，让模型不仅能模仿好答案，还能主动探索超越已有好答案的新路径。

如果说纯监督微调是“照着好答案练字”，那加上强化学习的专家迭代就是“在练字基础上，逐步形成自己的笔风”。OpenAI 的 o1 系列、DeepSeek-R1 等推理模型的训练管线，正是沿着这条“自动生成答案—自动评分—自我更新”的路径，实现了推理能力的持续爬升。

LRL(θ)=Eτ∼πθold[πθ(τ)πθold(τ)⋅A^(τ)]−β⋅KL(πθ∥πref)\mathcal{L}_{\text{RL}}(\theta) = \mathbb{E}_{\tau \sim \pi_{\theta_{\text{old}}}}\left[\frac{\pi_{\theta}(\tau)}{\pi_{\theta_{\text{old}}}(\tau)} \cdot \hat{A}(\tau)\right] - \beta \cdot \mathrm{KL}(\pi_{\theta} \| \pi_{\text{ref}})
PPO 的损失函数：前半部分是“好轨迹要多学、坏轨迹要少学”，后半部分是“别偏离参考模型太远”，两者配合保证模型稳步提升而非突然跑偏。
  1. $\frac{\pi_{\theta}(\tau)}{\pi_{\theta_{\text{old}}}(\tau)}$（新旧策略的概率比）衡量新策略在轨迹 $\tau$ 上的变化幅度，避免更新太猛。
    πθ(τ)πθold(τ)\frac{\pi_{\theta}(\tau)}{\pi_{\theta_{\text{old}}}(\tau)}
  2. $\hat{A}(\tau)$（优势函数估计）表示这条轨迹比“平均水平的轨迹”好多少。正的越多，越值得学习。
    A^(τ)\hat{A}(\tau)
  3. $\mathrm{KL}(\pi_{\theta} \| \pi_{\text{ref}})$（KL 散度）一个“距离尺子”，测量新策略偏离参考策略有多远，防止模型在优化中“性情大变”。
    KL(πθ∥πref)\mathrm{KL}(\pi_{\theta} \| \pi_{\text{ref}})

工程实战细节：铁匠铺的精益管理

纸上谈兵容易，真正落地专家迭代训练时，工程师面对的是一地鸡毛的工程问题。就像铁匠铺老板不仅要会打铁，还得管好炭火成本、铁矿石库存、学徒排班——每一处细节都影响最终的兵器品质。

第一个大头是算力成本。专家迭代需要模型反复采样：一个批次可能采样几百万条轨迹，每条轨迹可能长达数千 token。在超大模型上，这开销极其惊人。工程上常用小模型采样 + 大模型微调的路线来省钱：让小模型（比如 7B）生成海量候选轨迹，筛完后用大模型（比如 70B）做常规精度微调。还有些团队用动态采样预算——简单题少采样几轮，难题多采样几轮，把算力花在刀刃上。

第二个痛点是数据质量与多样性。采样 N 条轨迹里，可能有大量重复的、相似的、甚至作弊式的地图炮（比如把所有可能的选项都试一遍）。这类低质量数据进训练集会让模型变“油滑”。工程上要做去重（Deduplication）、长度过滤（异常长的轨迹多半是胡言乱语）、以及多样性控制（参考温度退火）——先高温探索，再低温精炼，保证轨迹池既广又精。

第三个是训练稳定性。迭代训练中最常遇到的坑是“灾难性遗忘”——新模型在数学题上进步了，但写代码能力突然倒退。解决办法是：在微调数据里混入一定比例的原有能力数据（比如通用对话、代码语料），让模型“温故而知新”。另外，每次模型更新后用固定测试集回归，一旦发现某项能力掉点，立即回滚到上一版。

铁匠铺的精益管理讲究“每一块炭都要烧出价值”。对于训练工程师来说，则是“每一步预算都要出效果”。专家迭代的工程落地，从某种意义上说就是一场成本与收益的精准博弈——把有限的 GPU 预算，花在最能提升推理能力的那部分采样和训练上。

迭代成本:Ctotal=Nrounds×(Csample+Cfilter+Ctrain)\text{迭代成本}: \quad C_{\text{total}} = N_{\text{rounds}} \times (C_{\text{sample}} + C_{\text{filter}} + C_{\text{train}})
总成本 = 迭代轮数 ×（每轮采样成本 + 筛选成本 + 训练成本）。工程目标就是在保证推理分数增长的前提下，把这三个 C 都压到最低。
  1. $N_{\text{rounds}}$（迭代轮数）太少进化不动，太多成本爆炸，通常 3-10 轮比较常见。
    NroundsN_{\text{rounds}}
  2. $C_{\text{sample}}$（采样成本）生成海量轨迹的推理开销，往往是最大头。
    CsampleC_{\text{sample}}
  3. $C_{\text{filter}}$（筛选成本）跑验证器或奖励模型的算力，也不可小觑。
    CfilterC_{\text{filter}}
  4. $C_{\text{train}}$（训练成本）微调或 RL 更新的 GPU 时间。
    CtrainC_{\text{train}}

局限与前景：铁匠的未解之谜

任何方法论都有天花板，专家迭代也不是万能神药。老铁匠最苦恼的问题，是有些宝剑怎么打都打不出来——不是手艺不够，而是有的材料（任务）本身就不好铸造。这对应专家迭代的几大局限。

第一是奖励稀疏与冷启动问题。如果任务太难，模型一开始采样的轨迹全部是错的（得分为 0），那筛选环节将无优质样本可用，训练根本无法启动。就像让一个完全不会打铁的新手直接打造屠龙刀，他打出的全是废铁，你没法从废铁里“优中选优”。解决思路是：从简单题开始迭代，逐步提高难度，或先用少量人工标注做种子数据。

第二是分布坍缩（Distribution Collapse） 陷阱。如果筛选标准过于单一（比如只看答案对不对），模型会逐渐收敛到少数几种固定解法，多样性下降，一旦遇到稍有变化的题目就崩盘。这需要奖励设计中加入“过程多样性”的考量，甚至显式惩罚重复解法。

第三是“谁给裁判打分”的哲学问题。当任务没有可验证的正确答案（比如写一首诗、做一个产品决策），怎么定义“专家轨迹”？这就得靠人类偏好模型，但偏好本身可能被模型生成的“花言巧语”带偏。因此，专家迭代目前最擅长的还是有标准答案的领域——数学、代码、逻辑推理，在这些领域它已经创造了惊人的成绩；而开放式创造性任务，仍需人类深度参与评判。

但无论如何，专家迭代代表了一条极有前景的道路：当机器能够自己定义优秀、自己寻找优秀、自己逼近优秀时，它就不再仅仅是模仿人类的工具，而是通往自主智能的一级阶梯。 铁匠的终极梦想，是锻造出一把能自己打磨自己的剑——专家迭代，正是让模型成为那柄“自砺之剑”的锻造法。

AI 应用场景

数学推理竞赛辅导系统的持续进化

阶段：数据飞轮构建与模型迭代训练

解决的问题：传统数学辅导系统依赖人工编写解题题库和标准答案，成本高、更新慢，且系统无法覆盖新题型。专家迭代让模型自动生成大量解题思路，用规则验证器自动判断对错，持续从“自己错题”中学习，实现零人工标注的推理能力升级

具体案例：一家在线教育公司为中学生打造数学 AI 助教。初始模型在 5000 道初中数学题上微调，准确率仅 62%。随后启动专家迭代管线：模型每轮为每道题生成 32 条解题轨迹，用符号计算引擎自动判定正误，将正确的轨迹收集起来做 SFT。经过 4 轮迭代，模型在 2000 道新题上的准确率升至 91%，且能写出分步解过程，直接服务了 20 万学生用户

代码生成助手的自我进化

阶段：强化学习与线上效果优化

解决的问题：代码模型如果只靠 GitHub 开源代码做有监督微调，容易产生“看起来像代码但编译不过”的问题。专家迭代以“编译 + 单测通过率”作为铁面裁判，自动淘汰伪代码，让模型在自我博弈中学会真正可运行的编码

具体案例：某独角兽公司的 AI 编程助手，在 HumanEval 基准上初始通过率 47%。工程团队构建了“生成器—验证器”闭环：让模型对每个函数题生成 50 个候选实现，逐一丢进 pytest 测试用例跑，通过的进训练集做 PPO 强化。3 轮迭代后，HumanEval 通过率提升至 79%，同时能自动修复自己此前产生的编译错误

Python 演示

python92 行
import randomimport mathfrom collections import Counter  class SimplePolicy:    """一个用参数猜测答案的极简模型"""     def __init__(self, weights=None):        self.weights = weights if weights else {"a": 1, "b": 1, "c": 1}     def sample_answer(self, question):        """给定问题，按当前权重随机采样一个答案"""        total = sum(self.weights.values())        r = random.uniform(0, total)        acc = 0        for ans, w in self.weights.items():            acc += w            if r <= acc:                return ans        return "a"     def compute_loss(self, question, answer):        """极简交叉熵损失：选到非最优答案时惩罚"""        best = question["answer"]        if answer == best:            return 0.0        return 1.0  # 最优答案之外都算一个单位的损失  def generate_trajectories(policy, question, n=20):    """采样 n 条解题轨迹（这里用答案代表轨迹）"""    return [policy.sample_answer(question) for _ in range(n)]  def filter_expert_trajectories(trajectories, question):    """用规则验证器筛选：只保留答对的轨迹"""    return [t for t in trajectories if t == question["answer"]]  def update_weights(policy, expert_trajs, question, lr=0.3):    """微调：提高被选中好答案的权重"""    counts = Counter(expert_trajs) if expert_trajs else Counter()    best = question["answer"]    # 如果没有好轨迹，就用正确答案做监督信号    if best not in counts:        counts[best] += 1    for ans in counts:        policy.weights[ans] += lr * counts[ans]    # 归一化    total = sum(policy.weights.values())    for ans in policy.weights:        policy.weights[ans] /= total    return policy  def evaluate(policy, questions, m=20):    """在评测题上计算正确率"""    correct = 0    for q in questions:        for _ in range(m):            if policy.sample_answer(q) == q["answer"]:                correct += 1                break    return correct / len(questions)  def main():    random.seed(42)    # 构造 100 道题，答案分布在 a/b/c    questions = []    for i in range(100):        questions.append({"id": i, "answer": random.choice(["a", "b", "c"])})     policy = SimplePolicy()    print("初始准确率: {:.2f}".format(evaluate(policy, questions)))     for rnd in range(5):        train_data = []        for q in questions[:60]:            # 1. 采样：生成 20 条解题轨迹            trajs = generate_trajectories(policy, q, n=20)            # 2. 筛选：规则验证器挑出正确轨迹            experts = filter_expert_trajectories(trajs, q)            # 3. 微调：提高好答案的权重            policy = update_weights(policy, experts, q)        acc = evaluate(policy, questions[60:], m=20)        print("第 {} 轮迭代后，新题准确率: {:.2f}".format(rnd + 1, acc))  if __name__ == "__main__":    main()
目的：用 100 道选项题模拟专家迭代的三步循环——采样（generate_trajectories）、筛选（filter_expert_trajectories）、微调（update_weights），观察模型在全新题目上的准确率随迭代稳步提升。
  1. class SimplePolicy:定义策略类，内部用三个答案的权重表示“模型倾向”，权重越高的答案越容易被采样到
  2. policy.sample_answer(question)按当前权重做随机采样，相当于让模型生成一条解题轨迹
  3. generate_trajectories(policy, question, n=20)对同一道题采样 20 次，模拟专家迭代的“广泛生成”阶段
  4. filter_expert_trajectories(trajectories, question)用规则验证器筛选，只保留答案正确的轨迹，对应专家轨迹筛选
  5. update_weights(policy, expert_trajs, question, lr=0.3)把好答案的权重调高，相当于监督微调让模型更倾向“说对的话”
  6. evaluate(policy, questions[60:], m=20)用没训练过的新题评估泛化能力，验证迭代是否真正让模型变聪明

常见误区

误区模型每轮都是用自己生成的数据训练自己，一个学生反复看自己写的作业怎么可能进步？这难道不是闭门造车吗？

正解这忽略了“筛选”这个关键环节。模型不是照单全收地抄自己，而是生成大量候选后，用规则验证器、奖励模型等外部信号挑出最优秀的轨迹来学。就像学徒打十把剑，只学最锋利那把的锻造手法——打磨自己最好的作品，本身就是进步。AlphaGo 正是靠这种方式超越人类棋谱的。而且强化学习的加入让模型还能主动探索新策略，不会困在原地

为何常见：很多人把“从自身数据学习”和“循环依赖”画等号，没有意识到外部验证信号打破了自嗨循环。实际上，筛选信号来自任务本身（答案对错、测试用例），是独立于模型的标准

误区我是做训练的，GPU 够多，是不是每道题采样 1000 条轨迹，效果一定比采样 100 条好很多？

正解采样数量不是越多越好。超过一定规模后，边际收益急剧下降——多出来的轨迹大多是重复的低质量内容。盲目堆采样量反而挤占微调预算，拖慢迭代周期。更好的做法是控制样本多样性（温度退火、分组采样），配合高质量筛选器，让每一批轨迹都“少而精”。同时速度优先，快速完成多轮迭代往往比单轮狂采更有效

为何常见：直觉上“数据多=效果强”，但忽略了轨迹数据的信噪比问题。专家迭代的关键在筛选率而非原始采样量，好筛子比大池子更重要

误区既然验证器能判断对错，那我直接把得分最高的几条轨迹全部拿去训练，是不是最优策略？

正解这样做容易“刷分”。模型可能学会利用验证器的漏洞，比如生成特别长的答案来干扰打分、或者猜一个看似精妙的错误步骤。更合理的做法是：结合多数投票（多个轨迹相互印证）、过程奖励（不只评结果还评过程）、以及人工抽样检查。就像铁匠试剑，不能只看剑能不能砍断一根麻绳，还得看刃口有没有崩、剑身有没有暗裂

为何常见：人容易把“得分高”等同于“质量高”，但验证器只能测到有限维度，建模不了推理过程的全部质量。这是所有“用模型评模型”范式共有的坑

误区听说大模型训练都要 RLHF，专家迭代也是迭代式的，还要奖励模型打分，这不就是同一种方法吗？

正解两者有本质区别。RLHF（基于人类反馈的强化学习）依赖人类标注者对模型输出排序打分，核心是建模人类偏好；而专家迭代的筛选信号主要来自任务本身的可验证规则（数学答案、代码用例）或模型内部的多数投票，可以完全不需要人工标注。专家迭代更强调“自我博弈—自动筛选”的闭环，适合有明确标准答案的场景；RLHF 更擅长开放式、主观偏好的对齐场景。两者也可以结合：先用专家迭代把推理能力练强，再用 RLHF 做安全与偏好对齐

为何常见：两者都用了强化学习和奖励模型，菜单看起来很像，让人误以为是一道菜。但“人类偏好”和“任务正确性”是两种根本不同的监督信号，训练目标也完全不同

误区既然专家迭代能让模型从 60% 准确率涨到 90%，那我把所有难题都丢给它，多迭代几轮它是不是就能解决哥德巴赫猜想了？

正解专家迭代的前提是任务结果可自动验证，且模型在初始阶段有一定的基础能力。对于完全超出模型能力边界的超难问题，采样出的轨迹全部是错的，筛选器筛不出任何专家轨迹，迭代根本无法启动。此外，迭代数据分布一旦与评测数据分布偏离，模型在真难题上仍会大幅退化。说白了，铁匠能打好剑是因为他先掌握了基本的打铁手艺，迭代是“从 70 分到 95 分”的路径，不是“从 0 分到 100 分”的魔法

为何常见：人们看到 benchmark 分数的漂亮曲线，容易过分外推模型能力，忽略了迭代的作用边界是“在已有能力基础上的自举强化”

面试题

Q1. 专家迭代（Expert Iteration）的核心思想与以下哪个概念最接近？

单选题 · mid

  • A.人类标注者逐条标注偏好数据
  • B.模型生成轨迹后筛选优质样本再学习← 正确答案
  • C.直接使用互联网语料预训练
  • D.用更大的模型蒸馏小模型

答案：B。专家迭代的骨架是“生成—筛选—学习”循环，先让模型输出大量轨迹，再用验证器挑出好的作为训练目标，对应选项 B。A 是 RLHF 的典型流程；C 是预训练；D 是知识蒸馏，都与“自我博弈式迭代”的核心机制不同。

Q2. 在专家迭代的“采样”阶段，控制模型生成多样性的关键参数是？

单选题 · easy

  • A.学习率
  • B.温度（Temperature）← 正确答案
  • C.批大小
  • D.权重衰减

答案：B。温度参数控制 softmax 输出的概率分布锐度，温度越高，模型越倾向随机采样不同路径，生成更多样化的解题轨迹。学习率、批大小、权重衰减都是优化器相关参数，不直接控制生成多样性。

Q3. 下列哪些方法可以作为专家迭代中筛选优质轨迹的“裁判”？

多选题 · mid

  • A.规则验证器（如数学答案核对、代码单测）← 正确答案
  • B.多数投票（Self-Consistency）← 正确答案
  • C.人类逐字转录模型输出
  • D.过程奖励模型（PRM）← 正确答案

答案：ABD。规则验证器用标准答案或测试用例检验，多数投票靠多条轨迹的一致性判断，过程奖励模型对逐步推理打分，三者都是专家迭代中常用的筛选手段。C 选项“人类逐字转录”不是筛选手段，是数据标注方式。

Q4. 专家迭代的“筛选”阶段，为什么要避免只使用最终答案作为唯一评判标准？

单选题 · mid

  • A.因为最终答案容易算错
  • B.因为可能出现“蒙对答案但推理过程错误”的轨迹← 正确答案
  • C.因为模型不会生成最终答案
  • D.因为最终答案会泄露训练集

答案：B。只核对最终答案时，模型可能随机猜中答案，但中间推理步骤一塌糊涂（“蒙对的学渣”）。这类轨迹进入训练集会污染模型。所以需要过程奖励模型给逐步推理打分，或结合多数投票过滤偶猜，保证学习到的是“会推理”而不是“会蒙”。

Q5. 专家迭代中，模型“自己生成数据自己学习”为什么不会简单退化？

单选题 · easy

  • A.因为模型会自动保存所有旧版本
  • B.因为外部验证器/奖励模型提供了独立的质量信号← 正确答案
  • C.因为模型参数量足够大就不会退化
  • D.因为每次迭代都会重新初始化权重

答案：B。模型的确在用自己产出的数据学习，但筛选环节的外部信号（规则验证器、奖励模型）是独立于模型的“客观标准”，保证只有优质轨迹被保留下来。这相当于学徒只向自己最好的作品学习，不学废品，因此能逐轮进步。

Q6. 专家迭代训练中，想要实现“新策略在探索的同时不偏离旧策略太远”，应该采用哪种技术？

单选题 · hard

  • A.交叉熵 SFT 损失
  • B.PPO 中的 KL 散度约束← 正确答案
  • C.温度退火调度
  • D.梯度裁剪

答案：B。PPO 损失中显式加入了 KL 散度项，衡量新策略与参考策略的分布距离，防止策略更新过猛导致训练崩溃。SFT 损失用于模仿阶段，温度退火控制采样多样性，梯度裁剪只防梯度爆炸，都与“策略偏移约束”不直接相关。

Q7. 专家迭代应用到代码生成任务时，常用的自动筛选信号包括？

多选题 · mid

  • A.代码是否通过单元测试← 正确答案
  • B.编译能否成功← 正确答案
  • C.代码注释数量多少
  • D.代码是否有语法错误← 正确答案

答案：ABD。编译通过、单测通过、无语法错误都是代码“可运行性”的硬信号，可作为验证器。代码注释数量与功能正确性无关，注释多不代表逻辑正确，因此不适合作为筛选标准。

Q8. 专家迭代中的“分布坍缩”陷阱指的是？

单选题 · mid

  • A.模型训练数据量越来越大
  • B.模型收敛到少数几种固定解法，多样性丧失← 正确答案
  • C.模型的参数分布越来越均匀
  • D.评测基准分数持续波动

答案：B。当筛选标准单一且迭代多轮后，模型会倾向重复产生少数几种被奖励过的解法，解题策略多样性下降，面对分布外题目时泛化能力变差。这是专家迭代中典型的“贪心陷阱”，需要通过奖励多样性和控制筛选阈值来缓解。

Q9. 关于专家迭代与 RLHF 的区别，下列说法正确的有？

多选题 · hard

  • A.专家迭代的反馈信号可以来自任务本身（答案、测试用例）← 正确答案
  • B.RLHF 必须依赖人类偏好标注← 正确答案
  • C.两者都使用强化学习更新模型← 正确答案
  • D.专家迭代不需要任何外部验证信号

答案：ABC。专家迭代的“裁判”可以是规则验证器等自动信号，不依赖人类；RLHF 的下游信号是人类偏好排序，两者都能结合强化学习做策略优化。D 错误——“不需要外部信号”是误解，专家迭代恰恰依赖验证器或奖励模型这种外部客观信号。

Q10. 数学推理任务中，专家迭代冷启动困难（奖励稀疏）时，最合理的应对策略是？

单选题 · easy

  • A.直接跳到超难题目开始训练
  • B.从简单题开始迭代，逐步提高难度← 正确答案
  • C.把温度调到最低，只生成确定性答案
  • D.放弃采样，全部用人类标注

答案：B。冷启动时模型能力弱，在难题上采样全是 0 分轨迹，无法筛选。从简单题起步能保证积累第一批优质轨迹，再逐步加大难度，是标准的课程学习（Curriculum Learning）策略。C 消除多样性后更无轨迹可选；A 会直接卡死；D 放弃了专家迭代的自动化优势。