Skip to main content

一个高中辍学生如何用AI攻克ICLR顶会Oral论文——Gabriel Petersson「递归式学习法」完整实战拆解

· 31 min read
Sanbu
Sanbu
AIGC Engineer, Open source contributor

核心逻辑：本文采用「人物背景→方法论深度拆解→实战演示」三层结构。第一层：介绍 Gabriel Petersson——一个瑞典高中辍学生，靠 ChatGPT 自学成为 OpenAI Sora 团队研究科学家的故事。第二层：不概括，不缩写，用他自己的原话和具体操作步骤，完整拆解他的「递归式知识填补法」——包括自上而下学习的完整流程、递归追问的具体话术、Learning by Doing 的执行细节、以及主动接触高手的策略。第三层：以 ICLR 2026 Oral 论文《MemAgent: Reshaping Long-Context LLM with Multi-Conv RL-based Memory Agent》（清华大学 AIR + 字节跳动 Seed）为例，假设你对该领域一无所知，用他的方法一步步攻克这篇关于「用强化学习训练 LLM Agent 管理超长文本记忆」的前沿论文，给出完整的学习路径。

一、Gabriel Petersson 是谁​

23 岁，瑞典人，高中辍学，没有大学文凭。

现在是 OpenAI Sora 团队的研究科学家。

在 OpenAI 这种博士扎堆的地方，没有学位拿到 Research Scientist 头衔，几乎是前无古人的事。这个头衔意味着他不是在做工程实现，而是在做模型核心算法研究。

他的经历不是"天才少年从小开挂"的剧本：

  • 14 岁：在瑞典乡下倒卖宝可梦卡，赚了超过 2 万美元。他因此自学做了第一个网站——一个价格对比页面
  • 17 岁：辍学。他表哥打了个电话说"我们在做一个 AI 推荐系统，你下一班巴士来斯德哥尔摩"。他去了，从此再没回学校
  • 18 岁：睡在公司沙发垫上整整一年。为了推销推荐系统，他爬取目标客户网站，把旧推荐和新推荐打印在 A3 纸上，带着 100 份文件夹挨家挨户敲门。见到 CEO 就当场把脚本贴进对方网站的控制台，说"今天就上线了，还内置了 A/B 测试"
  • 19 岁：被瑞典最大云厨房 Curb Food 聘为临时 CTO，从零组建 7 人工程团队
  • 20-22 岁：在 Midjourney 做性能工程，开发了被全球千万用户使用的人类反馈工具
  • 2024 年 12 月：正式加入 OpenAI Sora 团队

申请美国 O-1 杰出人才签证时，没有论文、没有学位。他把自己在 Stack Overflow 上累计数百万浏览量的技术回答甩给了移民局——居然通过了。

但最值得你关注的，不是他的经历，而是他的学习方法。 因为这套方法，在 AI 时代，任何人都可以复制。

二、方法论深度拆解：Gabriel 的「递归式知识填补法」​

Gabriel 在播客 Extraordinary 的采访中，花了超过 40 分钟详细阐述他的学习方法。以下不是概括，而是他方法论的完整还原。

2.1 核心原则：自上而下（Top-Down），而非自下而上（Bottom-Up）​

Gabriel 的原话：

"我认为传统的'自底向上'（Bottom-up）学习法效率极低。在大学里，如果你想学机器学习，他们会告诉你：'先别想 ML，先学四年数学。线性代数、矩阵乘法……'等你终于碰到真正的 ML 时，已经过去很久了。我认为最高效的是'自顶向下'（Top-down）。你从一个具体问题开始，递归地向下深挖。"

他举了一个对比：

维度传统自下而上Gabriel 的自上而下
起点线性代数 → 概率论 → 统计学习 → 深度学习 → 生成模型 → 扩散模型直接问："我想做一个扩散模型，第一步是什么？"
动力不知道学了有什么用，学得很痛苦每一步都有明确目的——为了解决眼前的问题
时间6 年3 天建立基本直觉
遇到不懂的跳过或死记硬背立刻追问，搞懂为止

关键洞察：Gabriel 说，以前这种"自上而下"的方法很难推广，因为你需要一个全知全能的老师，随时告诉你"接下来该补什么"。但现在，ChatGPT 就是这个老师。

2.2 具体操作步骤：递归式知识填补的完整流程​

Gabriel 把这个过程叫做 "Recursive Knowledge Gap Filling"（递归式知识填补）。他用学习扩散模型作为具体例子，详细描述了每一步：

Step 1：从一个具体目标开始​

"如果我想自己做一个小型视频生成模型，第一步要搞懂什么？"

