第 1 讲：课程导论——从 Scaling 到 Self-Improving AI Agents

对应：Stanford CS329A Self-Improving AI Agents，Autumn 2025 Lecture 1（Mon 9/22，Course Overview），Aakanksha Chowdhery 与 Azalia Mirhoseini 主讲。幻灯片没有公开，本讲依据课程主页、公开的课程录像及其笔记，并补充了原始论文。 配套代码：code/lecture01/（只用 Python 标准库，每个文件 1 秒左右跑完） 预计阅读时间：3~4 小时（含运行代码）

0. 本讲导航

0.1 学完本讲，你应该能够

1. 用一句话说出 self-improving AI agent 是什么，并区分两条时间轴上的自我改进：test-time（不改权重：多采样、验证、修改、搜索）和 train-time（改权重：用自己生成并验证过的数据训练、强化学习）。
2. 写出 scaling law 的函数形式 $L(C) = L_\infty + A \cdot C^{-\alpha}$，解释为什么它在 log-log 图上是直线、在普通坐标上却是”收益递减”，以及为什么说 pretraining 的扩展”越来越贵”。
3. 解释 in-context learning、chain-of-thought（CoT）和 emergent abilities；说出”涌现可能是指标造成的错觉”这一观点的论证。
4. 画出从 base model 到 ChatGPT 的 post-training 流程（pretraining → 高质量数据 → instruction tuning → RLHF），并说出训练信号是怎样从”人写的示范”一路演变到”可自动验证的奖励”的。
5. 说清 test-time compute scaling 的基本现象：coverage 随采样次数增长；pass@k 的无偏估计；temperature 的取舍；为什么 majority voting 和 reward model 跟不上 coverage（generation–verification gap）。
6. 说出 reasoning model（o1、DeepSeek-R1）在推理过程中做了哪些”自我改进”的动作，以及 test-time 与 train-time 怎样结合成一个闭环。
7. 区分 chatbot、agentic workflow 和 agent；说出五种常见的 workflow 模式；用”可靠性的算术”解释为什么长程任务难。
8. 用一句话说出本讲最重要的原则：一个自我改进的循环，最多只能好到它的反馈信号允许的程度；并能算出有误判的 verifier 给准确率设下的上限。

0.2 先修知识

0.3 本讲地图

第1节  这门课在学什么：self-improving AI agents 与"生成 → 反馈 → 改进"的循环
第2节  第一推动力：pretraining scaling，以及为什么它开始变贵           ← 代码 01 演示 1
第3节  涌现能力与 chain-of-thought                                   ← 代码 01 演示 2、3
第4节  从 GPT-3 到 ChatGPT：post-training 与训练信号的演变
第5节  第二推动力：test-time compute（重复采样、温度、验证、reasoning models）← 代码 02
第6节  第三推动力：从 chatbot 到 agent（workflow 模式、可靠性、反馈的质量）  ← 代码 03
第7节  应用：编程、客服、研究、AI 科学家
第8节  课程地图
第9节  课程安排与研究项目
第10–13节 小结、练习、延伸阅读、下一讲预告

0.4 本讲的玩具世界：多步算术题 + 一个模拟的 LLM

这门课要反复回答一些很细的问题：模型为什么会错？多采样 100 次能救回多少题？verifier 有 15% 的误判，会把准确率限制在多少？用真实的 LLM 做实验，这些问题很难说清楚：我们看不到模型”心里”每一步犯错的概率，而且又贵又慢。

所以代码 toy_llm.py 造了一个小世界，每个错误从哪里来都是已知的。

任务是一个”迷你 GSM8K”：多步算术链，例如

从 59 开始：× 8，+ 75，− 48，× 7。最后得多少？

答案能用 Python 精确算出来，所以这是一个 verifiable 的任务，就像数学题（核对答案）和带 unit test 的代码。

模型（ToyLLM）一步一步地算（像 CoT）。每一步它都按概率从三种 procedure（做法）里选一种：

选择概率是 $\text{softmax}(\text{logits}/T)$，其中 $T$ 是 temperature，三个 logit 是：

• $N$ 是参数量。规模每扩大 10 倍，做对的 logit 增加 $\beta = 1.2$。这是我们对 “scaling” 最简单的刻画。
• $\alpha_{\text{op}}$：加法 2.0、减法 1.5、乘法 0.5（乘法最难）。
• hardness：有进位的加法、有借位或结果为负的减法、乘两位数、乘大数都更难。于是不同的题难度差别很大，这一点对理解第 5 节的 coverage 曲线至关重要。

此外还有两个开关：

• cot=False（direct answer）：不写中间步骤，直接报答案。模型一次前向传播能做的串行步数有限（1B 模型 2 步、100B 模型 4 步），超出的步骤几乎只能靠猜（第 3.3 节）。
• tool_ops=("mul",)：乘法交给计算器。计算器不会错，但调用有一定概率失败（第 6.7 节）。

关于本讲的数字：讲义里有两类数字，请注意区分。

• 论文、报道和课堂上的真实数字（例如”SWE-bench Lite 上从 15.9% 提高到 56%”），会注明出处。
• 模拟实验的数字（例如”有误判的 judge 把准确率限制在 0.644”），都来自 01~03 号代码的实际输出。代码固定了随机种子，你运行会得到同样的结果，在 Python 3.9 和 3.13 上逐字相同。模型的参数是为了演示而设的，它们说明的是机制，不代表任何真实模型的数值。

1. 这门课在学什么：Self-Improving AI Agents

1.1 一句话

课程主页的描述是：研究那些通过与自身、与环境的交互不断改进自己的 AI agent 的最新技术和应用。

这句话里有两个关键词：agent 和 self-improving。我们先把它们拆开。

1.2 什么是 agent？

传统的 chatbot 是”一问一答”：你给一个 prompt，它生成一段回复，结束。agent 则是接到一个目标之后，自己规划步骤、和环境交互（运行代码、搜索网页、读写文件）、观察反馈、纠正错误，直到判断目标已经完成（或者无法完成）。第 6 节会详细比较两者。

例如你让一个 coding agent “把这个项目从 Python 3.8 升级到 3.12”，它会：浏览代码库 → 找出不兼容的写法 → 修改文件 → 运行测试 → 看到报错 → 再修改 → 测试全部通过后告诉你结果。整个过程可能有几十上百步，中间没有人参与。

1.3 什么是 self-improving？两条时间轴

“自我改进”听起来很玄，其实指的是一类很具体的技术。按”改进发生在什么时候”，可以分成两条时间轴：

还有第三层更”激进”的自我改进：改进系统本身的设计——让 AI 去搜索更好的 agent 架构（ADAS）、更好的算法（AlphaEvolve），甚至自己做科研（AI Scientist）。这是第 7 讲的内容。

1.4 核心循环：生成 → 反馈 → 改进

不管在哪条时间轴上，自我改进都是同一个循环：

          ┌──────────────────────────────────────────────┐
          │                                              │
          ▼                                              │
     ┌─────────┐      ┌──────────────────────┐      ┌──────────┐
     │ 生成     │ ───► │ 反馈（feedback）       │ ───► │ 改进      │
     │ generate │      │ · 自己检查（self）      │      │ · 挑一个  │
     └─────────┘      │ · 环境（执行代码、工具）  │      │ · 改答案  │
                      │ · 另一个模型（AI judge）│      │ · 改权重  │
                      │ · 人                  │      │ · 改设计  │
                      └──────────────────────┘      └──────────┘

整门课的大部分内容，都可以放进这张图的某个格子里：

• 生成怎样更多样、更聪明？（第 2 讲 test-time scaling、第 5 讲规划）
• 反馈从哪里来、有多可靠？（第 3 讲 verifier、第 4 讲工具与代码执行、AI feedback）
• 改进怎样利用反馈？（第 5 讲搜索、第 6 讲 RL、第 7 讲演化）

1.5 为什么是现在？

课程第一讲用了大约一个小时回顾”我们是怎么走到这里的”。可以概括为三股推动力：

