把自我改进 AI 变成人类学习算法：从 CS329A 到可执行教学系统与 MVP 实验

引言：AI 的自我改进算法，能否反过来训练人的思维？

斯坦福 CS329A《Self-Improving AI Agents》研究的核心问题，是一个已经具有一定能力的智能体，如何通过验证、反馈、搜索、规划、工具使用和训练循环持续提高表现。

2025 年秋季课程把 test-time compute、verifier、process supervision、ReAct、execution feedback、tree search、decomposition、STaR、强化学习、agentic search 等方法放在一条连续的技术线上。

如果暂时不考虑模型参数和梯度更新，而只观察这些系统在推理时采取的行为，会发现一个很有意思的共同结构：

flowchart LR
    A[尝试解决问题] --> B[观察过程或结果]
    B --> C{验证}
    C -->|可信| D[继续推进]
    C -->|可疑| E[定位错误]
    E --> F{怎么办}
    F --> G[局部修正]
    F --> H[换一个方案]
    F --> I[进一步拆解]
    F --> J[搜索外部信息]
    D --> K[完成任务]
    G --> A
    H --> A
    I --> A
    J --> A
    K --> L[反思并形成可复用经验]

这和优秀的人类学习者的行为相当相似。

数学高手并不只是“知道更多公式”，还更擅长判断哪一步可能错了；优秀程序员并不只是会写更多代码，还会主动设计测试，让错误尽早暴露；好的研究者并不只是阅读更多论文，而是知道什么时候缺的是推理、什么时候缺的是事实。

因此，这里的研究问题可以写成：

能否把自我改进 AI 中的 verifier、process reward、search、decomposition、feedback、curriculum 和 memory 等机制，转化成训练人类元认知与问题解决能力的教学算法？

这里需要避免一个过强的结论：AI 方法在模型上有效，并不意味着照搬到人类身上一定有效。

真正值得迁移的通常不是“大量采样”“几千次 rollout”这样的计算规模，而是其中的控制策略：

• 什么时候检查；
• 检查什么；
• 什么时候继续；
• 什么时候回溯；
• 什么时候拆问题；
• 什么时候寻找提示；
• 什么错误值得记录；
• 下一道题应该练什么。

1. PRM：从“答案错了”升级到“哪一步开始错了”

1.1 AI 中的方法

《Let's Verify Step by Step》提出的核心区别，是 Outcome Reward Model 与 Process Reward Model。

ORM 只关心最终结果：

flowchart LR
    A[完整推理过程] --> B[最终答案]
    B --> C{正确?}
    C -->|是| D[Reward = 1]
    C -->|否| E[Reward = 0]

PRM 则对中间步骤分别评价：

flowchart LR
    A[Step 1] --> B[Step 2]
    B --> C[Step 3]
    C --> D[Step 4]

    A --> A1[PRM score]
    B --> B1[PRM score]
    C --> C1[PRM score]
    D --> D1[PRM score]

OpenAI 随论文发布的 PRM800K 包含约 80 万个步骤级正确性标签，可以直接作为训练过程奖励模型的数据。

之后的 Math-Shepherd 等工作进一步尝试用自动 rollout 生成过程监督，而不必完全依赖人工逐步标注。

1.2 对人类教学的迁移

传统数学作业经常只有这种信息：

第 8 题：错。

这实际上只是 ORM。

更有教育价值的问题是：

你的推理从第几步开始失效？

例如：

1. 设函数 f(x) 连续。
2. 因此函数必然有零点。
3. 所以存在 x，使得 f(x)=0。

真正应该被拦截的是 Step 2。

学生如果能够自己识别：

“连续本身不能推出存在零点，还需要区间端点异号等附加条件。”

这比老师直接告诉他最终答案重要得多。

这与认知科学中的 self-explanation 研究也有较强联系。Chi 等人的经典研究发现，学习效果更好的学生在阅读 worked examples 时，会主动解释某一步为什么成立，并将具体步骤连接到一般原理。

1.3 人类版 PRM 可以怎么操作

可以要求学生每完成一个关键逻辑步骤，填写三个字段：

Step:
我做了什么？

Reason:
为什么这一步成立？

Confidence:
0% ~ 100%

并在完成整题以后再做一次：

Most suspicious step:
如果答案错了，我认为最可能错在哪里？

可以定义一个很有意义的能力指标：

$$\text{Error Detection Distance} =============================== |\text{真实首个错误位置}-\text{学生发现错误的位置}|$$

|\text{真实首个错误位置}-\text{学生发现错误的位置}|
$$

