大模型自检自改新范式，无需人工标注_AI热点日报

这篇论文提出的方法，可以说是给大模型装上了一个“自我审查”的大脑——它不再只是会解题的工具，还能像老师一样给自己批改作业。传统上，我们训练大模型做复杂推理（比如数学、编程题），往往依赖人工标注来告诉它对错；但这里，作者彻底碘伏了这套范式，用一套强化学习框架，让模型在同一个训练循环里同时学会“解题”和

_{❝一句话概括，这篇论文教大模型左右互搏，自己出题自己改，改不好还要挨板子，堪称精神分裂式学习法。}

第一阶段：识别核心概念

此阶段是介绍阶段，先不引入公式，用自然语言把关键想法讲清楚。

1. 论文的motivation分析

这篇论文讨论的核心问题是：当大语言模型（LLM）做复杂推理时，如何让它不仅“算对答案”，还能“自我审查”和“自我验证”。目前常见的强化学习方案是给模型一个“可验证的奖励”（verifiable reward）——比如数学题或编程题，答案对错可以用程序自动判定，然后拿这个对错信号来指导模型学习。但作者发现，这种做法很容易导致模型出现“表面式的自我检查”：模型可能靠运气猜对答案，并没有真正学会严谨地反思或验证自己的结论。

于是，作者提出一个新思路：在同一个强化学习过程中，同时教会模型“怎么解决问题”和“怎么评判自己的答案是否正确”。他们把这两件事整合到一个统一的训练流程中，每次迭代都让模型先解题，再对自己的解题结果做自我打分，然后一起更新模型参数。这样做的动机很直接——让“解决问题”和“自我验证”在训练时就紧密绑定，促使模型形成真实、有效的自我检查机制，而不是只学到表面形式。

简单说就是：“要让模型既会解题，又会当裁判”，并且这两个能力要在同一个强化学习循环里一起进步。

2. 论文主要贡献点分析

列出论文声称的主要创新点

论文声称的主要创新点可以总结为三条：

同时训练解题和自验证的强化学习框架。以往的做法往往是先让模型学会解题，再“另起炉灶”去学怎么验证；或者只在解题过程中简单引入一些自我反思的文本提示。作者这里强调的是，“解题”和“验证”都在同一个在线强化学习过程里互相反馈和提升。
利用可验证的奖励来同时监督解题和验证。原本只给正确解答的二元奖励（1或0），现在也用于判断模型的验证输出是否和真实判定吻合。因为既然我们能判断一个解是否正确，自然也能对“预测分数”（模型自验证时的打分）是否准确做出真假判定。这样一来，模型不仅被强化学习去做对答案，还被强化学习去“验对”答案。
显著提高自验证能力，并带来更可靠的推理表现。实验表明，这种方法能让模型在“解题正确率”和“自验证准确率”两个指标上都大幅提升。而且自验证能力在推理时还能反过来帮助模型——比如利用自信度进行答案重排或加权投票，让最终结果更稳健。

找出支撑这些创新的关键技术或方法

支撑这些创新的关键技术，在于将“解题”和“验证”两个过程整合到单一的在线强化学习循环中，并为两者都设计基于“可验证结果”的奖励机制。模型在同一次学习迭代里，既要为生成正确的答案而努力，也要为准确评估自己答案的正确性而努力，两者通过共享的奖励信号和策略更新机制相互促进。

论文有哪些显著性的结果

论文中最显著或最有意义的结果包括：

在数学解题场景中，模型不仅在正确率上显著超过baseline，还能学到更好的“自我打分”能力——预测自己是否正确的准确度远高于普通模型。
在推理时，“自我验证”可以用来进行答案重排或加权投票，让模型在推理步骤中更好地利用自信度，从而得到性能的进一步提高。这表明模型学会了更深层次的自我认知，而不仅仅是表面上的答案匹配。

3. 理解难点识别

分析哪些概念/方法是理解论文的关键

要深入理解这篇论文，需要抓住以下关键概念或方法：

可验证的奖励（Verifiable Reward）。不同于传统人工打分或人类偏好打分，这里的奖励是可以自动判断的对错信号。比如数学题中，如果模型最终答案和标准答案一致，奖励就是1，否则是0。这个机制既适用于检测“解题”，也适用于检测“自验证是否正确”。
在线强化学习与“自我验证”同时进行。论文核心在于：把生成答案的过程和随后自验证的过程都纳入同一条强化学习轨迹。这种“同时训练”的思路以及“先生成再检验，检验完再更新”的过程需要仔细理解。
自验证如何反过来帮助解题。论文不只是训练了一个验证器，还强调训练后模型内在地学会了边解题边反思——在推理过程中更倾向于产生对自己思路的检查，而不是简单按提示输出。