1. Pretraining scaling（第 2、3 节）：模型越大、数据越多、算力越多，能力越强，而且可以预测。这给了我们足够聪明的 base model。但到了 2024 年前后，单靠扩大预训练的收益开始递减。
2. Test-time compute（第 5 节）：不再只问”模型有多大”，而是问”推理时肯花多少计算”。多采样、验证、长 CoT 的 reasoning model，打开了一条新的扩展轴。
3. Agents（第 6 节）：模型开始能在真实环境里行动（写代码、跑测试、上网）。环境会给出真实的反馈：测试通过没有、代码报不报错。这种反馈不依赖人，可以大规模获得。

这三股力量汇合在一起，就是”自我改进的 agent”：一个足够聪明的模型 + 足够多的推理计算 + 来自环境的可靠反馈。

1.6 一个贯穿全课的提醒

“自我改进”不是永动机。本讲第 6.6 节会用代码演示一个原则：

一个自我改进的循环，最多只能好到它的反馈信号允许的程度。

如果反馈来自模型自己，而模型对自己的错误视而不见，循环就会原地打转，甚至越来越自信地犯错。这门课里每一个成功的自我改进方法，背后几乎都有一个比生成者更可靠、或者至少”错得不一样”的信号：unit test、编译器、定理证明器、计算器、独立训练的 verifier。请在后面的每一讲里都问一句：这里的反馈信号从哪里来？它有多可靠？

2. 第一推动力：Pretraining Scaling

2.1 模型越来越大

课堂上的第一张图是语言模型参数量的增长：

五年里参数量涨了一千多倍。驱动这股增长的不是盲目的乐观，而是一个被反复验证的经验规律：scaling law。

2.2 Scaling law：一个可以预测的规律

Kaplan et al. 2020（OpenAI，Scaling Laws for Neural Language Models）发现：语言模型的 test loss（预测下一个 token 的交叉熵）和三个量之间都有非常干净的关系：

• 参数量 $N$：$L(N) \propto N^{-0.076}$
• 数据量 $D$（token 数）：$L(D) \propto D^{-0.095}$
• 训练算力 $C$（FLOPs）：$L(C) \propto C^{-0.050}$

这种形式 $L \propto x^{-\alpha}$ 叫 power law（幂律）。它有一个直观的特点：

每把 $x$ 扩大 10 倍，loss 就乘以同一个因子 $10^{-\alpha}$。

两边取对数，$\log L = \text{常数} - \alpha \log x$，这是一条直线。所以 scaling law 的图总是画在 log-log 坐标上：横轴是 $\log(\text{算力})$，纵轴是 $\log(\text{loss})$，数据点排成一条直线，跨越七八个数量级都不弯。

为什么这件事这么重要？ 因为它让”花 1 亿美元训练一个模型”变成了一个可以计划的工程决策，而不是赌博：先用小模型做一组实验，拟合出直线，就能预测大模型的 loss。GPT-4 的技术报告就说，他们用一组训练算力最多只有 GPT-4 万分之一的小模型拟合 scaling law（而且用的是带 irreducible loss 项的形式，见第 2.3 节），准确预测了 GPT-4 最终的 loss。

Rich Sutton 2019 年的短文 The Bitter Lesson 把这种现象总结为：长期来看，能随算力扩展的通用方法（搜索和学习）总会赢过人类精心设计的知识。这句话也是理解本课的一把钥匙：test-time compute 本质上就是把”搜索”重新带回了语言模型。

2.3 Chinchilla：算力该怎样分配？

有了固定的算力预算，应该训练一个更大的模型，还是用更多的数据？Hoffmann et al. 2022（DeepMind，Chinchilla 论文）拟合了一个同时包含 $N$ 和 $D$ 的公式：

三项分别是：

• $E$：irreducible loss，再大的模型、再多的数据也消除不了。可以理解为文本本身的”不可预测性”（下一个词本来就有很多种合理的写法）。
• $A/N^\alpha$：模型太小造成的损失。
• $B/D^\beta$：数据太少造成的损失。

在算力 $C \approx 6ND$ 固定的条件下最小化 $L$，得到的结论是：$N$ 和 $D$ 应该同比例增长，大约每个参数配 20 个 token。按这个配比训练的 Chinchilla（70B 参数、1.4T token）打败了参数多 4 倍的 Gopher（280B）。在此之前，大家普遍把模型做得太大、数据给得太少。

2.4 收益递减：为什么说 pretraining 开始”变贵”？

到了 2024 年前后，“只靠扩大预训练”的路线遇到了几个问题。课堂上说得很直接：从 2018 年到 2024 年进步非常稳定，之后开始出现饱和。

原因一：power law 本身就意味着收益递减。 log-log 图上的直线，在普通坐标上是一条越来越平的曲线。我们用代码直观地看一下。

01_scaling_and_emergence.py 演示 1 用一条已知的”真实规律” $L(C) = 1.69 + 1.8 \cdot (C/10^{18})^{-0.155}$ 生成数据，最右一列是”每多 10 倍算力，loss 下降多少”：

每一行的算力都是上一行的 10 倍（表里隔行列出），换来的进步却越来越小。从 1e27 到 1e28，10 倍的算力只换来 0.022 的 loss 下降——而 10 倍的算力意味着 10 倍的钱、电和芯片。

原因二：irreducible loss 是一个下限，但它在哪里很难估计。 演示 1 还比较了两种拟合：

• 纯幂律 $L = K C^{-\alpha}$（很多人画 log-log 图时下意识做的事）：在观测范围（1e18~1e23）内就已经有系统性的偏差——两头低估、中间高估，数据其实是一条微微弯曲的线。外推到 1e29 时，它预测 loss = 0.965，远低于真实的 1.726。它看不到下限。
• 带下限的幂律 $L = L_\infty + K C^{-\alpha}$：这次几乎完全正确（拟合出 $L_\infty = 1.695$，真实值 1.69）。但换 8 组随机噪声重做实验，噪声 ±0.4% 时 $L_\infty$ 在 1.6701.750 之间，噪声 ±1.5% 时就漂到了 1.4851.835，而且 $L_\infty$ 和 $\alpha$ 一起漂（$L_\infty$ 估大时 $\alpha$ 也估大）。只靠几个点估计天花板在哪里，本身就很不确定。

原因三：数据墙（data wall）。 Chinchilla 的配比要求数据和参数同步增长，但人类写下的高质量文本是有限的。Ilya Sutskever 在 NeurIPS 2024 的演讲里有一句被广泛引用的话：pretraining as we know it will end，因为 “we have but one internet”（我们只有一个互联网）。

但要注意：loss 不等于能力。 loss 下降 0.02 看起来微不足道，但它可能意味着模型在某类题上从”几乎全错”变成”大部分对”。这就是下一节的 emergence。

小结：scaling law 给了我们越来越强的 base model，也告诉我们继续沿这条路走会越来越贵。于是大家开始问：除了在训练时多花算力，能不能在推理时多花算力？ 这是第 5 节和第 2 讲的主题。

3. 涌现能力与 Chain-of-Thought

3.1 In-context learning：不训练也能学

GPT-3 的论文标题是 Language Models are Few-Shot Learners（Brown et al. 2020）。它最让人吃惊的发现是：足够大的模型，不用更新任何参数，只要在 prompt 里给几个例子，就能完成新任务：

Translate English to French:     ← 任务描述（zero-shot 只有这一行）
sea otter => loutre de mer       ← 例子（few-shot 给几个，one-shot 给一个）
peppermint => menthe poivrée
cheese =>                        ← 模型续写：fromage

• zero-shot：只给任务描述。
• one-shot / few-shot：再给一个或几个例子。

这叫 in-context learning：模型在上下文里”学会”了任务。在此之前，每个新任务都要收集标注数据、微调一个模型；GPT-3 之后，prompt 本身就成了一种”编程”方式。而且这种能力随规模增长：小模型给了例子也没什么用，大模型的 few-shot 表现可以接近微调过的专用模型。

3.2 Chain-of-thought：让模型把步骤写出来

Wei et al. 2022（Google，Chain-of-Thought Prompting Elicits Reasoning in Large Language Models）做了一个非常简单的改动：few-shot 的例子里，不只给答案，还给出推理过程。课堂上用的是论文里的经典例子：

问：Roger 有 5 个网球。他又买了 2 罐网球，每罐 3 个。他现在有多少个网球？ 普通的例子：答案是 11。 CoT 的例子：Roger 一开始有 5 个球。2 罐、每罐 3 个，就是 6 个。5 + 6 = 11。答案是 11。

