第 8 讲：用搜索自我改进与深度研究 agent——AlphaCode、AlphaCode 2 与 Search-o1

对应：Stanford CS329A Autumn 2025 Lecture 8（Fri 10/17，Self improvement with Search & Deep Research Agents）。阅读材料：Competition-Level Code Generation with AlphaCode（Li et al. 2022）、AlphaCode 2 Technical Report（Google DeepMind 2023）、Search-o1: Agentic Search-Enhanced Large Reasoning Models（Li et al. 2025）。幻灯片没有公开，本讲依据这三篇材料编写，并补充了深度研究 agent 的公开信息。 配套代码：code/lecture08/（只用 Python 标准库；01 号约 3 秒，02 号不到 1 秒） 预计阅读时间：2.5~3 小时（含运行代码）

0. 本讲导航

0.1 学完本讲，你应该能够

1. 区分两种”搜索”：在解的空间里搜索（采样大量候选、过滤、挑选——AlphaCode）和在信息的空间里搜索（推理过程中检索外部知识——Search-o1、深度研究 agent）。
2. 说出 AlphaCode 的三个关键：干净的竞赛编程数据集、能高效采样的大模型、大规模采样 + 按程序行为过滤和聚类；说出它在 Codeforces 上的成绩（平均排名前 54.3%）和”解出率随采样数对数线性增长”。
3. 解释为什么”只能提交 10 次”让挑选变得关键，为什么样例测试是一个有大量 false positive 的 verifier，以及按行为聚类怎样把有限的提交机会分给不同的解法。
4. 说出 AlphaCode 2 的改进（基于 Gemini Pro、加入打分模型）和成绩（解出 43% 的题，约第 85 百分位）。
5. 说出 Search-o1 要解决的问题（reasoning model 的长推理链会遇到知识缺口）和两个设计：推理中途按需检索、Reason-in-Documents 提炼文档；以及为什么”把检索到的原始文档直接塞进推理链”可能有害。
6. 说出深度研究 agent 的基本结构和评估方式，以及它和第 2~5 讲方法的联系。

0.2 先修知识

0.3 本讲地图

第1节  两种搜索：在解的空间里、在信息的空间里
第2节  AlphaCode：采样上百万个程序，过滤、聚类、交 10 个        ← 代码 01
第3节  AlphaCode 2：更强的模型 + 打分模型
第4节  Search-o1：推理中途按需搜索，文档先提炼再用             ← 代码 02
第5节  深度研究 agent
第6节  搜索与自我改进
第7–10节 小结、练习、延伸阅读、下一讲预告

0.4 本讲的代码

• 01_alphacode.py：一个”猜隐藏函数”的小世界。每道题背后是一个由加、乘、取模、截断（min）、整除组成的函数；题目给 2 个很小的样例（输入 010），隐藏测试是 50 个 099 的输入。模型写的程序常有”差一”或”用错运算”的错误，而这些错误在小输入上常常看不出来。
• 02_search_o1.py：复用第 4 讲”要先查资料的算术题”（事实有流行度，模型记错时总编同一个值）。推理模型换成 100B（算术更可靠，知识缺口成为主要问题）；检索到的文档里有 3 个干扰数字。

关于本讲的数字：论文里的数字注明出处；模拟实验的数字都来自 01、02 号代码的实际输出（固定随机种子，Python 3.9 与 3.13 逐字相同）。模型的行为（错误类型的概率、被干扰的概率）是设定的，说明的是机制。

1. 两种搜索

第 1 讲第 5.6 节说过，搜索是自我改进的引擎之一：AlphaGo 用 MCTS 找到比神经网络直觉更好的走法。对 LLM 来说，“搜索”有两种含义：

两者的共同点是：用推理时的计算换取更好的结果，并且依赖某种外部的”检验”——程序的测试，或者检索到的事实。

2. AlphaCode：采样上百万个程序，过滤、聚类、交 10 个

2.1 为什么竞赛编程难

2022 年的大模型已经能完成简单的编程任务（例如把一句描述翻译成几行代码），但竞赛编程完全是另一回事：题目是一段很长的自然语言描述（一个故事 + 输入输出格式 + 约束），要理解问题、想出算法（动态规划、图论、数论……）、处理边界情况，再写出又对又快的代码。这需要的是解决问题的能力，而不只是”把指令翻译成代码”。

