第 5 周 · Day 5：面试冲刺——答题结构、估算、系统设计与分层题库

时长 5 小时：§1–§2 方法（0.5h）· §3 估算题 7 道（1h）· §4 系统设计（1h）· §5 题库模拟面试（2h）· 回放与补漏（0.5h）

对应学习计划 第 5 周 Day 5 的面试题库：架构层、训练层、对齐层、应用层四层题目，加一道开放题”公司内部知识库问答”。今天把它们整理成可以练的形式：每道题给出要点、常见追问和出处；估算题和设计题的每个数字都算出来。

配套代码 w5day5_checks.py（只用标准库）：7 道估算题和系统设计题的全部数字，外加示范答案里用到的小数字（训练天数还和 Llama 2 论文公开的 GPU 小时数交叉验证了一遍）

§B 参考实现（code/ 目录）：w5d5_mock_interview.py：模拟面试程序。从 §5 的题库里按”答得差的题多抽”的规则抽题、计时、按要点自评、记录历史；--estimate 模式练估算题，按数量级判分。

今天的目标：任意一道题能在 3 分钟内按”结论 → 动机 → 机制 → 代价”讲完，并且至少带一个数字；7 道估算题每道 5 分钟内算出正确的数量级；能在 20 分钟内把”公司内部知识库问答”从需求讲到上线。

§0 今天怎么安排

1. 先读 §1–§2（0.5h）：面试在考什么，三分钟怎么答。读完把 §2.2 的示范答案大声读一遍，感受节奏。
2. 估算题（1h）：§3 的 7 道题，每道限时 5 分钟，纸笔。先写假设再算，算完对照 out_w5day5.txt。
3. 系统设计（1h）：先合上文档，自己用 20 分钟把 §4 的题从头讲一遍（录音），再对照 §4 逐项补。
4. 题库模拟面试（2h）：python code/w5d5_mock_interview.py --n 20，每题限时 3 分钟口头作答、录音。程序会在你答完后给出要点清单让你自评。
5. 回放与补漏（0.5h）：听录音，按 §A.3 的清单挑毛病。自评低于一半的题，回到出处重看。

今天要用到的旧结论：全部。重点是 Day 3 §2（一个模型的全部数字）和 Day 4（28 个推导）：面试里”推一下”的题，答案都在 Day 4。

§1 面试在考什么

1.1 四种题型，各考一件事

面试官只有四五十分钟，要判断你能不能干这份工作。他能用的最便宜的信号，是你在被追问时能走多深。按这个目的，题目分四种：

为什么大厂偏爱估算题和设计题：概念和推导可以背，但估算和设计背不了。它们逼你把好几个知识点串起来，而且每个假设都会被追问。学习计划说设计题”占大厂 LLM 岗面试的半壁江山”，原因就在这里。

1.2 追问链：深度就是分数

几乎每道概念题，面试官都会连着问三四个”为什么”。以”为什么注意力要除以 $\sqrt{d_k}$“为例：

大多数人停在第 1 层，那是背出来的。能走到第 3 层，说明你真的理解；能接住第 4 层，说明你能把知识连起来。前五周每份讲义的”动机 → 直觉 → 推导 → 意义与代价”四拍，就是在为第 2、3 层做准备。

1.3 面试官最怕的三种回答，和最喜欢的两件事

最怕：

• 背诵：定义一字不差，但问”为什么”就卡住。
• 模糊：“GQA 更高效”——高效在哪？省了多少？省的是显存还是计算？
• 硬编：不会也要编一个。面试官往往就是这个方向的人，一听就知道；一次硬编会让他怀疑你前面所有的回答。

最喜欢：

• 主动说代价：“GQA 省了 KV Cache，但它不省计算，训练速度几乎不变。“说出代价，证明你权衡过。
• 带数字：“Llama 2 70B 每个 token 的 KV 从 2.5 MiB 降到 320 KiB。“一个数字胜过三句形容词。

§2 答题结构

2.1 三分钟四拍

为什么结论放最前面：讲义的四拍是”动机 → 直觉 → 推导 → 意义”，适合学习；面试官却要先确认你知道答案，再听你讲为什么。先给结论，后面讲到一半被打断也不吃亏。

为什么机制只讲一个点：三分钟讲不完整个推导。挑最关键的一步讲透（比如 DPO 里”$Z(x)$ 在两个回答相减时抵消”），面试官想听更多自然会追问。

2.2 示范一：“MHA、MQA、GQA 怎么选？”

结论：现代大模型基本都用 GQA，它在质量上接近 MHA，在推理显存上接近 MQA。

动机：自回归解码时每一步都要读一遍所有历史 token 的 K 和 V。KV Cache 的大小和 KV 头的个数成正比，它决定了一张卡能同时服务多少条序列；而解码是访存瓶颈，读得越多越慢。

机制：MHA 每个查询头有自己的 K、V；MQA 所有查询头共享一套 K、V；GQA 把查询头分成 $G$ 组，组内共享。以 70B 模型为例（80 层、64 个查询头、头维 128），每个 token 的 KV 在 MHA 下是 2.5 MiB，GQA 8 组是 320 KiB，省了 8 倍。已经训好的 MHA 模型可以把组内的 K、V 投影取平均，再用约 5% 的预训练算力继续训练，转换成 GQA。

代价：GQA 省的是 KV Cache 和解码时的访存，不省注意力的计算量（查询头一个没少），所以训练速度几乎不变。MQA 压得太狠，质量会掉、训练也不太稳。Llama 2 70B、Llama 3 全系列都用 8 个 KV 头。

数字出处：out_w5day5.txt 第 9 组；机制与代价：Week 1 Day 4 §2.3–2.6。

2.3 示范二：“DPO 和 PPO 有什么区别？”

结论：两者优化的是同一个目标（最大化奖励、同时用 KL 约束不偏离参考模型）。PPO 先训奖励模型再在线采样做强化学习；DPO 利用这个目标的闭式解，把问题变成在偏好对上的一个分类损失，不需要奖励模型，也不需要采样。

动机：PPO 要同时放四个模型（策略、价值、参考、奖励），8B 模型光状态显存就约 269 GiB，而且超参敏感、训练不稳。