注意他的提问方式：不是"请给我讲讲扩散模型"，而是"我想做一个，第一步是什么"。这是目标驱动的提问，不是百科全书式的提问。

ChatGPT 告诉他：最核心的概念是自动编码器（Autoencoder）。

Step 2：让 AI 直接写代码，先跑通再说​

"让 ChatGPT 直接写一段扩散模型的代码。一开始很多地方看不懂，但没关系，先把代码跑起来再说。能跑通，就有了调试的基础。"

Gabriel 的逻辑是：代码是最佳的知识载体。 一段能运行的代码，比十页数学公式更能帮你建立直觉。因为你可以看到输入是什么、输出是什么、中间发生了什么。

Step 3：递归追问——核心步骤​

这一步是整个方法的灵魂。Gabriel 的原话：

"我会盯着代码里的每一个模块问问题。比如看到 ResNet，我就问：'这是什么？'ChatGPT 说这是残差网络。我就继续问：'残差是什么意思？为什么需要它？'然后我会说：'请用 12 岁小孩能听懂的方式再解释一遍。'如果还不懂，我会要求它展示所有中间数据的形态——输入是什么形状、输出是什么形状。就这样一层层往下钻，直到彻底理解底层逻辑。然后再返回上一层，继续问下一个模块。"

他的追问话术具体包括：

  • "这个概念能不能举个例子？"
  • "有对应的代码吗？能解释一下每行是干嘛的？"
  • "这句我还是不懂，你能假设我只有 12 岁，再解释一遍吗？"
  • "背后的数学直觉是什么？不需要精确的数学公式，先给我一个直观的理解。"
  • "为什么需要这个？如果去掉它会怎样？"

这就是"递归"的含义：从一个高层概念出发 → 遇到不懂的子概念 → 追问 → 还是不懂 → 继续追问 → 直到理解最底层 → 回到上一层 → 继续下一个模块。

Gabriel 认为，学习的本质是追逐那个 "哈，点通了"（Aha moment） 的瞬间。而 AI 能让这种瞬间高频发生。他说他有时每天问 AI 一百多个问题。

Step 4：在代码中试错，直到跑通​

"以前学编程怕犯错，因为学校会扣分。但跟 ChatGPT 学，犯错只是一个 Debug 的过程。"

代码跑不通？把报错截图扔给 ChatGPT。它告诉你原因，你修复，再跑。这个循环极其高效，因为：

  1. 每次报错都暴露了一个具体的知识缺口
  2. 修复报错的过程就是填补这个缺口的过程
  3. 你得到的反馈是即时的，不需要等老师批改

Step 5：建立直觉后，再回头补理论​

Gabriel 强调，他不是不学理论，而是在建立了直觉之后再学理论。当你已经知道"这个东西干了什么"，再去理解"它为什么能干这件事"的数学原理，效率会高得多。

2.3 Learning by Doing：项目驱动学习​

Gabriel 在播客里反复强调的一点：

"如果你给我无限的时间去'学习'，我反而学不会。但当我有一个真实的问题要解决——比如要把推荐系统集成到客户网站上——一切就变得简单了。你需要去 Stack Overflow，去问朋友，一步步解决具体问题。"

他的学习从来不是"先学完再做"，而是"边做边学"。具体来说：

  1. 找一个真实的项目：不是做题，而是做一个有实际输出的东西
  2. 遇到问题立刻解决：不跳过，不拖延
  3. 把项目做到能展示的程度：Gabriel 强调"3 秒钟 Demo"——你的作品应该让人 3 秒钟就能看出你的水平
  4. 公开你的作品：发到 GitHub、Stack Overflow、博客上。Gabriel 靠 Stack Overflow 上的高质量回答拿到了美国签证

2.4 主动接触高手：Gabriel 的秘密武器​

这一步很多人忽略了。Gabriel 说他快速成长的关键策略之一是：

"我转成合同工，这样可以更灵活地选择项目，专门找最优秀的工程师合作，主动请求最严格的代码审查。我甚至打电话和资深工程师逐条过反馈。"

他的具体做法：

  1. 选择合同工而非全职：为了能接触更多不同的团队和技术栈
  2. 主动找最强的工程师合作：不是找"教我的人"，而是找"给我最严格反馈的人"
  3. 追着要 Code Review：不是等别人来审查，而是主动把代码发过去说"请告诉我哪里写得不好"
  4. 打电话逐条过反馈：不是看一眼 Review 意见就完了，而是约一个电话，一条一条地讨论为什么这样改、背后的原理是什么

