斯坦福 CS 329Z《Agent 工程》第 2 讲：给开发者的 LLM 原理

---------------------

课程 | 2026年斯坦福CS 329Z《Agent工程课》| 第1讲：智能体系统入门

---------------------

这是「斯坦福 Agent 工程课」系列的第 2 篇。课程是 Stanford 2026 年秋季的 CS 329Z《Engineering AI Agents》，讲师是 Diyi Yang、Michael Ryan 和 John Yang。课件在课程官网公开，我每讲写一篇，按课件逐页讲，一页不跳。

第 2 讲叫「LLMs for Builders」，官网课表上是 9 月 28 日，课件 176 页。页数多，是因为课件把动画拆成了一步一页，PDF 的文件标题就写着 Lecture2_no_animations。讲注意力的那几段，一张图会连着出现十几页，每页只多一个零件。

这一讲要回答的问题写在第 4 页的学习目标里：训练和推理一个现代 LLM，要做哪些核心的设计决定；这些决定又怎样变成限制，影响应用使用 LLM 的方式。

下面是这一讲的大纲，一共五块：什么是语言模型，语言模型的架构，训练，推理，给 agent 用的 LLM。后文按这个顺序走。

开场

开场几页交代这一讲的位置：这门课站在 LLM 技术栈的最上层，但仍然要懂一点下面是怎么工作的。

封面页。课程全名 CS 329Z: Engineering AI Agents，第 2 讲的标题是 LLMs for Builders，三位讲师的名字并列。

第 2 页是一座三层的金字塔，标题叫 The LLM Stack。最底层是 LLM Engineering，里面有分布式计算和架构，有 GPU 内核和 Scaling Laws，还有预训练和后训练，以及强化学习和分词器。中间一层是 LLM Adaptation，里面有微调和蒸馏，有上下文学习和 LoRA，还有从反馈中学习（RLHF/DPO）。塔尖是 LLM Applications，里面有 Agents，聊天机器人和 RAG。

图上用三种颜色的线圈出三门课各自覆盖的范围。蓝线是 CS336，圈住最底层的全部八项，还往上圈进了中间层的「从反馈中学习」。绿线是 CS224N，从塔尖往下圈住整个中间层，再伸到底层的架构，预训练和后训练三项。粉线是 CS329Z，也就是这门课，圈住塔尖的三项，并往下伸到微调和上下文学习。Agents 这一项被单独拉出来放大成一个粉色方框，里面写着这门课要讲的内容：agent 框架，多 agent，agent 记忆，主动型 agent，agent 评估，agent 设计。

补充三条线各圈住哪些项，我是按线条走向读的，边界处以原图为准。CS224N 是 Stanford 的自然语言处理课，CS336 是从零实现语言模型的课，两门都在第 1 讲的先修建议里出现过。

第 3 页只有一句话：我们会在 LLM 技术栈的最高一层工作，但了解一点它们是怎么工作的，仍然很重要。

第 4 页是学习目标，两条。第一条：理解并能解释训练和推理现代 LLM 时的核心设计决定。第二条：把这些设计决定和它们带来的限制联系起来，这些限制会影响应用使用 LLM 的方式。

第 5 页是大纲，已经放在本文开头。

一、什么是语言模型

语言模型做的事，是给一串 token 打概率；它是生成式的，所以可以从里面采样，采样的方式有好几种，各有代价。

第 6 页是第一块的标题页。页面底部有一条进度条，五块内容并排，当前这一块用红色标出。后面每进一块都会出现一次这样的页。

第 7 页是语言模型的定义，一个公式，课件用三种颜色把它拆成三段读。蓝色部分是等号左边：一个 token 序列的概率。红色部分是连乘号：从第一个 token 乘到最后一个 token。绿色部分是被乘的每一项：在给定前面所有 token 的条件下，当前这个 token 的概率。

补充token 是模型处理文本的最小单位，可以是一个词，半个词，或者一个标点。这个公式说的是，一整句话出现的概率，等于每个位置上「前文已知时，下一个 token 是它」的概率全部乘起来。

第 8 页把公式代进一个例句：The class was about agents.（这门课讲的是 agent。）第一项是 The 出现在句首的概率，0.0377。第二项是前面是 The 时出现 class 的概率，0.0001。第三项是前面是 The class 时出现 was 的概率，0.0344。中间省略，最后一项是前五个词都给定时出现句号的概率，0.0252。全部乘起来，这句话的概率是 1.2e-17。

页面底部有一行小字：实际操作中通常改成把这些概率取对数再相加，数值上更稳定。

补充1.2e-17 是 1.2 乘以 10 的负 17 次方。几十个小于 1 的数连乘，结果会小到计算机的浮点数存不准，取对数以后连乘变成连加，就没有这个问题。

第 9 页回到公式，用红圈圈住等号左边的 P(x₁:T)，旁边写着：这就是一个语言模型。

第 10 页是一张标题页，写着「生成式模型与判别式模型」，第 11 页是内容。左边是判别式模型：红点和蓝点之间画了一条虚线，模型学的是怎么把两类分开，例子是逻辑回归和 SVM。右边是生成式模型：红点和蓝点各被一片椭圆形的色块盖住，模型学的是数据本身的分布，例子是朴素贝叶斯和扩散模型。

第 12 页是一道随堂题。语言模型像下面这样给 token 序列的概率建模，它是生成式的，还是判别式的？页面下方补了一句：这不是脑筋急转弯，但这里的记号容易让人犯迷糊。

补充容易迷糊的地方在于，公式右边每一项都写成条件概率 P(xₜ | x<ₜ) 的样子，看起来像「给定输入，预测类别」的判别式写法。

第 13 页给出答案。公式换了一种写法：P(x₁:T) 等于 P(x₁, x₂, x₃, …, x_T)，也就是所有 token 的联合概率。下面一行大字：语言模型是生成式的，这意味着我们可以从里面采样。

第 14 页是标题页「语言模型采样」，第 15 页开始演示。句子写到 The class was about，后面分出十个候选的下一个 token：to，as，the，a，two，how，getting，three，time，还有一个左引号。

第 16 页给十个候选各写出一个条件概率。前面是 The class was about 时，下一个是 to 的概率 0.3171，as 是 0.0491，the 是 0.036，a 是 0.033，two 是 0.0147，how 是 0.0124，getting 是 0.0101，three 是 0.01，time 是 0.0091，左引号是 0.0081。

第 17 页把这十个概率画成横向的柱子，to 那一根远长于其他，被橙色框圈了出来，表示选中了它。

第 18 页往下走一步。句子变成 The class was about to，再列出十个候选和概率：be 是 0.1501，begin 是 0.0855，go 是 0.0627，start 是 0.0496，get 是 0.0390，become 是 0.0342，enter 是 0.0313，take 是 0.0220，end 是 0.0192，graduate 是 0.0180。这次橙色框圈住的是排第二的 begin。

右边的文字解释了原因：不一定每次都要选概率最高的那个 token，有不同的采样策略，也叫解码策略，列了三种：Greedy，Nucleus（top p），Top k。

补充Greedy（贪心）每一步都选概率最高的。Top k 只在概率最高的 k 个候选里按概率抽。Nucleus 也叫 top p，把候选按概率从高到低累加，加到总和超过 p 为止，只在这一批里抽。

第 19 页是采样的结果：The class was about to begin.（课就要开始了。）和第 8 页的例句开头相同，后半句走到了另一条路上。

第 20 页讲温度（Temperature）。四张柱状图画的是同一句话「I am tired, I will take a ___」的下一个 token 分布，候选是 nap，break，rest，bath，shower，温度分别是 0.1，0.5，1.0，2.0。温度 0.1 时，nap 几乎占了 100%。温度 0.5 时，nap 约 75%，break 约 18%。温度 1.0 时，nap 约 50%，break 约 24%，后三个各占一成上下。温度 2.0 时，五根柱子已经比较接近，nap 约 34%，shower 约 12%。

页面右边的红字是做法：把所有概率除以一个温度 T，再重新归一化，让它们加起来等于 1。

补充百分比是按图上柱子高度目测的。实现上，除以 T 的通常是 softmax 之前的那组分数（logits），再过 softmax 得到概率。温度越低，分布越集中在最高的那个候选上；温度越高，分布越平。

第 21 页讲束搜索（Beam Search），页面上只有一张图。从 start 出发，每一步都把所有候选展开，但只保留其中几条最好的路径继续往下走。图里第一步留下了 arrived 和 the 两个节点，往后每一步也各有几个节点被涂成绿色，表示这几条路径被保留，其余的被丢掉。

补充束搜索同时保留多条候选路径，每一步按整条路径的总概率来比较，最后选总概率最高的一整句。保留的路径数叫束宽。