理想状态不是“永远不犯错”，而是：

错误出现之后，很快能够被发现。

2. Test-time Compute：难题应该多想，但不是无限硬想

《Large Language Monkeys》和 test-time scaling 一类研究表明，在有可靠 verifier 的情况下，对同一个问题增加采样、搜索和验证，通常能够提升找到正确答案的概率。

但关键不是简单地“想得越久越好”。

更准确的问题是：

再投入一次推理，预期收益还有多大？

对人类也可以这样处理。

flowchart TD
    A[遇到问题] --> B{当前状态}
    B -->|基本确定| C[直接完成]
    B -->|有两个候选方案| D[增加推理预算]
    B -->|明显缺知识| E[查资料/获取提示]
    B -->|问题太大| F[进一步拆解]

    D --> G[第二解法 / 反例 / 特殊情况]

对于一个学生，可以把题目分成三种状态：

A. 已掌握

继续做大量同类题收益很低。

B. 接近会做

此时最值得增加 test-time compute。

例如：

• 重新解一次；
• 找第二种证明；
• 构造反例；
• 测试特殊情况；
• 从结论向前提逆推。

C. 完全没有入口

此时继续盲目搜索，常常只是消耗工作记忆。

更适合：

• 看一个 worked example；
• 获取一个最小提示；
• 补前置知识。

所以人类版 test-time scaling 更像一个思考预算管理器。

3. ReAct 与 RLEF：把学习变成“做一点—看反馈—再决定”

ReAct 的基本结构是：

flowchart LR
    T[Thought] --> A[Action]
    A --> O[Observation]
    O --> T

它的重要启示是：

智能不必全部发生在“脑内推理”中，环境反馈本身可以成为推理的一部分。

RLEF 把类似思想应用于编程，让代码模型根据真实执行、compiler 和 tests 的反馈继续修改程序。

4. 编程教育：训练的重点可以从“写代码”变成“设计反馈”

很多初学者的工作模式是：

flowchart LR
    A[想完整程序] --> B[写很多代码]
    B --> C[第一次运行]
    C --> D[大量错误]
    D --> E[不知道从哪里修]

更好的学习循环是：

flowchart LR
    A[定义小目标] --> B[写测试]
    B --> C[实现一点]
    C --> D[执行]
    D --> E[读取反馈]
    E --> F[修改]
    F --> C

教学目标也因此发生变化。

不只是问：

你会不会写这个函数？

还应该问：

你准备怎样最快发现这个函数写错了？

4.1 Public Test / Private Test

RLEF 中 Public Tests 与 Private Tests 的设计，对教育尤其有启发。

学生自己可以看到的测试：

public tests

用于学习和调试。

学生看不到的 edge cases：

private tests

用于判断学生是否真的理解了问题，而不是只针对已有例子打补丁。

可以类比成：

flowchart TD
    A[学生代码] --> B[Public Tests]
    B -->|失败| C[允许修改]
    C --> A
    B -->|通过| D[Private Tests]
    D --> E{真正掌握?}

这比传统“给三个例子，三个例子跑通就算完成”更接近真实的软件工程训练。

5. Constitutional AI：把老师的评价标准逐渐内化成学生自己的 verifier

Constitutional AI 中，一个重要结构是：

flowchart LR
    A[Draft] --> B[Critique]
    B --> C[Revision]
    C --> D[Better Draft]

对学生而言，可以设计一个显式的 Cognitive Constitution。

例如数学证明：

1. 是否偷偷用了待证结论？
2. 每一个量词是否保持一致？
3. 有没有遗漏边界条件？
4. “显然”能否展开成严格推导？
5. 是否可以构造反例？

编程：

1. 输入输出契约是什么？
2. 空输入怎么办？
3. 最大输入怎么办？
4. 哪些地方可能抛异常？
5. 时间复杂度是多少？
6. 如何独立验证结果？

论文：

1. 每个主要 claim 是否有证据？
2. citation 是否真的支持该 claim？
3. 是否把 correlation 写成 causation？
4. 是否遗漏主要反例？

长期目标不是让学生永远依赖 checklist，而是逐渐把这些检查规则内化。

关于 self-assessment 的 meta-analysis 显示，这类干预能够改善 self-regulated learning 和 self-efficacy，但学生自己的评价并非天然准确，因此仍需要 rubric、范例和外部校准。

6. LATS：复杂问题应该保留多个候选路径

LATS 把语言模型的推理转化为树搜索。

对人类而言，不需要真的执行大规模 MCTS。

真正值得学习的是：