Li et al. 2022（DeepMind）的 AlphaCode 第一次让 AI 在真实的编程竞赛里达到了人类参赛者的中等水平。

2.2 三个关键组件

论文总结了三个关键：

(1) 干净的、大规模的数据集。 CodeContests：从 Codeforces 等平台收集的 13,328 道训练题、117 道验证题、165 道测试题，按时间切分（训练题都在 2021 年 7 月之前，测试题都在 2021 年 9 月之后），防止测试题泄漏进训练数据。题目原来的测试太少，很多错误的程序也能通过（false positive 率高达 62%）；作者通过变异已有的测试输入生成了更多的测试，把 false positive 率降到 4%。另外在 715 GB 的 GitHub 代码上预训练。

(2) 能高效采样的大模型。 encoder-decoder 结构的 Transformer（编码器读题目，解码器写代码），最大 41B 参数；用 multi-query attention 让采样更快——因为后面要采样上百万次，采样的速度至关重要。

(3) 大规模采样，然后按程序行为过滤和挑选。 这是本讲的重点。

2.3 采样：让样本足够多样

每道题采样最多 100 万个程序。多样性比单个样本的质量更重要（第 1 讲第 5.3 节、第 2 讲第 3 节：coverage 取决于”有没有一个对的”）。为了增加多样性，AlphaCode 在采样时随机化题目的”元数据”：随机给定题目的难度评级（800~3500）、算法标签（从最常见的 50 个里随机挑）、编程语言（Python 或 C++），以及”这是一份正确的解答”的标记。相当于每次让模型”假装”这是一道不同风格的题。

2.4 过滤：用样例测试

竞赛题会给几个样例（输入和期望的输出）。AlphaCode 运行每个采样出的程序，只保留通过所有样例的。这一步去掉了大约 99% 的样本——绝大多数程序要么编译不过、要么在样例上就错了。

但样例测试是一个很弱的 verifier：样例很少、通常很小，很多错误的程序也能通过（第 2.1 节的 62%）。过滤之后剩下的程序里，仍然混着大量错误的解。

2.5 聚类：把提交机会分给不同的行为

比赛规则是每道题只能提交 10 次。过滤之后可能还剩几千个程序，怎样挑 10 个？

AlphaCode 训练了一个生成测试输入的模型，为每道题生成一批新的输入（没有答案）。在这些输入上运行剩下的程序，输出完全相同的程序归为一类。行为相同的程序很可能是”同一种解法”（不管代码写得多不一样）。然后从最大的类开始，每个类挑一个，一共提交 10 个。

为什么这样做有效？

• 正确的程序行为一致：不同写法的正确程序，在任何输入上输出都一样，会聚成一个大类。
• 错误五花八门：不同的错误在新输入上表现不同，分散在很多小类里。
• 10 次机会分给 10 种不同的行为，而不是浪费在同一种错误的 10 个副本上。

这其实是第 2 讲 majority vote 的一个更聪明的版本：不是对答案投票，而是对程序在没见过的输入上的行为投票。

2.6 结果

• Codeforces：在 10 场有超过 5000 名参赛者的比赛的模拟评估中，AlphaCode 的平均排名在前 54.3%——大致相当于中等水平的人类参赛者。
• CodeContests 测试集：每题采样 10 万个、提交 10 个时，解出 29.6% 的题。
• 扩展规律：解出率随采样数和训练计算量大致呈对数线性增长；更大的模型斜率更大。这和第 2 讲 Large Language Monkeys 的发现一致。
• 分析：模型并不是在复制训练数据里的长代码；它在动态规划、构造类题目上较弱，在位运算、排序类题目上较强；对题目描述的改动很敏感（说明它确实在”读题”）。

2.7 toy world 里的 AlphaCode

01_alphacode.py：60 道题，每题采样 $k$ 个程序，只能提交 10 个：