第 22 页是采样这一段的小结，四条。每种采样策略有不同的取舍。温度和 top-p、top-k 用来调节多样性。用哪种策略取决于任务：数学和代码更可预测，用更低的温度；创意写作可能受益于更高的多样性。策略还取决于预算，束搜索的时间和内存开销更高。

第 23 页是这一块的延伸阅读，三个链接：Hugging Face 上讲解码策略的博客，Hugging Face LLM 课程里讲分词器的一章，还有一份讲生成式模型的课程笔记。

二、语言模型的架构

Transformer 的注意力让每个 token 都能回看前面所有 token，代价是开销随上下文长度的平方增长；线性注意力把历史压进一个固定大小的状态，省了开销，长上下文上更吃力；课件给的两个实际例子，都是把两者混着用。

第 24 页是第二块的标题页，这是全讲最长的一块，从第 24 页到第 91 页。

第 25 页是语言模型架构的简史，四行。N-gram 模型，2010 年代以前。第一个神经语言模型，2003 年。循环神经网络（RNN）语言模型，2010 年。长短期记忆网络（LSTM），1997 年发明，2014 年在语言模型上流行起来。

补充N-gram 模型靠统计「前面几个词后面最常跟哪个词」来预测。RNN 和 LSTM 是按顺序一个词一个词读的神经网络，读到后面时，前面的信息靠一个不断更新的内部状态带过来。

第 26 页是小节标题页「Transformers」，第 27 页进入正题：2017 年的论文《Attention Is All You Need》，标题下面列了八位作者。图是论文里那张 Transformer 结构图，分左右两半。左半边的编码器（Encoder）被一块红色整个盖住了，右半边的解码器（Decoder）用红色虚线框了出来。

补充盖住编码器是在铺垫下一页。今天的 GPT 这一类语言模型只用了右半边，叫 decoder-only（只有解码器）的 Transformer。

第 28 页的标题就是 Decoder-only Transformer。页面几乎是空的，只在底部放了四个词：The，class，was，about。接下来三十多页都在这四个词上面一层一层往上搭。

第 29 页，每个词上方多了一排彩色圆点，标注 Embedding。意思是每个 token 先被换成一个向量，一排圆点代表一个向量，四个 token 用四种颜色区分。

第 30 页，每个 token 的向量左边多了一排黑色圆点，中间用加号连着，上方得到一排新的圆点，标注 Positional Embedding。位置信息也是一个向量，加到 token 自己的向量上。

补充位置向量告诉模型这个 token 排在第几个。单靠注意力本身，模型分不清「狗咬人」和「人咬狗」，因为两句话的 token 是同一批。

第 31 页，四个 token 的向量汇到中间，叠成一个四行的矩阵，每行一种颜色，对应一个 token。

第 32 页是一张提醒页，红字写着 Important! 后面是：这里请集中注意力。如果在这里跟丢了，这一讲后面的大部分内容都会很难懂。其中 Attention 一词用了蓝色斜体，一语双关。

第 33 页，标题换成 Attention Layer（注意力层），图和第 31 页一样。从这里开始拆注意力层内部。

第 34 页，矩阵外面套上了 Layer Norm。

补充Layer Norm 即层归一化。它调整每个向量里的数值，让数值落在稳定的范围内，很深的网络因此更容易训练。

第 35 页，归一化后的矩阵分别乘上三个权重矩阵 W_Q，W_K，W_V（图里的橙，红，蓝三个方块），得到三组新的矩阵 Q，K，V。红字标注：做矩阵乘法，得到 Q，K，V 的激活值。K 右上角带一个 T，表示转置。

补充Q，K，V 分别读作 query，key，value。可以这样理解：每个 token 拿自己的 query 去和所有 token 的 key 比对，比对上的程度决定它从对方的 value 里取多少信息。

第 36 页，Q 和 K 的转置相乘，得到一个橙色的方阵。页面左边出现了注意力的公式 Attention(Q, K, V) = softmax(QKᵀ / √d_k) V，等号右边只有 QKᵀ 是黑色，其余部分是灰色，表示现在算到了这一步。

补充这个方阵是 4 行 4 列，第 i 行第 j 列的数是一个匹配分数：拿第 i 个 token 的 query，去比第 j 个 token 的 key。

第 37 页，方阵的右上角被涂黑，标注 Causal Attention Mask（因果注意力掩码）。

补充涂黑的格子，对应前面的 token 去看后面的 token。语言模型要预测下一个 token，所以每个位置只允许看自己和自己之前的位置，不能偷看后面。

第 38 页，方阵整体除以 √d_k，公式里对应的分母变黑。

补充d_k 是 key 向量的维度。除以它的平方根是为了把分数缩小到合适的范围，否则下一步的 softmax 会过于极端。

第 39 页，外面套上 Softmax，等号右边得到一个新的方阵，只有左下三角有圆点。公式里的 softmax 变黑。

补充softmax 把一组任意的数变成一组加起来等于 1 的比例。做完这一步，方阵的每一行就是一组注意力权重：这个 token 把多少比例的注意力分给前面每个 token。

第 40 页，注意力权重的方阵再乘上 V，得到一个棕色的矩阵。公式全部变黑，这条公式算完了。

第 41 页，棕色矩阵再乘一个权重矩阵 W_O，得到粉色的矩阵。红字标注：做矩阵乘法，投影回模型的维度。

第 42 页，加上残差连接（Residual Connection）。一条线从 Layer Norm 之前的输入拉出来，经过一个加号，绕到最上面，和粉色的矩阵相加。

补充残差连接是把这一层的输入直接加到这一层的输出上。这样每一层只需要学「在输入上改动什么」，信息也可以绕过这一层直接往上传。

第 43 页，标题下面多了一个箭头，从 Attention Layer 指向 Multi-Head Attention Layer（多头注意力层）。图没有变。

第 44 页，标题改成多头注意力层，左边出现第一条红字：1. 多组权重矩阵。

第 45 页，图上的 W_Q，W_K，W_V 各变成了一叠，Q，K，V 和后面的方阵也都变成了一叠。每一组权重矩阵各算一遍刚才的注意力，每一遍叫一个头。

第 46 页，出现第二条红字：2. 把各个头的注意力输出拼接起来。图上几个棕色矩阵拼成了一个更宽的矩阵。

第 47 页，出现第三条红字：3. 更大的投影矩阵。W_O 变宽了，负责把拼接后的宽矩阵投影回模型的维度。残差连接照旧。

第 48 页去掉了红字，是多头注意力层的完整图。

第 49 页，标题回到 Decoder-only Transformer，一个粉色的大方块把整个注意力层盖住了。这是动画的中间帧：刚才那一大堆矩阵，接下来被收成一个盒子。

第 50 页，粉色方块缩成了一个小盒子，上面写着 Multi-head, Causal Self-Attention Layer（多头因果自注意力层），盒子上方是它输出的粉色矩阵。

第 51 页，粉色矩阵外面又套了一层 Layer Norm。

第 52 页，画出了绕过注意力层的那条残差连接：从下面的输入拉出一条线，经过加号，接到注意力层的输出上。

第 53 页，上面再加一个蓝色的盒子 Feed Forward（前馈网络），输出一个蓝色的矩阵。

补充前馈网络对每个 token 的向量单独做一次变换，token 之间不交换信息。token 之间的信息交换全部发生在注意力层里。

第 54 页，前馈网络旁边也加了一条残差连接。

第 55 页，一个红色的大方块把注意力层和前馈网络一起盖住。又是一张动画中间帧。

第 56 页，红色方块缩成一个盒子，写着 Transformer Block，右下角标着 x N。注意力层加前馈网络合起来是一个 Transformer 块，这样的块叠 N 层。

第 57 页，N 层之后，输出过一次 Layer Norm，上面接一个深红色的盒子 LM Head。

第 58 页，LM Head 输出了一个新的矩阵。

补充LM Head 是最后一个线性层，把每个位置的向量变成一长串分数，词表里每个 token 一个分数。

第 59 页，这个矩阵外面套上 Softmax。

第 60 页，矩阵的四行各自拉出一个箭头，每行单独做一次 Softmax，得到四个概率分布。也就是说，四个位置各输出一个「下一个 token 是什么」的分布，这就接回了第 16 页那张候选概率的图。

第 61 页的标题是「注意力对比循环」，表格来自《Attention Is All You Need》，红框圈出了两行两列。每层的计算复杂度：自注意力是 O(n²·d)，循环层是 O(n·d²)，n 是序列长度，d 是向量维度。必须按顺序执行的操作数：自注意力是 O(1)，循环层是 O(n)。

下面两行红字是讲师的结论。O(1) 的顺序操作数，对在 GPU 上并行训练是一件大事。O(n²) 的序列长度项，意味着长上下文会变贵。

补充循环网络必须读完第 1 个词才能读第 2 个，n 个词要排队走 n 步。注意力层里所有位置可以同时算，所以顺序操作数是常数。代价是每个 token 都要和其他所有 token 算一次分数，总量随长度的平方涨。