模型看到这样的例子后，回答新问题时也会先写推理过程。效果非常显著：PaLM 540B 加上 8 个 CoT 例子，在 GSM8K（小学数学应用题）上达到 56.9%，超过了此前用 GPT-3 微调加 verifier 的最好结果。

但论文同时发现了一个重要的现象：CoT 只对足够大的模型有效。在 LaMDA、GPT-3、PaLM 三个模型家族上，CoT 大约在 100B 参数的量级才开始带来收益；对小模型，CoT 反而会让表现变差——小模型能写出通顺但不合逻辑的推理链，一步错、步步错。

之后的两个工作把 CoT 推向了更广的应用：

• Zero-shot CoT（Kojima et al. 2022）：连例子都不用，只在问题后面加一句 “Let’s think step by step”。在 InstructGPT 上，GSM8K 从 10.4% 提高到 40.7%。
• Self-consistency（Wang et al. 2022）：同一个问题采样多条 CoT，对最终答案做 majority vote。PaLM 540B 在 GSM8K 上从单条 CoT 的 50% 多提高到 74.4%（+17.9 个百分点）。这其实是第一个广为人知的 test-time scaling 方法：多花推理计算，换来更高的准确率。

3.3 为什么 CoT 有用？

这是一个值得认真想的问题。至少有三种互相补充的解释。

解释一：CoT 提供了额外的串行计算。 Transformer 处理每一个 token 时，计算要依次穿过固定的 $L$ 层。不管问题多难，生成一个 token 能做的”串行步骤”都被层数限制住了。如果要求模型直接输出一道 10 步算术题的答案，它就必须在一次前向传播里完成全部 10 步——层数不够，就只能猜。写出中间步骤以后，第 $t$ 个 token 可以读取前面写下的中间结果，每个 token 只需要做”一步”。理论工作（Feng et al. 2023；Merrill & Sabharwal 2024；Li et al. 2024）严格证明了：在合理的假设下，不带 CoT 的固定深度 Transformer 解不了某些”本质上串行”的问题，而带上足够长的 CoT 就可以。

解释二：分解让每一步都”在分布内”。 “47 × 12 + 75 − 48” 这种完整的式子，训练数据里很少见；但”47 × 12 = 564”这样的单步运算，训练数据里多得是。把问题拆成小步，每一步都是模型熟悉的东西。

解释三：CoT 就是 test-time compute。 CoT 让模型为一个答案生成更多的 token，也就是花更多的推理计算。这条线索一直延伸到 o1、R1 这些会”想很久”的 reasoning model（第 5.5 节）。

我们用玩具模型看看解释一。01_scaling_and_emergence.py 演示 3 比较了 direct answer 和 CoT 在 $k$ 步题上的 exact match（1B 模型一次前向传播能做 2 步，100B 模型能做 4 步）：

• 步数在”串行上限”以内时，两者差不多（差别只是随机波动）。
• 一旦超过上限，direct 模式每多一步就多一个几乎只能靠猜的步骤，迅速掉到接近 0（1B 从 2 步的 0.387 跌到 3 步的 0.087；100B 从 4 步的 0.732 跌到 5 步的 0.387）。CoT 只随步数平滑下降。
• 代价是 token：$k$ 步题 CoT 多处理约 $10k$ 个 token。

这个玩具模型没有刻画什么？ 它假设 CoT 的每一步和 direct 模式一样可靠，所以 CoT 永远不会比 direct 差。它刻画不了”小模型写出通顺但错误的推理链、CoT 反而变差”的现象。玩具模型只演示一个机制（串行计算），而不是 CoT 的全部故事。

3.4 Emergent abilities：真的”突然出现”吗？

Wei et al. 2022（TMLR，Emergent Abilities of Large Language Models）给了 emergent ability 一个定义：小模型没有、大模型有的能力——表现在某个规模之前接近随机，之后突然大幅提高，没法从小模型的表现外推出来。他们列出了几十个例子：多位数加法、单词还原、CoT 本身……

这个说法很有冲击力：如果能力会”突然出现”，那我们就无法预测下一个更大的模型会做什么。

一年后，Schaeffer、Miranda、Koyejo 2023（NeurIPS 2023 杰出论文，Are Emergent Abilities of Large Language Models a Mirage?）提出了另一种解释：很多”涌现”是度量方式造成的。如果指标是”全或无”的（exact match：答案必须完全正确），那么即使模型的底层能力是平滑提高的，指标也会呈现突变。

道理很简单：一道题有 $k$ 步，每步的正确率是 $s$，全对的概率大约是 $s^k$。$s$ 从 0.5 平滑涨到 0.95，$s^{10}$ 就从 0.001 涨到 0.6——在线性坐标上，前半段贴着地面，后半段陡然上升。

01_scaling_and_emergence.py 演示 2 正好验证了这一点。同一批模型，三种指标：

（代码输出里还有 316M、3.2B 两行，这里省略了。）

• per-step 正确率随参数量的对数平稳上升，没有任何突变。
• 10 步题的 exact match 在 10B 之前几乎为 0，之后陡然上升——画在线性坐标上，就是一张标准的”涌现”图。但它几乎就等于 per-step$^{10}$（对比最后两列）。
• 2 步题的 exact match 起步早得多、也平缓得多。同一种能力，换个任务长度，“涌现点”就变了。

谁对？ 两种观点其实都有道理：

• 从预测的角度，Schaeffer 等人是对的：如果换用平滑的指标（per-step、log-likelihood），很多能力的进步是可以预测的。
• 从使用的角度，阈值效应是真实的：用户关心的就是”10 步全做对”，而这个指标确实会突变。这也解释了为什么长程任务（long-horizon tasks）这么难，第 6.5 节和第 14 讲会再回来讨论。

4. 从 GPT-3 到 ChatGPT：Post-Training

4.1 ChatGPT 时刻

2022 年 11 月 30 日，OpenAI 发布了 ChatGPT。它在 5 天内就有了 100 万用户，比几乎所有著名的软件和服务都快。

但 ChatGPT 背后的模型并不比 GPT-3 大多少。课堂上强调：让它脱颖而出的，是规模之外的创新，主要是 instruction tuning 和 RLHF。这两步合称 post-training（后训练）。

4.2 Base model 的问题：它只会”续写”

pretraining 的目标是”预测下一个 token”，训练数据是网页、书籍、代码。这样训练出来的 base model 学到了大量知识，但它学的任务是”续写文档”，不是”回答问题”。

比如你给 base model 输入”氮的沸点是多少？“，它可能会接着写”氧的沸点是多少？氢的沸点是多少？“——因为在网页上，这种问题常常出现在一张习题列表里。它没有”有人在问我问题，我应该回答”的概念。

4.3 Post-training 的流水线

课堂上把从 base model 到 ChatGPT 的过程分成几步：

① Pretraining              海量网页、书、代码                预测下一个 token        → 知识、语言能力
        │
② 高质量数据上继续训练        精选的书籍、文章、专业数据          还是预测下一个 token     → 在特定领域更强
        │
③ Instruction tuning (SFT)  (指令, 回答) 对，人写的 + 合成的     模仿高质量的回答         → 会"听指令"、会按格式回答
        │
④ RLHF                     人对两个回答的偏好比较              最大化奖励（带 KL 约束） → 更有帮助、更安全

② 高质量数据：课堂上提到，大公司为了获得高质量、往往有版权的数据，会花费数百万甚至上亿美元。数据质量对模型质量的影响非常大。

③ Instruction tuning：把大量任务都写成”指令 + 回答”的格式来微调模型，例如：

指令：请回答下面的问题：氮的沸点是多少？ 回答：氮的沸点约为 −196 °C（77 K）。

代表性的工作有 FLAN（Wei et al. 2021）、T0（Sanh et al. 2021）和 Flan-PaLM / Flan-T5（Chung et al. 2022，1800 多个任务）。课堂强调了两点：

• 数据混合了人写的和模型合成的。合成数据（例如 Self-Instruct：让模型自己生成指令和回答）便宜、量大；人写的数据质量高。这里已经有一点”自我改进”的影子：模型生成的数据被用来训练模型。
• 数据里要包含 CoT 的例子。Flan 的实验表明，混入 CoT 数据能保住、甚至提高模型的推理能力。数据集的质量和覆盖面，很大程度上决定了最终模型的质量（LIMA（Zhou et al. 2023）甚至只用 1000 条精选数据就做出了不错的效果）。