• 随机提交几乎没用：$k$ 再大，随机挑的 10 个里也很少有对的。
• 2 个小样例就能过滤掉约 94% 的程序，但通过样例的程序里只有大约四分之一真正正确：差一的常数、换错的运算，在 0~10 这样的小输入上常常看不出来。
• 过滤后随机挑 10 个提高得很慢：幸存者里错误的太多，10 个名额常常全部落在错误的程序上。
• 聚类把 10 次机会分给 10 种不同的行为：$k$ = 10000 时解出 0.90，过滤后随机挑只有 0.77，上限是 0.98。采样越多，正确的那个类越大、越容易被选中。

编写时的调整：最初样例的输入是 0~99 的随机数，模型每步写对的概率是 0.55。那时题目太容易，通过样例的程序里一半以上是对的，“过滤后随机挑”已经足够好，聚类反而没有优势。把样例限制成小输入（真实竞赛题的样例通常就很小）、让模型变弱之后，才出现 AlphaCode 面对的情形：通过样例的程序大多是错的。聚类的价值取决于过滤之后的 false positive 有多严重。

3. AlphaCode 2：更强的模型 + 打分模型

2023 年 12 月，DeepMind 随 Gemini 发布了 AlphaCode 2 的技术报告。它保留了 AlphaCode 的”采样 → 过滤 → 聚类 → 挑选”框架，主要的改进是：

• 策略模型换成 Gemini Pro，在竞赛编程数据上微调（用到约 1.5 万道 Codeforces 题目和 3000 万份人写的代码样本）。
• 一个打分模型：同样基于 Gemini Pro 微调，估计每个候选程序正确的概率。聚类之后，用它在类之间、类里面挑出最终的 10 个提交。这相当于在”行为投票”之外，再加一个学出来的 verifier（第 3 讲）。

结果：在 12 场 Codeforces 比赛的 77 道题上，AlphaCode 2 在 10 次提交内解出了 43%，是 AlphaCode（25%）的 1.7 倍，估计在参赛者中排在第 85 百分位左右。报告还提到，当人类程序员和 AlphaCode 2 合作（例如给出代码应满足的一些性质）时，表现还能进一步提高。

从 AlphaCode 到 AlphaCode 2，可以看到第 2~3 讲的规律：

• 生成器越强，同样的预算下 coverage 越高（更好的模型）；
• verifier 越强，越能把 coverage 变成真实的成绩（打分模型）；
• 挑选时要考虑多样性（聚类）。

4. Search-o1：推理中途按需搜索，文档先提炼再用

4.1 问题：长推理链里的知识缺口

o1、QwQ、DeepSeek-R1 这类 reasoning model 会写很长的推理链。推理链越长，越可能在中途遇到模型不确定的知识：一个公式、一个常数、一个化学反应的条件、一个历史事实。论文观察到，这类模型的推理里频繁出现”也许""可能”之类的不确定表达；一旦在某个知识点上出错，错误会沿着长链条传播下去。

已有的 RAG 是在推理之前检索一次（用问题去搜），但很多知识需求是推理到一半才出现的，问题本身里根本没提到。

4.2 做法

Search-o1（Li et al. 2025）以 QwQ-32B-Preview 为基础，做了两件事：

(1) Agentic 的检索：推理中途按需搜索。 模型在推理过程中，遇到不确定的知识点时，可以生成一个搜索查询，用特殊的标记包起来：<|begin_search_query|> … <|end_search_query|>。系统检测到这个标记，就暂停生成，执行搜索，把结果放回推理链（用 <|begin_search_result|> … <|end_search_result|> 包起来），模型接着往下推理。一次推理里可以搜很多次。这和第 4 讲的 ReAct 是同一个思想，只是发生在 reasoning model 的长推理链内部。

(2) Reason-in-Documents：文档先提炼再用。 搜回来的网页通常又长又杂，和当前的推理需求只有一小部分相关。直接把它们塞进推理链，会打断推理的连贯性，还会引入干扰。Search-o1 增加了一个独立的步骤：让模型结合当前的搜索查询和之前的推理，先分析检索到的文档，提炼出简洁、相关的信息，再把提炼的结果放回推理链。

此外，为了效率，Search-o1 支持批量推理：多个问题同时生成，搜索请求批量执行，文档批量提炼。

4.3 结果

论文在科学、数学、代码的难题和六个开放领域问答数据集上评估：