他说这个过程的收获比任何课程都大。因为你得到的不是抽象的理论，而是一个顶尖工程师面对具体问题时的思维过程。

2.5 方法论总结：Gabriel 学习法的完整框架​

Gabriel 递归式学习法
│
├── 第一步：定目标（自上而下）
│   └── "我想做 X，第一步是什么？"
│
├── 第二步：代码先行（Learning by Doing）
│   └── 让 AI 写代码 → 跑通 → 观察 → 建立直觉
│
├── 第三步：递归追问（核心步骤）
│   ├── 盯着每个不懂的模块问"这是什么"
│   ├── 追问"为什么需要它"
│   ├── 要求"用 12 岁能听懂的方式解释"
│   ├── 要求"展示中间数据的形态"
│   ├── 一层层下钻直到理解底层
│   └── 返回上一层，继续下一个模块
│
├── 第四步：Debug 即学习
│   └── 报错 → 问 AI → 修复 → 理解为什么错
│
├── 第五步：补理论
│   └── 有了直觉之后，再回头理解数学原理
│
└── 第六步：主动接触高手
    ├── 找最严格的 Code Review
    ├── 打电话逐条过反馈
    └── 公开你的作品（GitHub/博客/社区）

三、实战演示：用 Gabriel 的方法攻克 ICLR 2026 Oral 论文​

论文选定：MemAgent——用强化学习重塑 LLM 的长文本记忆​

我选择的论文是 《MemAgent: Reshaping Long-Context LLM with Multi-Conv RL-based Memory Agent》，来自清华大学智能产业研究院（AIR）+ 字节跳动 Seed 团队。

选它的理由：

  1. 解决的是 LLM 最核心的瓶颈之一：如何让大模型处理无限长的文本？这是业界公认的难题——GPT-4、Claude 等模型都有上下文窗口限制（128K-200K tokens），超过就"失忆"。MemAgent 的答案是：用 Agent + RL 让模型学会"边读边记"
  2. 技术难度极高：涉及 DAPO 强化学习算法扩展、多对话 RL 训练、Memory Overwrite 策略、自回归建模视角下的记忆优化。即使是资深博士，要完全吃透这篇论文也需要反复研读
  3. 来自顶级机构：清华 AIR + 字节跳动 Seed，作者包括多位 IEEE Fellow、ACM Fellow
  4. 结果惊艳：在 8K 上下文上训练，能外推到 3.5M（350 万 tokens）的 QA 任务，性能损失不到 5%。在 512K RULER 测试上准确率超过 95%

这篇论文到底在解决什么问题​

用 Gabriel 的第一步——先问宏观问题：

"MemAgent 这篇论文在解决什么问题？用 12 岁小孩能理解的方式解释。"

你会得到这样的回答：

想象你在读一本 1000 页的小说。你的大脑不是把每一页都拍照记住（那得需要超大的内存），而是边读边总结——记住关键人物、重要情节、核心矛盾。

但现在的大语言模型做不到这一点。它们有一个固定的"记忆容量"（上下文窗口），比如 128K tokens。一旦文本超过这个容量，就像你的大脑被清空了一样——前面的内容全部忘掉。

MemAgent 的做法是：给 AI 一个"笔记本"。AI 每读一段文本，就把重要信息写在笔记本上，同时擦掉过时的内容（这叫 Overwrite 策略）。这样，无论文本多长，AI 的"工作记忆"始终保持在固定大小。

但核心难题是：怎么让 AI 学会"什么该记、什么该忘"？ MemAgent 的答案是：用强化学习（RL）来训练它。让 AI 自己去试——记对了给奖励，记错了不给奖励。经过大量训练，AI 就学会了最优的"记忆管理策略"。

用递归追问攻克论文的核心技术​

现在，按照 Gabriel 的方法，开始对论文的核心概念进行递归追问。

第一层追问：理解论文的整体框架​

"MemAgent 的整体架构是什么？有哪些核心模块？"

模块职责
Segment Reader将长文本切分成固定大小的段（chunks），逐段处理
Memory Overwrite每读一段后，更新记忆——保留重要信息，擦除过时信息
Multi-Conv RL Training用多对话强化学习训练记忆管理策略
DAPO 算法扩展将 DAPO（Dynamic Advantage Policy Optimization）扩展到多对话场景

第二层追问：对 Memory Overwrite 下钻​

"什么是 Memory Overwrite 策略？它和简单的文本截断有什么区别？"

继续追问：

"Overwrite 具体是怎么实现的？是生成一段新的记忆文本来替换旧的，还是从旧记忆中选择性保留？用代码示例解释。"