机制：KL 约束目标的最优解是 $\pi^*(y|x)\propto\pi_{\text{ref}}(y|x)\exp(r(x,y)/\beta)$。反过来写，$r=\beta\log\frac{\pi^*}{\pi_{\text{ref}}}+\beta\log Z(x)$。代入 Bradley-Terry 模型时只用到两个回答的奖励之差，难算的 $Z(x)$ 正好抵消，剩下的只和策略、参考模型的对数概率有关。

代价：DPO 是离线的，只在固定的偏好数据上学，数据分布和当前策略差得越远越不准；被选中回答的概率也可能一起下降。需要在线探索、奖励能可靠打分的场景（比如有标准答案的数学和代码），在线 RL 仍然更强，这就是 GRPO 用在推理模型上的原因。显存上 DPO 约 135 GiB（8B），是 PPO 的一半。

数字出处：Day 3 §2.5；推导：Week 3 Day 4 §1.2、§2.1–2.2；局限：Week 3 Day 4 §3.3–3.4、§5.2。

2.4 遇到不会的题

一定会遇到。处理得好反而是加分项，因为它展示了你怎么面对未知。三步：

1. 承认边界：“这个我没有直接读过论文。“一句就够，不要道歉三遍。
2. 从已知推：“从名字和场景看，它要解决的应该是……；如果我来设计，会……”
3. 说出怎么验证：“我会去看它的论文里有没有和 X 的对比实验。”

例子：面试官问”Ring Attention 是什么？“假设你没读过。

“这篇我没读过，我从名字推一下。它应该是解决超长序列放不进一张卡的问题。注意力的难点是每个查询要看到所有的 K、V。如果把序列切到多张卡上，可以让各卡的 K、V 块沿着一个环依次传下去，每张卡用自己的查询和收到的块算部分结果。部分结果怎么合并？用 FlashAttention 里的 online softmax：维护最大值和归一化常数，新块来了就修正旧结果，最终结果是精确的。通信可以和计算重叠。我会去看它的通信开销是不是被计算完全掩盖了。”

这段推测和 Ring Attention 的真实做法基本一致。它不是靠运气：online softmax（Week 1 Day 6 §3.2）本来就是”分块合并注意力”的通用工具。把旧知识当工具箱用，是不会的题也能答好的原因。

2.5 常见失分点

§3 估算题

3.0 方法与常数

五步：写假设 → 拆成几个数相乘 → 保留一两位有效数字 → 用另一条路交叉验证数量级 → 说出没算进去的东西。假设说清楚，算错一步也只扣一步的分；假设不说，算对了面试官也不知道你对在哪。

要背下来的常数（每一个都在前几周推过）：

3.1 七道题

E1　全量微调一个 7B 模型要多少显存？LoRA 呢？QLoRA 呢？

• 假设：Llama 2 7B（6.74B 参数，32 层，$d=4096$）；bf16 混合精度 + AdamW；先不算激活。
• 全量：$6.74\times10^9\times16$ 字节 = 100.4 GiB。一张 80 GB 放不下；ZeRO-3 切到 8 张卡，每张 12.6 GiB，再加激活。
• LoRA（$r=16$，注入 q/k/v/o）：每个矩阵 $r(d_{in}+d_{out})=16\times8192$，每层 4 个、32 层，共 16.8M 个可训练参数（0.25%）。显存 ≈ 冻结的 bf16 底座 12.6 GiB + LoRA 的 16 字节/参数 0.25 GiB。
• QLoRA：底座 NF4 + 双重量化，约 4.127 bit/参数，3.24 GiB + LoRA 0.25 GiB。一张 24 GB 的消费级显卡就放得下。
• 没算的：激活。序列 4096、batch 1 时，用 FlashAttention 约 17 GiB，再开梯度检查点约 1.5 GiB（Week 2 Day 4 §4.1）。
• 常见追问：“为什么 Adam 是 8 字节？“（一阶矩 $m$、二阶矩 $v$ 各一个 fp32）“为什么要 fp32 主权重？”（§5 T4）

E2　70B 模型（80 层、8 个 KV 头、头维 128），bf16，batch 32、长度 8192，KV Cache 多大？

• 每 token：$2\times80\times8\times128\times2$ 字节 = 320 KiB；乘以 $8192\times32$ = 80 GiB，和 bf16 权重（约 130 GiB）一个量级。
• 如果是 MHA（64 个 KV 头）：640 GiB。GQA 省了 8 倍。
• 常见追问：“还能怎么省？” KV 量化（fp8 再省一半）、PagedAttention 减少碎片（Week 3 Day 1 §3.3）、滑动窗口注意力、更激进的共享（Week 1 Day 4 §2.7）。

E3　在 256 张 H100 上训练一个 7B 模型 2T token，要多久？

• $C=6ND=6\times6.74\times10^9\times2\times10^{12}=8.09\times10^{22}$ FLOPs。
• 每秒有效算力 $256\times989\times10^{12}\times0.4$；相除得约 80 万秒 ≈ 9.2 天。
• 交叉验证：换成 A100（312 TFLOPS）、同样 40% MFU，约 18.0 万 GPU 小时；Llama 2 论文报告 7B 用了 18.4 万 A100 GPU 小时。估算和真实数字差不到 3%（MFU 恰好猜得准，不要指望每次都这么巧）。
• 没算的：故障重启、存检查点、评测，真实项目留 20%–50% 余量。
• 常见追问：“2T 是 Chinchilla 最优吗？“不是。最优约 $20\times6.74\text{B}=135\text{B}$，2T 是它的 15 倍。这是为了推理便宜而过度训练：同样的推理成本下，小模型多训一些更划算（Week 2 Day 1 §4.1–4.2）。

E4　一张 H100 能同时服务多少条 4K 长的序列？batch 1 时每秒能生成多少 token？