找出这些概念中最具挑战性的部分

最具挑战性的部分在于：为什么要在同一个训练循环里做这两件事？以及如何具体实现在线生成与在线验证？需要“按轨迹”来做强化学习，轨迹里既包含“解题动作”的token流，也包含“验证动作”的token流，二者怎么拼在一起、怎么计算整体奖励、怎么同时做策略更新——这些都是理解的难点。

确定需要重点解释的核心概念

通过以上分析可以发现，“如何将解题和自验证融入同一个在线强化学习框架”，这一点是整篇论文最具新意、也最不直观的核心。具体来说有两点：一是可验证的奖励在解题和自验证两个任务上的具体用法；二是这两个子任务如何在一个在线（on-policy）的强化学习循环中互相促进。

4. 概念依赖关系

梳理核心概念之间的关系

结合上面的分析，读者需要先知道什么是可验证的奖励以及它和传统强化学习奖励的区别，才能理解为什么自验证也能被“打分”。在此之上，需要理解什么是在线强化学习过程：模型每次都要先解题、再验证、再一起更新策略参数。最后是自验证在推理时带来的影响：它如何改变模型的内在推理策略。

确定解释的最佳切入点

一个合适的切入点是：先介绍可验证的奖励 → 再介绍在线强化学习怎么把解题和自验证都纳入一个循环 → 最后让读者知道这个自验证学到的策略还能作用在推理里，带来更好的解题表现。

第二阶段：深入解释核心概念

此阶段重点是引入比喻，并将比喻和公式符号联系在一起。

1. 设计生活化比喻

选择一个日常场景或者容易理解的活动

让我们以“学生在考试中既要答题，也要给自己打分”来做比喻。

用这个比喻来展示核心机制是如何工作的

假设有一名考生小明，他参加了一场数学测验。测验形式很特殊：

做题：小明先要在试卷上完成每道题的解答。
自评：交卷前，小明还必须在旁边附上一个对“自己答案对不对”的打分或判断。
外部评分：最终有一个“绝对公正的自动阅卷系统”来判断小明交的答案到底是否正确，并且还会去比对“小明的自评”是否准确。

小明会根据自己答题+自评的表现拿到一定的分数，分数包含两部分：

解题分：如果答案正确，就给1分；若答题格式还对了（比如必须在答题卡指定位置写答案），可能再加一点；否则不给分或扣分。
自评分：如果小明自己说“我这题做对了”，而实际上系统判定也对了，那么自评就得分；反之，如果小明自己说对了但其实错了，则自评相当于打错分，就不得分；同理如果小明自己说“我错了”而事实是对的，也要扣自评分。

由于这个考试是“在线学习”的形式，小明在每一轮测验后都会根据系统打出来的分数（解题分+自评分）来反思、改进自己的解题策略和打分策略；然后继续下一轮的测验。

确保比喻简单且直观，最好是大多数人都熟悉的场景

这个场景中，小明做题的过程对应了解题生成，而小明给自己打分对应了自验证。那个自动判卷系统就像论文里提到的“可验证的奖励”，它可以不需要人工干预、直接判断对错，从而给出清晰的分数。

2. 建立比喻与实际技术的对应关系

列出比喻中的关键元素

“小明做题”
“小明给自己打分（自评）”
“自动判卷系统”
“拿到总分后，下一轮会改进策略”

说明每个元素对应的实际技术概念

“小明做题” ↔ “模型在生成解题答案（problem-solving trajectory）”。小明最终会写出详细解题步骤和答案；模型则会输出一步步的token直到得到最终答案。
“小明给自己打分（自评）” ↔ “模型对自己生成的答案做验证（self-verification trajectory）”。小明会写一句“我觉得我答对了”或“我觉得我答错了”；模型会对自己刚才产出的答案进行打分和解释。
“自动判卷系统” ↔ “outcome verifier（可验证的奖励信号）”。当小明完成解答和自评后，一个自动系统会算出“小明答案是否正确”，以及“小明是否自评正确”。模型中则是用一个规则/程序来对模型答案正确与否进行打分，同时对模型在自验证环节的判定准确性也进行打分。
“拿到总分后，下一轮会改进策略” ↔ “PPO等强化学习算法，对解题策略+验证策略做同时更新”。小明下次答题或自评时，可能会更加谨慎思考；模型在下一个训练iteration中，会通过策略梯度来更新参数，从而学习到更好更稳健的解题和自验证方法。