"为什么 Overwrite 比 Summary 更好？Summary 不是也能压缩信息吗？"

你会了解到：Summary（总结）的问题是它总是压缩所有信息，不管这些信息对后续任务是否重要。而 Overwrite 让模型自己决定"什么该保留、什么该丢弃"——这是一种任务感知的压缩。RL 训练让模型学会了根据任务需求来优化记忆内容。

"Overwrite 的粒度是什么级别的？是 token 级别、句子级别还是段落级别？"

第三层追问：对 Multi-Conv RL Training 下钻——论文的核心贡献​

这是论文最难的部分。开始追问：

"什么是 Multi-Conv RL Training？它和普通的 RL 训练有什么区别？"

继续追问：

"为什么要用'多对话'来训练？单次对话不够吗？"

你会了解到：因为 MemAgent 的工作方式是"分段处理"——每读一段文本就是一次"对话"。在训练中，模型需要经历多段文本的连续处理，每一段都可能修改记忆。这意味着奖励信号要等到所有段都处理完才能计算。这就是"Multi-Conv"的含义——一次训练 rollout 包含多个连续的对话（文本段），模型需要在整个过程中保持记忆的一致性。

"DAPO 算法是什么？它和 GRPO/PPO 有什么区别？"

继续追问：

"MemAgent 是怎么扩展 DAPO 的？'独立上下文多对话生成'是什么意思？"

"奖励信号具体是怎么设计的？长文本 QA 任务的奖励和普通 RL 任务有什么不同？"

你可能需要继续下钻的概念：DAPO 的动态优势估计 → 独立上下文采样的必要性 → 多对话 rollout 的 credit assignment 问题 → 如何把最终 QA 准确率的奖励归因到中间每一步记忆更新

第四层追问：对实验设计下钻​

"MemAgent 在哪些 benchmark 上做了实验？结果有多惊艳？"

Benchmark测什么关键结果
RULER-HQA超长文本多跳问答从 8K 训练外推到 3.5M，性能损失 < 5%
NIAH (Needle in a Haystack)在超长文本中找到隐藏信息512K 长度下准确率 95%+
LongBench多种长文本理解任务超越所有基线方法
VT (Variable Tracking)跨长文本追踪变量状态线性复杂度下保持高性能

继续追问：

"MemAgent 和其他长文本方法（如 LongRoPE、注意力稀疏化）比好在哪里？"

"从 8K 训练到 3.5M 推理，为什么性能几乎不下降？这在之前是不可能的对吗？"

你可能需要追问的完整概念树​

MemAgent
├── 1. 背景：LLM 的长文本瓶颈
│   ├── 上下文窗口限制（128K-200K tokens）
│   ├── 现有方法：长度外推 → 稀疏注意力 → 上下文压缩
│   └── 为什么这些方法都不够？（O(n²) 复杂度 / 性能衰减 / 外推失败）
│
├── 2. MemAgent 工作流
│   ├── 分段读取（Segment Reader）
│   ├── 记忆覆写（Memory Overwrite）
│   ├── 最终答案生成
│   └── 线性复杂度 O(N) 的保证
│
├── 3. Multi-Conv RL Training（核心贡献）
│   ├── 为什么需要 RL？（SFT 学不到最优记忆策略）
│   ├── DAPO 算法基础
│   │   ├── Dynamic Advantage（动态优势估计）
│   │   ├── 和 GRPO/PPO 的区别
│   │   └── 为什么适合记忆管理任务
│   ├── 扩展到 Multi-Conv 场景
│   │   ├── 独立上下文采样
│   │   ├── 多对话 rollout
│   │   └── Credit Assignment 问题
│   └── 奖励设计
│       ├── 最终 QA 准确率作为奖励
│       ├── 如何归因到中间记忆更新
│       └── 奖励稀疏性的处理
│
├── 4. 自回归建模视角
│   ├── 记忆作为一种"隐状态"
│   ├── 和 RNN/Transformer 的类比
│   └── 为什么 Overwrite 等价于学习状态转移函数
│
└── 5. 实验与分析
    ├── 外推能力：8K → 3.5M（< 5% 性能损失）
    ├── 和所有基线的对比
    ├── 消融实验：去掉 RL 只用 SFT 会怎样
    └── 复杂度分析：为什么是真正的 O(N)

四、Learning by Doing：动手实现 MemAgent 的核心组件​

Gabriel 的信条：如果你不能实现它，你就没有真正理解它。

练习 1：访问项目主页，理解整体架构​

打开 https://memagent-sialab.github.io/，阅读项目介绍和可视化 Demo。观察 MemAgent 是如何分段处理长文本的。