• 显存 80 GB，留 10% 给激活和碎片，再减去 bf16 权重，剩下的给 KV Cache。
• Llama 2 7B（MHA，32 个 KV 头）：权重 13.5 GB，剩约 54.5 GiB；每 token 512 KiB → 约 11 万个 token → 4K 序列约 27 条。
• Llama 3 8B（GQA，8 个 KV 头）：权重 16.1 GB，剩约 52.1 GiB；每 token 128 KiB → 约 43 万个 token → 约 104 条。
• batch 1 解码：每个 token 至少把 13.5 GB 权重读一遍，÷ 3.35 TB/s ≥ 4.0 ms，即 ≤ 249 token/s。
• 结论：并发数由 KV Cache 决定；解码受访存限制，batch 从 1 增大时每步耗时几乎不变，总吞吐几乎正比于并发数。所以 GQA 的价值不只是”省显存”，而是”同一张卡多服务近 4 倍的用户”（8B 的权重更大，所以略少于 4 倍）。
• 常见追问：“为什么 batch 大了每步耗时几乎不变？“屋脊点约 295 FLOP/字节，batch 1 解码的算术强度约 1 FLOP/字节，离屋脊点很远，算力大部分闲着（Week 1 Day 4 §1.5）。

E5　RAG 和”把整份文档塞进上下文”，每 1000 次问答的输入 token 差多少？

• RAG：系统提示 500 + 8 块 × 400 + 问题 50 = 3,750 token/次 → 1000 次 3.75M。
• 长上下文：一份 20 万 token 的文档 + 问题 → 1000 次 200M，是 RAG 的 53 倍。
• 常见追问：“有提示缓存呢？“缓存能给重复的前缀打折，但每次仍要付读取费，注意力的计算和延迟也还在。资料少、调用少、问题需要通读全文时，长上下文反而合适（Week 4 Day 1 §1.3）。

E6　一个智能体跑 20 步，系统提示加工具说明 5000 token，问题 100 token，每步新增 800 token，累计输入多少？提示缓存能省多少？

• 第 $t$ 步的输入是 $5100+800t$，$t=0,\dots,20$；累计 $(T+1)(P+u)+800\cdot\frac{T(T+1)}{2}$ = 275,100 token。随步数平方增长（Week 4 Day 3 §2.3）。
• 提示缓存（上一轮发过的前缀按 10% 计价，新增部分全价）：等价于 46,500 token，省 83%。（简化：没算写入缓存的溢价和缓存过期，各家规则不同。）
• 常见追问：“步数再多怎么办？“压缩历史（总结旧的观察）、子智能体隔离上下文（Week 4 Day 4 §5.1、§6.1）。

E7　两个系统准确率都在 70% 左右，想分辨出 3 个百分点的差别，评测集要多大？

• 5% 显著性、80% 功效。不配对（两个系统各测一批题）：$n\approx(1.96+0.84)^2\cdot\frac{2p(1-p)}{\Delta^2}$ ≈ 3,659 道/系统。
• 配对（同一批题），设两个系统意见不一的题占 20%：$n\approx(1.96+0.84)^2\cdot\frac{0.2}{\Delta^2}$ ≈ 1,742 道（Week 4 Day 5 §3.2）。
• 反过来：50 道题的黄金集，不配对只能分辨约 26 个百分点、配对约 18 个百分点的差别。
• 结论：几十道题的黄金集用来发现大问题（回归测试、明显的退化），分辨几个点的改进要上千道题；配对设计能把题数压掉一半左右。
• 常见追问：“为什么配对更省？“难题两个系统都错、易题都对，这些题对比较没有贡献；配对只看分歧题，把题目难度的方差消掉了。

§4 系统设计：公司内部知识库问答

题目：“设计一个公司内部的知识库问答助手。“面试官会给 30–40 分钟，期间不断打断追问。

答题框架（七步，后面逐步展开）：澄清需求 → 定义成功 → 基线方案 → 算数字 → 模型与微调 → 评测 → 安全、上线与迭代。

为什么按这个顺序：设计题最常见的失败是一上来就画架构图。需求没问清楚，架构再漂亮也可能是错的（比如文档有严格的权限分级，而你的方案没考虑）。先问清楚、再定指标，后面每个选择才有依据。

4.1 澄清需求（5 分钟）

4.2 定义成功

离线指标（上线前、每次改动后都测）：

• 检索：召回率@k、MRR（Week 4 Day 2 §3.1、§3.3）。
• 生成：答案正确率、忠实度（每句话都有检索到的资料支持）、引用准确率、资料不足时的拒答正确率。
• 分项：答错时是检索没找到，还是找到了没用好（Week 4 Day 6 §3.3）。

线上指标：点赞 / 点踩率、追问率（用户换个说法再问，说明没答好）、转人工率、P95 延迟、每问成本。

4.3 基线方案

先给出最简单、能工作的方案，再讲怎么改进。面试官想看你能不能先交付，再迭代。

离线：建索引

文档 → 解析（PDF、表格转 Markdown）→ 清洗 → 切块（500 token，重叠 50，每块前面加上"文档标题 > 章节标题"）
     → 嵌入（多语言模型）→ 向量索引
     → 分词 → BM25 倒排索引
     → 元数据：部门、权限组、更新时间、来源链接

在线：回答一个问题

用户问题（+ 对话历史）
  → 查询改写：把"那它的报销上限呢？"改写成完整问题
  → 混合检索：BM25 top-50 + 稠密 top-50，RRF 融合，**按用户权限过滤**
  → 交叉编码器重排，取前 8 块
  → 拼提示：资料带编号；要求逐句引用；资料不够就说不知道
  → LLM 生成（流式输出）
  → 检查引用的编号是否存在、引用的块是否真的包含相关内容

每一步的理由（面试时挑面试官追问的讲）：

• 切块 + 标题面包屑：太长的块会稀释语义（Week 4 Day 1 §2.1）；块离开了原文会丢主语，补上标题能找回来（Week 4 Day 2 §5.3）。
• 混合检索：内部文档里有大量专有名词、工单号、产品代号，稠密检索容易漏，BM25 擅长；同义改写则靠稠密检索。两者的分数不能直接相加，用只看名次的 RRF（Week 4 Day 2 §2.1–2.3）。
• 权限过滤放在检索阶段：不能先检索再让模型”别说出来”。没有权限的块根本不能进提示，否则一次提示注入就能把它套出来。
• 重排：双塔模型把问题和文档分开编码，看不到两者的细粒度交互；交叉编码器看得到，但太贵，只能用在召回的几十个候选上（Week 4 Day 2 §4.1–4.2）。
• 要求引用、允许拒答：可审计，用户能点进原文核对；拒答比编一个答案代价小得多（§4.1 最后一行）。