• GPQA diamond（博士级的科学题）：物理 77.9、化学 47.3、生物 78.9。
• 数学：MATH500 86.4，AMC23 85.0，AIME24 56.7；代码：LiveCodeBench 33.0。
• 和人类专家比较：在 GPQA 的扩展集上，Search-o1 的整体得分是 57.9。按领域和人类专家比较：在物理和生物上超过了相应领域的专家（物理学家 39.9、生物学家 37.2），在化学上不如化学家（48.9）。
• 多跳问答（exact match）：HotpotQA 45.2、2Wiki 58.0、MuSiQue 16.6、Bamboogle 56.0；在五个数据集上平均比”agentic 检索但不提炼文档”的 RAgent-QwQ-32B 高 4.7%。

4.4 toy world 里的 Search-o1

02_search_o1.py 比较五种做法（100B 推理模型，300 道要查两个事实的题，每题跑 3 次；按需搜索的阈值 0.9：模型对一个事实的把握低于 0.9 就搜）：

• 直接推理在长尾上很差：知识缺口。
• 标准 RAG 反而比直接推理差，头部的题掉得最多（0.758 → 0.444）：模型本来就记得的事实，被原始文档里的干扰数字带偏了。检索不是免费的——无关、嘈杂的上下文会损害推理（Shi et al. 2023 专门研究过 LLM 怎样被无关的上下文干扰）。而且只在推理之前检索一次，有些需要的事实没被覆盖。
• agentic RAG 按需搜索，长尾提高了（0.319 → 0.462），但原始文档同样会干扰，整体仍略低于直接推理。
• Search-o1 加上 Reason-in-Documents 之后，干扰几乎消失，三个档次都大幅提高（整体 0.729）。这正是论文设计这个模块的理由。

演示 2 扫描了 Search-o1 的搜索阈值：

（同一设定在演示 1、演示 2 里用的随机数不同，0.02 左右的差别是随机波动。）

• 在这个 toy world 里，搜得越多越准（提炼后的文档比记忆可靠），代价是搜索次数。
• 只搜”把握最低”的事实，用少得多的搜索就能拿到相当一部分收益：阈值 0.7 时平均只搜 0.57 次，就拿到了”总是搜”的大约一半的提升。
• 前提是模型知道自己不知道。这里假设模型的把握是校准的。第 4 讲已经看到，真实的模型对编造的事实常常很自信——按不确定性触发搜索，在最需要搜的地方可能恰恰不触发。

5. 深度研究 agent

5.1 从 Search-o1 到产品

2024 年底到 2025 年，各家相继推出了深度研究（deep research）产品：Google 的 Gemini Deep Research（2024 年 12 月）、OpenAI 的 Deep Research（2025 年 2 月）等。给它一个研究问题，它会：

1. 规划：把问题拆成若干子问题，决定先查什么；
2. 反复搜索和阅读：浏览几十上百个网页，读 PDF、表格，根据读到的内容决定下一步查什么；
3. 综合：把信息整理成一份有结构、带引用的报告。

这正是 Search-o1 的思路推到极致：推理和搜索深度交织，持续几分钟到几十分钟。OpenAI 的 Deep Research 是用强化学习在大量浏览、检索任务上训练出来的（基于 o3 的一个版本）——第 6 讲的 RLVR 用在了”搜索 + 阅读 + 综合”上。学术界也有类似的开源工作，例如用 RL 训练模型在推理中交替调用搜索引擎的 Search-R1（训练时把检索返回的内容从损失里屏蔽掉，只训练模型自己写的部分）。

5.2 怎样评估

深度研究的评估本身就是难题（CS224V 第 2 讲有详细的讨论）。几类常用的 benchmark：

• BrowseComp（OpenAI 2025）：答案很短、容易核对，但需要在网上做大量、有创造性的搜索才能找到的问题——专门衡量”搜索的坚持和策略”。
• Humanity’s Last Exam 这类极难的、需要专业知识的问答。
• 长报告的评估：覆盖面、事实准确性、引用是否真的支持论点（第 14 讲的 DeepScholar-Bench）。

5.3 常见的失败

• 引用不支持论点：报告引用了一个网页，但网页里并没有那样说（CS224V 第 2 讲”引用不等于支持”）。
• 被低质量的来源误导：搜到的第一个结果不一定可靠。
• 何时停止：搜索太少，覆盖不全；搜索太多，成本高、报告冗长。
• 综合时的幻觉：把不同来源的信息错误地拼在一起。