解释为什么这些对应关系是合理的

这个比喻之所以合理，是因为它很好地体现了论文所说的“在线自验证”：解题和验证在同一个过程中，相互影响，统一地被奖励信号所更新，而不是把验证拆成一个独立的后处理模块。

3. 深入技术细节

从比喻过渡到实际的技术原理

在上面的比喻基础上，接下来我们用论文中的关键数学公式和算法术语，来解释这个“同时训练解题和自验证”的强化学习机制。读者可以对照比喻，先把抽象的数学符号映射到“考生答题”的场景。

解释相关的数学公式或算法

（一）政策梯度公式（Policy Gradient）

原始数学形式： （略，论文中用到的标准策略梯度公式）
符号替换版本：“为了让小明拿到更高总分，我们要沿着会让小明分数上升的方向调整小明的答题策略。假设小明对每道题每一步写下的答案片段（token）都有一个概率。我们就不断地微调这些概率分布，让那些导致分数变高的行为更容易被执行，让导致分数变低的行为更不容易被执行。”
其中，π是策略网络，输出动作的概率；A是优势函数，代表“在这个时刻输出这一步，究竟比平均表现好多少”。如果比平均值好，就要更多地增加它的概率；反之则要抑制。

（二）优势函数（Advantage Function）

原始数学形式：论文里给出的优势函数常见形式是GAE或TD残差。
符号替换版本：“某个回答步骤的价值（优势）= 这道题最后拿到的总奖励 - 大家在类似题目上通常拿到的水平”。例如：将优势值标准化为“这次尝试的奖励 - 所有尝试的平均奖励）/所有尝试奖励的波动程度”。当为正时，表示“写下这个步骤”好过一般，应该提升写下它的几率；反之则减少。

（三）可验证奖励（Verifiable Reward）

原始数学形式：论文中没有直接给统一数学公式，而是描述其机制。
符号替换版本：“如果小明既答对了题，也正确地判断自己做对没，那么解题奖励+自评奖励两部分都能拿到好处；反之要么丢掉解题奖励，要么丢掉自评奖励。”
- 解题奖励：如果最终答案正确且格式合规，解题奖励=1；若答对了但格式不对，也许给个负分或不加分；若答错了就给0或-1。
- 验证奖励：如果模型在自验证环节给出的打分或判断和真实对错一致，则验证奖励=1分，否则是0分。

（四）PPO（Proximal Policy Optimization）在这里的作用

原始数学形式：PPO核心目标函数包含clip操作。
符号替换版本：“我们要让小明每次根据上次考试策略和这次考试策略之间的差别，适度地修正自己的答题偏好，不能一下子大幅度改头换面（通过一个‘裁剪’操作限制变化幅度），以免走极端。”

说明技术实现中的关键步骤

论文中主要使用PPO算法，把上面那些奖励值、策略概率等信息组合到一起进行更新。PPO有控制更新幅度的技巧（如clip操作或KL惩罚），核心思想是在保证策略不会走极端的同时，让解题策略和验证策略都朝着“更高分”的方向前进。

4. 将技术细节与比喻相互映射

解释每个技术步骤在比喻中的体现

在比喻里，“小明做题+小明自评”就是模型生成答案+模型生成验证结论，合在一起构成一条完整的“回答轨迹”。
“自动判卷系统”对回答轨迹打出的分数，对应了可验证奖励。
“小明拿到分数后反思，下次考试时策略会更好”对应了在PPO里进行一次策略更新。每次更新后，策略参数都往“解题更正确、验证更可靠”的方向移动。
整个过程重复多轮，每轮的答题和自评都在“on-policy”状态下进行采样，保证了模型学到的验证策略和解题策略是彼此关联的。

说明比喻如何帮助理解技术细节

比喻将抽象的强化学习概念（策略、奖励、优势函数、PPO更新）具象化为学生考试、评分和学习改进的过程，使得理解“在线同时训练解题与自验证”这一核心机制变得更加直观。

将数学公式中的概念对应到比喻中的具体行为或现象