练习 2：实现一个简化版的 Memory Overwrite​

"帮我用 Python 实现一个简化版的 Memory Overwrite：给定一个固定大小的记忆缓冲区（比如 2000 tokens）和一段新的文本，用 LLM 生成一段新的记忆文本，保留旧记忆中的重要信息并融入新文本中的关键信息。"

写完之后，问 AI：

"我这样实现和论文里的 Overwrite 策略有什么区别？论文还做了哪些优化？"

练习 3：理解 Multi-Conv RL 的训练循环​

"帮我用 PyTorch 实现一个简化版的多对话 RL 训练循环：模拟 MemAgent 处理 3 段文本的过程，每段处理后更新记忆，最后根据 QA 准确率计算奖励，然后用策略梯度更新模型。"

练习 4：从自回归视角理解 MemAgent​

"论文说 MemAgent 可以从自回归建模的角度理解。帮我解释：记忆覆写操作等价于 RNN 的哪个组件？和 Transformer 的 KV Cache 有什么本质区别？"

练习 5：主动接触高手​

  1. 去 MemAgent 的项目主页找到代码仓库，提一个高质量的问题
  2. 这篇论文的作者来自清华 AIR 和字节跳动 Seed，可以在 Twitter/X 或知乎上找到相关讨论
  3. 把你的学习过程和复现结果写成博客发出去

五、学习路径总结​

把 Gabriel 的方法应用到 MemAgent 这篇论文上，完整的学习路径如下：

阶段目标具体行动预期时间
Day 1：建立直觉知道这篇论文在干嘛问 AI 宏观问题，看项目主页的可视化 Demo半天
Day 2-3：递归追问理解每个核心模块按概念树逐层追问，从 Memory Overwrite → DAPO → Multi-Conv RL → 自回归视角2 天
Day 4-5：动手实现验证理解实现 Memory Overwrite、简化版 Multi-Conv RL、跑通 Demo2 天
Day 6-7：深度交流纠正盲区写笔记、提 Issue、参与社区讨论持续进行

六、Gabriel 学习法的本质：三个核心洞察​

洞察一：目标驱动，而非路径驱动​

传统教育的问题是：你不知道学线性代数有什么用，所以你学得很痛苦。Gabriel 的方法是：先有目标（我要理解 MemAgent 的 Multi-Conv RL 训练），再倒推需要什么知识（需要理解策略梯度 → PPO → DAPO → Multi-Conv 扩展）。每一步学习都有明确的"为什么"。

洞察二：AI 是苏格拉底，不是百科全书​

大多数人用 AI 的方式是："帮我总结这篇论文"。这是把 AI 当百科全书用。Gabriel 的方式是："DAPO 的 Dynamic Advantage 是什么意思？为什么需要它？如果没有它会怎样？请用 12 岁能听懂的方式解释。" 这是把 AI 当苏格拉底用——通过追问来逼近本质。前者的结果是你"知道"，后者的结果是你"理解"。

洞察三：犯错是学习，不是惩罚​

Gabriel 说："以前学编程怕犯错，因为学校会扣分。但跟 ChatGPT 学，犯错只是一个 Debug 的过程。"在传统教育体系里，犯错 = 扣分 = 失败。但在真实世界里，犯错 = 发现知识缺口 = 学习机会。

七、写在最后​

Gabriel Petersson 从瑞典一个偏僻小镇的高中辍学生，到 OpenAI 的研究科学家。他的武器不是天赋，不是学历，而是一套和 AI 协作学习的方法论。

这套方法在 AI 之前很难实现——因为你需要一个全知全能的老师。但现在，这个老师就在你手边。

关键在于：你是把它当百科全书，还是当苏格拉底？

附录 A：问了就忘怎么办？——Gabriel 的「递归锁定法」​

很多人用 Gabriel 的方法问了很多问题，但问完就忘。这是因为提问不等于理解，回答不等于掌握。Gabriel 本人在采访中提到，他的方法有一个隐含的关键环节：每学完一个概念，必须用自己的话"锁定"它。以下是完整的操作流程。

第一步：每次追问后，让 AI 帮你生成「理解检查点」​

每当你搞懂一个概念，立刻执行以下 Prompt：

我刚刚理解了 [概念名]。请帮我生成一个「理解检查点」，格式如下：

## 核心定义（一句话）
[你自己的话]

## 为什么需要它（一句话）
[没有它会怎样]

## 它是怎么工作的（三句话以内）
[核心流程]

## 和其他概念的关系
- 上游：[依赖什么前置概念]
- 下游：[谁依赖它]