不要让第一个想到的方案变成唯一方案。

传统思维经常是：

flowchart TD
    A[Problem] --> B[方案 A]
    B --> C[A1]
    C --> D[A2]
    D --> E[A3]
    E --> F[失败]

树搜索式思维则是：

flowchart TD
    P[Problem]

    P --> A[方案 A]
    P --> B[方案 B]
    P --> C[方案 C]

    A --> A1[快速 probe]
    B --> B1[快速 probe]
    C --> C1[快速 probe]

    A1 --> V{评估}
    B1 --> V
    C1 --> V

    V --> S[选择最有希望的路径]

教学中可以明确要求：

在开始长推导前，先提出 2～3 个候选入口。

然后给每个方案一个低成本 probe。

例如数学题：

• 代数；
• 几何；
• 不变量；
• 归纳；
• 反证。

研究问题：

• 做理论分析；
• 找公开数据；
• 做小实验；
• 查相关领域已有结果。

7. ADaPT：问题应该拆多细，取决于学习者是谁

ADaPT 的核心思想非常适合教学：

只有当当前任务无法直接完成时，才继续分解。

也就是说，“原子任务”不是绝对的。

例如：

实现一个 REST endpoint

对熟练程序员可能已经足够小。

对初学者可能需要继续拆：

flowchart TD
    A[REST Endpoint]
    A --> B[定义 route]
    A --> C[解析输入]
    A --> D[validation]
    A --> E[调用 service]
    A --> F[异常处理]
    A --> G[serialization]
    A --> H[test]

所以可以写成：

$$\text{Required Decomposition Depth} =================================== f(\text{Task Difficulty},\text{Learner Skill})$$

f(\text{Task Difficulty},\text{Learner Skill})
$$

这一点也和 expertise reversal effect 的研究方向相符：对新手有帮助的详细指导，随着专业知识增加可能变得冗余。

8. SPRINT：真正值得迁移的是依赖关系，而不是“人脑并行”

SPRINT 将复杂推理重构成 DAG，使独立任务可以并行执行。

对单个人来说，同时进行多个复杂认知任务并不现实。

真正值得迁移的是：

识别依赖。

例如写研究论文：

flowchart LR
    Q[研究问题]

    Q --> L[文献研究]
    Q --> D[数据准备]
    Q --> M[方法设计]

    L --> S[综合解释]
    D --> A[数据分析]
    M --> A

    A --> S
    S --> W[论文写作]

这个图会立即暴露：

• 哪些工作必须等待；
• 哪些工作可以提前开始；
• 卡住一个任务时还能推进什么。

因此在人类学习中，与其叫 Cognitive Parallelism，更适合叫：

Dependency-Aware Planning

9. STaR：正确答案也可以成为训练数据，但必须重新生成

STaR 有一个非常有教育意义的机制。

模型第一次没有做对时，可以把正确答案作为提示，再要求模型构造能够抵达正确答案的推理链。

对应到学生：

flowchart TD
    A[独立尝试] --> B{成功?}
    B -->|是| C[解释为什么成功]
    B -->|否| D[给最小提示]
    D --> E[重新构造推导]
    E --> F[关闭提示]
    F --> G[独立再做]
    G --> H[做一道结构相似的新题]

这一点与 worked-example research 相当契合。

Sweller 与 Cooper 的研究表明，对新手而言，worked examples 可以减少无效 problem search，有助于 schema acquisition。

但这里有一个严重风险：

看懂解答并不等于会做。

所以最后必须加入 retrieval / transfer。

Roediger 与 Karpicke 的经典研究表明，相较于重复阅读，主动检索在延迟测试中能够产生更强的长期保持。

因此人类版 STaR 的最后一步应该永远是：

关闭答案，再做一次。

10. Curriculum Learning：下一题不应该随机出现

理想的自适应系统，不应该只维护一个：

数学水平 = 75

而应该维护技能图：

flowchart TD
    M[数学]

    M --> A[代数]
    M --> C[微积分]

    A --> A1[因式分解]
    A --> A2[方程]
    A --> A3[不等式]

    C --> C1[极限]
    C --> C2[导数]
    C --> C3[积分]

    C2 --> C21[链式法则]
    C2 --> C22[隐函数]
    C2 --> C23[极值]

每一道题的目标也不是单纯“再练一次”。

更重要的问题是：

做这道题以后，我们能获得多少关于学生能力的新信息？

可以把训练价值抽象成：

$$\text{Learning Value}(q) ======================== \mathbb{E}[\text{Future Performance Gain}\mid q]$$