第 62 页的标题是「Transformer 又好又便宜」，还是那篇论文的表格，比的是机器翻译。红框圈出最后两行：Transformer 基础版英译德 BLEU 27.3，英译法 38.1，训练开销 3.3×10¹⁸ FLOPs；大号版英译德 28.4，英译法 41.8，训练开销 2.3×10¹⁹ FLOPs。表里其他模型的训练开销从 9.6×10¹⁸ 到 1.2×10²¹ 不等，其中成绩最好的 ConvS2S 集成模型英译德是 26.36，英译法是 41.29。

补充BLEU 是机器翻译的自动评分，越高表示越接近人工译文。FLOPs 是浮点运算次数，用来衡量训练花了多少算力。

第 63 页是小节标题页「Linear Attention」（线性注意力），第 64 页开始讲。标题下一个箭头，从 Attention Layer 指向 Linear Attention。图还是那张注意力图，但只剩第一个 token The，每个矩阵只有一行。

第 65 页，标题定为 Linear Attention，图不变。

第 66 页，红字写着「Drop Softmax」，去掉 softmax。图上的 Softmax 和除以 √d_k 都不见了，换成一个箭头。

第 67 页，红框圈住从 Q，K，V 到输出的这一段，旁边三句红字：这里的一切现在都是线性的了！我们可以改变结合的顺序。那就改成先把 K 和 V 乘起来。

补充原来的顺序是先算 Q 乘 K，过 softmax，再乘 V。softmax 夹在中间，三个矩阵不能换顺序。去掉 softmax 以后只剩连乘，而矩阵连乘满足结合律，先算 K 乘 V 再乘 Q，结果一样。

第 68 页把图清空，只留下 Q，K，V。

第 69 页，K 的转置和 V 相乘，得到一个小方阵，记作 S₁。左下角用红框圈住了 The，S 的下标 1 也用红框标出，表示这是读完第 1 个 token 之后的状态。

第 70 页，Q 和 S₁ 相乘，得到这一个位置的输出。

第 71 页，输出再乘 W_O，加上残差连接，和普通注意力层的收尾一样。

第 72 页，标题变成 Linear Attention Update Rule（线性注意力的更新规则），图不变。

第 73 页，红框里写着 Clear Unimportant Memory，清掉不重要的内存。Q，K，V 和中间结果都清空了，只有 S₁ 还在。

第 74 页，红字换成 Save the state，保存状态。图上只留着 S₁。

第 75 页，第二个 token class 进来，过 Layer Norm。S₁ 还在右上角。

第 76 页，算出 class 的 Q，K，V。

第 77 页，class 的 K 和 V 相乘，得到一个新的小方阵，摆在 S₁ 旁边。

第 78 页，新方阵和 S₁ 相加，得到 S₂。class 的 Q 再和 S₂ 相乘。

第 79 页，得到 class 这个位置的输出。

第 80 页，再次清掉不重要的内存，这次留下的是 S₂。

第 81 页，第三个 token was 进来，重复同样的步骤，S₂ 更新成 S₃。

第 82 页，第四个 token about 进来，S₃ 更新成 S₄。

补充这十几页演示的是同一件事。线性注意力每读一个 token，就把它的 K 乘 V 加进一个固定大小的状态 S 里，然后只保留 S。新 token 不再回头去看前面每一个 token，只和 S 打交道。S 的大小不随序列变长而变大。

第 83 页的标题是「线性注意力快得多，内存占用也更小」，图来自论文《Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention》。左图纵轴是一次前向加反向传播的时间，右图纵轴是 GPU 内存，横轴都是序列长度，从 2⁹ 到 2¹⁶，两个轴都是对数刻度。红色虚线是 softmax 注意力，画到 2¹² 就停了，斜率比其他线都陡。黑色实线是线性注意力，在两张图里都是最低的一条，一直画到 2¹⁶。蓝色虚线是 Reformer 的三种配置。图注写明：线性注意力和 Reformer 随序列长度线性增长，softmax 注意力在时间和内存上都随序列长度的平方增长。

第 84 页的标题是「但是……它在更长的上下文上更吃力」，图来自 RULER 这篇论文。左边的表是三种「大海捞针」任务的样例：在一长段无关文章里藏一个或几个「特殊魔法数字」，再问模型这个数字是多少。右边是架构对比图，横轴是序列长度，从 1K 到 8K，纵轴是准确率。Llama2-7b 在 1K 时约 96，到 4K 时约 85。RWKV-v5-7b 从约 87 降到约 51。Mamba-2.8b 从约 62 降到约 16。三条线的后半段都画成了虚线：Llama2-7b 和 RWKV 是 4K 到 8K 这一段，Mamba 从 2K 起就是虚线。到 8K 处，Llama2-7b 掉到 0，RWKV 约 13，Mamba 接近 0。

补充数值按图目测。Llama2 是普通的 Transformer，RWKV 和 Mamba 这两种架构，都靠一个固定大小的状态往后传信息，和线性注意力是一类思路。在 4K 以内，Transformer 的那条线一直在最上面。

第 85 页是一条关于上下文长度的说明。Transformer 和线性注意力本身都没有规定一个严格的上下文长度，唯一的限制来自模型处理位置向量的方式。实际中，模型需要学会使用这些位置向量，所以我们被限制在训练时用过的上下文长度以内。

补充Llama 2 训练时的上下文长度是 4K。上一页它在 8K 处掉到 0 的那段虚线，可以对照这一页来看：架构上能读更长的输入，但那些位置的向量，模型在训练时没有见过。

第 86 页是小节标题页「Bringing it together」（合起来看），第 87 页是一张对照表。

完整的 softmax 注意力：开销随上下文长度是 O(n²)；所有 token 都可以回看之前的全部 token，这对长上下文有帮助；KV 缓存占的内存按 O(n) 增长。

线性注意力：开销随上下文长度是 O(n)；新 token 只和一个压缩过的状态表示打交道，长上下文更难；状态表示占的内存是常数。

补充KV 缓存在第四节讲推理时会正式出现，第 133 页。

第 88 页的标题是「实际中人们把全局注意力和线性注意力混着用」，图来自 Songlin Yang 的博客《DeltaNet Explained (Part III)》，画了两种混法。左边一种：DeltaNet 层和 SWA 层一层隔一层交替，SWA 旁边的小图是一个只有对角线附近一条带子被涂色的矩阵。右边一种：大部分是 DeltaNet 层，中间插两层 Global Attention，旁边的小图是整个下三角都涂色的矩阵。

补充DeltaNet 是线性注意力的一种。SWA 是滑动窗口注意力，每个 token 只看离自己最近的一小段，所以矩阵里只有对角线附近有值。Global Attention 就是前面讲的完整注意力，每个 token 看前面全部 token，所以整个下三角都有值。

第 89 页是同一篇博客里的结果表，三行三列。纯 DeltaNet：维基百科困惑度 28.24，常识任务平均 42.1，检索任务平均 22.7。加滑动窗口注意力：27.06，42.1，30.2。加全局注意力：27.51，42.1，32.7。表头的箭头标明困惑度越低越好，另外两项越高越好。

三行的常识任务分数相同，差别集中在检索任务上：从 22.7 升到 30.2 和 32.7。

补充困惑度（perplexity）衡量模型对一段文本有多「意外」，越低说明预测得越准。检索任务考的是从上文里把某条信息原样找回来，这正是固定大小的状态不擅长的事。

第 90 页是一个当前模型的例子：Kimi K3，图来自《Kimi K3: Open Frontier Intelligence》（arXiv 2607.24653）。讲师在原论文的结构图上加了四个彩色框，把一个块里的四层标了出来，从下往上是：线性注意力（图中的 KDA 层），前馈网络（Stable LatentMoE），多头注意力（Gated MLA，讲师标的是 Multi-Head (Latent) Attention），再一个前馈网络。原图在这四层的左侧还标了重复次数：下面的「KDA 加前馈」这一组旁边是 3×，上面的「Gated MLA 加前馈」这一组旁边是 1×。左边两张小图是 KDA 层和前馈层的内部结构，KDA 层的小图里写着 Kimi Delta Attention。

第 91 页回答一个问题：这些对 agent 为什么重要？四条。agent 可能要处理极长的上下文。推理效率是搭建 agent 系统时的一个设计考量。了解底层的模型架构，能帮你为自己的 agent 应用选对模型。围绕你所用模型的长处和短处去开发 harness 和脚手架，会让你成为更好的 agent 工程师。

三、训练

训练分三段：预训练在海量网页文本上学预测下一个 token，中训练把数据配比往目标领域偏，后训练教模型听指令，奖励信号从人的偏好走向可以自动验证的结果。

第 92 页是第三块的标题页 LLM Training。