④ RLHF（Reinforcement Learning from Human Feedback）：instruction tuning 是”模仿”，但很多时候人很难写出完美的回答，却很容易判断两个回答哪个更好。RLHF 利用的正是这一点：

1. 对同一个 prompt 生成几个回答，让人标注哪个更好。
2. 用这些比较训练一个 reward model $r_\phi(x, y)$，通常用 Bradley–Terry 模型：$P(y_1 \succ y_2) = \sigma(r_\phi(x, y_1) - r_\phi(x, y_2))$。
3. 用强化学习（PPO）优化语言模型 $\pi_\theta$，让它生成高奖励的回答，同时不要离原来的模型 $\pi_{\text{ref}}$ 太远：

课堂上特别提到，奖励可以有很多维度：正确性、有帮助、具体、无害……可以训练多个 reward model，再按权重组合，从而精细地控制模型的行为。例如 Llama 2 就分别训练了 helpfulness 和 safety 两个 reward model。

效果非常惊人：InstructGPT 论文（Ouyang et al. 2022）报告，在人工评估中，13 亿参数的 InstructGPT 比 1750 亿参数的 GPT-3 更受欢迎。参数少了 100 多倍，靠的是 post-training。

这一部分在同目录的其他课程里有详细的讲解：CS329H 第 1、8、9 讲（RLHF、DPO 与偏好建模）、CS224N 第 10 讲、CS336 第 15、16 讲。本课只需要知道整体流程。

4.4 训练信号的演变：从”人”到”可验证”

从自我改进的角度看，post-training 的历史就是训练信号的来源不断变化的历史：

越往下，信号越便宜、越容易大规模获得，人的参与越少。这正是”self-improving”的含义：训练信号越来越多地来自模型自己和它所处的环境。但每往下一步，都要回答同一个问题：这个信号可靠吗？会不会被模型”钻空子”（reward hacking）？

5. 第二推动力：Test-Time Compute

5.1 一个新的扩展轴

在 2024 年之前，“让模型更强”几乎就等于”训练一个更大的模型”。推理的时候，我们通常只让模型做一次，取它的第一个答案。

但人不是这样解决难题的。难题要多想一会儿、多试几种方法、检查一下答案。下围棋的 AlphaGo 也不是只靠神经网络”直觉”出一步，它在每一步之前都要做大量的树搜索。能不能让语言模型也”多想一会儿”？

这就是 test-time compute scaling（也叫 inference-time scaling）：在推理时投入更多计算，换取更好的结果。它和 pretraining scaling 有一个重要的区别：

• pretraining 的算力是一次性的，所有问题都受益，但再也调不了；
• test-time compute 是按需的，可以给难题多花、给简单题少花。

第 2 讲会专门讨论”给定总预算，训练和推理之间怎样分配”（Snell et al. 2024）。这里先看最简单的方法：重复采样。

5.2 Repeated sampling：Large Language Monkeys

课堂上用了讲师自己实验室的工作 Large Language Monkeys（Brown et al. 2024）。名字来自无限猴子定理：一只猴子在打字机上随机乱敲，只要时间足够长，总能敲出莎士比亚全集。语言模型当然比猴子聪明得多，它的每一次尝试都有一定概率做对。那么：

同一道题让模型做很多次，再用一个 verifier 挑出做对的那一次，能做对多少题？

论文把”至少有一个样本做对”的题目比例叫做 coverage。主要发现：

• 在多个任务、多个模型上，coverage 随采样次数持续增长，跨越了四个数量级（1 到 10000 次）。
• coverage 和采样次数的关系常常是 log-linear 的，可以用 exponentiated power law 很好地拟合——这暗示存在 inference-time scaling law（第 2 讲会推导它从哪里来）。
• 在答案能自动验证的领域（代码、形式化证明），coverage 的提高可以直接变成真实的成绩。例如在 SWE-bench Lite（修复真实 GitHub 仓库里的 issue）上，DeepSeek-Coder-V2-Instruct 从采样 1 次的 15.9% 提高到采样 250 次的 56%，超过了当时单次采样的最好成绩 43%。
• 课堂上还展示了：Llama 3 8B 这样的小模型采样 1 万次以后，coverage 超过了 GPT-4o 单次的成功率。讲师的评价是：模型知道的，比我们原来以为的多得多。

怎样估计 coverage？pass@k 的无偏估计。 对一道题采样 $n$ 次，其中 $c$ 次正确。“随机抽 $k$ 个样本，至少一个正确”的概率怎么估？最直接的做法是只看前 $k$ 个样本，但这浪费了剩下 $n-k$ 个样本的信息。Codex 论文（Chen et al. 2021）给出了一个更好的估计：考虑从 $n$ 个里不放回地抽 $k$ 个的所有组合，

分子是”抽到的 $k$ 个全是错误样本”的组合数。这是无偏的：它的期望恰好等于真实的 pass@$k$。coverage@$k$ 就是所有题目的 pass@$k$ 的平均。代码里的实现是 toy_llm.pass_at_k。

玩具世界里的结果。 02_inference_scaling_preview.py 演示 1 让 1B 和 100B 两个模型各自对 100 道 3~8 步题采样 500 次：

1B 模型只采一次时只能做对 11.6% 的题，采 20 次就超过了 100B 模型采一次的 63.4%，采 500 次达到 98%。

为什么 coverage 增长得越来越慢？ 看每道题的单次成功率 $p$ 的分布（1B 模型）：

一道单次成功率为 $p$ 的题，采样 $k$ 次至少做对一次的概率是 $1-(1-p)^k$，大约需要 $1/p$ 次采样才能做对。$p$ 大的题几次就能解决；剩下的都是 $p$ 很小的”硬骨头”，每多做对一道都要成倍地增加采样。所以 $p$ 的分布在 0 附近有多少题，决定了 coverage 曲线的形状。第 2 讲会证明：如果 $p$ 的分布在 0 附近像 $p^{b-1}$ 那样变化，coverage 的缺口 $1-\text{coverage}$ 就会像 $k^{-b}$ 那样按 power law 下降（Schaeffer et al. 2025，How Do Large Language Monkeys Get Their Power (Laws)?）。

相同计算量下比较才公平。 大模型一次采样的计算量是小模型的 100 倍（推理 FLOPs ≈ 2 × 参数量 × token 数）。在相同的 FLOPs 预算下：

在这个玩具世界里，小模型 + 重复采样在相同预算下都略胜一筹，但优势随预算增大而缩小（两者都逼近 1）。这里有一个巨大的前提：我们假设有一个完美的 verifier（oracle），能从 500 个样本里准确地挑出正确的那个，而且 verifier 本身不花钱。下面两小节会看到，这个前提往往不成立。

5.3 Temperature：多样性与质量的取舍

重复采样要有效，样本之间必须不一样。控制多样性的旋钮是 temperature $T$：模型选每个 token 的概率是 $\text{softmax}(z/T)$。

• $T = 1$：按模型本来的概率采样。
• $T \to 0$：越来越集中到概率最大的选项上（greedy decoding），每次结果都一样。
• $T$ 很大：越来越接近均匀分布，什么都可能出现，包括胡言乱语。课堂上提到，温度超过 1.2 左右，真实模型就会开始输出不连贯的文字。

02_inference_scaling_preview.py 演示 2（1B 模型，每题 100 次）：

• $T = 0$ 时，采 100 次和采 1 次完全一样。 更糟的是，如果某一步模型”最相信”的恰好是那个错误套路，greedy 解码就永远做不对这道题。
• pass@1 在低温时最高，coverage@100 在 $T = 1.0 \sim 1.5$ 附近最高，coverage@10 的最佳温度在 0.6 左右。预算越大，越值得用高温去”探索”。Codex 论文在真实代码任务上也发现了同样的规律：pass@1 的最佳温度约 0.2，pass@100 的最佳温度约 0.8。

这是一个经典的 exploration–exploitation trade-off（探索与利用的权衡），后面的搜索（第 5、8 讲）和强化学习（第 6 讲）里还会反复遇到。