这些失败都指向同一个问题：对检索到的信息的验证。Search-o1 的 Reason-in-Documents 是”先理解、再使用”的一小步；完整的深度研究系统还需要交叉核对来源、检查引用。

6. 搜索与自我改进

把本讲放回整门课的框架里：

1. 搜索是 test-time 的自我改进：AlphaCode 用海量采样 + 程序测试，让一个单次很少做对的模型解出了大量竞赛题；Search-o1 用检索补上了模型知识的缺口。
2. 搜索的结果可以变成训练数据：AlphaGo Zero 用 MCTS 的结果训练网络（第 1 讲第 5.6 节），STaR 用过滤后的正确解训练模型（第 6 讲）。竞赛编程里，通过测试的程序就是天然的高质量训练数据；深度研究的 RL 训练用的也是”搜索成功的轨迹”。
3. verifier 和挑选仍然是瓶颈：AlphaCode 的样例测试有大量 false positive，于是需要聚类和打分模型；深度研究需要验证来源和引用。第 3 讲的结论在这里同样成立。
4. 多样性和挑选要一起设计：采样时随机化元数据（多样性）、挑选时按行为聚类（不重复），两者缺一不可。

7. 小结

1. 两种搜索：在解的空间里（采样大量候选 + 过滤 + 挑选）和在信息的空间里（推理中检索外部知识）。都是用推理计算换结果，都依赖外部的检验。
2. AlphaCode：干净的数据集（CodeContests，按时间切分，补充测试把 false positive 从 62% 降到 4%）、能高效采样的大模型、每题最多采样 100 万个程序，用样例过滤掉约 99%，在生成的输入上按行为聚类，从最大的类里挑 10 个提交。Codeforces 平均排名前 54.3%；解出率随采样数对数线性增长。toy world 显示：样例测试过滤后大多仍是错的，聚类把有限的提交机会分给不同的行为，比过滤后随机挑好得多；聚类的价值取决于过滤后的 false positive 有多严重。
3. AlphaCode 2：Gemini Pro 微调的策略模型 + 打分模型，解出 43% 的题（AlphaCode 25%），约第 85 百分位。
4. Search-o1：reasoning model 在推理中途遇到不确定的知识就生成搜索查询；Reason-in-Documents 先提炼检索到的文档再放回推理链。在 GPQA、数学、代码和多跳问答上都有提升。toy world 显示：原始文档里的干扰会让检索适得其反（标准 RAG 比直接推理还差），提炼之后才稳定地有益；按不确定性触发搜索能省下很多搜索，但前提是模型知道自己不知道。
5. 深度研究 agent：规划、反复搜索阅读、综合成带引用的报告，用 RL 训练；评估和”验证检索到的信息”是主要的难点。

8. 练习

1. 10 次提交（第 2.5 节） 过滤之后剩下 1000 个程序，其中 200 个正确（都属于同一个行为类），800 个错误分散在 100 个类里（每类 8 个）。 (a) 随机挑 10 个，至少有一个正确的概率是多少？ (b) 按类的大小挑最大的 10 个类，各交一个，能解出吗？ (c) 如果 800 个错误里有 300 个属于同一个类（一个常见的错误），还能解出吗？

(a) $1 - (800/1000)^{10} \approx 1 - 0.107 = 0.893$（近似为有放回）。 (b) 正确的类有 200 个，是最大的类，一定会被选中——能解出。 (c) 最大的类是那个 300 个的错误类，第二大是 200 个的正确类，两个都会进前 10——仍能解出。只有当”大的错误类”多于 10 个、把正确的类挤出前 10 时才会失败。

2. 样例测试的 false positive（第 2.4、2.7 节） (a) 为什么 toy world 里把样例限制成小输入（0~10）后，false positive 大大增加？举一个具体的错误程序的例子。 (b) AlphaCode 用”变异已有的测试输入”生成更多的测试。为什么这能降低 false positive？如果生成的测试输入都和样例很像，效果会怎样？