第 93 页是小节标题页「Defining the Loss」（定义损失），第 94 页给出一条训练数据的例子，一段英文：The class was about how agents work, and how to build AI systems that use tools, retrieve information, and carry out tasks across multiple steps…（这门课讲的是 agent 怎么工作，以及怎么搭建会用工具、会检索信息、能跨多个步骤完成任务的 AI 系统……）

第 95 页回到第 15 页那张图：The class was about 后面分出十个候选。

第 96 页给十个候选配上概率柱，和第 17 页一样，to 最高，0.3171。右下角多了一个框，里面是训练数据里的原文：The class was about how agents work…

第 97 页，原文里的 how 变成了红色，候选里的 how 那一行也被红框圈出，它的概率是 0.0124。模型认为最可能的是 to，训练数据里真正的下一个 token 是 how。

第 98 页，其他候选都隐去，只留下 how 和它的 0.0124。

第 99 页，页面上方多了一行算式：Loss = − log(0.0124) = 1.907。损失就是模型给正确 token 的概率取对数，再取负号。

补充1.907 是以 10 为底算出来的。训练时通常用自然对数，同一个概率算出来约是 4.39。两种算法方向一致：模型给正确 token 的概率越高，损失越接近 0；概率越低，损失越大。

第 100 页是损失的完整公式，名字叫交叉熵损失（Cross Entropy Loss），课件用三种颜色读它。红色是求和号：对词表里的每一个 token 求和。蓝色是 yᵢ：这个 token 是训练数据里的那个 token 时取 1，否则取 0。绿色是 log(pᵢ)：模型给这个 token 打了一个概率，这里取它的对数。

补充因为 yᵢ 只在正确的那个 token 上是 1，求和以后只剩一项，就是上一页的 − log(0.0124)。

第 101 页是小节标题页「Pretraining」（预训练），第 102 页是预训练数据的处理流程，一行图标：HTML 网页，文本抽取，语言识别，基于规则的过滤，质量过滤，去重，最后得到训练数据。

第 103 页是一个真实的例子，图来自 DCLM 这篇论文（arXiv 2406.11794），画的是从 DCLM-Pool 做出 DCLM-Baseline 数据集的过程，百分比都以原始文档总数为基数。

第一段是启发式清洗。英文过滤去掉 50.8%，重复内容过滤去掉 9.6%，其他过滤（词长，省略号数量，停用词等）去掉 9.0%，页面长度过滤去掉 7.9%，词移除比例过滤去掉 2.0%，URL 过滤去掉 0.8%。剩下 19.9%。

第二段是去重，Bloom filter 去掉 6.2%，剩下 13.7%。

第三段是基于模型的过滤，fastText 分类器去掉 12.3%，最后剩下 1.4%，这就是 DCLM-Baseline。

补充图注写明 DCLM-Pool 是从 Common Crawl 里抽取出来的。Common Crawl 是一个公开的网页抓取存档。按这张图，一百篇抓下来的网页文档里，最后进训练集的不到两篇。

第 104 页是第二个例子，一个数学专用的预训练数据集 Nemotron-CC-Math（arXiv 2508.15096）。流程从左到右：98 份 Common Crawl 快照；拿几份现成数学数据集里的网址去筛，筛出数学相关的网页 2.2954 亿篇；用 Lynx 把 HTML 渲染成文本，图上 Resiliparse 和 Trafilatura 两个名字被打了红叉；用 LLM 清洗文本；去重和去污染。最后得到 1.0115 亿篇文档，1332.6 亿个 token。

右边的饼图是主题分布：数学 60.28%，计算机科学 11.99%，物理 11.22%，统计 7.50%，经济 3.18%，化学 1.71%，其他 4.12%。

补充Lynx 是一个纯文本的网页浏览器。Resiliparse 和 Trafilatura 是两个常用的网页正文抽取工具，上一页的 DCLM 用的就是 Resiliparse。

第 105 页的右上角写着「DCLM 里的数据样例」。页面上叠着几张文档，最上面一张是一份编程手册的片段，讲 Fortran 里的 EOSHIFT 函数：对数组的元素沿某个维度做移位，移出去的元素丢掉。

这一页的 PDF 里，下面还压着另外两份样例，被最上面这张盖住了，页面上看不到。一份是论坛 AnimeSuki 上的一个帖子，楼主在问有没有讲传奇黑客的动画。一份是一篇报道的开头，写美国烹饪学院早上七点的烘焙课，厨师在给学生讲派和挞的区别。

第 106 页是另一个数据集 The Pile 的构成（arXiv 2101.00027，一个 800GB 的文本数据集），用一张面积图表示，按颜色分五类。蓝色是学术类，有 PubMed Central，ArXiv，FreeLaw，USPTO 等。绿色是互联网类，有 Pile-CC，OpenWebText2，StackExchange，Wikipedia。橙色是书面作品类，有 Bibliotik，PG-19，BC2。黄色是对话类，有 Subtitles，IRC，EP，HN，YT。灰色是其他，有 Github 和 DM Math。

第 107 页讲数据配比（Data Mixing），图来自 Olmix 这篇论文（arXiv 2602.12237），三步。第一步 Swarm：准备很多种不同的数据配比，每种配比训一个小的代理模型，记下各自的表现。第二步 Regression：用这些结果拟合一个回归模型，输入配比，预测表现；图里的散点基本落在对角线上，表示预测值和真实值接近。第三步 Optimization：在回归模型上求最优，找出预测表现最好的那个配比。

第 108 页是小节标题页「Midtraining」（中训练），第 109 页的标题是一句做法：把数据配比改得更偏向你的目标领域，比如数学和代码。图来自 OpenAthena 的文章《Curating 25 Trillion Tokens for LLM Pretraining》，是两张并排的色块表，左边是 PRETRAINING（预训练）阶段，右边是 COOLDOWN（冷却）阶段。每张表的行是内容领域，截图里露出五个：应用与网页开发，艺术历史与文化，商业软件与战略，基督教信仰与灵修，临床治疗与牙科。列是质量档，从 Q0 到 Q4。两张表里同一个格子的颜色深浅不同。

补充课件这一页没有放图例，每种颜色具体代表多大的比例，需要看原文。能从这一页读出来的是：数据按「领域 × 质量档」切成格子，两个训练阶段给同一个格子的权重不一样。

第 110 页的标题是：把更多目标领域的数据混进「预训练」，往往有帮助。图来自论文《The Finetuner's Fallacy》（arXiv 2603.16177）。

左图是「专门化的预训练配比」：一大块通用数据，下面加上重复 10 到 50 遍的领域数据，每个蓝色小块代表把领域数据集过一遍。

右图比的是两种基座模型在后续微调中的表现，都用了 2000 亿 token 做预训练。实线是预训练时混入了 33 遍领域数据的模型，虚线是只用通用数据预训练的模型。横轴是微调步数。蓝色线看左轴，是领域测试损失；橙色线看右轴，是通用损失。实线的蓝线最低点比虚线的更低，而且出现得更早；在各自的最低点处，实线对应的通用损失也更低。图的标题是：领域内泛化更好，微调时遗忘更少。

第 111 页没有标题，是一张示意图，来自论文《Midtraining Bridges Pretraining and Posttraining Distributions》（arXiv 2510.14865）。图上有三个点：预训练结束时的参数 θ_pre，目标参数 θ_target，以及中训练之后的参数 θ_mid。红色虚线是标准微调的路径，从 θ_pre 直接走向 θ_target，中间穿过一片红色区域。白色实线是中训练的路径，先向下绕到 θ_mid，再到 θ_target，全程走在蓝色区域里。右边的色条标注的是梯度对齐程度，并注明是示意。

第 112 页是小节标题页「Posttraining」（后训练），第 113 页讲指令微调（Instruction Finetuning），图来自论文《Scaling Instruction-Finetuned Language Models》（arXiv 2210.11416）。

虚线上方是训练。指令微调的样例：请回答下面的问题，氮的沸点是多少？答案是 −320.4F。思维链微调的样例：请一步一步推理来回答，食堂有 23 个苹果，用掉 20 个做午饭，又买了 6 个，现在有几个？答案把推理过程写了出来：23 − 20 = 3，3 + 6 = 9。图上标注这是多任务的指令微调，共 1800 个任务。

虚线下方是推理：泛化到没见过的任务。问题是「Geoffrey Hinton 能和乔治·华盛顿对话吗？回答前先给出理由」。模型答：Hinton 生于 1947 年，华盛顿死于 1799 年，所以两人不可能对话，答案是不能。

第 114 页讲从人类偏好中学习，图来自论文《Training language models to follow instructions with human feedback》（arXiv 2203.02155），分三步。

第一步，收集示范数据，训练一个有监督的策略。从 prompt 数据集里抽一条（图里是「向 6 岁小孩解释登月」），由标注员写出理想的回答，用这些数据对 GPT-3 做有监督微调。