5.4 Coverage 只是上限：Generation–Verification Gap

coverage 回答的是”有没有一个样本是对的”。但实际使用时，我们必须交出一个答案。没有完美 verifier 的时候，怎么从一堆样本里挑？

两种常见方法：

• Majority voting（self-consistency）：选出现次数最多的答案。
• Best-of-$k$ with a reward model：用一个打分模型给每个样本打分，选分数最高的。

02_inference_scaling_preview.py 演示 3 比较了三者（1B 模型；reward model 把一对正确、错误答案排对的概率约 92%，并且对同一个错误答案每次给同样的分数，模拟它自己的”误解”）：

coverage 一路涨到 0.98，两种实际可用的方法都远远落在后面：

• Majority vote 有一个天花板。 只有”正确答案恰好是最常见答案”的题，投票才可能选对；在这 100 道题里，这样的题只占 29%（用全部 500 个样本估计）。原因是 systematic error：模型的固定错误套路每次都给出同一个错误答案。一旦犯这个错的概率比做对还高，错误答案就会赢得投票，样本再多也没用。
• Reward model 先升后降，在 $k = 64$ 附近最好。$k$ 小时，多采样让正确答案更可能出现在候选里；$k$ 大时，候选里的错误答案越来越多（每题平均出现 116 个不同的答案），总有一些被 RM”误判”成高分，把正确答案挤掉。Cobbe et al. 2021（第 3 讲的阅读材料）在 GSM8K 上观察到了同样的现象：候选答案太多时，verifier 反而更容易被骗。
• Large Language Monkeys 在没有自动 verifier 的数学任务上也看到：majority voting 和 reward model 在几百个样本之后就不再进步，远远跟不上 coverage。

“能生成正确答案”和”能认出正确答案”之间的这个差距，叫做 generation–verification gap。它是这门课最核心的概念之一：test-time scaling 能走多远，很大程度上取决于 verifier 有多好。第 3 讲专门讨论怎样缩小这个差距（outcome vs process verifier、组合多个弱 verifier）。

5.5 Reasoning Models：把”多想一会儿”训练进模型

重复采样是在模型外面加计算。2024 年下半年开始，出现了另一种思路：训练模型在一个回答内部进行很长的思考。

• OpenAI o1（2024 年 9 月）：用强化学习训练模型生成很长的内部 CoT。OpenAI 的博客展示了两条曲线：在 AIME（美国数学邀请赛）上，准确率随训练时的 RL 算力和推理时的思考算力都呈 log-linear 增长。博客报告，在 AIME 2024 上，GPT-4o 平均只能做对 12%，o1 单次采样 74%，64 个样本做 majority vote 83%，用一个学到的打分函数对 1000 个样本重排序 93%。
• Gemini 2.0 Flash Thinking（2024 年 12 月）、Claude 3.7 Sonnet 的 extended thinking（2025 年 2 月）等也相继推出。
• DeepSeek-R1（2025 年 1 月）：公开了训练方法。R1-Zero 直接在 base model 上做 RL，奖励只是”答案对不对、格式对不对”这样的规则（verifiable rewards），算法是 GRPO。训练过程中，模型的回答自发地越来越长，AIME 2024 的 pass@1 从 15.6% 提高到 71.0%，majority vote 达到 86.7%。论文还记录了一个”aha moment”：模型在推理中途写下类似”等等，我重新检查一下”的话，然后推翻了自己之前的做法。

课堂上展示了 OpenAI o1 博客里的一个例子：让模型写一个 bash 脚本，把 [1,2],[3,4],[5,6] 这种格式的矩阵转置。模型的思考过程大致是：

1. 分析问题：用户要一个 bash 脚本；先搞清楚输入输出的格式。
2. 分解任务：解析输入 → 存成二维数组 → 转置 → 按同样的格式输出。
3. 自我纠正：写到一半发现”等等，这里有问题”，回头修改。
4. 回溯：一种方法走不通，换另一种。

这些动作——分析、分解、自我验证（例如执行代码、跑 unit test、用计算器）、自我纠正、回溯——其实就是第 1.4 节”生成 → 反馈 → 改进”的循环，只不过发生在一次回答的内部。所以 reasoning model 可以看作把 test-time self-improvement 内化了。

reasoning model 也不是万能的。o1 的博客报告，在人类偏好评测中，o1-preview 在数据分析、编程、数学等重推理的类别上明显更受欢迎，但在个人写作、编辑文字这类任务上并没有优势。课堂上也强调了这一点：推理模型擅长的是有明确对错、可以验证的任务。

5.6 闭环：test-time 搜索 + train-time 学习

课堂上讲师说，他们最兴奋的是把 test-time scaling 和训练结合起来的”self-improving piece”：

   当前模型 ──(test-time：多采样 / 搜索 / 验证)──► 更好的解（比模型单次输出好）
      ▲                                                │
      └────────(train-time：用这些更好的解训练)◄────────────┘

1. 用 test-time compute（多采样、搜索、verifier）得到比模型单次输出更好的解；
2. 把这些解当作训练数据，微调模型；
3. 新模型单次输出就更好了，再用它做 test-time 搜索，得到更好的解……

这个想法并不新。AlphaGo Zero 就是这样做的：MCTS 搜索得到的走法比神经网络直接给出的更好，于是用搜索结果训练网络，网络变强以后搜索也变强。在语言模型上，STaR（Zelikman et al. 2022）、rejection sampling fine-tuning、expert iteration 都是这个思路，第 6 讲会详细讲。

这个闭环里，verifier 处在核心位置：如果 verifier 把错误的解当成”更好的解”，模型就会学会犯错。第 5.4 节的 generation–verification gap，在这里会被放大成”越训练越歪”。

6. 第三推动力：从 Chatbot 到 Agent

6.1 Agent 和 chatbot 有什么不同？

课堂上的说法是：agent 有以目标为导向的规划和反馈循环。

6.2 真实的 agent

• Deep Research（Google Gemini 2024 年 12 月、OpenAI 2025 年 2 月）：给一个研究问题，它会自己规划搜索、浏览几十上百个网页、汇总成一份带引用的报告。课堂上的例子是：调研”在斯坦福读书一年，租房有哪些选择”，它会分析各个网站，总结各种选择的优缺点。
• Claude Code、OpenAI Codex：coding agent。你用自然语言描述需求，它在你的代码库里工作：

   用户的指令（自然语言）
        │
        ▼
   ┌──► 浏览代码库、搜索文件 ──► 查看 / 编辑文件 ──► 在终端运行命令（测试、编译）
   │                                                          │
   │                                                          ▼
   └────────────────── 分析输出：通过了吗？报了什么错？ ◄───────────┘
                          │
                          └─► 目标完成 → 汇报结果

课堂上的评价是：一年前的 coding agent 还很不可靠，现在已经变得相当可靠。第 10 讲会专门讨论软件工程的 agent。

6.3 Agentic workflow vs agent

课堂上指出，目前大多数实用的系统其实是 agentic workflow：由人设计好流程图（handcrafted graph），LLM 只负责图中的某些节点；而不是让 LLM 完全自由地决定下一步做什么。

Anthropic 2024 年 12 月的文章 Building Effective Agents 给出了一个被广泛采用的区分：

• Workflow：LLM 和工具按预先写好的代码路径编排。
• Agent：LLM 动态地决定自己的流程和工具使用。

两者都由同样的构件（building blocks）搭成：

• LLM call：输入指令，输出结果。
• Verifier：检查输出对不对（unit test、数学验证、规则检查）。
• LLM-as-judge：用另一个 LLM 评价输出（用于没有自动 verifier 的任务）。
• Tool call：网页搜索、天气 API、文件操作、计算器……

以及五种常见的编排模式：

Anthropic 的建议是：从最简单的方案开始，只在确实需要时才增加复杂度。workflow 更可预测、更容易调试；agent 更灵活，但更难控制、成本更高、错误也会累积。

6.4 Agent 需要什么能力？

课堂上列出了三项：更好的规划、多步推理、自我改进 / 自我纠正。这三项正好对应课程的主体：

• 规划和多步推理：第 5 讲（树搜索、按需分解）、第 6 讲（用 RL 训练推理）。
• 自我纠正：第 3 讲（verifier）、第 4 讲（工具和代码执行的反馈、AI feedback）。
• 另外还需要记忆（第 11 讲）和可靠的评估（第 14 讲）。