## 我的类比
[用一个生活场景解释]

## 验证问题
[给我一个简单的问题，让我用这个概念来回答，检验我是不是真懂了]

关键：检查点不是复制粘贴 AI 的回答，而是用你自己的话重写。如果你写不出来，说明你还没真懂，继续追问。

第二步：每学完一个模块，做一次「递归回顾」​

我刚刚学完了论文的以下模块：
1. [模块A名]：[一句话我的理解]
2. [模块B名]：[一句话我的理解]
3. [模块C名]：[一句话我的理解]

请帮我做一次递归回顾：
1. 这三个模块之间的逻辑关系是什么？用箭头画出数据流
2. 如果去掉其中一个模块，整个系统会怎样崩溃？
3. 这三个模块共同形成了什么「洞察」？用一句话概括
4. 基于这三个模块，论文的核心贡献到底是什么？

第三步：建立「概念依赖图」——防止迷失​

每次学完一个新概念，更新你的概念依赖图：

我正在学习论文《[论文标题]》。以下是我目前的概念依赖图：

[之前的概念图，如果没有就写"空"]

我刚学完了一个新概念：[概念名]
- 它依赖的前置概念：[列出]
- 依赖它的后续概念：[列出]

请帮我把这个新概念插入依赖图，并更新完整的图。用缩进格式表示层级关系。

示例（MemAgent 的概念依赖图）：

MemAgent
├─ 前置知识
│  ├─ 上下文窗口限制（128K-200K tokens）
│  ├─ 策略梯度 → PPO → GRPO → DAPO
│  └─ 自回归语言模型
│
├─ 核心方法
│  ├─ Memory Overwrite（记忆覆写）
│  │  ├─ 依赖：上下文窗口限制（为什么需要压缩）
│  │  ├─ 依赖：自回归模型（怎么生成新记忆）
│  │  └─ 区别于 Summary：任务感知 vs 任务无关
│  │
│  ├─ Multi-Conv RL Training（多对话强化学习）
│  │  ├─ 依赖：DAPO（基础 RL 算法）
│  │  ├─ 依赖：Memory Overwrite（要训练的对象）
│  │  └─ 核心难题：Credit Assignment（奖励归因）
│  │
│  └─ 线性复杂度 O(N)
│     ├─ 依赖：分段处理（固定窗口大小）
│     └─ 依赖：Memory Overwrite（记忆大小固定）
│
└─ 实验验证
   ├─ 8K → 3.5M 外推（核心结果）
   ├─ NIAH 95%+（细节保留能力）
   └─ 消融：去掉 RL 只用 SFT（证明 RL 的必要性）

为什么这有效：概念依赖图让你始终知道"我在哪里"。每次追问时，你都能看到这个概念在整体中的位置，而不是孤立地记住一堆碎片。

第四步：用「费曼锁定」检验真正掌握​

每学完一个大模块，执行以下 Prompt：

我刚刚学完了论文的 [模块名]。现在我要用费曼学习法检验自己是否真正理解。

我将尝试用自己的话解释这个模块，假装我在给一个大一新生讲课。请你扮演那个大一新生，认真听我的解释，然后：

1. 如果我的解释有错误，指出并纠正
2. 如果我的解释模糊不清，追问"为什么？"和"具体怎么做？"
3. 如果我使用了专业术语而没有解释，要求我换一种说法
4. 最后给我打分（1-10），并告诉我哪里还需要加强

我的讲解开始：

[在这里写你的解释——不要偷看笔记，用你自己的话]

第五步：论文学完后，做「终极锁定」​

我刚刚完成了论文《[论文标题]》的完整学习。请帮我做终极锁定：

1. 请用 3 句话概括这篇论文的核心洞察（不是方法，是 insight）
2. 这篇论文最大的"妙手"是什么？（最让你意外的设计选择）
3. 这篇论文有哪些局限性？如果你是审稿人，你会问什么问题？
4. 基于这篇论文，有哪些可以继续探索的方向？
5. 请给我出 3 道题，检验我是否真正掌握了这篇论文（难度递增）

完整流程总结​

步骤什么时候做目的
理解检查点每搞懂一个概念防止"以为自己懂了其实没懂"
递归回顾每学完一个模块把碎片整合成整体理解
概念依赖图贯穿全程始终知道自己"在哪里"
费曼锁定每学完一个大模块检验真正的掌握程度
终极锁定学完整篇论文提炼核心洞察，建立长期记忆