第二步，收集比较数据，训练一个奖励模型。对同一条 prompt 采样出几个模型回答，由标注员从最好到最差排序，用排序数据训练奖励模型。

第三步，用强化学习针对奖励模型优化策略。抽一条新的 prompt（图里是「写一个关于青蛙的故事」），策略生成回答，奖励模型给这个回答打分，分数用来通过 PPO 更新策略。

补充这套做法通常叫 RLHF（基于人类反馈的强化学习），第 2 页金字塔的中间一层写着它。PPO 是一种常用的强化学习算法。

第 115 页列出人类反馈的四个问题。人类标注员可能不可靠。每个人的偏好都不一样。会给模型优化带来坏的激励，课件举了两个例子：谄媚，以及摆出权威的口气。数据本身的来源可能不合伦理。页面右下角注明这一页的灵感来自 CS329X。

第 116 页讲基于可验证奖励的强化学习（RLVR），左边三条。让奖励可以被验证。对数学和代码特别好用！需要小心设计验证器。

右边的紫红色方框列了几种可验证的奖励：单元测试，Lean 证明，精确匹配，系统状态。

下面是 GRPO 的流程图，来自 DeepSeekMath 这篇论文（arXiv 2402.03300）。一个问题 q 进入策略模型，生成一组回答 o₁ 到 o_G；奖励模型给每个回答打分，得到 r₁ 到 r_G；经过一步「组内计算」得到 A₁ 到 A_G，用来更新策略模型。图例标明策略模型是被训练的，参考模型和奖励模型是冻结的，参考模型通过一个 KL 项连回策略模型。

补充Lean 是一种定理证明语言，用它写出的证明可以被程序自动检查对错。GRPO 的做法是对同一道题采样一组回答，按每个回答在组内的相对好坏来决定往哪个方向更新。KL 项的作用是不让策略模型离参考模型太远。

第 117 页讲针对 agent 的训练，例子是 SWE-smith（arXiv 2504.21798），图分四栏。第一栏是真实的代码仓库，有源码，也有单元测试。第二栏是创建环境：SWE-agent 尝试安装仓库并运行测试，再由开发者根据 SWE-agent 的操作写出 Dockerfile。第三栏是四种生成任务的策略：程序化修改，用语言模型生成，把几个 bug 组合起来，镜像真实的 PR。第四栏是产出的新任务实例：一个环境镜像，加上一批合成任务，每个任务包含一条生成的 issue，一个带 bug 的补丁，和一组验证过的测试。

补充SWE-smith 的第一作者是本课讲师 John Yang。它解决的问题是，训练一个会修 bug 的 agent 需要大量「仓库 + bug + 测试」这样的任务，靠人工从 GitHub 上收集太慢，这套流程是在真实仓库里自动造 bug。

第 118 页是 SWE-smith 论文里的结果表，列的是各模型在 SWE-bench Lite 和 Verified 上的解决率。

上半部分是闭源模型。Claude 3.7 Sonnet 配 SWE-agent：Lite 48.0，Verified 58.2，是全表最高。Claude 3.5 Sonnet 配 OpenHands：41.7 和 53.0。GPT-4o 配 Agentless：32.0 和 38.8。这一部分的最后一行是 Llama3-SWE-RL-70B 配 Agentless，训练数据量 1100 万条，Verified 41.0。

下半部分是开放权重模型。表里有一列训练数据量，闭源模型那几行都是空的。最后一行 SWE-agent-LM-32B 用了 5000 条训练数据，Lite 30.7，Verified 40.2，在开放权重模型里两项都是最高。同一部分里，SWE-fixer-72B 用 11 万条数据，Verified 32.8；R2E-Gym-32B 用 3300 条，Verified 34.4；SWE-gym-32B 用 491 条，Verified 20.6。

四、推理

推理分预填充和解码两段，瓶颈不同；KV 缓存让解码不用重算前文；推理时多花算力可以换更好的结果，花法有三种：让模型多想，多采样几次再验证，多采样几次再投票。

第 119 页是第四块的标题页 LLM Inference。

第 120 页是小节标题页「Prefill and Decode」（预填充和解码），第 121 页先讲硬件。标题是 GPUs，图把 CPU 和 GPU 并排画。CPU 那边是一大块控制单元，四个 ALU（算术逻辑单元），一大块缓存，下面是内存。GPU 那边是密密麻麻一整片绿色小方格，每一格是一个小的计算单元，下面也是内存。

第 122 页讲 Roofline 性能模型。横轴是算术强度，单位是每读写一个字节的数据做多少次浮点运算。纵轴是能达到的每秒浮点运算次数。图上一条斜线，一条水平线，两条线连起来像屋顶的轮廓。斜线的斜率由内存带宽决定，水平线是硬件的峰值算力。交点左边叫带宽受限（Bandwidth-bound），右边叫算力受限（Compute-bound）。

补充意思是一段计算跑得多快，可能卡在两个地方。如果它每搬一点数据只做很少的运算，时间都花在搬数据上，瓶颈是内存带宽。如果它搬一点数据要做大量运算，瓶颈才是芯片的算力。

第 123 页用一张图定义预填充和解码。prompt 是 The quick brown fox，四个 token 在预填充（prefill）阶段一次算完，各自产生一份 KV 向量，这些向量被缓存下来，同时给出第一个输出 token jumps。然后是解码（decode）阶段，每一步读入上一个输出 token，算出它的 KV 向量并入缓存，再生成下一个：读入 jumps 生成 over，如此往下。

第 124 页，标题 Prefill。图是第 42 页那张带残差连接的注意力层，四个 token 都在，矩阵都是满的。预填充就是把整个 prompt 一次性过一遍注意力。

第 125 页，标题 Decode。图里只有 The 一个 token，每个矩阵只有一行。课件用同一句话重新演示：如果一个 token 一个 token 地算，会发生什么。

第 126 页，红框写着 Clear Unimportant Memory。大部分中间结果清空了，K 和 V 里 The 的那一份留着。

第 127 页，第二个 token class 进来。Q 里只有 class 这一行，K 和 V 里有两份：留下来的 The，和新算出来的 class。class 的 query 和这两份 key 算注意力，得到 class 这个位置的输出。

第 128 页，再次清掉不重要的内存，K 和 V 里的两份都留着。

第 129 页，第三个 token was 进来，K 和 V 变成三份。

第 130 页，清内存，留下三份 K 和 V。

第 131 页，第四个 token about 进来，K 和 V 变成四份。

第 132 页，清内存，留下四份 K 和 V。

第 133 页，注意力层的中间结果都拿掉了，只剩 K 和 V 两个矩阵，旁边红字写着 KV Cache（KV 缓存）。页面底部的四个 token 还在。

补充对比第 73 到 82 页的线性注意力。那边每一步留下的是一个固定大小的 S，这边每一步留下的是到目前为止所有 token 的 K 和 V，每多一个 token 就多一份。第 87 页对照表里写的「KV 缓存按 O(n) 增长」和「状态占常数内存」，说的就是这个差别。有了 KV 缓存，生成新 token 时前面的 token 不用重新算。

第 134 页回到 Roofline 图，多了两个绿色的标签。Decode 贴在左边带宽受限的区域，Prefill 贴在右边算力受限的区域。

补充预填充一次处理一大批 token，运算量大，卡在算力上。解码每步只算一个 token，运算量小，却要把整个模型的权重和越来越长的 KV 缓存都读一遍，卡在搬数据上。

第 135 页是两个指标。横轴是经过的时间。前面一段橙色实线是预填充，它的长度对应首 token 时间（time to first token）。后面一串蓝色的点是解码，每个点是一个输出 token，相邻两点的间隔对应每个输出 token 的时间（time per output token）。

第 136 页讲推测解码（Speculative Decoding）。左边是一个小的草稿模型（Draft Model），从 Once 开始，一个接一个生成 upon，a，time，there。右边是大的目标模型（Target Model），把 Once upon a time 四个位置一次性送进去，一次算出每个位置它自己会生成什么，再和草稿对比：upon，a，time 三个打了绿勾，there 打了红叉。

补充打勾的 token 直接采用，从打叉的位置开始改用目标模型自己的结果，再让草稿模型接着往下猜。大模型验证好几个 token 只需要过一遍，和它自己生成一个 token 的开销差不多，所以草稿猜对得越多，省得越多。

第 137 页是推测解码的效果，三张图来自论文《Accelerating Large Language Model Decoding with Speculative Sampling》（arXiv 2302.01318），横轴都是每轮让草稿模型先猜几个 token，从 0 到 7。左图和中图各有两条线，分别是 HumanEval（写代码）和 XSum（写摘要）两个任务；右图只有一条线，不分任务。