6.5 可靠性的算术：为什么 agent 难做

agent 的任务往往有几十上百步。如果每一步的成功率是 $p$，而且错误无法纠正，那么 $n$ 步全对的概率是 $p^n$。03_feedback_loops.py 演示 1：

99% 听起来已经很可靠，但走 100 步之后只剩 37%。想让 100 步全对的概率达到 80%，每一步要有 99.78% 的可靠性。这就是”最后 10% 是 90% 的工作量”的数学版本，也和第 3.4 节的 emergence 是同一个公式：长程任务的成功率是每步成功率的高次方。

出路只有两条：

1. 让每一步更准：更好的模型、更好的训练。
2. 在过程中发现并纠正错误：反馈、验证、重试。这就是 agent 的 feedback loop。

第 14 讲的阅读材料 METR 2025（Measuring AI Ability to Complete Long Tasks）用”AI 有 50% 的把握完成的任务，人类专家要花多长时间”来衡量 agent 的能力，发现这个”时间跨度”大约每 7 个月翻一倍。

6.6 反馈的质量决定自我改进的上限

这是本讲最重要的一个实验。03_feedback_loops.py 演示 2 实现了一个 evaluator–optimizer 循环：生成一个答案 → 检查 → 不通过就重新生成，最多 $T$ 次。我们比较四种反馈来源（10B 模型，200 道 4~8 步题，每题重复 3 次）：

• 没有反馈：第一次的答案就交上去，等于 chatbot。
• Self-check：让同一个模型再独立做一遍，两次答案一致就接受。每次检查多花一次生成。
• 外部 judge：一个独立的评委，答案对时以 90% 的概率判”对”（TPR = 0.9），答案错时以 15% 的概率误判成”对”（FPR = 0.15）。
• 工具检查：用计算器把每一步重算一遍。在算术这个领域它是完美的，就像一套完整的 unit test 之于代码。

结果（准确率 / 平均生成次数）：

（$T = 1$ 那一行，四种方法本质上都等于单次采样，差别只是随机波动。）

工具检查让准确率随尝试次数稳步上升，$T = 16$ 时达到 0.910，而且平均只用 4.69 次生成——一旦通过就停下。

外部 judge 很省（平均不到 3 次生成），但它停在 0.63 附近。这个上限是可以算出来的。每一轮有三种结局：接受了正确答案（概率 $p \cdot \text{TPR}$）、接受了错误答案（概率 $(1-p) \cdot \text{FPR}$）、拒绝（再来一轮）。允许无限次重试时，最终交出正确答案的概率就是两种”接受”的相对比例：

这正是 judge 在这道题上的 precision。对一道 $p = 0.1$ 的难题，上限只有 $0.09 / (0.09 + 0.135) = 0.4$：错误答案太多，15% 的误判率足以让它们一次次被放进来。对所有题目平均，上限是 0.644，和模拟结果吻合。

Self-check 最贵、最慢，上限（0.572）还低于外部 judge。原因是相关的错误（correlated errors）：模型对同一道题犯的错是有规律的。如果它在某一步”最相信”错误套路，两次很可能犯同一个错、得到同一个错误答案，然后”互相确认”。数学上，生成答案 $a$ 的概率是 $q_a$，复查又得到 $a$ 的概率还是 $q_a$，所以接受 $a$ 的概率正比于 $q_a^2$：

平方会放大最常见答案的优势。self-check 实际上是一种”软的 majority vote”，继承了 majority vote 的毛病（第 5.4 节）：最常见的答案是错的，它就倾向于接受错的。

这和真实 LLM 上的研究结论一致。Huang et al. 2023（Large Language Models Cannot Self-Correct Reasoning Yet）发现：在没有外部反馈的情况下，让 LLM 检查并修改自己的推理答案，往往不能提高准确率，有时还会把对的改成错的。

本讲最重要的原则：一个自我改进的循环，最多只能好到它的反馈信号允许的程度。自我改进需要一个比生成者更可靠、或者至少错得不一样的信号：执行结果、unit test、计算器、编译器、定理证明器、独立训练的 verifier。

6.7 Tool use：把容易错的步骤交给程序

反馈之外，工具还可以直接替代模型容易出错的步骤。03_feedback_loops.py 演示 3 让模型在算乘法时调用计算器（调用有 5% 的概率失败，失败时模型只能自己算）：

• 步数越多，相对提升越大：1B 模型在 6 步题上从 0.072 提高到 0.247，是原来的 3 倍多。每个被工具替代的步骤都不再贡献错误，而错误是逐步累积的。
• 用了计算器的 1B 模型补上了它和 10B 模型之间的大部分差距（在这个设定里还没有超过）。一个便宜、可靠的工具，效果接近把模型放大 10 倍。
• 工具没有消除所有错误：加减法仍由模型自己算，工具调用本身也会失败。真实的 agent 还要学会什么时候该调用工具、怎样写出正确的调用。第 4 讲会讨论怎样用工具和代码执行的反馈训练模型（ReAct、RLEF）。

6.8 可验证的领域 vs 不可验证的领域

把第 5、6 节合起来看，一个模式就很清楚了：自我改进最先在”容易验证”的领域取得成功。

这也是课堂上提到的 generator–verifier gap 在创造性任务上特别突出的原因：没有可靠的 verifier，test-time scaling 和 RL 都很难施展。

7. 应用

课堂上用几分钟列举了 agent 正在改变的领域：

编程与数据工程

• 代码迁移、版本升级、代码库重构——这些任务步骤多、规则清楚、有测试可以验证，非常适合 agent。
• 数据抽取与清洗、数据仓库迁移。

客户服务

• 实时转写：记录每一次交互，改善记录保存。
• 知识助手：员工不需要背下所有政策，LLM 去查知识库。
• 智能回复：AI 建议回复内容，人来确认。
• 通话摘要：自动生成摘要，改善客户体验。

研究与报告

传统的流程是：文献综述 → 逐篇总结 → 综合成文。agent 可以从一条指令出发完成整个流程。课堂上的例子来自 STORM（Shao et al. 2024，CS224V 第 2 讲有详细介绍），题目是”2022 年冬奥会开幕式”：

1. 找到相关的参考资料；
2. 构建大纲，标出每一节对应哪些参考资料；
3. 逐篇总结参考资料，突出和主题相关的内容；
4. 综合成一篇完整的文章。

AI 科学家

The AI Scientist（Lu et al. 2024，第 7 讲的阅读材料）把科研分成几个阶段：产生想法 → 迭代实验 → 写论文（还有自动审稿），据报道每篇论文的成本约 15 美元。课堂上提到一个有意思的观点：模型的”幻觉”在产生想法时可能反而是优点，它能提出超出常规领域知识的”脑洞”。当然，这些想法最后必须经过实验的验证——又回到了反馈信号的问题。

机器人

第 16 讲的客座讲座（Physical Intelligence 的 Danny Driess）会讨论物理世界里的多模态 agent。

8. 课程地图

把第 1.3 节的”两条时间轴”和第 1.4 节的”生成 → 反馈 → 改进”循环放在一起，就是这门课的结构：

原课 10/24、10/27、10/31 是学生的期中项目展示，没有独立的讲义内容；做研究项目的经验并入第 17 讲。

                         第1讲 导论：生成 → 反馈 → 改进
                 ┌───────────────┼────────────────┐
     第2讲 test-time compute   第3讲 verification    第4讲 工具 / 代码 / AI 反馈
                 └───────┬───────┘                    │
                  第5讲 多步推理与规划 ◄────────────────┘
                         │
                  第6讲 RL 的扩展（train-time）──► 第9讲 后训练的演变
                         │
          ┌──────────────┼──────────────┐
   第7讲 开放式演化   第8讲 搜索与深度研究   第12讲 LLM 推理
          │              │              │
   第10讲 软件工程   第11讲 记忆      第13讲 AlphaProof / IMO
          └──────────────┼──────────────┘
                  第14讲 评估与长程任务
                         │
          第15讲 自主性    第16讲 机器人    第17讲 未来方向