4.4 算数字

以下全部来自 w5day5_checks.py 第 8 组：

用 API 时的成本：每天成本 = 202M × 输入单价 + 15M × 输出单价。单价各家不同、变化很快，面试时说公式、再代入你知道的当前价格即可。减少输入 token 是最直接的省钱办法：少放几块（8 → 5）、块更短、系统提示走提示缓存。

这一节的结论：这个系统不是算力问题。索引几 GB，推理一两张卡。质量和成本的关键在”检索准不准”和”答案忠不忠实”。面试时主动说出这个判断，比报一堆数字更有分量。

4.5 模型选型与微调

选模型：

• 先用最强的模型确定质量上限（如果合规允许，直接用 API），把评测集和管线搭起来。
• 再看能不能换小：用评测集比较 14B、8B 的开源模型；差距大的话，用强模型生成的回答做 SFT 蒸馏（Day 2 §3.4 的第二种”蒸馏”）。
• 嵌入模型和重排模型要支持中英混合，按评测集上的召回率选，不按排行榜选（排行榜的数据分布和你的不一样）。

什么时候微调，微调什么（Week 4 Day 1 §1.3）：

• 不要用微调注入公司知识：知识天天变、需要引用和权限控制，微调都做不到，还会增加幻觉。
• 值得微调的三样：
  1. 嵌入模型：用”员工真实问题 → 被点开的文档”做正样本对，InfoNCE 训练（Week 4 Day 1 §3.3）。领域内的检索往往是收益最大的一处。
  2. 重排模型：同样的数据，训练交叉编码器。
  3. 生成模型的行为：引用格式、资料不够时拒答、公司的术语和语气。几千条高质量样本的 LoRA 就够（Week 2 Day 6 §1.1、§3）。

4.6 评测

• 黄金集：从真实日志里抽问题（脱敏），请各部门的专家写参考答案和”应该检索到的文档”。先做 300–500 道覆盖主要部门和问题类型；§3 E7 说明，它只能发现大的退化，要分辨几个点的改进需要配对比较、上千道题。
• 分项评测：检索看召回率@k；生成看正确率和忠实度。答错的题先分类：检索没找到、找到了但排太后、放进去了但没用上、模型自己编了（Week 4 Day 6 §3.3）。每一类的修法完全不同。
• LLM 评委：用固定的评分标准逐条打分，交换顺序消除位置偏差，先在 100 道题上和人工标注比一致性（κ），够高才用它替代人工（Week 4 Day 6 §1.4–1.5、§2.1–2.4；Week 4 Day 5 §2.2）。
• 回归测试：每次改切块、换模型、改提示，都在黄金集上跑一遍，配对比较新旧版本。
• 线上 A/B：小流量对比点赞率和追问率。

4.7 安全、上线与迭代

安全：

• 权限：检索时按用户的权限组过滤（§4.3）；日志也按权限存。
• 提示注入：任何员工都能编辑 wiki，文档里可能藏着”忽略之前的指令……”。资料放在明确的分隔符里、告诉模型资料只是数据；如果助手还能调用工具（发邮件、改工单），要警惕”私有数据 + 不可信内容 + 对外通信”三者同时出现（Week 4 Day 3 §6.1–6.2）。
• 隐私：工单里可能有个人信息，建索引前脱敏。

上线：

• 延迟：流式输出；检索和改写并行；重排模型用小的。
• 缓存：系统提示走提示缓存；高频问题（“年假怎么请”）做答案缓存，但要随文档更新失效。
• 可观测性：每次请求记录改写后的查询、检索到的块、重排分数、各阶段耗时、token 数。答错时能定位是哪一步的锅。

迭代：点踩的问题 → 按 §4.6 的分类定位 → 修 → 加进黄金集。文档更新时增量重建对应的块，删除文档时同步删除它的块（否则会引用已经作废的制度）。

4.8 面试官常见的追问

4.9 同一个框架，换个场景

§5 分层题库

每道题给出要点（三分钟内应该说到的）、追问和出处。题号和 code/w5d5_mock_interview.py 里的题库一一对应，程序会按你的历史表现抽题。

怎么用：先遮住要点，自己口头作答（3 分钟，录音），再对照要点逐条打勾。漏掉的要点就是要回出处补的地方。

5.1 架构层

A1　手推注意力，并分析复杂度

• 要点：$Q=XW_Q$、$K=XW_K$、$V=XW_V$；$S=QK^\top/\sqrt{d_k}$；$P=\mathrm{softmax}(S)$（按行）；$O=PV$。时间：$QK^\top$ 和 $PV$ 各约 $2n^2d$ FLOPs，投影约 $8nd^2$；显存要存 $n\times n$ 的注意力矩阵。序列短时投影主导，长序列时 $n^2$ 主导。训练时所有位置并行，推理时只能一个一个生成。
• 追问：反向传播怎么推？长序列时先撞墙的是算力还是显存？
• 出处：Week 1 Day 1 §1.3、§2.3、§5.1–5.4

A2　为什么除以 $\sqrt{d_k}$

• 要点：$q\cdot k$ 的方差是 $d_k$；除以 $\sqrt{d_k}$ 让方差回到 1；否则 softmax 饱和，雅可比 $\mathrm{diag}(p)-pp^\top\to0$，梯度消失。不是为了防止溢出（那是减最大值解决的）。
• 追问：和采样温度是一回事吗？（§1.2 第 4 层）
• 出处：Week 1 Day 1 §2.1

A3　MHA、MQA、GQA 怎么取舍

• 要点：见 §2.2。KV 头数决定 KV Cache 和解码访存；GQA 质量接近 MHA、显存接近 MQA；可以从 MHA 均值池化 + 约 5% 继续训练转换；不省注意力的计算量。
• 追问：为什么 GQA 对训练速度几乎没有帮助？
• 出处：Week 1 Day 4 §2.1–2.6