\mathbb{E}[\text{Future Performance Gain}\mid q]
$$

这里很接近 active learning。

系统应优先寻找：

• 不是稳定会做的题；
• 也不是完全无法进入的题；
• 而是能够暴露当前边界能力的题。

11. Search-o1：学习者需要区分“不会推”和“不知道”

Search-o1 的关键是：

推理过程中遇到知识缺口时，动态触发搜索。

其代码已经公开，项目本身采用 MIT License。

对人的迁移非常直接。

遇到问题时先判断：

flowchart TD
    A[卡住] --> B{为什么卡住?}

    B -->|信息已经足够| C[Reasoning Gap]
    B -->|缺事实/定义/API/文献| D[Knowledge Gap]

    C --> E[继续推理]
    D --> F[检索]

    F --> G[提取相关证据]
    G --> H[更新原来的判断]

这种区别非常重要。

一个人如果遇到所有问题都立即搜索，就无法训练推理。

但如果面对事实缺口仍不断猜测，也不会得到可靠结论。

12. 一个统一的人类 Self-Improvement Loop

将这些方法合起来，可以得到一个更完整的学习架构。

flowchart TD
    C[Curriculum<br/>下一步练什么]

    C --> P[Problem / Goal]

    P --> PLAN[Planning<br/>怎么做]

    PLAN --> A[Attempt<br/>尝试]

    A --> ACT[Action / Execution]

    ACT --> V[Verifier / PRM<br/>检查]

    V --> Q{结果如何}

    Q -->|可信| CONT[Continue]
    Q -->|局部错误| FIX[Local Repair]
    Q -->|路线不好| BACK[Backtrack]
    Q -->|任务太难| DEC[Decompose]
    Q -->|缺知识| SEARCH[Search]

    FIX --> A
    BACK --> PLAN
    DEC --> PLAN
    SEARCH --> PLAN

    CONT --> DONE{完成?}

    DONE -->|否| A
    DONE -->|是| R[Reflection]

    R --> M[Memory / Skill Model]

    M --> C

这套结构所训练的，不只是 Solver。

还包括：

• Human Verifier；
• Human PRM；
• Human Planner；
• Human Decomposer；
• Human Search Controller；
• Human Curriculum Designer。

这可能比单纯“AI 帮学生解题”更值得研究。

13. 怎样真的搭一个系统：现成模型与工具

到这里为止还只是教学理念。

下面进入真正可以实现的部分。

截至 2026 年 8 月，如果目标是快速做一个实验，我不会先自己训练 PRM，而会直接采用已有开放权重模型。

13.1 数学 Solver

Qwen2.5-Math-7B-Instruct

用途：

• 生成数学题解；
• 生成候选提示；
• 生成变式题；
• 产生错误轨迹供 PRM 测试。

Hugging Face 模型：

Qwen/Qwen2.5-Math-7B-Instruct

模型采用 Apache-2.0 License，可以直接通过 Transformers 使用。

这个模型并不是必须的。

第一版系统甚至可以完全不需要 Solver：

学生自己产生 reasoning，PRM 只负责评分。

这反而更适合测试 PRM 对人类学习的作用。

13.2 最推荐的 PRM

Qwen2.5-Math-PRM-7B

Hugging Face：

Qwen/Qwen2.5-Math-PRM-7B

它专门用于对数学推理中间步骤进行评分，并在 ProcessBench 上进行了 error identification 测试。

模型可以通过 Transformers 加载：

from transformers import AutoTokenizer, AutoModel

MODEL = "Qwen/Qwen2.5-Math-PRM-7B"

tokenizer = AutoTokenizer.from_pretrained(
    MODEL,
    trust_remote_code=True,
)

model = AutoModel.from_pretrained(
    MODEL,
    trust_remote_code=True,
    device_map="auto",
)

这里不建议自己随意定义 score extraction。

直接按照模型 card 的 Quick Start 实现，因为 Qwen PRM 对 reasoning step 的分隔方式以及 reward token 有特定约定。

相关模型 card 明确建议将推理步骤分开，并通过特殊 reward token 获取每步对应的概率分数。

13.3 更轻量的 PRM

如果 GPU 比较有限，可以尝试：

Skywork/Skywork-o1-Open-PRM-Qwen-2.5-1.5B

其模型文件约 3.1 GB，明显比 7B PRM 更容易部署。

还有：

Skywork/Skywork-o1-Open-PRM-Qwen-2.5-7B

Skywork 的评测中同时比较了：