阅读材料里有很多来自两位讲师自己的实验室（Large Language Monkeys、Archon、Weaver、CodeMonkeys、KernelBench、Cartridges、SWiRL……）。这说明这门课是一门研究生研讨课：讲的是正在发生的研究，很多问题还没有定论。

9. 课程安排与研究项目

9.1 讲师

• Aakanksha Chowdhery：曾任 Google PaLM（540B）的技术负责人，参与过 Gemini 的开发。
• Azalia Mirhoseini：斯坦福计算机系助理教授，此前在 Google Brain、Google DeepMind 和 Anthropic 工作，参与过 Gemini 和 Claude 的开发。

这门课是第二次开设，相比第一次更新了讲座内容和课程结构。

9.2 考核

三次作业合计 50%，研究项目合计 50%。作业帮助建立对自我改进、多步推理和工具使用这些基础技术的直觉。每人有 4 天免费的迟交额度，每次作业最多用 2 天；期末报告不能迟交。课程不允许旁听。

9.3 研究项目

作为研究生研讨课，研究项目是重点。2~4 人一组（可以一个人，但不推荐），课程提供 API 额度（组越大，总额度越多）。

课堂上明确了什么样的项目可以：

• 构建新的评测数据集或 benchmark；
• 分析 agent 系统的可靠性；
• 带着新想法去”爬”某个 benchmark（hill-climbing）；
• 改进已发表的方法；
• 质疑、检验论文里的方法论选择。

以及什么样的项目不行：

• 综述（survey）；
• 没有研究假设、只是”搭一个应用”。

一个好的项目应该有：研究假设 → 实验设计 → 对结果和性质的分析。往届学生的课程项目已经有发表成论文的。

9.4 从本讲得到的几条研究建议

本讲的几个实验，其实也是做这个领域的研究时最容易踩的坑：

1. 在相同的计算量下比较。 “方法 A 采样 100 次比方法 B 采样 1 次好”不说明任何问题。要么按 FLOPs、要么按 token 数、要么按美元，把预算对齐（第 5.2 节）。
2. 分清 coverage 和实际能选出来的准确率。 报告 pass@k 时说清楚有没有 oracle verifier；没有的话，要报告实际选择方法（投票、RM）的结果（第 5.4 节）。
3. 说清楚反馈信号从哪里来。 一个”自我改进”的方法提高了分数，要检查它是否偷偷用了测试集的答案、一个和评测指标相同的 verifier，或者只在可以验证的子集上有效（第 6.6 节）。
4. 报告方差。 本讲的很多表格里，相邻两行的差别只是随机波动（例如第 6.6 节”没有反馈”那一列）。多跑几个随机种子、多用一些题目。
5. 注意指标的非线性。 换一个更平滑的指标，“突然出现”的现象可能就消失了（第 3.4 节）。

10. 小结

1. Self-improving AI agent = 通过与自身、与环境的交互不断改进的 agent。改进可以发生在 test-time（不改权重：采样、验证、修改、搜索）或 train-time（改权重：用验证过的自生成数据训练、RL），还可以改进系统的设计本身（开放式演化）。所有方法都是”生成 → 反馈 → 改进”的循环。
2. Pretraining scaling：loss 和参数量、数据量、算力之间是 power law，可以预测；但 power law 意味着收益递减，再加上 irreducible loss 和数据墙，单靠扩大预训练越来越贵。
3. Emergence 与 CoT：in-context learning 和 CoT 都是随规模出现的能力。CoT 提供了额外的串行计算、把问题分解成熟悉的小步，本身就是一种 test-time compute。很多”涌现”可能来自 exact match 这类非线性的指标：每步正确率 $s$ 平滑提高，$s^k$ 却会突变。
4. Post-training：base model 只会续写；instruction tuning 教它听指令，RLHF 让它更有帮助、更安全。训练信号从”人写的示范”演变到”人的偏好”、“AI 的反馈”、“可验证的奖励”和”环境的反馈”，越来越便宜，也越来越需要关心它是否可靠。
5. Test-time compute：重复采样让 coverage 随样本数持续增长，小模型多采样可以胜过大模型采一次；temperature 控制多样性，预算越大越值得用高温。但 coverage 只是上限：majority vote 受 systematic error 限制，reward model 在候选太多时会被骗。这就是 generation–verification gap。
6. Reasoning models（o1、R1）用 RL 把”分析、分解、自我验证、纠错、回溯”训练进了一次回答内部。test-time 搜索得到更好的解、再用它们训练模型，构成自我改进的闭环。
7. Agents：以目标为导向、和环境交互、利用反馈纠正自己。大多数实用系统是人设计的 workflow（prompt chaining、routing、parallelization、orchestrator–workers、evaluator–optimizer）。长程任务的成功率是每步成功率的高次方，必须靠反馈来纠错。
8. 反馈的质量决定自我改进的上限：完美的工具检查可以把准确率一直推高；有误判的 judge 的上限是它的 precision $\frac{p\,\text{TPR}}{p\,\text{TPR} + (1-p)\,\text{FPR}}$；self-check 因为错误相关，是一种软的 majority vote，提升最有限。所以自我改进最先在数学、编程这类容易验证的领域成功。

11. 练习

1. pass@k 的无偏估计（第 5.2 节） 一道题采样 $n = 10$ 次，$c = 2$ 次正确。 (a) 用无偏估计算 pass@3。 (b) 如果用”有放回”的公式 $1 - (1 - c/n)^k$ 会得到多少？为什么两者不同？哪个更大？ (c) 能用这 10 个样本估计 pass@20 吗？为什么？

(a) $1 - \binom{8}{3}/\binom{10}{3} = 1 - 56/120 \approx 0.533$。 (b) $1 - 0.8^3 = 0.488$。无偏估计考虑的是”从这 10 个样本里不放回地抽 3 个”：抽到一个错误样本以后，剩下的错误样本变少了，下一个抽到正确样本的机会变大，所以不放回时”至少一个正确”的概率更大。$1-(1-\hat p)^k$ 这个”代入式”的估计是有偏的，会系统性地低估 pass@k。 (c) 不能。$k > n$ 时组合数 $\binom{n}{k}$ 没有意义，代码里会抛出 ValueError。想估计 pass@$k$，至少要采 $k$ 个样本。

2. 需要采多少次？（第 5.2 节） 一道题的单次成功率是 $p = 0.01$。要让”至少做对一次”的概率达到 90%，大约要采样多少次？$p = 0.001$ 呢？这和”coverage 增长越来越慢”有什么关系？

$1 - (1-p)^k \ge 0.9 \Rightarrow k \ge \ln 0.1 / \ln(1-p)$。$p = 0.01$ 时约 229 次，$p = 0.001$ 时约 2302 次，大约都是 $2.3/p$。题目越难，需要的采样次数按 $1/p$ 增长；coverage 的后半段由这些 $p$ 很小的题决定，所以 $k$ 每增加 10 倍，只能多解决下一批”难 10 倍”的题。

3. Scaling law 的算术（第 2 节） 假设 reducible loss $L - L_\infty \propto C^{-0.155}$。 (a) 要把 reducible loss 减半，算力要扩大多少倍？ (b) 如果 Kaplan 的 $L(C) \propto C^{-0.050}$ 是对的（不考虑 $L_\infty$），把 loss 减半要扩大多少倍？ (c) 这些数字说明了什么？

(a) $2^{1/0.155} \approx 2^{6.45} \approx 87$ 倍。 (b) $2^{1/0.05} = 2^{20} \approx 100$ 万倍。 (c) power law 的指数很小时，每一点进步都需要成数量级的算力。这就是为什么 scaling 能持续很多年（总能再扩大 10 倍），也是为什么它越来越贵。

4. 可靠性与重试（第 6.5、6.6 节） 一个 agent 的每一步成功率是 0.9。 (a) 不纠错，20 步全对的概率是多少？ (b) 如果每一步都有一个完美的 verifier，失败了可以重试，最多重试到第 $r$ 次。要让每一步的成功率达到 0.99，$r$ 至少是多少？这时 20 步全对的概率是多少？ (c) 如果 verifier 的 FPR = 0.1、TPR = 1，允许无限次重试，每一步的成功率上限是多少？