A4　RoPE 的原理，以及为什么外推会失败

• 要点：把 $q$、$k$ 的维度两两配对，第 $i$ 对按 $m\theta_i$ 旋转，$\theta_i=\text{base}^{-2i/d}$；旋转后的内积只依赖相对位置 $m-n$。每层作用在 $q$、$k$ 上，不加到嵌入上，也不旋转 $v$。外推失败：低频的维度在训练长度内连一圈都没转完，超出后出现没见过的角度。修法：位置插值（压缩位置）、NTK-aware（改 base）、YaRN（按频率分段处理），之后通常还要用长文本继续训练。
• 追问：“能算”和”能用”为什么不是一回事？
• 出处：Week 1 Day 5 §2.2–2.3、§3.1–3.7

A5　KV Cache 的显存怎么算，为什么解码是访存瓶颈

• 要点：每 token $2\times L\times n_{kv}\times d_{head}\times$ 字节数；70B、batch 32、8K：80 GiB（§3 E2）。解码每一步都要读全部权重和 KV，batch 1 的算术强度约 1 FLOP/字节，远低于 H100 约 295 的屋脊点；prefill 一次处理整段提示，是计算瓶颈。
• 追问：怎么提高解码吞吐？（增大 batch、GQA、量化、推测解码）
• 出处：Week 1 Day 4 §1.3–1.5；Day 3 §2.3

A6　Pre-LN 和 Post-LN

• 要点：Post-LN 是 $\mathrm{LN}(x+F(x))$，归一化在残差路径上，深层梯度要穿过很多 LN，需要 warmup，层数多了难训；Pre-LN 是 $x+F(\mathrm{LN}(x))$，残差是一条干净的恒等路径，梯度直达，训练稳定。代价：残差流的范数随深度增长，最后要再加一个 LN。现代模型用 Pre-LN + RMSNorm（去掉减均值，更省）。
• 追问：为什么 LN 的输入越大，穿过它的梯度越小？
• 出处：Week 0 Day 2 §4.5；Week 1 Day 2 §2.2–2.5

A7　FlashAttention 在优化什么

• 要点：不减少 FLOPs（反向还要重算），减少的是显存读写：不把 $n\times n$ 的注意力矩阵写回显存。做法：分块 + online softmax（维护最大值和归一化常数，新块来了修正旧结果），反向时重算 $P$。结果是精确的，不是近似；额外显存从 $O(n^2)$ 降到 $O(n)$。
• 追问：它和 KV Cache 有什么区别？（§2.5）它和稀疏、线性注意力有什么区别？
• 出处：Week 1 Day 6 §3.1–3.4

A8　MoE 的总参数和激活参数

• 要点：Mixtral 8x7B 总参数 46.7B，每 token 激活 12.9B（选 2 个专家）。只有 FFN 复制了 8 份，注意力和嵌入共享，所以不是 56B，激活也不是 14B。计算量看激活参数，显存看总参数；解码时 batch 大了几乎每个专家都会被用到，访存优势消失。训练难点：路由坍缩，用负载均衡损失和容量因子解决。
• 追问：负载均衡损失为什么能把负载推均匀？
• 出处：Week 2 Day 2 §2.1–2.3、§3.1–3.3

A9　推测解码为什么不改变输出分布

• 要点：小模型（草稿）先猜 $k$ 个 token，大模型一次前向并行验证；对每个猜测以 $\min(1,p/q)$ 接受，拒绝时从 $(p-q)^+$ 归一化后重采。可以证明输出分布恰好是 $p$。加速的原因：解码是访存瓶颈，验证 $k$ 个 token 和生成 1 个的耗时差不多；加速比取决于接受率。
• 追问：草稿模型和目标模型差得太远会怎样？
• 出处：Week 3 Day 1 §3.2

5.2 训练层

T1　7B 模型全量微调的显存账

• 要点：§3 E1。16 字节/参数 → 100 GiB，再加激活；ZeRO-3 切到 8 卡；梯度检查点把激活从 17 GiB 降到 1.5 GiB。
• 追问：激活显存和什么成正比？
• 出处：Week 2 Day 4 §4.1–4.2；§3

T2　LoRA 的原理与超参

• 要点：$W'=W+\frac{\alpha}{r}BA$，$B\in\mathbb R^{d\times r}$、$A\in\mathbb R^{r\times k}$，$r\ll d$。$B$ 初始化为 0，训练开始时模型和底座完全一样。动机：微调需要的改动是低秩的。可以合并回 $W$，推理零开销。超参：$r$ 常取 8–64；$\alpha/r$ 让换 $r$ 时不用重调学习率；学习率比全量大一个数量级（$10^{-4}$ 量级）；注入全部线性层通常好于只注入 q、v。
• 追问：$A$ 和 $B$ 为什么不能都初始化为 0？
• 出处：Week 2 Day 6 §3.1–3.5、§1.5

T3　QLoRA 的三个组件

• 要点：① NF4：按正态分布的分位点放 16 个码值，配合每 64 个数一个缩放因子；② 双重量化：把缩放因子本身再量化，额外开销从 0.5 降到约 0.127 bit/参数；③ 分页优化器：显存峰值时把优化器状态换到 CPU 内存。计算时把权重反量化到 bf16 再算，梯度只流向 LoRA。
• 追问：训练完怎么合并？（合并到 4-bit 底座会引入量化误差，要合并到原始的 bf16 权重）
• 出处：Week 2 Day 5 §4.1–4.3；Week 2 Day 6 §4.1–4.3

T4　BF16 和 FP16

• 要点：BF16 是 8 位指数、7 位尾数：范围和 FP32 一样，精度低；FP16 是 5 位指数、10 位尾数：精度高，范围小（最大 65504），小梯度会下溢，要配合损失缩放。BF16 不需要损失缩放，但 1 附近能分辨的最小变化只有 $2^{-7}\approx0.008$，学习率 × 梯度这样的小更新会被舍入掉，所以要保留 FP32 主权重。
• 追问：混合精度训练里哪些操作要保持 FP32？
• 出处：Week 2 Day 4 §3.1–3.3