核心原则：Gabriel 的方法不是"问 100 个问题"，而是"问 10 个关键问题 + 每个问题后锁定理解"。追问是输入，锁定是输出。只有经过锁定的知识，才是你真正掌握的知识。

附录 B：Gabriel「递归式学习法」Prompt 库——直接复制拿走用​

以下是根据 Gabriel Petersson 的学习方法论整理的完整 Prompt 库。每个 Prompt 都可以直接复制粘贴到 ChatGPT / Claude / DeepSeek 中使用。按照学习阶段分类，覆盖从"完全不懂"到"深度掌握"的全流程。

阶段一：建立直觉（Day 1）​

Prompt 1.1——宏观理解

我要学习一篇论文：《[论文标题]》（[arxiv链接]）。我目前对这个领域一无所知。请你用 12 岁小孩能理解的方式解释：这篇论文在解决什么问题？为什么这个问题重要？核心思路是什么？不要用任何专业术语。

Prompt 1.2——类比理解

现在请用生活中的一个具体场景来打比方，帮我建立直觉。比如："MemAgent 就像一个学生在读 1000 页的小说，他不能拍照记住每一页，而是边读边在笔记本上记要点……" 请给出类似的类比。

Prompt 1.3——5 分钟演讲稿

假设我要在 5 分钟内给一个非技术人员讲解这篇论文的核心思想。请帮我写一份演讲稿，要求：只讲"为什么"和"怎么做"，不堆砌术语，让听众听完觉得"这个想法真妙"。

阶段二：递归追问（Day 2-3）​

Prompt 2.1——概念拆解

我现在已经理解了论文的宏观思路。接下来请帮我把论文拆解成核心模块，每个模块用一句话概括。格式如下：
- 模块 A（[英文名]）：[一句话职责]
- 模块 B（[英文名]）：[一句话职责]
然后告诉我：这些模块之间的数据流向是怎样的？哪个模块是论文的核心贡献？

Prompt 2.2——单个概念深度追问

我对论文中的 [概念名，如 Memory Overwrite] 不太理解。请按以下步骤解释：
1. 它是什么？（用一句话定义）
2. 为什么需要它？（没有它会怎样？）
3. 它是怎么实现的？（核心算法或流程）
4. 它和 [相关概念，如 Summary] 有什么本质区别？
5. 请给我一个具体的数值例子来说明它的工作过程。

Prompt 2.3——公式拆解

论文中有一个关键公式：[粘贴公式或描述]。请帮我逐步拆解：
1. 这个公式里的每一个符号代表什么？
2. 公式的直觉含义是什么？（不要用数学语言，用自然语言解释）
3. 如果去掉其中某一项，会发生什么？
4. 请用一个具体的数值例子（用简单的数字）帮我验证这个公式的计算过程。

Prompt 2.4——概念之间的关联

我现在分别理解了 [概念A] 和 [概念B]。但我不太清楚它们之间的关系。请帮我解释：
1. A 是 B 的前置条件？还是并列关系？还是递进关系？
2. 如果把 A 和 B 合在一起看，它们共同解决了什么问题？
3. 请画一个简单的流程图（用文字描述）展示它们如何配合工作。

Prompt 2.5——"为什么不用 X"追问

论文选择了 [方法X，如 Memory Overwrite] 来解决 [问题]。但据我所知，还有其他方法也能解决类似问题，比如 [方法Y，如 Summary]、[方法Z，如 滑动窗口]。请帮我分析：
1. 方法 X 和方法 Y 的本质区别是什么？
2. 为什么论文选择 X 而不是 Y？论文的实验或分析支持这个选择吗？
3. 在什么情况下，Y 可能反而比 X 更好？

Prompt 2.6——从零推导

假设我是这个领域的研究者，我想从零推导出论文的核心方法。请用苏格拉底式提问的方式引导我思考：
- 不要直接告诉我答案
- 每次只问一个问题
- 根据我的回答决定下一个问题
- 最终引导我自己"发明"出论文的核心思路

起点：[描述你要解决的问题，如"如何让 LLM 处理无限长文本"]

Prompt 2.7——知识缺口检测

我正在学习这篇论文。以下是我目前理解的内容：
[粘贴你的笔记或理解]

请帮我检测知识缺口：
1. 我的理解中有哪些错误或偏差？
2. 有哪些重要概念我遗漏了？
3. 基于我目前的理解，下一步最应该深入追问的是什么？

阶段三：动手实现（Day 4-5）​

Prompt 3.1——最小可运行实现

我想实现一个简化版的 [论文核心组件，如 Memory Overwrite]。要求：
1. 不看论文代码，先从最简版本开始
2. 用 Python，代码不超过 50 行
3. 不依赖任何特殊库（只用标准库 + PyTorch/Transformers）
4. 给我完整的、可运行的代码，包含测试用例