π(a|s)（策略网络输出动作的概率）对应“小明在当前题目和已写步骤下，选择写下一个特定字词或符号的倾向性”。
A(s,a)（优势函数）对应“小明写下某个步骤后，最终得分比他平时在类似情况下写这个步骤的平均得分高多少”。
r_sol（解题奖励）和r_ver（验证奖励）对应“自动阅卷系统给小明答题部分和自评部分分别打的分数”。
PPO的clip操作对应“老师告诉小明，即使这次考得特别好或特别差，下次调整学习方法时也不要一下子改得太猛，要循序渐进”。

指出比喻的局限性（如果有的话）

真实的强化学习还有许多超参数和细节实现（学习率、价值函数更新方式、熵正则化等），在“小明考试”的场景中没有呈现得那么复杂。但这个比喻至少帮助读者理解了“在同一次答题过程中，如何同时对解题和自评给分并更新”。

5. 总结

重申比喻与实际技术的核心联系

通过“小明既要答题又要给自己打分，再由自动系统做客观判卷”的生活场景，比喻了论文中“解题+自验证+可验证奖励+在线RL训练”的核心机制。

强调这种对应关系如何帮助理解整个概念

可以看到：小明的行为策略好比模型的“问题求解策略+自检策略”；考试评分系统则是一个“可验证奖励机制”，既能打解题分，也能打自评对不对的分；小明在每次测验后会同步改进自己的解题和自评方法——对应的就是在线策略梯度/强化学习对模型进行更新。

用比喻来总结最关键的数学原理

这个对应关系帮助我们把复杂的强化学习框架和自验证思路形象化。等读者明白了这个流程，就很容易理解为什么把“解题”和“自验证”放在同一个训练循环中，可以让模型学到更真实、有用的“自我审核”技能。最关键的数学原理——策略梯度，就像小明根据每次考试的“优势”（做得比平时好还是差）来调整自己“解题和自评的习惯（策略）”，PPO则保证这种调整是稳健的。

第三阶段：详细说明流程步骤

1. 论文提出的完整模型或方案处理问题的具体流程是什么，举个例子从输入如何处理通过模型和方法处理得到输出详细说明

该论文的核心方法是一个在线强化学习框架，用于同时训练大语言模型的“解题（生成）”和“自验证（验证）”能力。整个流程可以被拆解为以下几个主要阶段：

批量取样问题（Batch Sampling）——从训练数据中取出一批问题，模型将对每个问题先进行答案生成，得到若干条完整的解答。
答案评估并生成可验证奖励——每条答案交由一个“可验证的外部判定器”来检测对错并计算奖励。
构建自验证任务——根据模型生成的答案，再构造新的“验证提示”让模型对自己刚刚生成的答案进行打分或评判。然后同样用外部判定器比较模型打分与真实答案对错，得到验证任务的奖励。
拼接解题和验证的轨迹，一并做强化学习更新——将每条问题的“解题序列”与“自验证序列”都作为一个整体来计算优势函数和策略梯度；在PPO等RL算法下，对模型的参数进行更新。
重复迭代——多轮地进行以上步骤，模型的解题策略和自验证策略会逐步变好。

这样就能保证模型在训练时，解题与自验证是“绑定”在同一条RL轨迹里：模型输出答案后立刻要对自己答案做打分，并且能同时获得相应的奖励或惩罚信号。

下面把整个流程展开得更细致一些，尤其关注输入和输出的衔接：

准备输入
- 输入的数据集由“问题（及其标准答案）”组成，比如数学题、编程题等。
- 在每轮迭代中，我们先随机抽取一个批次的问题（例如batch size=1024）。
模型生成解题答案（Generation Phase）
- 对于每个问题，模型在当前策略下依次输出解题步骤与最终答案，可以采样多次（例如rollout=8），产生多条候选解答。
- 这些解答的输出（文本token序列）会被记录，接下来要进入判定环节。
外部判定器计算“解题奖励”
- 这一步就像论文中提到的outcome verifier（OV），根据最终答案与标准答案的对比来判定对错以及格式是否规范，赋予一个离散数值奖励（如1/0/-1）。
- 这样就得到了一批训练样本。
构造“验证问题”并让模型做自验证
- 以解题结果（问题 & 解答 & 解题奖励）作为上下文，利用一个固定模板生成验证提示，要求模型输出对之前那条解答的打分或判断。
- 模型在“自验证阶段”也会生成一段文本，包括解释“为什么正确或错误”，以及一个数字分数（如1表示认为自己是对的，0表示认为自己是错的）。
外部判定器计算“验证奖励”
- 再次将模型的自验证结论与实际的对错结果做比较。如果模型在自验证里说“答案对”，而且实际确实对，则验证奖励=1；否则=0或负值。
- 由此得到新的训练样本。
将“解题轨迹”和“验证轨迹”合并成一个RL更新批次
- 模型在解题时生成的token序列，和在自验证时生成的token序列，都需要打上各自的“奖励”标签（一个对应解题奖励，一个对应验证奖励），并计算各自的优势函数。
- 最后合并到统一的PPO或其他RL算法里做一次参数更新。
重复迭代
- 当这一步更新结束后，模型策略（指“如何解题”和“如何验证”）都会同时发生变化；
- 下一轮再重复“抽样问题-解题-计算奖励-自验证-计算奖励-合并更新”的循环。
- 不断迭代，直至训练过程收敛或达到预设的最大步数为止。