• Qwen2.5 Math PRM；
• OpenR Math-psa；
• RLHFlow PRM；
• Skywork PRM。

需要注意许可证：

Skywork 使用自己的 Community License，而不是 Apache/MIT；研究使用问题通常不大，但正式商业部署前应该重新阅读许可证条款。

13.4 其他可研究 PRM

还可以尝试：

RLHFlow/Llama3.1-8B-PRM-Deepseek-Data

模型目前可直接从 Hugging Face 获取并通过 Transformers 加载。

OpenR 则公开了：

openreasoner/Math-psa

以及完整 OpenR reasoning framework。

OpenR 的目标本身就是把 advanced reasoning、PRM 和搜索相关组件做成公开框架。

Math-psa 权重本身采用 MIT License。

13.5 数据：不要一开始自己做

两个最有用的数据集：

PRM800K

OpenAI 官方 GitHub：

openai/prm800k

包括大量数学解题过程和步骤级人工正确性标签。

可以用来：

• 理解 PRM 数据结构；
• 微调自己的小模型；
• 设计人类 annotation UI；
• 找典型错误步骤。

ProcessBench

Hugging Face：

Qwen/ProcessBench

GitHub：

QwenLM/ProcessBench

数据包含 problem、reasoning steps、最终答案是否正确以及错误步骤位置，并提供官方 evaluation code。

它尤其适合回答：

这个 PRM 到底会不会找到第一个错误步骤？

这应该在让 PRM 给真人反馈之前先验证。

13.6 如果想自己训练 PRM

Hugging Face TRL 已经提供实验性的：

PRMTrainer

输入数据结构直接是：

prompt
completions
labels

其中 completions 是 reasoning steps，labels 是各步骤的正确性。TRL 官方示例甚至直接使用 Math-Shepherd 数据训练 Qwen 小模型。

所以第二阶段可以做：

flowchart LR
    A[学生真实解题轨迹] --> B[教师标注首个错误]
    B --> C[形成教学 PRM dataset]
    C --> D[TRL PRMTrainer]
    D --> E[Teaching-specific PRM]

这样就可以研究一个更有意思的问题：

针对 AI reasoning 训练的 PRM，是否适合评价人类 reasoning？

如果不适合：

用少量真实学生数据重新训练以后，会不会显著改善？

这本身就可以成为一篇论文。

13.7 如果研究强化学习

Hugging Face 的 Open-R1 项目已经公开：

• SFT；
• GRPO；
• synthetic data generation；
• math reward；
• code reward；

等完整训练 pipeline。

例如官方已有 Qwen2.5-1.5B 的 GRPO recipe。

但对于教育 MVP：

不要从 RL 开始。

第一阶段根本没必要训练模型。

先证明：

PRM 式反馈是否真的能够改变人的学习？

如果答案都是否定的，那么训练一个更大的模型没有意义。

13.8 编程实验可以用什么

Solver 可以直接使用：

Qwen/Qwen2.5-Coder-7B-Instruct

它是 Apache-2.0 模型，可直接用 Transformers 加载。

真正的 verifier 不应该主要依赖 LLM。

应该优先使用：

pytest
compiler
type checker
static analyzer

例如：

flowchart TD
    A[学生代码] --> B[pytest]
    A --> C[type checker]
    A --> D[lint]
    A --> E[hidden tests]

    B --> F[feedback]
    C --> F
    D --> F

    F --> G[学生自行修复]

    G --> A

    E --> H[最终能力评价]

运行学生提交的任意代码时，应放在受限 sandbox 中，而不是直接在服务器宿主环境执行。

13.9 Planning / Research 实验不需要特殊模型

LATS、ADaPT、SPRINT 的教育实验其实不需要训练新模型。

普通 instruction model 就可以充当：

• task decomposer；
• alternative generator；
• dependency checker；
• reflection assistant。

真正重要的是 UI 和 interaction protocol。

例如要求学生先提交：

Goal
Subgoals
Dependencies
Alternative plans
Stop conditions

然后 AI 只允许提出问题：

“B 是否真的依赖 A？”

而不是直接替学生重新规划。

13.10 一个最小技术架构

第一版系统完全可以非常简单：

flowchart LR
    U[Student UI<br/>Gradio / Web]

    U --> API[Python API]

    API --> P[PRM<br/>Qwen2.5-Math-PRM-7B]

    API --> DB[(SQLite / JSONL)]

    API --> SOL[Optional Solver<br/>Qwen2.5-Math-7B]

    P --> POLICY[Feedback Policy]

    SOL --> POLICY

    POLICY --> U

    DB --> ANALYSIS[Experiment Analysis]