T5　ZeRO 的三个阶段

• 要点：数据并行时每张卡都存一份完整的状态（16 字节/参数）。ZeRO-1 切优化器状态（16 字节里有 12 字节是它，所以收益最大）；ZeRO-2 再切梯度；ZeRO-3 再切参数，只有它让每卡显存随卡数线性下降。代价：ZeRO-3 的通信量约为 DDP 的 1.5 倍。FSDP 就是 ZeRO-3 的 PyTorch 实现。
• 追问：ZeRO 和张量并行、流水线并行有什么区别？
• 出处：Week 2 Day 4 §5.1–5.5

T6　梯度检查点

• 要点：不存每层的中间激活，只存每层的输入，反向时重算这一层的前向。计算从 3 份变 4 份（+33%），激活显存降一个数量级。显存不够时通常比减小 batch 更划算。
• 追问：为什么是 +33% 而不是 +100%？
• 出处：Week 2 Day 4 §4.2

T7　SFT 的 loss mask

• 要点：只在助手回答的 token 上算损失，系统提示和用户输入的标签设为忽略（如 −100）。理由：不需要学用户怎么提问，把容量用在回答上；多轮对话里每一轮回答都算。chat template 必须和推理时一致。打包（packing）多条样本时，注意不要让注意力跨样本、损失也按样本隔离。
• 追问：如果忘了加 mask，会出现什么现象？
• 出处：Week 2 Day 6 §1.2–1.4

T8　数据质量和数量

• 要点：SFT 阶段质量远比数量重要：LIMA 用 1000 条精选样本；QLoRA 论文里 9k 条的 OASST1 胜过 45 万条的 FLAN v2 子集。“表面对齐假说”：知识来自预训练，SFT 学的是格式和行为。预训练阶段数量仍然关键（缩放律），但要先去重、质量过滤。合成数据要防止模型坍缩。
• 追问：怎么判断一份 SFT 数据的质量？
• 出处：Week 2 Day 6 §1.1；Week 2 Day 4 §1.2–1.3；Day 1 §4.2

T9　Chinchilla 缩放律，以及为什么现在的模型都”过度训练”

• 要点：固定算力 $C\approx6ND$ 下，最优的参数量和 token 数同比例增长，约 20 token/参数。但它只对训练最优；模型要被推理很多次，小模型多训更划算。Llama 3 8B 用了 15T token，约 1875 token/参数。
• 追问：Kaplan 当年为什么得出了不同的结论？
• 出处：Week 2 Day 1 §3.1–3.4、§4.1–4.2

5.3 对齐层

R1　RLHF 三个阶段的数据流

• 要点：① SFT：人写的示范回答；② 奖励模型：同一个提示的多个回答由人排序，用 Bradley-Terry 损失训练；③ RL：只需要提示，策略采样回答，奖励模型打分，减去对参考模型（SFT 模型）的 KL 惩罚，用 PPO 更新。
• 追问：为什么不直接用第 ① 步的数据一直做 SFT？（比较比写容易；SFT 只能模仿）
• 出处：Week 3 Day 2 §3.1、§1.1–1.3

R2　奖励模型的损失

• 要点：$P(y_w\succ y_l)=\sigma(r_w-r_l)$，损失 $-\log\sigma(r_w-r_l)$；梯度按”排错的程度”加权。只有差值有意义（整体平移不变）。结构：语言模型 + 标量头，取最后一个 token。留出集准确率通常只有 65%–75%，因为标注者之间本来就不一致。
• 追问：奖励模型会学到标注者的哪些偏见？（比如偏爱长回答）
• 出处：Week 3 Day 2 §2.2–2.5

R3　PPO 的四个模型

• 要点：策略（训练）、价值 / 评论家（训练）、参考（冻结）、奖励（冻结）。8B 模型状态显存约 269 GiB。裁剪目标限制每次更新的幅度，让同一批样本能多用几次；价值函数用 GAE 估计优势。
• 追问：KL 惩罚加在哪？（逐 token 加进奖励）
• 出处：Week 3 Day 3 §3.2–3.3、§4.3；Day 3 §2.5

R4　DPO 的推导思路

• 要点：见 §2.3。KL 约束目标的闭式解 → 反解出奖励 → 代入 Bradley-Terry，$Z(x)$ 抵消 → 只依赖对数概率之差的分类损失。梯度按 $\sigma(-\Delta)$ 加权：排错越严重的样本，权重越大。
• 追问：β 大了、小了分别会怎样？
• 出处：Week 3 Day 4 §1.2、§2.1–2.3、§3.2

R5　KL 惩罚与 reward hacking

• 要点：奖励模型只是人类偏好的代理，优化得太狠会钻它的空子（古德哈特定律）：真实质量先升后降。常见现象：回答越来越长、迎合用户、格式套路。KL 约束让策略留在奖励模型可信的区域附近。工具箱：KL 惩罚、奖励模型集成、长度惩罚、定期用新数据更新奖励模型、提前停止。
• 追问：怎么在训练中发现 reward hacking？
• 出处：Week 3 Day 2 §3.2–3.4

R6　GRPO 去掉了什么

• 要点：去掉了价值网络：同一个提示采样一组回答，用组内奖励的均值和标准差算优势 $\hat A_i=(r_i-\bar r)/\mathrm{std}$。KL 作为损失项而不是加进奖励。显存从 36 降到 20 字节/参数。问题：全对或全错时优势全为 0、没有信号（DAPO 用动态采样过滤）；除以标准差和按长度归一化带来偏置（Dr. GRPO）。
• 追问：为什么价值网络在 LLM 上难训？
• 出处：Week 3 Day 5 §3.1–3.4、§4.1–4.2

R7　RLVR 的适用边界

• 要点：适用于答案能被程序判定的任务：数学（核对最终答案）、代码（跑测试）、格式。不适用于开放式写作、有用性这类主观质量，仍然需要奖励模型或评委。风险：验证器被钻空子（比如改测试）；题太难时全错、没有信号。研究发现 RL 主要提高 pass@1，大 $k$ 时的 pass@k 未必提高，更像是”磨尖”而不是”拓展”。
• 追问：怎么给一道证明题设计奖励？
• 出处：Week 3 Day 5 §2.1–2.3、§5.1–5.2