2. 这个阶段重点在于对过程的详尽描述，你需要保证其中一个过程的输入经过这个过程的处理后，得到的输出可以作为下一个过程的输入。

上述流程已经保证了这一点。例如：步骤1的输出（一批问题）是步骤2的输入；步骤2的输出（模型生成的解答）和步骤1的输入（问题）一起，成为步骤3的输入，用于计算解题奖励；步骤3的输出（解题奖励）连同步骤1和2的输出（问题、解答），成为步骤4的输入，用于构造验证提示；步骤4的输出（模型生成的验证结论）和步骤3的输出（真实的解题奖励/对错情况）成为步骤5的输入，用于计算验证奖励；步骤2、3、4、5产生的所有数据（问题、解答、解题奖励、验证提示、验证输出、验证奖励以及对应的模型生成序列）成为步骤6的输入，用于强化学习更新；步骤6更新后的模型，又会用于下一轮迭代的步骤2。

3. 确保一个没有看过这篇论文的人，能够根据你的详细叙述准确还原出方法或流程的伪代码

为了让读者能“照着就能写”，下面给出一段简化的伪代码，体现上面描述的关键逻辑。可以将其视作论文中算法流程的概括版：

# 假设我们使用PPO为主干RL方法
initialize policy π_θ and value function V_ϕ with model parameters

for iteration in range(num_iterations):
    # Step 1: 采样问题
    problem_batch = sample_problems(batch_size)  # (问题列表)

    generation_trajectories = []  # 用于存储 (问题, 解答序列, 解题奖励, 解题log_probs, 解题values)
    verification_trajectories = []  # 用于存储 (验证提示, 验证序列, 验证奖励, 验证log_probs, 验证values)

    # Step 2 & 3: 生成阶段并获取解题奖励
    for problem_prompt in problem_batch:
        # 在当前策略下，采样多条解答 (rollouts)
        for _ in range(num_generation_rollouts):
            # generated_solution_tokens: list of tokens
            # log_probs_gen: log probability for each token
            # values_gen: value estimate for each state (token prefix)
            generated_solution_tokens, log_probs_gen, values_gen = π_θ.generate_with_logprobs_values(problem_prompt)
            generated_solution_text = detokenize(generated_solution_tokens)

            # 使用外部判定器评估
            reward_for_solution = outcome_verifier(problem_prompt, generated_solution_text)  # e.g., 0 or 1

            # 记录解题轨迹相关信息
            generation_trajectories.append({
                "prompt": problem_prompt,
                "solution_tokens": generated_solution_tokens,
                "reward": reward_for_solution,
                "log_probs": log_probs_gen,
                "values": values_gen
            })

    # Step 4 & 5: 自验证阶段并获取验证奖励
    for gen_traj_data in generation_trajectories:
        problem_prompt = gen_traj_data["prompt"]
        solution_text = detokenize(gen_traj_data["solution_tokens"])
        actual_solution_correctness = (gen_traj_data["reward"] == 1)  # True if solution was correct

        verification_prompt = make_verification_prompt(problem_prompt, solution_text)

        for _ in range(num_verification_rollouts):
            # verification_output_tokens: list of tokens
            # log_probs_ver: log probability for each token
            # values_ver: value estimate for each state (token prefix)
            verification_output_tokens, log_probs_ver, values_ver = π_θ.generate_with_logprobs_values(verification_prompt)
            verification_output_text = detokenize(verification_output_tokens)

            # 判定自验证是否准确
            # parse_verification_assessment: extracts model's belief (e.g., True if model thinks solution is correct)
            model_assessment_is_correct = parse_verification_assessment(verification_output_text)
            reward_for_verification = 1.0 if (model_assessment_is_correct == actual_solution_correctness) else 0.0

            verification_trajectories.append({
                "prompt": verification_prompt,
                "verification_tokens": verification_output_tokens,
                "reward": reward_for_verification,
                "log_probs": log_probs_ver,
                "values": values_ver
            })

    # Step 6: 拼接轨迹做RL更新（使用PPO的方式）
    # combined_trajectories 将 generation_trajectories 和 verification_trajectories 的数据
    # 按照PPO的要求（如计算GAE优势、格式化）进行整合
    # 然后执行一次或多次PPO优化步骤
    # 注意：在PPO更新时，解题轨迹和验证轨迹是分别计算其优势函数和损失的，
    # 但它们都贡献于同一个策略网络 π_θ 的梯度。
    ppo_update_step(policy=π_θ, value_function=V_ϕ,
                    generation_data=generation_trajectories,
                    verification_data=verification_trajectories)