3. 聚类和投票（第 2.5 节） (a) 聚类挑选和第 2 讲的 majority vote 有什么相同、有什么不同？ (b) 如果两个正确的程序在某个生成的输入上输出不同（例如那个输入不合法，两者处理方式不同），聚类会怎样？这对生成测试输入的模型提出了什么要求？

4. 检索什么时候有害（第 4.4 节） (a) toy world 里，标准 RAG 在头部的题上从 0.758 掉到 0.444。设模型记对头部事实的概率约 0.9，原始文档的干扰概率 0.25，检索覆盖率 0.75，估算一个头部事实”最后得到正确值”的概率，和不检索时比较。 (b) 提炼之后（干扰概率 0.03）呢？ (c) 这说明在什么情况下应该”相信记忆”而不是”相信检索”？

(a) 被覆盖（0.75）时：搜索成功（0.85）且没被干扰（0.75），正确的概率 $0.85 \times 0.75 \approx 0.64$；搜索没有结果（0.12）就回到记忆（0.9），贡献 $0.12 \times 0.9 = 0.108$；查到相似实体（0.03）则错误。合计 $\approx 0.75$。没被覆盖（0.25）时靠记忆：0.9。总体 $0.75 \times 0.75 + 0.25 \times 0.9 \approx 0.78$，低于不检索的 0.9。两个事实都要对，$0.78^2 \approx 0.61$ vs $0.9^2 = 0.81$，再乘上算术的成功率，就是表里的下降。 (b) 被覆盖时 $0.85 \times 0.97 + 0.108 \approx 0.93$，总体 $0.75 \times 0.93 + 0.25 \times 0.9 \approx 0.92$，略高于不检索。 (c) 当记忆本来就很可靠、而检索的信息又嘈杂时，检索反而有害。好的系统要么提高”读文档”的可靠性（Reason-in-Documents），要么只在记忆不可靠时才检索（按不确定性触发）。

5. 按不确定性触发（第 4.4 节） (a) 如果模型过度自信（对每个事实的把握都比真实的记对概率高 0.3），演示 2 的阈值曲线会怎样变化？ (b) 在 02 号文件里实现这个”过度自信”的版本（把 confidence 加上 0.3 再截断到 1），验证你的预测。

6. 动手改代码 (a) 01 号文件：把样例的个数从 2 改成 5，过滤后的 false positive 比例怎样变化？聚类的优势还在吗？ (b) 01 号文件：给”过滤 + 聚类”加一个打分模型（例如：每个类的分数 = 类的大小 × 一个有噪声的”正确概率”），模拟 AlphaCode 2。 (c) 02 号文件：把 DISTRACT_RAW 改成 0.05（文档很干净），标准 RAG 还会比直接推理差吗？

7. 设计题 你要做一个”根据最新的研究论文回答医学问题”的深度研究 agent。说说你会怎样决定什么时候搜索、怎样读搜到的论文、怎样在最终答案里给出可以核查的引用，以及你会用什么方式评估它。

9. 延伸阅读

本讲的阅读材料

• Li et al. 2022. Competition-Level Code Generation with AlphaCode.（Science）
• Google DeepMind 2023. AlphaCode 2 Technical Report.
• Li et al. 2025. Search-o1: Agentic Search-Enhanced Large Reasoning Models.

相关工作

• Chen et al. 2021. Evaluating Large Language Models Trained on Code.（Codex、HumanEval、pass@k）
• Shi et al. 2023. Large Language Models Can Be Easily Distracted by Irrelevant Context.
• Jin et al. 2025. Search-R1: Training LLMs to Reason and Leverage Search Engines with Reinforcement Learning.
• Wei et al. 2025. BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents.
• 同目录 CS224V 第 1、2、5 讲（RAG 的失败、STORM、WikiChat）。

10. 下一讲预告

第 9 讲：后训练的演变——从 Chatbot 到 Agent（客座：Melvin Johnson，Google DeepMind）

前八讲分别看了 test-time 的搜索与验证、train-time 的 RL、设计层的演化。第 9 讲从训练流水线的角度把它们串起来：模型的”后训练”是怎样从 SFT + RLHF 一步步演变成今天训练 agent 的流程的——训练信号从人的示范到可验证的奖励，任务从单轮对话到多轮的工具使用，评估从聊天质量到能不能把事做完。