R8　测试时缩放有哪些方法

• 要点：并行：采样多个再挑（多数投票、best-of-n、加权投票）；串行：让模型想得更久（预算强制）；搜索：过程奖励模型引导逐步搜索。多数投票会饱和（模型系统性地错时，投票救不回来）；验证器也会被钻空子。计算最优的分配：简单题少采样，难题多采样。
• 追问：什么时候花算力在测试时，比花在训练时更划算？
• 出处：Week 3 Day 6 §2.1–2.4、§3.1、§4.1–4.3

5.4 应用层

P1　RAG 还是微调

• 要点：要注入知识（经常变、要引用、要权限控制）→ RAG；要改变行为（格式、风格、任务能力）→ 微调；资料少、调用少、需要通读全文 → 长上下文。实证：同样的新知识，RAG 一致好于微调；SFT 里学模型原本不知道的知识，会增加幻觉。两者常一起用。
• 追问：模型有 1M 的上下文窗口，为什么还要 RAG？（§3 E5）
• 出处：Week 4 Day 1 §1.3

P2　混合检索与 RRF

• 要点：BM25 擅长精确词、稀有名词、编号；稠密检索擅长同义改写。两边的分数尺度不可比，直接加权相加很脆弱；RRF 只看名次：$\sum 1/(k+\text{rank})$，$k$ 常取 60。两个系统互补时才有收益：在我们的讲义上，LSA 和 BM25 用的是同一套词频统计，融合几乎没有提升。
• 追问：$k$ 取大、取小分别意味着什么？
• 出处：Week 4 Day 2 §2.1–2.3、§6

P3　重排放在哪里

• 要点：两阶段：召回（双塔或 BM25，便宜，取前 50–100）→ 重排（交叉编码器把问题和文档一起编码，准但贵）→ 前几块交给 LLM。交叉编码器不能用在全库上：每个查询要对每个文档跑一次前向。重排的上限是召回阶段的召回率。折中：ColBERT 的晚交互；也可以用 LLM 重排。
• 追问：召回多少个候选再重排？怎么定？
• 出处：Week 4 Day 2 §4.1–4.4

P4　怎么控制智能体的错误累积

• 要点：每步成功率 0.95 时，20 步全对只有 0.36。办法：减少步数（能用固定工作流就别用自由的智能体、工具设计得更强）；每步检查 + 重试；护栏（最大步数、循环检测、预算上限）；不可逆操作前人工确认；用 pass^k 衡量一致性。
• 追问：检查器的召回率不完美时，重试能把成功率提高到多少？
• 出处：Week 4 Day 4 §3.1–3.4、§4.1–4.3

P5　ReAct 循环

• 要点：思考 → 行动（调用工具）→ 观察（工具返回）→ 再思考。把推理和行动交替：推理指导下一步做什么，观察纠正推理里的错误。实现要点：解析模型输出的行动；在 “Observation:” 处截断，防止模型自己编造观察结果；设定停止条件。
• 追问：ReAct 和原生的函数调用接口是什么关系？
• 出处：Week 4 Day 4 §2.1–2.4

P6　LLM 当评委的偏差与缓解

• 要点：位置偏差（交换顺序评两次，只算一致的结果）；冗长偏差（评分标准里写明不奖励长度、做长度控制）；自我偏好（用不同家族的模型当评委，或多评委集成）；其他：格式、权威语气、评委自身能力不够。最重要的一步：先和人工标注比一致性，够高才用。
• 追问：Chatbot Arena 的排名是怎么算出来的？（Elo 是对 Bradley-Terry 似然的随机梯度上升）
• 出处：Week 4 Day 6 §2.1–2.5、§1.4–1.5

P7　MCP 是什么，解决什么问题

• 要点：工具接入的标准协议：N 个应用 × M 个工具，原本要写 N × M 个适配，标准化后变成 N + M。架构：宿主、客户端、服务端；基于 JSON-RPC 2.0，流程是初始化 → 列出工具 → 调用工具。它和函数调用的关系：MCP 负责”工具从哪来、怎么调”，函数调用负责”模型怎么决定调哪个”。安全：工具说明和返回结果里都可能藏着提示注入。
• 追问：什么是”致命三要素”？
• 出处：Week 4 Day 3 §5.1–5.4、§6.1–6.2

P8　怎么评测一个 RAG 系统

• 要点：分项：检索（召回率@k、MRR、NDCG）和生成（正确率、忠实度、引用准确率）分开测；答错时先判断是哪一环的问题。黄金集要有”应该检索到的文档”；要包含”资料里没有答案”的题。LLM 评委要先和人工对齐。
• 追问：只有最终答案的标注，怎么评检索？
• 出处：Week 4 Day 6 §3.3；Week 4 Day 2 §3.1–3.3

5.5 前沿

F1　ViT 怎么把图像变成 token，视觉语言模型怎么接

• 要点：把图切成 16×16 的块，每块展平后线性投影（等价于步长 16 的卷积），加位置嵌入，送进标准的 Transformer。归纳偏置比 CNN 弱，数据少时不如 CNN、数据多时反超。视觉语言模型两种接法：视觉编码器的输出经过投影层，作为 token 直接拼进 LLM 的输入；或者在 LLM 里加交叉注意力层去看图像特征。
• 追问：为什么 Transformer 能迁移到这么多模态？
• 出处：Day 1 §2.1–2.4

F2　扩散语言模型和自回归模型的区别

• 要点：掩码扩散：随机遮住一部分 token，训练模型预测被遮住的；生成时从全遮住开始，每步揭开一部分。训练目标（按 $1/t$ 加权）等价于”任意顺序的自回归”。优点：一步能生成多个 token、双向上下文。代价：同一步揭开的 token 彼此独立，步数越少质量越差；KV Cache 不能直接用；训练更慢（Day 1 §3.5 的小实验里，扩散模型用 4 倍的步数还略差于自回归）。
• 追问：为什么”先揭开最有把握的位置”不总是更好？
• 出处：Day 1 §3.3–3.6