(a) $0.9^{20} \approx 0.122$。 (b) 每一步最多尝试 $r$ 次，失败的概率是 $0.1^r$。$r = 2$ 时成功率 $1 - 0.01 = 0.99$；20 步全对 $0.99^{20} \approx 0.818$。 (c) $\frac{0.9 \times 1}{0.9 \times 1 + 0.1 \times 0.1} = 0.9 / 0.91 \approx 0.989$。注意 $p = 0.9$ 时误判的影响很小；$p$ 很小时影响才大（下一题）。

5. Judge 的上限（第 6.6 节） 一道难题，模型单次成功率 $p = 0.1$。外部 judge 的 TPR = 0.9。 (a) FPR = 0.15 时，无限次重试的准确率上限是多少？ (b) 要让上限达到 0.9，FPR 最多是多少？ (c) 从 (b) 的结果看，为什么说”越难的题，越需要好的 verifier”？

(a) $0.09 / (0.09 + 0.9 \times 0.15) = 0.09 / 0.225 = 0.4$。 (b) $\frac{0.09}{0.09 + 0.9 f} \ge 0.9 \Rightarrow 0.09 \ge 0.081 + 0.81 f \Rightarrow f \le 0.0111$，FPR 要低于约 1.1%。 (c) 上限 $= \frac{1}{1 + \frac{1-p}{p}\cdot\frac{\text{FPR}}{\text{TPR}}}$。$p$ 越小，$\frac{1-p}{p}$ 越大，FPR 被放大得越厉害。难题上错误答案多，verifier 必须几乎不放过任何错误答案。

6. Self-check、majority vote 和 judge（第 5.4、6.6 节） 某道题上，模型生成的答案分布是：正确答案 0.3，某个 systematic error 的答案 0.5，其余 0.2 均匀分散在 20 个不同的错误答案上（每个 0.01）。 (a) 样本很多时，majority vote 选对的概率是多少？ (b) self-check 循环（无限次重试）的上限是多少？ (c) 外部 judge（TPR = 0.9，FPR = 0.15）的上限是多少？ (d) 用这道题解释”错得不一样”为什么重要。

(a) 约为 0：样本足够多时，出现最多的是 0.5 的那个错误答案。 (b) $0.3^2 / (0.3^2 + 0.5^2 + 20 \times 0.01^2) = 0.09 / 0.342 \approx 0.263$。 (c) $0.27 / (0.27 + 0.7 \times 0.15) = 0.27 / 0.375 = 0.72$。 (d) majority vote 和 self-check 的信号都来自模型自己，模型最常犯的错会被反复确认。外部 judge 虽然不完美，但它的错误和生成者无关，不会系统性地偏向那个最常见的错误答案。

7. Temperature（第 5.3 节） (a) 为什么 temperature = 0 时，coverage@100 = pass@1？ (b) 假设某一步，模型对 bug 做法的 logit 比 correct 高 0.5。分别在 $T = 0$、$T = 1$、$T = 2$ 时，这一步做对的概率是多少（只考虑 correct 和 bug 两种做法）？ (c) 为什么预算越大，最佳温度越高？

(a) greedy 解码是确定性的，100 次采样完全相同。 (b) 两个选项时做对的概率是 $\sigma(-0.5/T)$：$T = 0$ 时为 0（永远选 bug）；$T = 1$ 时 $\sigma(-0.5) \approx 0.378$；$T = 2$ 时 $\sigma(-0.25) \approx 0.438$。温度升高，“少数派”做法的概率变大。 (c) pass@1 只关心最可能的那个答案，低温最好；pass@k 关心”$k$ 次里有没有一次对”，需要样本之间足够不同，才能覆盖模型”不太相信”但正确的做法。$k$ 越大，越能承受单次准确率的下降来换取多样性。

8. 动手改代码 (a) 在 toy_llm.py 里把 BETA 从 1.2 改成 0.6（规模的作用减半），运行 01 号文件。“涌现点”往哪边移动了？ (b) 在 03 号文件里把 JUDGE_FPR 从 0.15 改成 0.05，judge 的上限变成多少？和练习 5 的公式对得上吗？ (c) 在 03 号文件演示 3 里把 tool_fail_prob 从 0.05 改成 0.3，工具的效果下降了多少？ (d) 在 02 号文件演示 3 里把 reward model 的 signal 从 2.0 改成 3.0。best-of-$k$ 还会先升后降吗？峰值出现在更大还是更小的 $k$？

9. 思考题 (a) 为什么最先变得可靠的 agent 是 coding agent，而不是写作 agent？用第 6.8 节的表格回答。 (b) 你要为一家电商设计客服系统：大部分问题是”查订单状态”，少数是复杂的退款纠纷。你会用第 6.3 节的哪些模式？为什么不直接用一个完全自主的 agent？ (c) 第 5.6 节的闭环里，如果 verifier 有 10% 的 false positive，多轮训练之后可能发生什么？

10. 研究项目头脑风暴 按照第 9.3、9.4 节的要求，写一个一段话的项目提案：研究假设是什么？用什么 benchmark（有没有自动 verifier）？baseline 是什么？怎样做到 compute-matched 的比较？

12. 延伸阅读

Scaling 与涌现

• Kaplan et al. 2020. Scaling Laws for Neural Language Models.
• Hoffmann et al. 2022. Training Compute-Optimal Large Language Models.（Chinchilla）
• Brown et al. 2020. Language Models are Few-Shot Learners.（GPT-3）
• Wei et al. 2022. Emergent Abilities of Large Language Models.
• Schaeffer, Miranda, Koyejo 2023. Are Emergent Abilities of Large Language Models a Mirage?
• Rich Sutton 2019. The Bitter Lesson.（一篇短文）

推理与 CoT

• Wei et al. 2022. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.
• Kojima et al. 2022. Large Language Models are Zero-Shot Reasoners.
• Wang et al. 2022. Self-Consistency Improves Chain of Thought Reasoning in Language Models.
• Li et al. 2024. Chain of Thought Empowers Transformers to Solve Inherently Serial Problems.

Post-training

• Ouyang et al. 2022. Training Language Models to Follow Instructions with Human Feedback.（InstructGPT）
• Chung et al. 2022. Scaling Instruction-Finetuned Language Models.（Flan）
• Bai et al. 2022. Constitutional AI: Harmlessness from AI Feedback.（第 4 讲阅读材料）

Test-time compute 与 reasoning models

• Brown et al. 2024. Large Language Monkeys: Scaling Inference Compute with Repeated Sampling.（第 2 讲阅读材料）
• Chen et al. 2021. Evaluating Large Language Models Trained on Code.（Codex；pass@k 的无偏估计）
• OpenAI 2024. Learning to Reason with LLMs.（o1 博客）
• DeepSeek-AI 2025. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.

Agents

• Anthropic 2024. Building Effective Agents.（博客；workflow 与 agent 的区分、五种模式）
• Yao et al. 2022. ReAct: Synergizing Reasoning and Acting in Language Models.（第 4 讲阅读材料）
• Huang et al. 2023. Large Language Models Cannot Self-Correct Reasoning Yet.
• METR 2025. Measuring AI Ability to Complete Long Tasks.（第 14 讲阅读材料）

同目录的相关课程

• CS224V（Agentic AI）第 1、3 讲：幻觉、可靠性的算术、agent 的构件与 harness。
• CS329H（从人类偏好中学习）第 1、8、9 讲：RLHF、DPO、reward model 的偏差。
• CS336 第 9、11 讲（scaling laws）、第 15、16 讲（SFT、RLHF、RLVR）。

13. 下一讲预告

第 2 讲：Test-Time Compute Scaling

本讲只看了 test-time compute 最简单的形式：重复采样 + oracle verifier。第 2 讲会深入回答：

• coverage 曲线为什么是 power law？ 从”每道题的成功率 $p$ 的分布”出发，推导 Large Language Monkeys 观察到的 scaling law（How Do Large Language Monkeys Get Their Power (Laws)?）。
• 给定预算，怎样分配最好？ 多采样（并行）还是多修改（串行）？简单题和难题该花一样多的计算吗？什么时候”小模型 + 多推理”比”大模型”划算？（Snell et al. 2024）
• 能不能把多种推理技巧组合起来？ 集成多个模型、生成后融合、排序、批评、验证……Archon 把这些组合当作一个”架构搜索”问题。

代码会继续使用本讲的 toy_llm.py。