关键是把两件事分离：

PRM

只负责：

哪一步可疑？

Feedback Policy

决定：

告诉学生多少？

这非常重要。

PRM 得到一个低分，并不意味着系统应该立即给正确答案。

更合理的是：

flowchart TD
    A[PRM 找到疑似错误] --> B[第一次]
    B --> C[只提示检查某一步]

    C --> D{学生修正?}

    D -->|否| E[给方向性问题]
    E --> F{仍失败?}

    F -->|是| G[给最小 hint]

    G --> H{仍失败?}

    H -->|是| I[最后才展示 worked example]

14. 最值得先做的 MVP：PRM 辅助数学纠错

如果只做一个实验，我建议先做这个。

原因：

1. 技术最简单；
2. PRM 已经有现成模型；
3. 数学步骤可以明确标注；
4. 可以设置 hidden transfer test；
5. 因果变量容易控制。

15. MVP 的核心研究问题

研究问题不是：

PRM 能不能帮助学生把当前题做对？

这太容易。

真正应该问：

步骤级错误反馈能否训练学生更好的错误检测能力，并最终提升没有 AI 帮助时的新题表现？

16. 实验假设

H1：学习迁移

接受步骤级反馈的学生，在无 AI 的新题测试中表现优于只接受最终答案反馈的学生。

定义：

\mu_{\text{Outcome, delayed}}

H2：错误定位能力

PRM 组在训练后能够更准确地判断自己的第一个错误步骤。

\text{ErrorLocalization}_{Control}

H3：校准能力

学生对自己步骤正确性的 confidence，会变得更接近真实正确率。

一种简单指标是 Brier Score：

$$\text{Brier} ============ \frac{1}{N} \sum_{i=1}^{N} (c_i-y_i)^2$$

\frac{1}{N}
\sum_{i=1}^{N}
(c_i-y_i)^2

其中：

• $c_i$ 为学生对某一步正确性的置信度；
• $y_i$ 为真实正确性。

Brier Score 越低越好。

H4：辅助依赖下降

随着训练进行，学生对 AI 提示的依赖应该下降。

$$\text{Assistance Dependence} ============================ \frac{\text{请求 AI 提示次数}} {\text{训练题目数量}}$$

\frac{\text{请求 AI 提示次数}}
{\text{训练题目数量}}
$$

如果学生最后只是变得更依赖 AI，那么这不是我们想训练的能力。

17. 实验分组

第一版只做两组。

不要一次实验五种 tutor。

Control：Outcome Feedback

学生提交完整推理。

系统只告诉：

答案正确

或者：

答案不正确，请重新检查。

不指出错误位置。

Treatment：Process Feedback

学生提交分步推理：

Step 1
Step 2
Step 3
...

PRM 找到最可能的首个错误位置。

系统只提示：

“建议优先重新检查 Step 3。”

第一次不解释原因。

学生自己修改。

如果第二次仍然错误，再给 metacognitive question，例如：

“这一步是否使用了题目中尚未建立的条件？”

仍然不直接给答案。

18. 一个可行的实验流程

flowchart TD
    R[招募参与者]

    R --> PRE[Pretest<br/>无 AI]

    PRE --> RAND{随机分组}

    RAND --> C[Control<br/>Outcome Feedback]
    RAND --> P[PRM Group<br/>Process Feedback]

    C --> TRAIN[训练题]
    P --> TRAIN2[训练题]

    TRAIN --> POST[Immediate Transfer Test<br/>无 AI]
    TRAIN2 --> POST

    POST --> DELAY[7 天后 Delayed Test<br/>无 AI]

    DELAY --> ANALYZE[比较学习效果]

19. MVP 规模

如果目的只是判断“有没有值得继续研究的信号”，可以考虑：

40～60 名参与者

随机分成两组。

例如：

30 Control
30 PRM

这不能自动保证统计功效足够发表论文。

正式研究应该根据 pilot effect size 再做 power analysis。

MVP 的目标只是判断：

有没有明显方向值得扩大实验？

20. 题目设计

例如高中代数或大学基础微积分。

选择一个很窄的技能范围。

不要混：

代数 + 几何 + 概率 + 微积分

例如只研究：

链式法则 + 隐函数求导

或者：

一元方程与不等式变形。

可以设计：

Pretest: 10～12 题
Training: 20～30 题
Immediate transfer: 10～12 题
Delayed transfer: 10～12 题

关键是：

transfer test 必须使用没有出现过的新题。

否则你测到的可能只是记忆。