F3　推理模型是怎么训练出来的

• 要点：R1-Zero 证明了只用规则奖励（格式 + 正确性）做 GRPO，推理能力就能涌现，但可读性差。R1 的配方：冷启动 SFT → 推理数据上的 GRPO → 拒绝采样得到约 60 万条推理数据 + 约 20 万条通用数据做 SFT → 全场景 GRPO。小模型用大模型的推理轨迹做 SFT（蒸馏），比自己做 RL 更有效。
• 追问：“蒸馏”在这里和 DistilBERT 的蒸馏有什么不同？
• 出处：Day 2 §3.4；Week 3 Day 5 §1.3、§5.3

F4　怎么控制模型”想多久”

• 要点：预算强制（模型想停时追加 “Wait” 让它继续，超过预算强行结束）；在提示里告诉模型 token 预算、按难度分配；训练时加长度惩罚。也可以在测试时用 best-of-N 等并行方法增加算力。
• 追问：想得越久一定越好吗？
• 出处：Day 2 §3.3；Week 3 Day 6 §4.3

§A 模拟面试：工具用法与边界

A.1 w5d5_mock_interview.py

流程：显示题目 → 你口头作答，答完按回车（程序计时，超过 3 分钟会提醒）→ 显示要点，逐条输入 y / n 自评 → 记录到 code/logs/interview_history.json。

抽题规则：每道题的权重 = 1 + 2 × (1 − 历史平均得分) + (没答过的题额外 + 1)。没答过和答得差的题更容易被抽到，答得好的题也不会完全消失。这是一个最简单的间隔重复（Day 3 §A）。

边界：

• 自评是诚实系统：程序没法判断你说得对不对，只能记录你给自己打的分。宁可打低，不要打高。
• 要点清单是最低要求，不是全部。说到了要点但讲不清楚，也该打 n。
• 历史文件是普通 JSON，想重来就删掉它。

A.2 让 LLM 当面试官

学习计划建议”可以让 AI 当面试官，但要口头作答”。一个可用的提示：

你是一位大模型方向的面试官。每次只问我一道题，等我回答后：
1. 按"结论、动机、机制、代价"四项逐项打分（0–2 分），指出缺了什么；
2. 追问一个更深的问题（参考"为什么 → 为什么 → 和什么有关"的追问链）；
3. 如果我说错了，直接指出哪里错，不要客气。
题目范围：<粘贴 §5 的某一层>。

边界：

• LLM 面试官倾向于夸你（迎合）。所以提示里要求它按清单逐项打分、明确指出缺失；它说”很好”时，追问一句”如果满分是 10 分，扣分点在哪”。
• 它的”标准答案”也可能错，特别是具体数字。和讲义冲突时，以讲义的出处和 checks.py 的数字为准，或者自己再推一遍。
• 口头作答后用语音转文字发给它，不要打字作答：打字时你会不自觉地组织和修改，面试时没有这个机会。

A.3 回放清单

听录音时逐项检查：

• 前 15 秒内给出了结论吗？
• 每道题至少有一个具体数字吗？
• 讲了代价或局限吗？
• “嗯""然后""就是”多不多？
• 超时了吗？超时通常是机制部分讲得太散。
• 有没有硬编的地方？

§B 实操

1. 估算题（1h）：§3 的 7 道题，每道限时 5 分钟，纸笔闭卷，再用 python code/w5d5_mock_interview.py --estimate 练一遍数字。
2. 系统设计（1h）：合上文档，用 20 分钟把 §4 讲一遍（录音），对照 §4.1–§4.7 逐项补漏。再挑 §4.9 的一个场景，用同一个框架讲 10 分钟。
3. 模拟面试（2h）：python code/w5d5_mock_interview.py --n 20，每题限时 3 分钟口头作答、录音、自评。
4. 回放与补漏（0.5h）：按 §A.3 的清单听录音；自评低于一半的题回出处重看，明天再抽一次。
5. 挑战（可选）：用 §A.2 的提示让 LLM 面试官做一场 45 分钟的完整面试：2 道估算 + 1 道设计 + 若干概念题。

参考实现：code/w5d5_mock_interview.py。

§C 自测

一场 45 分钟的模拟面试（录音，闭卷）：

1. （3 分钟）为什么现代 LLM 都用 decoder-only 架构？
2. （3 分钟）FlashAttention 和 KV Cache 分别解决什么问题？能不能同时用？
3. （5 分钟）估算：Llama 3 8B 在一张 H100 上，4-bit 权重，batch 1 时每秒最多生成多少 token？bf16 呢？
4. （3 分钟）LoRA 的 $B$ 为什么初始化为 0？如果 $A$、$B$ 都初始化为 0 会怎样？
5. （3 分钟）GRPO 相比 PPO 省了什么？代价是什么？
6. （3 分钟）你的 RAG 助手答错了一道题，按顺序说出你会检查的地方。
7. （20 分钟）设计题：为一家电商公司设计一个能查订单、能处理退货的客服智能体。要求说清楚：工具设计、哪些操作需要人工确认、怎么评测一致性、上线成本。
8. （5 分钟）面试官问了你一个完全没听过的方法（比如”Native Sparse Attention”），按 §2.4 的三步回答。

答案线索：1 → Week 2 Day 1 §1.2；2 → §2.5、Week 1 Day 6 §3.5；3 → Day 3 §2.3（≤ 209 / 834 token/s）；4 → Week 2 Day 6 §3.2；5 → §5 R6；6 → Day 3 §C 第 3 题、§4.6；7 → §4.9、Week 4 Day 4 §3.3、§4.3；8 → 从 Week 1 Day 6 §1 的稀疏注意力出发推。

出关标准

• §3 的 7 道估算题，每道 5 分钟内写出假设并算对数量级
• 能在 20 分钟内把 §4 的设计题讲完，覆盖七步框架，并说出”这不是算力问题”的判断和依据
• python code/w5d5_mock_interview.py --n 20 完成一轮，平均自评得分 ≥ 70%
• 回放录音，每道题都能在 15 秒内给出结论
• §C 的模拟面试完成，录音回放并列出三个最需要改进的地方

疑问清单