# end for

在这个伪代码里：outcome_verifier负责计算解题对错的奖励；make_verification_prompt根据问题和解答构造验证任务的提示；parse_verification_assessment从模型的验证输出中解析出模型对原解答的判断（例如，模型认为原解答是“对”还是“错”）；ppo_update_step代表了PPO算法的核心更新逻辑，它会使用收集到的所有轨迹数据（包括解题和验证两部分）来计算损失并更新策略网络和价值网络。

等到最后，训练好的策略就具备了更强的解题能力，并且在回答问题时更善于做自我批判、知道什么时候自己很可能答错。

完整示例：一道数学题从输入到输出

输入
- 训练集中的一道题：“Question: 求 2 + 2 的值。” 正确答案：4
模型解题（Generation Phase）
- 模型接收 "Question: 求 2 + 2 的值。" 作为 problem_prompt。
- 模型生成解题过程 generated_solution_tokens，可能输出：["2", "+", "2", "=", "5", "，", "最", "后", "答", "案", "=", "5"]（detokenized: "2+2=5，最后答案=5"）。
- 同时记录 log_probs_gen 和 values_gen。
外部判定器计算“解题奖励”
- outcome_verifier("Question: 求 2 + 2 的值。", "2+2=5，最后答案=5") 返回 reward_for_solution = 0。
- generation_trajectories 添加此条目。
构造“验证问题”并让模型做自验证（Verification Phase）
- make_verification_prompt("Question: 求 2 + 2 的值。", "2+2=5，最后答案=5") 生成："以下是对问题 'Question: 求 2 + 2 的值。' 的解答：'2+2=5，最后答案=5'。请判断此解答是否正确 (输出 '正确' 或 '错误') 并说明理由。"
- 模型接收此 verification_prompt，生成 verification_output_tokens，可能输出：["这", "个", "解", "答", "是", "错", "误", "的", "。", "2", "+", "2", "应", "该", "等", "于", "4", "。"]（detokenized: "这个解答是错误的。2+2应该等于4。"）。
- 同时记录 log_probs_ver 和 values_ver。
外部判定器计算“验证奖励”
- parse_verification_assessment("这个解答是错误的。2+2应该等于4。") 返回 model_assessment_is_correct = False（模型认为原解答错误）。
- actual_solution_correctness 在此例中是 False（因为原解答"2+2=5"是错的）。
- 由于 model_assessment_is_correct == actual_solution_correctness（False == False），所以 reward_for_verification = 1.0。
- verification_trajectories 添加此条目。
PPO 更新
- ppo_update_step 使用 generation_trajectories 和 verification_trajectories 中的数据（包括tokens, rewards, log_probs, values）来计算优势和损失，并更新模型参数 π_θ 和 V_ϕ。
- 对于解题部分，因为 reward_for_solution = 0，模型会学着减少生成 "2+2=5" 这种错误答案的概率。
- 对于验证部分，因为 reward_for_verification = 1.0，模型会学着增强其正确判断 "2+2=5是错误的" 这种验证行为的概率。

通过大量此类迭代，模型最终便能更稳定地输出“2+2=4”，同时也能很准确地给自己输出答案打分，从而形成一个既会做题又会审阅自己答案的“自洽”策略。