左图是生成 128 个 token 的平均时间。不用草稿时约 1800 毫秒。HumanEval 一路降到 7 个草稿 token 时的约 670 毫秒。XSum 在 3 个草稿 token 时降到约 930 毫秒，再往后反而回升到约 1000 毫秒。

中图是草稿被接受的比例。猜得越多，接受率越低。HumanEval 到 7 个时还有约 0.68，XSum 降到约 0.45。讲师用红字和箭头指着这张图：有些领域比其他领域更容易预测。

右图是单轮循环的总时间，从约 14 毫秒线性升到约 28 毫秒。

第 138 页是小节标题页「Inference Time Scaling (Test Time Scaling)」（推理时扩展），第 139 页从思维链（Chain of Thought）讲起，图来自提出它的论文（arXiv 2201.11903）。

左边是标准 prompt。示例里的问答只给答案：Roger 有 5 个网球，又买了 2 罐，每罐 3 个，现在有几个？答案是 11。然后问食堂苹果那道题，模型答 27，错。

右边是思维链 prompt。示例里的答案把推理过程写了出来：Roger 原来有 5 个球，2 罐每罐 3 个是 6 个，5 + 6 = 11。同样问苹果那道题，模型也跟着写出过程：原来 23 个，用掉 20 个剩 3 个，又买 6 个，3 + 6 = 9，答案是 9，对。

第 140 页讲推理模型（Reasoning LLM）。问题是：一件夹克 80 美元，商店先涨价 25%，再在新价格上打 25% 的折扣，最后多少钱？

左下是传统 LLM 的回答，直接列式：80 × 1.25 = 100，100 × 0.75 = 75。

右边是推理模型的回答。它先写了一个错的想法：加 25% 再减 25% 看起来没有变化，最终价格应该是 80。接着写「等等」，说这种抵消要求两个百分比用同一个基数，而这里的折扣是打在涨价后的价格上的。然后重算：涨 20 到 100，降 25 到 75。再验算一遍：80 + 20 − 25 = 75。最后给出答案 75 美元，比原价少 5 美元。

第 141 页的小标题是「Aha moments」（顿悟时刻），图来自 Sebastian Raschka 的文章。题目是：一张电影票和一份爆米花一共 18 美元，电影票比爆米花贵 6 美元，电影票多少钱？

模型的回答包在 think 标签里。它先设爆米花是 p，电影票是 p + 6，然后列了一个错的式子 p + 6 = 18，得出 p = 12，电影票 18。下一行它写：等等，这不可能对。它发现自己只用了电影票的价格，没用两者的总和。改成 p + (p + 6) = 18，解出 p = 6，电影票 12。最后在 answer 标签里给出 12。

那句「等等，这不可能对」被红框圈出，旁边的红字是：模型学会了自我纠正。

第 142 页没有标题，是一张来自 OpenAI 发布页面的图，基准叫 Agents' Last Exam。横轴是每个任务的花费，从 0.02 美元到 20 美元，对数刻度。纵轴是得分，从 30% 到 61%。图例里有 GPT-6 Astra，GPT-6 Sol，GPT-6 Luna，GPT-5.6 Sol，GPT-5.6 Luna，Claude Opus 5，以及带 Opus 4.8 兜底的 Claude Fable 5。每个模型是连起来的几个点。

讲师把 GPT-6 Astra 那条线放大，在几个点上标了红字：Low，Medium，Max。从 Low 到 Max，花费往右，得分往上。右下角是一个产品界面的截图，一根滑杆，当前档位显示 High，下面写着 GPT-6 Astra。

补充同一个模型的几个点，对应的是不同的推理力度档位。档位越高，模型在回答前想得越多，生成的 token 越多，花的钱也越多。被放大的 Astra 这条线上，得分随档位一路上升。图里另外几条线并不都这样，GPT-6 Sol 和 Claude Opus 5 的折线上，都有花费更高而得分回落的点。

第 143 页讲怎么设置推理档位，例子是 GPT-OSS。页面上是三个系统提示词，内容分别是 Reasoning: low，Reasoning: medium，Reasoning: high，下面是用户提示词 Solve this math problem...。也就是说，档位是写在系统提示词里的一行字。

第 144 页讲模型是怎么被训练成能按档位思考的，举了两家的做法。

左边是 Thinking Machines 的 Inkling。奖励公式是 R(e) = R_task − λ(e)·N_tokens：任务本身的奖励，减去一个系数乘以用掉的 token 数。低档位时把 λ 设得高，高档位时把 λ 设得低。

右边是 Moonshot 的 Kimi K3。奖励规则是：答对得 1，答错得 0，答错而且超出预算得 −1。下面是一个三行三列的方格，三列是通用任务，通用 agent，编码 agent，三行是高中低三个档位，每格是一个教师模型，九个教师一起汇到下面的一个学生模型，标注是多教师蒸馏（Multi Teacher Distillation）。

补充λ 可以理解成每个 token 的「价格」。价格高，模型多想一步的代价大，就学会少想；价格低，就学会多想。蒸馏是让一个学生模型去模仿教师模型的输出。

第 145 页讲另一种花算力的办法：重复采样，图来自论文《Large Language Monkeys》（arXiv 2407.21787）。第一步，让 LLM 对同一个问题生成很多个候选解。第二步，用一个验证器挑出最终答案，验证器可以是单元测试，证明检查器，或者多数投票。

图下方写出了这个办法面对的两个问题。问题一是覆盖率（coverage）：生成的候选里有没有一个正确的？问题二是精度（precision）：能不能从候选里把正确的那个认出来？

第 146 页是这篇论文的结果，四张图。横轴是采样次数 k，从 1 到 10⁴，对数刻度。纵轴是覆盖率，也就是 k 次采样里至少有一次答对的题目比例。蓝线是 Llama-3-8B，绿线是 Llama-3-70B，红色虚线是 GPT-4o 只答一次的成绩。

MiniF2F-MATH（形式化证明）：两条线都从约 0.2 升到约 0.5，GPT-4o 单次约 0.27。CodeContests：8B 从接近 0 升到约 0.24，70B 从约 0.08 升到约 0.38，GPT-4o 单次约 0.2。MATH：8B 从约 0.27 升到接近 1，70B 从约 0.48 升到接近 1，GPT-4o 单次约 0.64。GSM8K：两条线都升到接近 1，GPT-4o 单次约 0.93。

四张图里，小模型多采样若干次以后，覆盖率都超过了 GPT-4o 答一次的那条红线。

补充数值按图目测。下面两张图的标题里写着 Oracle Verifier，意思是假设有一个完美的验证器，只要候选里有正确答案就一定能认出来。所以这页回答的是上一页的问题一，问题二要看实际有没有可靠的验证器。

第 147 页的标题是：没有验证器怎么办？自洽性（Self-Consistency）。图来自提出它的论文（arXiv 2203.11171），第 1 讲的第 38 页也用过。

上半部分是普通的思维链加贪心解码，只走一条路。题目是 Janet 的鸭子每天下 16 个蛋，她早餐吃 3 个，烤松饼用 4 个，剩下的每个卖 2 美元，每天赚多少？这条路算错了，答 14 美元。

下半部分是自洽性：采样出多条不同的推理路径，三条路径分别答 18 美元，26 美元，18 美元，把推理过程放到一边，只对最终答案做汇总，取出现最多的 18 美元。

第 148 页是自洽性的效果，一张图，任务是 ARC (Challenge)。横轴是采样的推理路径数，纵轴是准确率。橙线是贪心解码，只有一条路径，是一条约 43% 的水平线。绿线是「采样后排序」，从约 34.5% 升到 40 条路径时的约 43.7%，和贪心基本持平。蓝线是自洽性，1 条路径时约 36%，5 条时约 46.5%，10 条时约 50%，20 条时约 52.5%，40 条时约 53.7%。

补充数值按图目测。这里的 ARC 是一个科学常识选择题数据集，和测抽象推理的 ARC-AGI 不是同一个。

五、给 agent 用的 LLM

LLM 进了 agent 系统以后，有两件事要工程师自己管：输入输出要有结构，组件之间才接得上；上下文里放什么要挑，放得越多不代表越好。

第 149 页是第五块的标题页 LLMs for Agents。

第 150 页是第 1 讲反复出现的那张 agent 结构图：规划与推理，记忆，LLM 核心，工具，agent 动作，环境。这次红框圈住的是中间的 LLM 核心。这一讲前面四块讲的都是这一个方框里面的事。

第 151 页是小节标题页「Structured I/O」（结构化输入输出），第 152 页讲动机。图来自伯克利 BAIR 的那篇博客，也是第 1 讲的必读：左边是一个单独的神经网络，箭头指向右边，变成几个模型加上数据库，搜索，计算器，终端这些组件互相连接的系统。图下面是博客里的一句话：越来越多新的 AI 成果来自复合系统。

讲师在下面加了一句：这要求系统里的各个组件之间，有一份约定好的通信契约。