21. 还要记录什么

每一个 reasoning step 记录：

student_id
problem_id
step_id
step_text
confidence
PRM_score
human_label
revision_count
hint_count
timestamp

这样未来可以研究：

• PRM 与教师是否一致；
• 哪些类型错误 PRM 最容易错；
• 学生是否越来越早发现错误；
• confidence 是否逐渐校准；
• 学生是否减少 hint request。

22. 一定要有人类标注子集

这是整个实验设计里非常关键的一环。

不要假定 PRM 是 ground truth。

抽取例如：

10%～20% reasoning traces

让教师独立标注：

首个真正错误的位置。

然后计算 PRM 的定位能力。

例如：

$$\text{First Error Accuracy} =========================== \frac{\text{PRM 正确找到首个错误的样本数}} {\text{总错误样本数}}$$

\frac{\text{PRM 正确找到首个错误的样本数}}
{\text{总错误样本数}}

还可以计算：

$$\text{Localization Error} ========================= |\hat e-e|$$

|\hat e-e|
$$

如果这个指标很差，那么教育实验失败时不能立即得出：

“Process feedback 对人没有用。”

可能只是：

“这个 PRM 不适合评价真人的 reasoning。”

23. 实验怎样区分“当前表现提高”和“真正学习”

这是最重要的部分。

假设实验出现四种结果。

结果 A：训练时明显提高，Posttest 没提高

说明：

AI 帮学生把当前题做出来了，但能力没有迁移。

这叫 performance improvement，不足以证明 learning improvement。

这种结果会否定一个较强版本的假设：

“PRM feedback 自动产生长期学习。”

结果 B：Immediate Posttest 提高，7 天后消失

说明：

有短期学习，但 retention 不够。

可能需要：

• retrieval practice；
• spaced repetition；
• 更少提示；
• 更多独立重做。

结果 C：Delayed Transfer 也明显提高

这是最有价值的结果。

它支持：

步骤级反馈训练的不只是当前题表现，而是某种可迁移的错误检测或问题解决能力。

这才真正支持“AI self-improvement mechanism 可以迁移给人”的核心论点。

结果 D：错误定位提高，但最终成绩没有提高

这其实也很有意思。

说明 PRM 可能确实训练了：

metacognitive monitoring

但 monitoring 的提高暂时不足以提升 domain competence。

那么下一阶段就可以研究：

verifier improvement 与 solver improvement 之间是什么关系？

结果 E：弱学生提高，强学生下降

这是非常合理的可能结果。

对强学生而言，PRM 提示可能变成干扰。

这可能体现 expertise reversal：

flowchart LR
    A[新手] --> B[需要较强脚手架]
    C[中级] --> D[需要部分提示]
    E[高手] --> F[只需要异常报警]

这意味着教学系统最终应该 adaptive。

结果 F：PRM 组反而更差

先不要直接宣布理论失败。

需要检查：

flowchart TD
    A[PRM 组更差] --> B{PRM 准确吗?}

    B -->|否| C[Verifier failure]
    B -->|是| D{Feedback 太频繁吗?}

    D -->|是| E[Over-scaffolding]
    D -->|否| F{学生是否过度相信模型?}

    F -->|是| G[Automation bias]
    F -->|否| H[Process feedback 假设可能不成立]

这就是为什么必须单独评估 PRM 本身。

24. 最简单的数据分析

主结果可以直接比较：

\text{Delayed Posttest}

\text{Pretest}

比较：

$$\Delta_{PRM} ------------ \Delta_{Control}$$

\Delta_{Control}

如果数据量增加，可以使用 mixed-effects model：

$$Score_{ij} ========== \beta_0 + \beta_1 Condition_i + \beta_2 Pretest_i + u_i + v_j + \epsilon_{ij}$$

\beta_0
+
\beta_1 Condition_i
+
\beta_2 Pretest_i
+
u_i
+
v_j
+
\epsilon_{ij}
$$

其中：

• $u_i$ 表示学生随机效应；
• $v_j$ 表示题目随机效应。

这样可以避免把“某些题本来比较容易”误认为 treatment effect。

25. MVP 能证明什么，不能证明什么

即便实验结果很好，也不能直接证明：

“PRM 是所有教育领域的最佳方法。”

能够支持的是一个更窄的因果判断：

在特定年龄、特定数学主题、特定反馈设计和特定 PRM 准确度下，步骤级错误反馈相较于结果级反馈，提高了某些学习指标。

如果 Delayed Transfer 没有改善，则可以否定这个具体版本的假设。