Prompt 3.2——和论文代码对比

我实现了 [组件名]，代码如下：
[粘贴你的代码]

请帮我对比论文的实现：
1. 我的实现和论文有什么关键区别？
2. 论文做了哪些我没有考虑到的优化？
3. 我的实现有什么潜在问题或边界情况没处理？
4. 请给出改进建议和修改后的代码。

Prompt 3.3——训练循环实现

请帮我用 PyTorch 实现一个简化版的 [训练方法，如 Multi-Conv RL] 训练循环。要求：
1. 包含完整的 forward → reward → loss → backward 流程
2. 每一步都有清晰的注释解释"这里在做什么"
3. 使用简单的示例数据，让我可以直接运行
4. 标注出"这里是论文的核心创新点"的位置

Prompt 3.4——Debug 助手

我在复现论文时遇到了以下报错：
[粘贴完整报错信息]

我的环境是：[操作系统、Python 版本、PyTorch 版本、GPU 型号]

我执行的命令是：[粘贴命令]

请帮我：
1. 分析报错的根本原因
2. 给出具体的修复步骤
3. 解释为什么会出现这个问题（帮我理解底层原理）

阶段四：深度交流（Day 6-7）​

Prompt 4.1——写学习笔记

我刚刚学完了论文《[论文标题]》。请帮我整理一份结构化的学习笔记，格式如下：

## 一句话总结
[论文核心贡献]

## 问题定义
[这篇论文在解决什么问题]

## 核心方法
[方法概述，3-5 个要点]

## 关键实验结果
[最惊艳的实验数据]

## 我的疑问
[列出你还没搞懂的问题]

## 和其他工作的关系
[这篇论文和哪些工作相关]

Prompt 4.2——提 Issue 的草稿

我正在复现论文《[论文标题]》。在阅读代码后，我发现了一个可能的 issue：
[描述你的发现或疑问]

请帮我写一个 GitHub Issue，要求：
1. 标题简洁明确
2. 描述清楚背景、问题、我的理解、我的疑问
3. 语气礼貌专业
4. 展示我已经做了充分的思考（不是随便问的）

Prompt 4.3——写博客/推文

我刚刚深度学习完论文《[论文标题]》。请帮我写一条 Twitter/X 推文（280 字以内）和一篇简短的博客摘要（300 字以内），要求：
1. 用通俗易懂的语言
2. 突出最惊艳的实验结果
3. 附上论文链接
4. 推文要有吸引力，让人想点击阅读

万能追问模板​

模板 A——"解释层次"追问

我对 [概念] 还是不太理解。请换一种方式解释：
- 先用一句话概括
- 再用一个生活类比
- 然后用数学语言精确定义
- 最后用代码伪代码实现

模板 B——"极限情况"追问

如果 [概念/方法] 在以下极端情况下会怎样？
1. 输入数据量极小（只有 1 条）
2. 输入数据量极大（1 亿条）
3. 输入数据全是噪声
4. 输入数据分布和训练数据完全不同

请分析每种情况下的行为和可能的失败模式。

模板 C——"教学检验"追问

我现在尝试用自己的话解释 [概念]。请你扮演一个严格但耐心的教授，评估我的解释：

我的解释是：[粘贴你的解释]

请评估：
1. 我的理解是否正确？有哪些偏差？
2. 我的解释中遗漏了什么关键信息？
3. 按照学术标准，我的解释能得几分（满分 10 分）？
4. 如何改进？

模板 D——"论文对比"追问

请帮我对比以下两篇论文的核心思路：
- 论文 A：《[标题]》（[链接]）
- 论文 B：《[标题]》（[链接]）

对比维度：
1. 解决的问题是否相同？
2. 核心方法的本质区别是什么？
3. 实验结果谁更强？在哪些维度？
4. 两篇论文能互补吗？如果能，怎么结合？

使用建议：

  • 每个 Prompt 中的 [方括号] 部分替换为你实际的内容
  • Prompt 2.6（苏格拉底式追问）是 Gabriel 最核心的用法——不要让 AI 直接告诉你答案，而是让它引导你自己想出来
  • Prompt 2.7（知识缺口检测）建议每学完一个模块就跑一次，确保没有遗漏
  • Prompt 3.4（Debug 助手）在实际动手阶段会频繁使用，建议保存为快捷回复
  • 模板 C（教学检验）是费曼学习法的 AI 版——如果你不能讲清楚，说明你还没真懂

参考资源：