第 153 页讲约束解码（Constrained Decoding），副标题是：强制语言模型按特定的结构输出。图来自 SGLang 这篇论文（arXiv 2312.07104），例子是要求输出以 {"summary": " 这一串字符开头。

图 (a) 是普通的有限状态机（FSM）：这串字符被拆成一个一个字符，从状态 0 走到状态 13，每一步只允许一个字符。图 (c) 是按这个状态机解码的过程：几段固定的文字之间，要调用好几次 LLM。

图 (b) 是压缩后的状态机：整串字符合并成一步，从状态 0 直接到状态 1。图 (d) 是对应的解码过程：固定的那几段直接填上，到真正需要生成内容的地方才调用一次 LLM。

补充有限状态机在这里的作用是一张「当前位置允许输出什么」的清单。解码时每一步只在清单允许的 token 里选，输出就一定符合格式。格式里本来就写死的部分没有选择余地，不需要模型去算，直接跳过就能省时间。

第 154 页是 SGLang 论文里的吞吐量对比，测试用的是 Llama-7B 模型，数值做了归一化，越高越好。对比的是 SGLang，vLLM，Guidance，LMQL 四个系统，任务有十一种，包括 MMLU，ReAct agent，Generative Agents，思维树，LLM 评审，JSON 解码，多轮对话，DSPy 的 RAG 流程等。SGLang 在每一组里都是 1.0。vLLM 在长的多轮对话和 Generative Agents 上接近 SGLang，其余任务上只有 SGLang 的一半上下或更低。Guidance 和 LMQL 只在部分任务上有柱子，多数很低。

页面下方一行字：SGLang 在解码中用了有限状态机，另外还有其他优化。

第 155 页讲 DSPy 的 Signature（签名），图来自 DSPy 官网。左边是一段 Python 代码，定义了一个叫 Extract 的类，文档字符串是「提取联系信息」。它有一个输入字段 message，类型是字符串；三个输出字段：name 是字符串，email 是可以为空的字符串，intent 只能是 meeting，intro，follow-up 三个值之一。然后用 dspy.Predict 调用它，传入一句话：I'm Sarah (sarah@acme.co). Meet Thursday?

右边是输出：name 是 Sarah，email 是 sarah@acme.co，intent 是 meeting。图下方一行小字：签名定义任务，并强制输出的类型。

第 156 页的标题是 Peek inside，往里看一眼，展示 DSPy 实际发给模型的 prompt。

系统提示词先列出输入字段和输出字段，带着各自的类型。然后规定所有交互的格式：每个字段用 [[ ## 字段名 ## ]] 这样的标记开头，下面是字段的值。email 字段后面带一条注释，要求值必须符合一个 JSON schema。intent 字段后面也带一条注释，要求值必须和 meeting，intro，follow-up 之一完全一致，不能多字符。最后是一个 [[ ## completed ## ]] 标记，以及任务目标：Extract contact info。

用户提示词里是 [[ ## message ## ]] 标记和那句话，后面跟着一段指令：按顺序输出 name，email，intent 三个字段，最后以 completed 标记结束。

补充上一页那几行 Python 类型声明，被 DSPy 翻译成了这一页的一整段 prompt。和约束解码相比，这是另一条路：约束解码在生成时限制模型能选的 token，这里是用 prompt 把格式讲清楚，再按标记把输出解析回来。按官网课表，10 月 7 日的「Frameworks & Orchestration」一讲会讲 DSPy 的签名，模块和优化器。

第 157 页的标题是「约束模型：分类器」，副标题是：在 embedding 上面训练一个小的头，映射到类别标签。图来自 Jay Alammar 的博客。一句影评 a visually stunning rumination on love（一部视觉上令人惊叹的关于爱的沉思）被切成 token，送进 DistilBERT，取出第一个位置的输出向量，交给一个逻辑回归模型，输出 85% 是正面，15% 是负面，最后判为正面。

补充这是约束输出的最彻底的办法。模型不再生成文字，只能在几个预先定好的类别里选一个。

第 158 页的标题是「约束模型：System One 模型」，副标题是：眼下很流行的一个词，但大致就是选项可以调整的分类器，用来做「决策」。图来自一个对比学习项目的页面，分三步，例子是超级马里奥。

第一步，对比式的状态-动作预训练：游戏画面过一个状态编码器，动作的文字描述（比如 right jump）过一个动作编码器，训练时让配对的状态和动作在表格的对角线上得分最高。

第二步，生成候选动作：把 left，jump，right run 填进「Mario should {action}.」这句话，过动作编码器。

第三步，零样本的动作分类：当前画面过状态编码器，和三个候选动作各算一个分数，过 softmax，得到 left 5%，jump 80%，right run 15%，于是 Mario 应该跳，再把动作送回游戏里执行。

补充上一页的分类器，类别在训练时就定死了。这里的候选动作是用文字临时给的，换一组文字就换了一组选项，这就是副标题里「选项可以调整」的意思。

第 159 页是一个例子：工具调用，图来自 Toolformer 这篇论文（arXiv 2302.04761），第 1 讲的第 51 页也用过。四段文字里各插着一个带颜色的工具调用。写到「《新英格兰医学杂志》是……的注册商标」时，插入一个问答调用，返回 Massachusetts Medical Society。写到「1400 名参与者中有 400 人」时，插入 Calculator(400 / 1400)，返回 0.29。写到西班牙语 la tortuga 时，插入一个翻译调用，返回 turtle。写到 Brown Act 时，插入一个维基搜索调用，返回一段条文说明。

工具调用是结构化输出的一个例子：模型输出的那一小段，必须严格符合「工具名加参数」的格式，程序才能拿去执行。

第 160 页是小节标题页「Context Engineering」（上下文工程），第 161 页是一张对比图，来自 Anthropic 的文章《Effective context engineering for AI agents》，也是这一讲的选读。

左边是面向单轮问答的 prompt 工程：上下文窗口里只有系统提示词和用户消息，模型输出一条回复。

右边是面向 agent 的上下文工程。最左一栏是「可以给模型的上下文」，东西很多：好几份文档，好几个工具，记忆文件，详尽的指令，领域知识，消息历史。中间经过一步筛选（Curation），进入上下文窗口的只有其中一部分：系统提示词，两份文档，一个记忆文件，两个工具，用户消息，消息历史。模型的输出可能是一条回复，也可能是一次工具调用；工具调用的结果又流回到最左边那一栏，成为下一轮可选的上下文。

第 162 页列出一个 agent 的上下文里有什么，五项：系统提示词，消息历史，记忆，工具调用的结果，附加的文件。

第 163 页的标题是：为什么不干脆全放进去？上下文腐烂（Context Rot）。图来自 OOLONG 这篇论文（arXiv 2511.02817），画的是这个基准里的两类题目。

左边一题：关于经济的新闻，是九月多还是八月多？给模型的是一批带日期的新闻文章。模型要先判断每篇是不是讲经济的，再按月份数出来，回答「九月两篇，八月一篇，所以是九月」。

右边一题：在这几集里，角色 Jester 用了几次 Healing Word？给模型的是 12 小时对话的文字记录。模型要找出每一次施法，分清是哪个法术，再数出来，回答「两次」。

补充这两题的共同点是，答案不在某一句话里。模型要对上下文里的很多处分别做判断，再把结果汇总。这比第 84 页「大海捞针」式的找一个数字要难。

第 164 页是 OOLONG 的结果，两张图，横轴是上下文长度，纵轴是得分，每条线是一个模型，图例里有 gemini-2.5-pro，gpt-5，gpt-5-mini，gpt-5-nano，o3，o4-mini，claude-sonnet-4，llama-4-maverick，deepseek-r1-0528，黑色虚线是随机基线。

左图是合成数据（OOLONG-synth），上下文从 8K 到 512K。8K 时大部分模型在 0.7 到 0.9 之间；到 128K，画到这里的几条线多数落在 0.4 上下，gemini-2.5-pro 降到约 0.25。随机基线在 0.2 到 0.3 之间。llama-4-maverick 和 deepseek-r1 两条线全程在随机基线下面。

右图是真实数据（OOLONG-real），上下文从 64K 到 512K。最高的 gemini-2.5-pro 从约 0.6 降到约 0.3，其他模型多数从 0.4 到 0.5 降到 0.2 上下。

两张图里，所有在基线之上的线都是往右下走的：上下文越长，得分越低。

补充数值按图目测。

第 165 页是两段大字。搭建上下文没有唯一的办法，这是你们要在作业一里自己试的东西。所以我们只给一些实用的建议和考量。

接下来六页讲了四条建议。

第 166 页，第一条建议：避免臃肿（Avoid bloat）。副标题是：有时候几个工具就够了，Pi 只有 read，write，edit，bash 四个。

图来自 arena.ai 的一篇博客，标题是「Terminal-Bench 2：同一个模型下不同 harness 的影响」。四个 Claude 模型，每个分别配 Pi，Codex，Claude Code 三种 harness，左边是每次运行的花费，右边是成功率，绿框标出每组里最好的。

Claude Fable 5：Pi 花 1.08 美元，成功率 71.1%；Codex 花 0.98 美元，72.2%；Claude Code 花 1.55 美元，75.6%。Claude Opus 4.8：Pi 花 0.76 美元，72.2%；Codex 花 0.85 美元，72.2%；Claude Code 花 0.90 美元，68.9%。Claude Sonnet 4.6：Pi 花 0.61 美元，65.6%；Codex 花 0.55 美元，63.3%；Claude Code 花 0.67 美元，62.2%。Claude Haiku 4.5：Pi 花 0.25 美元，47.8%；Codex 花 0.21 美元，31.1%；Claude Code 花 0.25 美元，41.1%。

只有四个工具的 Pi，在后三个模型上成功率都是第一或并列第一，在 Fable 5 上比最高的 Claude Code 低 4.5 个百分点。

补充Pi，Codex，Claude Code 都是编码 agent 的 harness。这张图里，同一个模型换一个 harness，成功率和花费都会变。第 1 讲第 7 页的 Terminal-Bench 排行榜，也是把模型和 agent 分成两列写的。

第 167 页还是「避免臃肿」，第二个办法：用检索把最相关的记忆或文件找回来。图来自 NVIDIA 的一篇博客，画的是一条检索链：prompt 先过 embedding 模型，到向量数据库里搜索，再过一个重排序模型，把找到的内容和原始 prompt 一起交给 LLM，生成回答。页面下方写着：下一讲细讲！

第 168 页，第二条建议：按顺序往后加（Add sequentially）。副标题是：避免让 KV 缓存失效。图上是 The class was about 四个 token，上方是它们的 KV 缓存。

第 169 页演示反例。在句子最前面插入一个词 Actually，原来的四个 token 都往后挪了一位。红色箭头指着每个 token 旁边的位置向量，红字写着：这些位置向量全都变了。上方的 KV 缓存被打了一个大红叉，标着 Invalidated（已失效）。

补充KV 缓存里存的每一份 K 和 V，都是由「token 向量加位置向量」算出来的，而且每个 token 的结果还依赖它前面的所有 token。在中间或开头改动任何东西，后面所有 token 的缓存都要重算。只在末尾追加，前面的缓存可以原样复用。

第 170 页，第三条建议：用实验来评估上下文的选择。副标题是：可以搭好基准和评估，然后测试你的改动。

配图来自 Toolformer 论文，三张图分别是 LAMA，数学基准，问答基准，横轴是模型参数量，蓝线是开着工具的 Toolformer，红线是关掉工具的 Toolformer，紫色虚线是 GPT-3。三张图里蓝线都不低于红线。在 LAMA 和数学基准上，最小的模型两条线重合，模型越大差距越明显；在问答基准上，差距在中等大小的模型上最大，到最大的模型又缩小了。在 LAMA 和数学基准上，最大的 Toolformer 超过了 GPT-3 那条线；在问答基准上没有超过。

补充这张图在这里是当作示范用的。「给模型加上工具」是一个上下文层面的改动，值不值得做，是靠同一批基准上开和关的对比测出来的。

第 171 页，第四条建议讲压缩（Compaction），四条。等到需要压缩的时候，上下文已经变得极长。新的决定是：新的上下文里留什么。留得太多，很快又得再压缩一次。丢得太多，可能丢掉完成任务所必需的关键上下文。

页面下半部分是两条连在一起的帖子截图，日期都是 2026 年 2 月 23 日，来自 therundownai。内容是：Meta Superintelligence 的安全与对齐负责人 Summer Yue 透露，一个 AI agent 在漏掉一条关键指令后，出乎意料地批量删除了她个人邮箱里的邮件。她原本让 OpenClaw 只给出删除建议，在她发话之前不要采取任何行动。但收件箱太大，系统触发了上下文压缩，把「行动前先确认」这条指令丢掉了，agent 开始自行删除邮件。她说自己不得不冲到她的 Mac mini 前把进程杀掉。

第 172 页的标题是「另一种思路：递归语言模型（RLMs）」，图来自论文《Recursive Language Models》（arXiv 2512.24601）。

图的主体是一个深度为 0 的根 RLM。用户的 prompt 是：你正在读一本极长的书，能不能列出所有在「大灾变」之前制作的物品？这个 prompt 没有直接送进语言模型，那条路径上打了红叉。它被作为一个变量加载到一个 Python 环境里。

语言模型在这个环境里写代码。第一格代码是 print(prompt[:100])，只打印开头 100 个字符，看看这是什么。第二格代码按「Chapter 2」把 prompt 切成两段，然后对每一段各调用一次 llm_query，一次问「在第 1 章里找出……」，一次问「找找……」。右边画着两个深度为 1 的子 RLM，各自拿到一小段 prompt，各自交回一条子回答。最后一格代码打印 FINAL_ANSWER，得到最终回答。

补充前面几页的建议都是在想「怎么挑东西放进上下文」。这里的做法是不把长内容放进上下文，把它当成环境里的一份数据，让模型写代码去翻它，需要读某一段时，再开一个子模型只读那一段。

第 173 页是 RLM 的结果，图来自作者的博客，任务是 OOLONG 的 trec_coarse 子集，上下文 26.3 万 token。五根柱子：GPT-5 直接做，34.2%；GPT-5-mini 直接做，23.2%；用 GPT-5-mini 做 RLM，51.1%；用 GPT-5 做 RLM 但不允许子调用，40.9%；ReAct 加 GPT-5 加 BM25 检索，30.7%。

套上 RLM 的 GPT-5-mini 比直接读全文的 GPT-5 高出约 17 个百分点。

最后

第 174 页是总结的标题页，进度条上五块都走完了。

第 175 页是本讲总结，五块都打了勾：什么是语言模型；语言模型的架构，包括 Transformer 和线性注意力；语言模型的训练，包括预训练，中训练，后训练和 agent 训练；语言模型的推理，包括预填充和解码，以及推理时扩展；给 agent 用的 LLM，包括结构化输入输出和上下文工程。

第 176 页是结束页：周三见，讲 RAG！

把这 176 页压成几段话：

语言模型给一串 token 打概率，做法是把每个位置上「下一个 token 是它」的条件概率连乘起来。它是生成式的，所以可以采样。采样时不一定选概率最高的，温度，top-p，top-k 调的是多样性，束搜索更贵。

Transformer 的注意力层让每个 token 回看前面所有 token，好处是可以并行训练，对长上下文也有帮助，代价是开销随长度的平方涨，KV 缓存随长度线性涨。线性注意力去掉 softmax，把历史压进一个固定大小的状态，开销和内存都省了，长上下文的检索变差。课件给的两个实际例子都是混着用。

训练分三段。预训练的数据从网页里一层层筛出来，DCLM 的例子里最后只留下 1.4%。中训练把数据配比往目标领域偏。后训练从指令微调和人类偏好，走到可验证的奖励，再到 SWE-smith 这种专门为 agent 造的训练任务。

推理分预填充和解码，前者卡在算力，后者卡在内存带宽。推理时多花算力能换来更好的结果，课件讲了三种花法：让模型按档位多想，多采样再用验证器挑，没有验证器就多采样再投票。

LLM 进了 agent 系统，输入输出要有结构，办法有约束解码，DSPy 的签名，分类器。在 OOLONG 这个基准上，上下文越长得分越低，所以上下文要挑着放。课件给的建议是：工具少一点，用检索，只往后追加以保住 KV 缓存，用评估来验证改动，压缩时小心别丢掉关键指令。

据课程官网，这一讲的必读是 Anthropic 的《Building Effective Agents》：

https://www.anthropic.com/engineering/building-effective-agents

选读是 Anthropic 的《Effective Context Engineering for AI Agents》，第 161 页的图就出自这一篇：

https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

按官网课表，下一讲是 9 月 30 日的「Retrieval-Augmented Generation (RAG)」，内容包括幻觉与事实依据，embedding 和向量库，切块策略，混合搜索，交叉编码器和 ColBERT 这类延迟交互方法，还有一段动手环节：从零搭一条 RAG 流程。课件已经挂出，63 页。

本文是斯坦福 CS 329Z《Engineering AI Agents》（Fall 2026）第 2 讲课件的逐页讲解，非官方笔记，内容以课件原件为准。课件版权归讲师 Diyi Yang、Michael Ryan、John Yang。课程主页 https://cs329z.stanford.edu/ ，本讲课件 PDF https://drive.google.com/file/d/1kekt_p0n-_Q4Y2dKYEkH87NEx6mr8nRE/view （链接来自课程主页课表里第 2 讲的 Slides）。

微信群