这种“窄而可证伪”的设计反而比：

“AI 会彻底改变教育”

更有研究价值。

26. 第二阶段：从数学扩展到编程

如果第一个实验成立，下一步可以研究：

Execution Feedback 是否训练 debugging skill？

实验组：

运行代码
→ 看 compiler/test feedback
→ 学生自行解释错误
→ 修改

对照组：

系统直接展示修复后的代码

最终测试：

没有 AI 的情况下，学生能否更快定位一个陌生程序中的 bug？

这实际上是在测：

RLEF 风格训练是否提高了人的 debugger。

27. 第三阶段：问题拆解训练

再往后可以研究 ADaPT / LATS。

给两组学生同一个复杂编程或研究任务。

Control：

自由规划。

Treatment：

强制执行：

flowchart TD
    G[Goal] --> S1[列出 3 个候选方案]
    S1 --> S2[每个方案做低成本 probe]
    S2 --> S3[选择方案]
    S3 --> S4{当前任务能直接执行?}

    S4 -->|否| S5[继续 decomposition]
    S4 -->|是| S6[执行]

    S6 --> S7{失败?}

    S7 -->|是| S8[记录失败原因]
    S8 --> S9[回溯]
    S9 --> S3

最终比较：

• 项目完成率；
• 计划修改次数；
• 无效工作时间；
• 独立解决新项目的能力。

28. 最终目标不是更强的 AI Tutor，而是更强的 Human Agent

现在很多教育 AI 的优化目标实际上是：

也就是：

学生问问题，AI 尽量帮他把题做出来。

但如果目标是教育，更合理的目标函数可能包含：

$$R = \alpha \cdot Accuracy + \beta \cdot Transfer + \gamma \cdot ErrorDetection + \delta \cdot Calibration ------------------------ \lambda \cdot AssistanceDependence$$

\alpha \cdot Accuracy
+
\beta \cdot Transfer
+
\gamma \cdot ErrorDetection
+
\delta \cdot Calibration

\lambda \cdot AssistanceDependence
$$

最有意思的部分是最后一项。

一个优秀 Tutor 的长期目标应该是：

让自己逐渐变得不再必要。

29. AI 与人的差异仍然不能忽略

模型可以轻易产生几十甚至上百条 reasoning trajectories。

人类不能。

人的工作记忆容量很有限，因此很多 AI 算法必须转化为外部工具：

flowchart LR
    H[Human Working Memory]

    H --> N[Notes]
    H --> W[Whiteboard]
    H --> T[Task Graph]
    H --> C[Checklist]
    H --> E[Computer / Tests]

因此：

对人而言，笔记、白板、debugger 和 checklist 并不是辅助工具，而是认知系统的一部分。

人类还有 AI 不具有的另一层限制：

• 疲劳；
• 动机；
• 自我效能感；
• 挫败；
• 好奇心；
• 社会评价。

所以 AI 可以承受数千次 zero reward，而人的 curriculum 必须更加谨慎。

结语

CS329A 中的自我改进方法，可以被看成一组关于“如何学习”的可执行算法。

PRM 研究：

怎样发现错误发生在哪里？

ReAct 与 RLEF 研究：

怎样从环境反馈中学习？

LATS 研究：

怎样避免过早锁定一条路线？

ADaPT 研究：

什么情况下应该继续拆问题？

SPRINT 研究：

哪些子问题彼此依赖？

STaR 研究：

怎样把失败和答案重新转化成训练数据？

Curriculum Learning 研究：

下一步应该练什么？

Search-o1 研究：

什么情况下应该停止内部推理并获取外部知识？

它们共同组成了一种更完整的学习循环：

flowchart LR
    A[尝试] --> B[反馈]
    B --> C[验证]
    C --> D[修正]
    D --> E[反思]
    E --> F[更新策略]
    F --> G[选择下一任务]
    G --> A

真正值得研究的，也许不是：

“如何用 AI 把题讲得更清楚？”

而是：

能否用 AI 自我改进算法，训练人的 verifier、planner、debugger、decomposer 和 search controller？

如果能够做到这一点，那么教育 AI 的目标就不再只是制造一个越来越聪明的外部助手。

它开始尝试改善学习者本人的认知控制系统。

而最现实的第一步，并不需要训练一个新的大型模型。

只需要：

一个现成的 PRM，一个简单的分步解题界面，一组隐藏迁移题，以及一个能够区分“学生当前把题做对”和“学生以后真的更会思考”的实验。

这已经足以开始验证这个方向究竟成立到什么程度。