[{"content":" 整理日期：2026-08-16 素材来源：\nInference Engineering（Baseten 出品）Ch 5: Quantization \u0026amp; Speculative Decoding：https://inferenceengineering.tech/chapters/techniques/ 配套交互练习 Quantization Quality Estimator：https://inferenceengineering.tech/exercises/quantization-estimator/ Han Song（韩松）MIT 6.5940 TinyML and Efficient AI Computing（EfficientML.ai）课程 业界论文：GPTQ / AWQ / SmoothQuant / LLM.int8() / SqueezeLLM / QuIP# / KIVI / QServe / QLoRA / BitNet b1.58 等 目录 # 怎么用这份笔记 为什么学量化：收益与风险 量化为什么能加速：Prefill 与 Decode 数字格式全景 量化的基本数学与粒度 量化对象与敏感性排序 方法谱系：从 RTN 到 1-bit 质量评估三板斧 交互练习实测：Quantization Quality Estimator 生产建议与决策清单 Han Song MIT 6.5940 课程地图 论文阅读清单 工具与生态 术语速查 参考资料 1. 怎么用这份笔记 #这是一份\u0026quot;教材 + 课程 + 论文\u0026quot;三合一的量化学习路线：\n先读正文（第 2–8 节）：建立量化为什么存在、怎么工作、什么时候会翻车的完整框架，来源是 Inference Engineering Ch 5。 动手玩练习（第 9 节）：打开 Quantization Quality Estimator，对照笔记里的实测表自己调参数。 再看 MIT 课程（第 11 节）：Han Song 的 6.5940 第 5/6 讲讲量化原理与 PTQ/QAT，第 13 讲讲 LLM 量化部署，视频和幻灯片全公开。 按顺序读论文（第 12 节）：先读方法谱系里\u0026quot;一环扣一环\u0026quot;的 5 篇核心论文，再按兴趣扩展。 2. 为什么学量化：收益与风险 #量化是 LLM 推理优化里收益最直接的一招。\n收益：同时改善 TTFT（首 Token 延迟）和 TPS（吞吐），提升吞吐，还为其他优化腾出显存/带宽余量。 风险：一旦量化失当，会实质性地降低输出质量（perplexity 变差、推理/代码任务退化），而且错误是\u0026quot;静默\u0026quot;的——模型不报错，只是变笨。 关键事实：实践中，精度每降低一级，LLM 性能大约提升 30–50%。 章节原话的 Key Takeaway：FP8/MXFP8 是生产环境的甜点区间。权重和激活用 FP8 量化，KV cache 谨慎量化，attention 保持原精度。如果完全不能承受质量风险，本章其余技术（推测解码、缓存等）都是无损的。\n3. 量化为什么能加速：Prefill 与 Decode #后训练量化（PTQ）把权重从原生格式（通常 BF16/FP16）降到更低精度。加速的来源取决于处于推理的哪个阶段：\n阶段 瓶颈 量化带来的收益 Prefill（预填充） 计算密集（compute-bound） 在低精度 Tensor Core 上跑，FLOPS 翻倍（2x） Decode（逐 Token 生成） 访存密集（memory-bound） 权重数据加载量减半，等效带宽翻倍（2x） 所以量化对两类延迟都有帮助：TTFT 受益于更快的矩阵乘，TPS 受益于更少的显存搬运。这也是为什么 4-bit 权重 + 8-bit 激活（W4A8）这类组合在服务系统里成为主流方向。\n4. 数字格式全景 #4.1 格式总览（章节原表） # 名称 位数 首个支持架构 用途 FP16 16 Pascal（2016） 默认推理格式 BF16 16 Ampere（2020） 训练与推理 FP8（E4M3 / E5M2） 8 Hopper（2022） 质量/速度的甜点 MXFP8 8 Blackwell（2024） Microscaling，精度更好 FP4 4 Blackwell（2024） 激进量化 NVFP4 4 Blackwell（2024） FP4 里精度最好（block size 16） 4.2 位布局 #浮点格式 = 符号位（S）+ 指数位（E）+ 尾数位（M）。指数位决定了动态范围——这是浮点相对整数的核心优势：更能表达量化后仍然存在的离群值（outliers）。\n格式 S E M 相对精度（约） 动态范围特点 FP16 1 5 10 高（约 2⁻¹⁰） 与 FP32 相同的精度区间，范围小（max ~65504） BF16 1 8 7 低（约 2⁻⁷） 与 FP32 相同的动态范围，精度粗 FP8 E4M3 1 4 3 中（约 2⁻³） 范围中等（max 448），无 Infinity，单 NaN FP8 E5M2 1 5 2 低（约 2⁻²） 范围接近 FP16（max ~57344），精度粗 FP4（E2M1） 1 2 1 很低 只有 16 种取值（max 6），必须配合块缩放 NVFP4 1 2 1 很低 + 块缩放 block size 16，FP8 E4M3 块缩放 + FP32 张量缩放 MXFP8 / MXFP4 1 4/2 3/1 中/低 + 块缩放 block size 32，E8M0 共享指数缩放 4.3 可表示数值数量（章节原表） # 格式 可表示的不同取值 FP16 65,536 BF16 65,536 FP8（E4M3） 256 FP8（E5M2） 256 FP4 16 NVFP4 16 位数越少，存储和带宽收益越大，但精度风险也越高。\n4.4 FP8 两种变体怎么选（E4M3 vs E5M2） # E4M3：4 位指数 + 3 位尾数，精度更高、范围更小（max 448）。适合权重和激活——它们的值通常集中在较小范围，精度更重要。NVIDIA 推荐 E4M3 用于前向（inference/训练 forward）。 E5M2：5 位指数 + 2 位尾数，范围大（接近 FP16）但精度粗。适合梯度/反向传播，或值域跨度大的场景。 依据：NVIDIA/Arm/Intel 联合白皮书《FP8 Formats for Deep Learning》（arXiv:2209.05433）。\n4.5 MXFP8 / MXFP4 与 NVFP4 的区别 # MX 格式（OCP Microscaling Formats）：一组元素（block size 32）共享一个 E8M0 指数缩放（纯 2 的幂），元素本身仍是指数+尾数格式。用\u0026quot;一组一个缩放\u0026quot;换更细的适配，Blackwell 原生加速。 NVFP4：NVIDIA 在 Blackwell 上的 4-bit 方案。元素是 E2M1（16 种取值），但 block size 缩小到 16，块缩放用 FP8 E4M3（比 E8M0 更细），再加一个 FP32 张量缩放。粒度更细 → 目前 FP4 里精度最好。 一句话：FP8 = 平衡；MXFP8 = FP8 的精度升级；FP4/NVFP4 = 激进压缩，省 75% 权重显存，但必须接受质量验证。\n5. 量化的基本数学与粒度 #5.1 均匀量化公式 #对称量化（最常用）：\nq = clamp(round(x / s), q_min, q_max) s = max|x| / 2^(b-1) 反量化：x ≈ q * s 非对称量化额外有一个 zero-point z：q = clamp(round(x / s) + z, ...)。\n5.2 粒度（Granularity）决定风险与开销 # 粒度 一个 scale 覆盖范围 质量风险 开销 Tensor-level（整层一个 scale） 整个权重矩阵 高 最小 Channel-level（按输出通道） 每行/每列一个 scale 中 低 Block/Group-level（按块） 每 16/32/128 个元素一个 scale 低 更高（scale 也要存储） 粒度越细，质量损失越小，但 scale 本身的存储和计算开销越大。 GPTQ/AWQ/QuIP# 的 4-bit 能逼近 FP16 质量，很大程度靠的就是细粒度分组 + 精心的 scale 选择。\n6. 量化对象与敏感性排序 #Transformer 各组件对量化的敏感度从低到高（章节原表）：\n权重（线性层） —— 最不敏感 激活 —— 有些敏感 KV cache —— 中等敏感（误差会逐 Token 累积） Attention（尤其是 softmax） —— 高度敏感 原因直觉：\n权重是\u0026quot;静态\u0026quot;的，可以用校准数据精调（GPTQ/AWQ），且 outlier 可以单独处理； 激活是\u0026quot;动态\u0026quot;的，每层输入分布未知，LLM 激活还有著名的 outlier 问题（少数维度值巨大），直接量化会毁掉精度（→ SmoothQuant / LLM.int8() 的动机）； KV cache 误差会随着序列变长反复参与计算，错误像滚雪球一样累积； softmax 的指数运算对数值范围极其敏感，所以生产上通常让 attention 留在高精度。 7. 方法谱系：从 RTN 到 1-bit #按\u0026quot;要量化什么、怎么克服误差\u0026quot;这条主线，业界方法可以排成一条清晰的谱系：\n7.1 基线：RTN（Round-to-Nearest）+ 均匀量化 #把权重四舍五入到最近的量化网格。实现最简单，但 4-bit 以下质量崩得快，因为忽略了权重的重要性和分布。\n7.2 权重低比特（Weight-only） # GPTQ（ICLR 2023）：逐层量化 + 用二阶 Hessian 信息做误差补偿（近似最优的逐列更新）。一次性把 OPT-175B/BLOOM-176B 量化到 3–4 bit 只需约 4 GPU 小时，perplexity 几乎不涨。→ \u0026ldquo;数学补偿派\u0026rdquo; AWQ（MLSys 2024，Han Lab）：不动模型，只根据激活分布找出约 1% 的显著权重，用 per-channel 缩放保护它们。比 GPTQ 更省事、硬件更友好（无逐列重建）。→ \u0026ldquo;保护重要权重派\u0026rdquo; SqueezeLLM（ICML 2024）：基于敏感度的非均匀量化 + 稠密/稀疏分解，把 outlier 权重单独用高精度存。→ \u0026ldquo;outlier 单独处理派\u0026rdquo; QuIP#（ICML 2024）：用随机 Hadamard 变换把权重\u0026quot;打散\u0026quot;成对量化友好的分布（incoherence），配合 E8 格码本，2-bit 权重达到当时 SOTA。→ \u0026ldquo;先洗牌再量化派\u0026rdquo; 7.3 权重 + 激活（W8A8） # LLM.int8()（NeurIPS 2022）：INT8 矩阵乘 + 混合精度分解——把激活里有 outlier 的列挑出来留在 FP16 算，其余走 INT8。首个无精度损失的 175B 模型 INT8 推理方案。 SmoothQuant（ICML 2023，Han Lab）：激活难量化、权重好量化，那就通过数学上等价的缩放把\u0026quot;量化难度\u0026quot;从激活迁移到权重（s = max|X|^α / max|W|^(1−α)），实现 W8A8 且精度几乎无损。已被 TensorRT-LLM 采用。 7.4 KV Cache 量化 # KIVI（ICML 2024）：首个免调参的 2-bit KV cache 量化。洞察：Key 的分布模式稳定（per-channel 量化），Value 的分布易变（per-token 量化）。KV 省 4 倍显存，长上下文场景吞吐大增。 7.5 系统协同（Quantization × Serving System） # QServe / QoQ（MLSys 2025，Han Lab）：W4A8KV4——4-bit 权重、8-bit 激活、4-bit KV cache，配合专门设计的 GEMM 调度（int4 权重打包、避免 dequant 开销），是\u0026quot;算法 + 系统\u0026quot;一起设计的代表作。 7.6 训练侧：QAT 与 1-bit # QAT（Quantization-Aware Training）/ STE：训练时模拟量化误差（直通估计器），模型学会\u0026quot;容忍\u0026quot;低精度。质量上限最高，但需要数据和训练算力。 QLoRA（NeurIPS 2023）：NF4（4-bit NormalFloat）+ 双重量化 + paged optimizer，让 65B 模型能在单张 48GB GPU 上微调，且不损失 16-bit 微调效果。→ 量化 + 参数高效微调的经典组合。 BitNet b1.58（2024）：参数只有 {-1, 0, +1} 的三值权重（1.58 bit），从头训练，同等规模/训练 Token 下匹配 FP16 Transformer 的困惑度与下游表现，推理能耗大幅下降。 7.7 前沿：Attention 量化与大规模实践 # FlashAttention-3（2024）：Hopper 上支持 FP8 的 attention（低精度 + 异步拷贝）。 SageAttention（2024）：FP8 量化 attention 且保持精度，图像/视频生成加速。 DeepSeek-V3（2024）：671B MoE 全程 FP8 训练/推理（DeepGEMM），证明 FP8 在超大模型上是可行的。 8. 质量评估三板斧 #量化有没有搞砸，用三种方法检查（章节原表），每种都在找\u0026quot;与噪声不可区分\u0026quot;的差异：\n方法 成本 灵敏度 说明 Perplexity（WikiText-2 / C4） 最低 最粗 最常用的快速筛查，量化后涨幅应可忽略 智能基准（MMLU、SWE-bench 等） 中 中 覆盖知识和真实编程任务，更能暴露应用层退化 自定义评测（Custom Evals） 最高 最准 用你真实业务的 prompt/任务集评测，最终以它为准 要点：只跑 perplexity 不够；只跑几个 MMLU 题也不够。生产上线前，至少要在自定义评测上把量化模型和原模型做并排对比，确认差异落在噪声范围内。\n9. 交互练习实测：Quantization Quality Estimator #我把练习页 Quantization Quality Estimator 实际跑了一遍（70B 模型、FP16 原始精度），实测结果如下：\n量化组件 目标精度 量化后大小 内存节省 估算加速 估算质量风险 仅权重 FP8 70 GB 50% ~1.4x Medium 权重 + KV FP8 70 GB 50% ~1.6x High 权重 + 激活 FP8 70 GB 50% ~1.5x High 全部 FP8 70 GB 50% ~1.5x High 仅权重 FP4 35 GB 75% ~2.2x High 权重 + KV FP4 35 GB 75% ~2.5x High 权重 + 激活 FP4 35 GB 75% ~2.5x High 全部 FP4 35 GB 75% ~2.8x High 几个值得注意的点：\n内存节省只看目标精度：FP16→FP8 省 50%，FP16→FP4 省 75%（模型 70B = 140 GB / 70 GB / 35 GB）。勾选哪些组件不影响内存数字——估算器只按权重算模型大小，KV/激活的显存与上下文长度相关，没被建模。 组件勾选影响加速比和风险：加量化 KV/激活，加速比略升（1.4x → 1.6x；FP4 从 2.2x → 2.8x），但风险迅速拉高。 估算器比章节结论保守：章节说 FP8 是甜点、值得把权重+激活量到 FP8；但估算器对 70B 模型把\u0026quot;FP8 全组件\u0026quot;标成了 High risk。两者不矛盾——估算器是启发式\u0026quot;提示你小心\u0026quot;，章节的立场是\u0026quot;小心但值得做，用评测验证\u0026quot;。 结论：这个工具只给数量级直觉；真实部署必须跑第 8 节的评测流程。\n10. 生产建议与决策清单 #10.1 默认配方（从章节和业界实践综合） # 首选 FP8 / MXFP8（W8A8）：权重 + 激活都量化，Hopper/Blackwell 上有原生 Tensor Core 支持，收益 1.5x 左右，质量风险最低。 KV cache 单独谨慎处理：先跑长上下文场景的评测再决定是否量化（KIVI 类方法可到 4-bit/2-bit）。 Attention 留在原精度：除非用 FlashAttention-3/SageAttention 这类专门方案。 4-bit 权重（W4A16/W4A8）是激进选项：用 GPTQ/AWQ/QuIP# 生成，配合 vLLM/TensorRT-LLM 的 kernel，收益 2x+，但必须过自定义评测。 能用无损优化就先无损：推测解码、prefix caching、KV 复用等全部无损，优先级应该在\u0026quot;激进量化\u0026quot;之前。 10.2 上线检查清单 # 用校准集（几百条代表性 prompt）跑 perplexity，与 FP16 基线对比 跑 MMLU/SWE-bench 等基准，量化前后差异 \u0026lt; 噪声 用真实业务 prompt 集做自定义评测（尤其代码、数学、长上下文） 检查 outlier 场景：长 prompt、多轮对话、流式输出 实测 TTFT / TPS / 吞吐 / 显存占用，确认收益达到预期 保留 A/B 开关，可随时回退到高精度版本 11. Han Song MIT 6.5940 课程地图 #韩松（Song Han）是 MIT EECS 副教授，HAN Lab 负责人，也是 SmoothQuant、AWQ、QServe 等方法的作者。他的公开课 6.5940 TinyML and Efficient AI Computing（EfficientML.ai） 是学习量化的最佳课程入口。\n11.1 课程主页 # 2026 Fall（当前）：https://hanlab.mit.edu/courses/2026-fall-65940 2024 Fall：https://hanlab.mit.edu/courses/2024-fall-65940 2023 Fall：https://hanlab.mit.edu/courses/2023-fall-65940 课程视频/讲义聚合：https://efficientml.ai 11.2 与量化直接相关的讲座 # 讲座 内容 视频入口 Lecture 5: Quantization (Part I) 线性量化的数学基础：bitwidth、均匀/非均匀量化、PTQ（RTN、GPTQ、LLM.int8、SmoothQuant） Class Central（Fall 2024） Lecture 6: Quantization (Part II) QAT 与 STE、蒸馏、低比特/二值网络、量化与部署的配合 Class Central（Fall 2024） Lecture 13: LLM Quantization and Deployment（2026 版）/ LLM Deployment Techniques（2024 版） 把量化放进真实 LLM 服务系统：KV cache、并行、serving 课程主页 Schedule 里找 [Slides]/[Video] 提示：B 站有该课程的搬运与笔记（如 EfficientML.ai Lecture 6 笔记），中文学习可配合使用。课程中文介绍可看澎湃新闻的报道。\n11.3 课程里的配套 Lab #6.5940 有动手 Lab（实现剪枝/量化并部署 Llama 到笔记本/移动端）。建议至少做量化相关的 lab：亲手实现 uniform quantization → 对比 RTN vs GPTQ vs AWQ 的质量差异，比只看论文有效得多。\n12. 论文阅读清单 #按推荐阅读顺序排列（核心 5 篇在前，扩展在后）：\n# 论文 会议/年份 一句话要点 1 LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale NeurIPS 2022 outlier 列单独高精度，首个无损 INT8 大模型推理 2 GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers ICLR 2023 二阶 Hessian 误差补偿，一次性 3–4 bit 量化 175B 3 SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models ICML 2023 激活→权重迁移量化难度，W8A8 无损 4 AWQ: Activation-aware Weight Quantization MLSys 2024 按激活重要性保护 1% 权重，硬件友好的 4-bit 5 QLoRA: Efficient Finetuning of Quantized LLMs NeurIPS 2023 NF4 + 双重量化，量化模型上直接微调 6 SqueezeLLM: Dense-and-Sparse Quantization ICML 2024 敏感度非均匀量化 + outlier 分离 7 QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks ICML 2024 Hadamard 洗牌 + E8 格码本，2-bit SOTA 8 KIVI: A Tuning-Free Asymmetric 2-bit Quantization for KV Cache ICML 2024 Key 按通道、Value 按 Token 量化，KV 省 4 倍 9 QServe: W4A8KV4 Quantization and System Co-design MLSys 2025 算法与 GEMM 调度协同，4-8-4 组合落地 10 The Era of 1-bit LLMs: BitNet b1.58 2024 三值权重 {-1,0,1}，匹配 FP16 质量、大幅降耗 11 FP8 Formats for Deep Learning（NVIDIA/Arm/Intel） 2022 E4M3 / E5M2 规格与使用建议 12 OCP Microscaling Formats (MX) Specification OCP 2023 MXFP8/MXFP4 的 block-32 + E8M0 标准 13 FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision 2024 Hopper 上的 FP8 attention 14 SageAttention: Accurate 8-Bit Attention 2024 FP8 量化 attention 保持精度 15 DeepSeek-V3 Technical Report 2024 671B MoE 全程 FP8 训练/推理实践 16 NVFP4: NVIDIA 官方介绍 2025 Blackwell 4-bit：block 16 + E4M3 缩放 阅读策略：先把 1–5 读完，你就能回答\u0026quot;量化为什么难、怎么解决\u0026quot;；6–10 是进阶（极低比特 + KV cache + 系统协同）；11–16 是格式规范与生产案例，按需查阅。\n13. 工具与生态 # 工具 说明 vLLM 最主流的开源推理引擎，支持 AWQ/GPTQ/FP8/MXFP8/FP4、KV cache 量化（量化文档） TensorRT-LLM NVIDIA 高性能引擎，深度支持 FP8/INT4/FP4 与 SmoothQuant/AWQ llama.cpp GGUF 生态，Q2_K–Q8_0 各档量化，本地/边缘部署首选 bitsandbytes NF4/INT8，HuggingFace 生态 + QLoRA 微调 SGLang 高性能推理框架，量化支持同样丰富 HAN Lab omniserve QServe/LServe 官方代码，学 W4A8KV4 系统实现 HuggingFace 量化文档 GPTQ/AWQ/FP8/bitsandbytes 的 API 与教程 14. 术语速查 # PTQ（Post-Training Quantization）：训练后量化，不需要重训，用少量校准数据即可。推理优化默认指这个。 QAT（Quantization-Aware Training）：训练时模拟量化误差，质量上限更高、成本更高。 RTN：Round-to-Nearest，最朴素的四舍五入量化。 W8A8 / W4A16 / W4A8KV4：权重位数-激活位数（-KV位数）的缩写，如 W4A8KV4 = 4-bit 权重 + 8-bit 激活 + 4-bit KV cache。 Scale / Zero-point：量化缩放系数与零点偏移，负责把实数区间映射到整数网格。 Block size / Group size：一组元素共享一个 scale 的元素个数（16/32/128）。 Outlier（离群值）：远大于其他值的少数维度，是低比特量化的主要敌人。 KV cache：解码时缓存的历史 Key/Value 向量，长上下文下占显存大头。 TTFT / TPS：Time To First Token（首 Token 延迟）/ Tokens Per Second（生成吞吐）。 15. 参考资料 # Inference Engineering, Ch 5: Quantization \u0026amp; Speculative Decoding — https://inferenceengineering.tech/chapters/techniques/ Inference Engineering, Recommended Reading — https://inferenceengineering.tech/reading/ Inference Engineering, Quantization Quality Estimator — https://inferenceengineering.tech/exercises/quantization-estimator/ MIT 6.5940 EfficientML.ai（Han Song）— https://hanlab.mit.edu/courses/2026-fall-65940 HAN Lab 论文主页（SmoothQuant / AWQ / QServe / BitNet）— https://hanlab.mit.edu 本笔记对应的论文（见第 12 节表格，均为 arXiv 原文链接） ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E7%90%86%E4%BC%98%E5%8C%96-quantization%E9%87%8F%E5%8C%96%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/","section":"笔记","summary":"LLM 量化（Quantization）系统学习笔记：从 FP8/FP4 数字格式、量化粒度与敏感性排序，到 GPTQ、AWQ、SmoothQuant、KIVI、BitNet 方法谱系。生产默认配方：W8A8 FP8 是甜点、KV cache 谨慎量化、attention 保持高精度，附质量评估三板斧与 MIT 6.5940 课程清单。","title":"LLM 推理优化 · 量化（Quantization）系统学习笔记"},{"content":"Answer #Standard attention is slow because the N×N score matrix is read and written through HBM, not because the chip is short of FLOPs. FlashAttention never materializes that matrix. It cuts the work into tiles that fit in on-chip SRAM, runs online softmax so the blocked result is still exact, and recomputes in the backward pass instead of storing the big matrix.\nWhat to remember #Tiling answers the memory question. Online softmax answers the “softmax needs the whole row” question. Recompute answers the training-memory question. The algorithm is exact; the speedup is fewer HBM round trips. The Chinese note walks the IO bound, a hand calculation of the online update, and how FA1, FA2, and FA3 line up with GPU generations.\nWhen this is the wrong lever #Decode of one token is often bandwidth-bound on the weights and the KV cache, not on an N×N score matrix. Cutting KV heads (MQA, GQA, MLA) or reusing a prefix is a different problem.\n","date":null,"permalink":"https://doraemeng.dev/en/flashattention/","section":"页面","summary":"Standard attention is slow because the N×N score matrix is written to HBM, not because the GPU lacks FLOPs. FlashAttention tiles that work into SRAM and still computes exact softmax.","title":"Why is FlashAttention faster and lighter on memory?"},{"content":" 量化方法横跨信息论、数值格式、权重量化、激活量化、KV cache 与训练内量化，按论文时间线硬读容易在几条线上来回跳。这份总览给出两条阅读路径、各章要点与全系列共用的符号约定；每章独立成文件，包含形式化定义、推导、伪代码、算例、直觉与习题。更早的概览版见 LLM 推理优化-Quantization 量化学习笔记。 全系列 11 章已完成（2026-08-17），按$01 \\to 11$顺序阅读即可；每章\u0026quot;延伸阅读\u0026quot;末尾有上一篇/下一篇跳转。\n1. 系列结构与来源映射 # 章节 文件 核心内容 对应来源 00 本文件 学习地图、符号约定、阅读顺序 — 01 01-数值编码与计算机表示基础 信息论（bit/熵/率失真）、整数/定点编码、IEEE 754 浮点、舍入与截断、存储层次 MIT L5 开场；IEEE 754；Goldberg；Horowitz 02 02-量化问题形式化与均匀量化理论 量化的一般形式、均匀量化数学、误差与 SNR 理论 MIT 6.5940 L5（前半）；Inference Engineering Ch5 03 03-数值格式与硬件 FP16/BF16/FP8(E4M3/E5M2)/FP4/MXFP8/NVFP4 的位布局、动态范围、Tensor Core 与带宽 Inference Engineering Ch5；FP8 白皮书；OCP MX 规范 04 04-量化粒度校准与离群值 per-tensor/channel/block、校准数据、outlier 问题 MIT L5；LLM.int8()；Inference Engineering Ch5 05 05-权重量化 I $RTN \\to GPTQ$（二阶误差补偿，含逐层推导） GPTQ 论文；MIT L5 06 06-权重量化 II AWQ（激活感知缩放）、SqueezeLLM（稠密/稀疏）、QuIP#（Hadamard + 格码本） AWQ / SqueezeLLM / QuIP# 论文 07 07-激活量化 LLM.int8()（outlier 分解）、SmoothQuant（迁移公式推导）、W8A8 LLM.int8() / SmoothQuant 论文 08 08-KV Cache 量化 为什么 KV 是瓶颈、KIVI（per-channel key / per-token value）、误差累积 KIVI 论文；Inference Engineering Ch5 09 09-QAT 与训练内量化 STE、QLoRA(NF4)、BitNet b1.58（三值化） MIT L6；QLoRA / BitNet 论文 10 10-质量评估方法论 perplexity、MMLU/SWE-bench、自定义评测、统计显著性、校准集设计 Inference Engineering Ch5；SWE-bench 11 11-系统协同与部署 QServe(W4A8KV4)、FP8 Attention、vLLM/TensorRT-LLM/llama.cpp 工程 QServe / FlashAttention-3 / SageAttention — AWQ 和 GPTQ 有什么区别？4-bit 权重量化怎么选 把 05、06 两章并起来看的选型对比篇，并辨析 GPTQ/AWQ 与 GGUF 处于不同维度 本文 2. 两条学习主线 #主线 A：按\u0026quot;问题\u0026quot;走（推荐给第一次系统学习） # 打地基（01）：信息论、整数/浮点编码、舍入与截断——回答\u0026quot;一个数在计算机里到底怎么存、误差从哪来\u0026quot;。 为什么能省（02–03）：量化 = 有损压缩；位宽每减 1，噪声音量减半、SNR 涨$\\sim 6 dB$；浮点格式用指数位换动态范围。 难在哪（04）：outlier、分布利用不充分、粒度选择——所有方法都在绕这三个坑。 怎么解决（05–08）：权重（GPTQ/AWQ/QuIP#）$\\to$激活（LLM.int8/SmoothQuant）$\\to KV cache$（KIVI），从\u0026quot;最不敏感\u0026quot;到\u0026quot;最敏感\u0026quot;逐层攻克。 训练侧怎么做（09）：QAT、QLoRA、BitNet。 怎么验收（10）＋怎么部署（11）。 主线 B：按\u0026quot;论文时间线\u0026quot;走（适合已经读过概览） #$LLM.int8 (2022) \\to GPTQ (2022) \\to SmoothQuant (2023) \\to AWQ (2023) \\to QLoRA (2023) \\to KIVI (2024) \\to QuIP$#$(2024) \\to QServe (2025)$。这条线能看出：先解决权重，再解决激活，再解决 KV cache，最后做算法-系统协同设计。\n3. 配套资源 # 资源 用途 MIT 6.5940 Fall 2024 Lecture 5（Class Central） 量化 Part I：线性量化、bitwidth、PTQ（RTN/GPTQ/LLM.int8/SmoothQuant） MIT 6.5940 Fall 2024 Lecture 6（Class Central） 量化 Part II：QAT、STE、蒸馏、低比特/二值 6.5940 课程主页（2026 Fall） 讲义/视频入口（Lecture 5/6/13） 6.5940 Lab 2：Quantization（GitHub） 动手实现 linear quantize / k-means 量化，配套每章习题 Inference Engineering Ch5 教材正文（本系列的\u0026quot;骨架\u0026quot;） 各章引用的 arXiv 论文 见每章末尾\u0026quot;延伸阅读\u0026quot; 4. 全局符号约定（全系列通用） # 符号 含义 b 位宽（bitwidth） r 原始实数（权重/激活/KV 值） $\\hat{r}$ 反量化后的近似实数 q 量化后的整数值 qmin, qmax 量化整数值域（如$INT8: -128 \\sim 127$） s 缩放因子 scale（实数） z 零点 zero-point（整数） $\\Delta$ 步长 step size（相邻量化层间距） [rmin, rmax] 量化覆盖的实数范围 $\\varepsilon$ 量化误差（$\\varepsilon = r - \\hat{r}$） $\\sigma ^{2}$ 方差（信号$\\sigma ^{2}_s$，噪声$\\sigma ^{2}_e$） SNR / SQNR 信噪比 / 量化信噪比（dB） W8A8 / W4A16 / W4A8KV4 权重位数-激活位数（-KV 位数）记法 PTQ / QAT 训练后量化 / 量化感知训练 RTN Round-to-Nearest（就近舍入） clamp(x, lo, hi) min(max(x, lo), hi) round(·) 四舍五入到最近整数 5. 使用建议 # 每章先读\u0026quot;本章目标\u0026quot;，再读主体，最后做\u0026quot;习题\u0026quot;；习题答案在本章末尾，先自己算再看。 涉及代码的习题建议直接在 Lab 2 notebook 的环境里跑，公式与本系列一致。 数学符号统一用上表；遇到跨章引用会标注章节号。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-00-%E6%80%BB%E8%A7%88%E4%B8%8E%E5%AD%A6%E4%B9%A0%E5%9C%B0%E5%9B%BE/","section":"笔记","summary":"LLM 量化完整学习地图：从信息论与数值编码、均匀量化误差公式，到 RTN/GPTQ/AWQ、SmoothQuant、KV Cache 量化，再到 QServe 与 vLLM 部署验收，11 篇精读笔记的阅读顺序与每章要点速览。","title":"LLM 量化从入门到部署：11 篇精读笔记总览"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜下一篇： 量化误差是怎么算出来的？均匀量化公式推导\n定位：前置知识章。量化是在回答\u0026quot;一个数用多少 bit、以什么格式表示\u0026quot;——所以它站在三块地基之上：信息论（bit 是什么、能压缩到什么程度）、编码（整数/浮点在硬件里怎么编码）、计算机组成（为什么位宽直接决定性能）。本章把这三块地基一次性补齐，全部内容都以\u0026quot;服务于后面的量化推导\u0026quot;为取舍标准。 对应：MIT 6.5940 Lecture 5 开头的数据类型总览；Inference Engineering Ch5 的 Number Formats 前情；经典教材 IEEE 754 部分。 学完本章你应该能：① 说出 b bit 能表示多少种取值、均匀分布的熵是多少；② 手写 4-bit 补码并解释为什么用补码；③ 手算一个数的 FP32/FP16 位模式，解释 exponent bias、次正规数、machine epsilon；④ 分清 6 种舍入模式，并解释为什么量化用 round-half-even；⑤ 分清\u0026quot;截断（truncation）\u0026ldquo;和\u0026quot;饱和（clamp）\u0026quot;，并证明截断噪声是舍入的 4 倍。\n目录（本章） # 本章目标 信息论三件套：bit、熵、率失真 整数表示 定点数与 scale 的世界 IEEE 754 浮点数 舍入（Rounding） 截断（Truncation）与饱和（Clamp） 计算机组成视角：为什么 bit 少就快 预备知识$\\to$量化概念映射表 习题与解答 延伸阅读 1. 本章目标 # 量化的全部数学（02 章）都在做一件事：把一个实数 r 用\u0026quot;有限个 bit\u0026quot;表示出来；而\u0026quot;有限个 bit 能表示什么、表示得有多准、代价是什么\u0026quot;正是本章的内容。\n后面的章节会频繁用到本章的四个结论，先记住它们：\nb bit 只有$2^b$种位模式——这是所有压缩的起点。 整数用补码表示，INT8 的范围是 [−128, 127]——量化公式里的 qmin/qmax 就是从这来的。 浮点 = 符号位 + 偏置指数 + 尾数，指数位换动态范围、尾数位换精度——FP16/BF16/FP8 的主要区别都在这句话里。 舍入误差 ≤ 半步长（$\\Delta /2$），截断误差 ≤ 一步长（$\\Delta$）且噪声功率是舍入的 4 倍——所以量化默认\u0026quot;四舍五入\u0026quot;而不是\u0026quot;直接砍掉\u0026rdquo;。 2. 信息论三件套：bit、熵、率失真 #2.1 bit：信息的基本单位 #一个 bit 有两种状态（0/1）。b 个 bit 可以组成 $2^b$ 种不同的位模式：\n$b = 1 \\to 2$种取值$b = 4 \\to 16$种取值 $b = 8 \\to 256$种取值$b = 16 \\to 65,536$种取值\n这就是量化格式表里\u0026quot;Distinct Values Representable\u0026quot;（$FP16/BF16 = 65,536$，$FP8 = 256$，$FP4 = 16$）的来历。位宽 b 直接决定了\u0026quot;码本\u0026quot;（codebook）的大小。\n信息量的定义（Shannon）：一个概率为 p 的事件，其信息量为\n$I = -\\log_2(p)$（单位：bit）\n直觉：p 越小，事件越\u0026quot;意外\u0026quot;，信息量越大。log2 让\u0026quot;两个独立事件合起来的信息量 = 各自信息量之和\u0026quot;，这是 bit 取对数的根本原因。\n2.2 熵：表示一个分布最少需要多少 bit #一个随机变量 X 的熵（entropy）是它的平均信息量：\n$$ H(X) = -\\sum _i p_{i} \\cdot \\log_2(p_{i}) $$熵是\u0026quot;无损压缩\u0026quot;的下界：用 b 个 bit 表示 X 的所有可能取值，如果 b \u0026lt; H(X) 就一定会有信息损失；如果$b \\ge \\lceil H\\rceil$理论上可以做到无损。\n两个极端：\n分布 H（bit） 含义 均匀分布在$2^b$个值上 b 每个值等概率，无法压缩 $P(0)=0.9, P(1)=0.1$ ≈ $0.469$ 大量冗余，理论上 1 bit 足够甚至还可以进一步压缩 均匀分布时$H = b$，正好等于位宽。这就是为什么\u0026quot;均匀量化 + 均匀分布\u0026quot;是最理想的情形：码本没有浪费。\n2.3 率失真：有损压缩的边界（直觉版） #无损压缩的下界是熵 H；但量化是有损的。率失真理论回答：给定允许的失真 D，最小需要的速率 R(D) 是多少（R 随 D 增大而减小）。\n对量化而言：\n码本大小$2^b ↔$速率 b bit 量化误差$\\varepsilon ^{2} ↔$失真 D\n\u0026ldquo;每$bit \\approx 6 dB$\u0026quot;（02 章会完整推导）对应均匀量化器的一条率失真曲线：速率每 +1 bit，失真（噪声功率）÷4，即 SNR +6 dB。\n不需要掌握率失真定理的证明，但要建立这个直觉：量化是在\u0026quot;速率\u0026quot;和\u0026quot;失真\u0026quot;之间沿着一条曲线做交易，而不同的编码方式（均匀网格、非均匀网格、浮点）对应不同的曲线。 后续每一篇论文（GPTQ/AWQ/QuIP#…）都是在\u0026quot;同样的 b bit 预算下，把曲线往左上方推\u0026rdquo;。\n2.4 信息论视角预演：outlier 问题 #假设某个权重张量 90% 的值在$[-1, 1]$，10% 的值在$\\pm 100$附近。它的熵其实不高（大部分值集中在小区间），但动态范围很大。\n如果用一个均匀网格覆盖$[-100, 100]$，绝大多数码字落在没人用的区域：\n网格： -100 ... -1 ... 0 ... 1 ... 100 实际值： ████████████████ 码字利用率： ~1%（90% 的值挤在 1% 的码字里） 结果：正常值的有效位宽被 outlier 稀释（02 章算过：范围只用了 1/100，等效丢约 6.6 bit）。这就是 LLM.int8()、SmoothQuant、AWQ 要解决的同一个问题。先有信息论的框架，才能看懂他们为什么这么设计。\n3. 整数表示 #3.1 无符号整数（Unsigned） #b bit 无符号整数表示$0 \\sim 2^b - 1$：\n4-bit 无符号：$0000=0, 0001=1, ..., 1111=15$\n适合\u0026quot;天然非负\u0026quot;的量（地址、计数）。量化的非对称形式会用到它：值域$[0, 255]$对应无符号 INT8。\n3.2 有符号整数：补码（Two\u0026rsquo;s Complement）——硬件唯一真解 #b bit 补码表示范围：\n$$ [-2^{b-1}, 2^{b-1} - 1] $$4-bit 例子：\n位模式 补码值 位模式 补码值 0111 7 1000 −8 0011 3 1101 −3 0001 1 1111 −1 0000 0 1001 −7 求负数：按位取反 + 1。\n求 -5 的 4-bit 补码： $5 = 0101 \\to$取反$1010 \\to +1 \\to 1011$（= $-5$）✓\n为什么硬件用补码？三个原因：\n加减法统一：$a - b = a + (-b)$，同一套加法器处理所有情况，不需要专门的减法器。 0 唯一：0000 和 1000 不会同时表示 0（原码/反码都有$\\pm 0$问题，见 3.3）。 符号位自然融入：最高位就是符号位（1 为负），但不用单独判断，加法器自动处理。 记忆法：补码 = \u0026ldquo;取反加一\u0026rdquo;；最小的负数（1000）是\u0026quot;取反加一\u0026quot;自指（−8 的补码还是 1000），这是它比 7 多一个的原因。\n3.3 原码 / 反码的坑（为什么被淘汰） # 编码 表示 -0？ 4-bit 的 -0 位模式 问题 原码（sign-magnitude） 是 1000 比较大小要判符号；$\\pm 0$两个零 反码（ones\u0026rsquo; complement） 是 1111 加法需要循环进位修正 补码 否 无 加法统一、0 唯一 有意思的是：浮点数恰恰用的是\u0026quot;原码\u0026quot;思想（符号位 + 尾数绝对值），因为浮点运算不需要比较整数大小，而原码的对称性（$\\pm 0$）在浮点里是刻意保留的（见 5.3）。\n3.4 溢出：饱和（Saturation）vs 环绕（Wraparound） #INT8 的 127 + 1 会怎样？取决于硬件/软件策略：\n环绕（wraparound）：$127 + 1 = -128$（模$2^{8}$，补码天然行为） 饱和（saturation）：$127 + 1 = 127$（clamp 到边界）\n量化里的 clamp(q, qmin, qmax) 就是饱和。饱和牺牲一点动态范围，但不会让数值\u0026quot;跳到对面去\u0026quot;——这对神经网络非常重要：一个溢出变成 −128 的激活值会彻底破坏后续计算。\n3.5 从整数编码到量化：qmin/qmax 的来源 #量化公式里的量化值域直接来自整数编码：\nINT8 无符号：$q \\in [0, 255] \\to$用于非对称量化 INT8 有符号：$q \\in [-128, 127] \\to$对称量化默认值域 对称量化的实际网格：$q \\in [-127, 127]$（用$2^{b-1}-1$作分母时，-128 不参与）\n以后看到\u0026quot;对称 INT8 用 127 做分母、有些 kernel 用 128\u0026quot;不要困惑——127 来自$2^{b-1}-1$（保证$\\pm$对称且 0 精确），128 来自$2^{b-1}$（把补码的 −128 也用上）。两个约定各有拥趸，不影响原理。\n4. 定点数与 scale 的世界 #4.1 定点数（Fixed-Point） #定点数 = 整数 + 一个固定的缩放因子 scale：\n真实值 = 整数 q × scale s\nQ 格式记法：Qm.n 表示 m 位整数 + n 位小数（如 Q1.7 表示 1 位整数位、7 位小数位，共 8 bit）。\n4.2 量化就是\u0026quot;把浮点转定点\u0026quot; #回看 02 章的对称量化公式：\n$$ q = \\operatorname{round}(r / s), \\hat{r} = q \\cdot s $$这就是定点化的标准流程：除以$scale \\to$取整$\\to$乘回 scale。整数 q 就是定点表示，s 就是定点格式的步长。\n定点算术的硬件含义：矩阵乘全部用整数乘加，累加器用 FP32（或 INT32）防溢出，最后再乘回 scale。Tensor Core 的整数/低精度浮点乘加单元就是干这个的。\n记住这个等价：量化后的推理 = 定点矩阵乘 + 少量 scale 换算。所有\u0026quot;量化推理 kernel\u0026quot;的复杂性都来自怎么把 scale 运算塞进这条流水线（11 章讲 QServe 时深入）。\n5. IEEE 754 浮点数 #5.1 从科学计数法到二进制 #十进制科学计数法：$3.75 = 1.875 \\times 10^{1}$。二进制版本：\n$$ 3.75 = 11.11_{2} = 1.111_{2} \\times 2^{1} $$浮点存储的就是这三个要素：符号、指数、尾数。\n5.2 FP32 位布局与手算 #$FP32 = 1$位符号 + 8 位指数 + 23 位尾数（隐含 1 位前导 1，共 24 位有效精度）：\n值= $(-1)^s \\times 1.m \\times 2^{e - 127}$\n其中 e 是指数字段（8 bit，无符号$0\\sim 255$），$bias = 127$（指数是\u0026quot;偏置编码\u0026quot;，excess-127）。为什么要 bias？让指数部分变成无符号整数，比较大小/排序更简单。\n手算 −3.75：\n符号：负数$\\to s = 1$ $3.75 = 11.11_{2} = 1.111_{2} \\times 2^{1} \\to$指数真值= $1 \\to e = 1 + 127 = 128 = 10000000_{2}$ 尾数：111 后面补 20 个 0（23 位） 结果：1 10000000 11100000000000000000000 十六进制：0xC0700000 手算 0.1（演示\u0026quot;十进制小数转二进制不精确\u0026quot;）：\n$0.1 = 0.0001100110011001100110011..._{2}$（0011 无限循环） 规格化：$1.1001100110011... \\times 2^{-4}$ 指数：$e = 127 - 4 = 123$ 尾数只取 23 位，第 24 位是$1 \\to$舍入进位 结果：存储值= $0.100000001490116119384765625 \\ne 0.1$\n这就是\u0026quot;$0.1 + 0.2 \\ne 0.3$\u0026ldquo;的根源：0.1 和 0.2 在二进制下都是无限循环小数，存储时已经被舍入。量化同理——先接受\u0026quot;表示本身就带误差\u0026rdquo;，才能理性地讨论\u0026quot;量化误差\u0026quot;。\n5.3 特殊值、次正规数与 machine epsilon #FP32 指数全 0 / 全 1 时进入特殊状态：\n指数字段 尾数字段 含义 值 $e = 0$ $m = 0$ $\\pm 0$ 有 +0 / −0（原码思想的残留） $e = 0$ $m \\ne 0$ 次正规数（subnormal） $(-1)^s \\times 0.m \\times 2^{-126}$ $1 \\le e \\le 254$ 任意 规格化数（normal） $(-1)^s \\times 1.m \\times 2^{e-127}$ $e = 255$ $m = 0$ $\\pm \\infty$ 溢出/除零 $e = 255$ $m \\ne 0$ NaN 0/0、√负 等非法运算 次正规数（denormal）存在的意义：让数值在接近 0 时\u0026quot;平滑下溢\u0026quot;而不是直接跳成 0（避免除以接近 0 的数时出现空洞）。代价是精度和速度都差一些。\nmachine epsilon：1 与下一个可表示的浮点数之间的距离：\n$\\varepsilon = 2^{-M}$，M 为尾数位数\n$$ \\begin{aligned} FP32: \\varepsilon \u0026= 2^{-23} \\approx 1.19e-7 FP16: \\varepsilon \u0026= 2^{-10} \\approx 9.77e-4 BF16: \\varepsilon \u0026= 2^{-7} \\approx 7.81e-3 \\end{aligned} $$浮点数的相对精度≈ $\\varepsilon /1$的量级：尾数每少 1 bit，相对精度减半。\n5.4 FP16 与 BF16：同一个 16 bit 预算，两种分配 # 格式 符号 指数 尾数（含隐含位） bias 最大正常值 最小正常值 $\\varepsilon$ FP16 1 5 11（10 存储） 15 65,504 $2^{-14} \\approx 6.1e-5$ $2^{-10} \\approx 9.8e-4$ BF16 1 8 8（7 存储） 127 ≈ $3.4e38$（同 FP32） $2^{-126}$（同 FP32） $2^{-7} \\approx 7.8e-3$ 关键对比：\nFP16：指数$5 bit \\to$范围小（$\\sim \\pm 65k$），尾数$11 bit \\to$精度高 BF16：指数$8 bit \\to$范围同 FP32，尾数$8 bit \\to$精度低（约 3 位十进制）\n这解释了 Inference Engineering Ch5 的一句话：\u0026ldquo;exponent gives higher dynamic range than integers\u0026rdquo;——指数位多的格式能表示更大的数量级跨度，这在训练（梯度跨多个数量级）里极其重要；而推理时值域已知且稳定，可以牺牲范围换精度，于是 FP16 做推理默认格式、BF16 做训练主流。\n5.5 动态范围 vs 精度：浮点格式的永恒 tradeoff #位预算固定时： 指数位$↑ \\to$动态范围 ↑、精度 ↓ 尾数位$↑ \\to$精度 ↑、动态范围 ↓\n这一条是 03 章\u0026quot;数值格式\u0026quot;的总纲：FP8 的 E4M3（指数 4、尾数 3）与 E5M2（指数 5、尾数 2）就是同一位预算下的两种分配；FP4（E2M1）是更极端的压缩。看到任何格式的名字（E×M×），第一反应就是算它的动态范围和精度。\n6. 舍入（Rounding） #6.1 为什么需要舍入 #真实数在二进制下几乎总是无限精度的（比如 0.1），而存储/计算格式只有有限位。把高精度结果塞进有限位，有两个策略：\n策略 A：舍入（round）——找最近的可用值$\\to$误差 ≤ 半个格距 策略 B：截断（truncate）——直接砍掉低位$\\to$误差可达一个格距\n量化里的 round(r/s) 就是策略 A；int(r/s)（强制取整）是策略 B。\n6.2 六种舍入模式 # 模式 2.5 −2.5 2.7 −2.7 round-half-even（银行家舍入） 2 −2 3 −3 round-half-away-from-zero 3 −3 3 −3 round-half-up（向 +∞） 3 −2 3 −2 truncation（向 0 截断） 2 −2 2 −2 floor（向下取整） 2 −3 2 −3 ceil（向上取整） 3 −2 3 −2 6.3 为什么 IEEE 754 默认 round-half-even #round-half-even 的规则：恰好落在两个整数正中间时，取偶数的那个。\n$2.5 \\to 2$（2 是偶数）$3.5 \\to 4$（4 是偶数）\n$$ -2.5 \\to -2 -3.5 \\to -4 $$为什么不用更\u0026quot;直觉\u0026quot;的 half-away-from-zero？\n无偏性：half-away 对 +2.5 向上、−2.5 向下，在大数据量下误差会系统性偏向一侧（均值不为 0）；half-even 正负对称、期望误差为 0。 避免累积漂移：金融/科学计算里大量求和时，系统性偏差会线性累积；half-even 让误差在统计上相互抵消。 量化里的意义：模型有上亿次量化/反量化，任何系统性偏差都会被放大，所以默认用无偏舍入。PyTorch 的 torch.round、NumPy 的 np.round 都是 half-even；CUDA 的 __float2int_rn 也是 round-to-nearest-even。部分量化库（如 bitsandbytes）用 round-to-nearest（half-away），实际影响通常很小，但做严格对比实验时要注意复现性。\n补充：训练里还有一种随机舍入（stochastic rounding）：以概率往上下取整，期望值恰好等于原数。它在 QAT 里用于去掉量化噪声的偏差（09 章会再见到）。\n6.4 舍入的误差界 #当 r 落在量化范围内时：\n$$ |\\varepsilon_{\\text{round}}| \\le \\Delta /2 $$且假设误差在$[-\\Delta /2, \\Delta /2]$均匀分布时：\n$$ E[\\varepsilon ] = 0, Var[\\varepsilon ] = \\Delta ^{2}/12 $$这是 02 章 6 dB/bit 推导的出发点。舍入 = 无偏 + 最小噪声，所以量化默认舍入而不是截断。\n7. 截断（Truncation）与饱和（Clamp） #7.1 截断 vs 舍入：噪声功率差 4 倍 #向 0 截断（truncation toward zero）：正数误差落在$[0, \\Delta )$，负数误差落在$(-\\Delta , 0]$。\n对对称分布的信号：\n截断：$Var[\\varepsilon ] = \\Delta ^{2}/3$ 舍入：$Var[\\varepsilon ] = \\Delta ^{2}/12$ 比值：4 倍= $6 dB$\n所以\u0026quot;能舍入就别截断\u0026quot;——截断白白损失 6 dB（约等于 1 bit）。这也是为什么 int(x) 直接砍小数位做量化是坏习惯。\n对单侧分布（比如全正的激活），截断还有系统性偏差：\n所有正值的$\\hat{r} \\le r \\to E[\\varepsilon ] = +\\Delta /2$（输出系统性偏小）\n这种偏差在深层网络里会累积成可观察的质量问题。\n7.2 术语澄清：两种\u0026quot;截断\u0026quot; #中文/英文里\u0026quot;截断\u0026quot;有两个容易混淆的含义：\n术语 英文 含义 在量化里的角色 位截断 truncation 丢弃低位 bit（向 0 取整） 坏习惯，噪声 4 倍 值域截断 clamping / saturation 超出 [rmin, rmax] 的值压到边界 02 章的$\\varepsilon_{\\text{clip}}$，outlier 的锅 02 章说\u0026quot;量化误差 = 舍入 + 截断\u0026quot;，那个\u0026quot;截断\u0026quot;其实是 clamping（值域饱和），不是位截断。 分清这两个词，读论文才不会晕。\n7.3 clamp 的误差特征 #$\\varepsilon_{\\text{clip}} = r - r_{\\max}$（当 r \u0026gt; rmax）或 r - rmin（当 r \u0026lt; rmin）\n关键性质：\n与位宽无关：bit 再多，边界外的值照样被压到边界。 可任意大：outlier 离边界越远，误差越大。 有方向性：全部压向边界，均值不为 0。 所以量化器设计的第一课是选范围（rmin/rmax）：范围决定会不会出现灾难性截断；舍入模式只影响 $\\Delta /2$ 以内的误差（04 章专门讲校准与范围选择）。\n8. 计算机组成视角：为什么 bit 少就快 #8.1 存储层次与数据搬运 #现代 GPU/CPU 的存储层次（从快到慢）：\n寄存器（几 KB）$\\to L1$（几十 KB）$\\to L2$（几 MB）$\\to$共享/显存 HBM（几十 GB） 延迟递增、带宽递减、容量递增\nLLM 推理 decode 阶段的本质是：每个 token 都要把权重从 HBM 搬一遍。70B 模型 FP16 权重= $140 GB$，decode 一次 forward（batch=1）要搬运 140 GB——带宽成了瓶颈，算力反而用不满。\n8.2 位宽如何变成性能 #权重位宽减半（$FP16 \\to FP8$）： 同一次搬运的数据量减半$\\to$等效带宽翻倍 HBM 能量消耗近似减半 低精度 Tensor Core 的 FLOPS 翻倍（$Hopper FP8 = 2x FP16$）\n常被引用的 Horowitz（ISSCC 2014）能量数量级：一次 32-bit DRAM 访问的能量（数百 pJ 量级）比一次 32-bit 整数乘加（几 pJ 量级）高约两个数量级。结论：推理性能瓶颈在\u0026quot;搬数据\u0026quot;而不是\u0026quot;算数\u0026quot;，而量化能直接减少每次搬运的数据量。\n8.3 Tensor Core 预告 #Tensor Core 是 GPU 上的低精度矩阵乘专用单元：一次指令算一块小矩阵（如 16×16×16），支持 FP16/FP8/INT8 等格式。位宽决定它能塞进多少元素（FP16 塞 16 个，FP8 塞 32 个），这就是\u0026quot;FP8 的 FLOPS 是 FP16 的两倍\u0026quot;的硬件原因。03 章讲数值格式时会展开。\n9. 预备知识 → 量化概念映射表 # 本章概念 对应的量化概念 后续章节 $b bit \\to 2^b$个码字 $FP16=65,536 / FP8=256 / FP4=16$种取值 02、03 熵、率失真 均匀量化浪费位、非均匀量化动机、6 dB/bit 02、06 补码$q \\in [-2^{b-1}, 2^{b-1}-1]$ qmin/qmax、对称 INT8 的 127 vs 128 02 定点数 = 整数 × scale 量化公式$q = \\operatorname{round}(r/s)$、$\\hat{r} = q\\cdot s$ 02、11 IEEE 754：指数换范围、尾数换精度 FP16 vs BF16、FP8 E4M3 vs E5M2 03 machine epsilon 浮点格式的相对精度（FP8 风险来源） 03 round-half-even 无偏 量化默认舍入、误差≤ $\\Delta /2$ 02 truncation 噪声$\\Delta ^{2}/3 vs$舍入$\\Delta ^{2}/12$ 为什么不能 int() 硬截断 02 clamp（饱和） $\\varepsilon_{\\text{clip}}$、outlier 截断误差 02、04、07 存储层次、数据搬运 位宽 = 带宽 = 性能（30–50% 收益的来源） 03、11 10. 习题与解答 #题 1（手算）：补码 #写出 4-bit 补码中 −6、−1、0、5 的位模式；验证 −(−6) 用\u0026quot;取反 + 1\u0026quot;能回到 6。\n题 1 解答 $6 = 0110 \\to$取反$1001 \\to +1 \\to 1010$（−6）。 $-1 = 0001 \\to 1110 \\to 1111$。 $0 = 0000$。 $5 = 0101$。 验证：1010（−6）取反$0101 \\to +1 \\to 0110 = 6 ✓$。\n题 2（手算）：浮点位模式 #(a) 把 3.5 写成 FP32 位模式（十六进制）。 (b) 把 −0.75 写成 FP32 位模式。 (c) 把 1.5 写成 FP16 位模式。\n题 2 解答 (a) $3.5 = 11.1_{2} = 1.11_{2} \\times 2^{1}$。$s=0$，$e=128=10000000_{2}$，$m=11000...0 \\to$0 10000000 11000000000000000000000= $0x40600000$。\n(b) $0.75 = 0.11_{2} = 1.1_{2} \\times 2^{-1}$。$s=1$，$e=127-1=126=01111110_{2}$，$m=1000...0 \\to$1 01111110 10000000000000000000000= $0xBF400000$。\n(c) $FP16 bias=15$。$1.5 = 1.1_{2} \\times 2^{0}$。$s=0$，$e=15=01111_{2}$，$m=10 0000 0000 \\to$0 01111 1000000000= $0x3E00$。\n题 3（填表）：舍入模式 #对 1.5、−1.5、2.3 分别填出 6 种舍入模式的结果。\n题 3 解答 模式 1.5 −1.5 2.3 half-even 2 −2 2 half-away 2 −2 2 half-up 2 −1 2 truncation 1 −1 2 floor 1 −2 2 ceil 2 −1 3 题 4（计算）：熵 #(a) 分布 {0.5, 0.25, 0.25} 的熵是多少？与 2-bit 均匀分布比较。 (b) 一个 8-bit 均匀量化器，码本 256 个值；如果实际值只有其中 16 个等概率取值，熵是多少？这说明什么？\n题 4 解答 (a) $H = -0.5\\cdot \\log_2(0.5) - 0.25\\cdot \\log_2(0.25) - 0.25\\cdot \\log_2(0.25) = 0.5 + 0.5 + 0.5 = 1.5 bit$。2-bit 均匀分布熵= $2 bit$。前者用 1.5 bit 理论上就够，直接 2-bit 编码浪费 0.5 bit/样本。\n(b) 16 个等概率取值$\\to H = \\log_2(16) = 4 bit$。说明 256 个码字里 240 个是浪费的，等效只有 4 bit 的有效信息——量化器设计应该让\u0026quot;码本尽量贴着真实分布\u0026quot;（非均匀/分组动机，04/06 章）。\n题 5（推导）：截断噪声是舍入的 4 倍 #设均匀量化步长$\\Delta$，信号足够随机且无截断。证明向 0 截断的噪声功率（对称分布输入下）是舍入的 4 倍。\n题 5 解答 舍入误差均匀分布在$[-\\Delta /2, \\Delta /2]$：$Var = \\Delta ^{2}/12$。\n向 0 截断：正值误差均匀分布在$[0, \\Delta )$，负值误差均匀分布在$(-\\Delta , 0]$。对称输入下$E[\\varepsilon ]=0$，$E[\\varepsilon ^{2}] = (1/\\Delta )\\int _{0}^\\Delta x^{2} dx = \\Delta ^{2}/3$（正负各半，均值平方相同）。\n比值= $(\\Delta ^{2}/3)/(\\Delta ^{2}/12) = 4 \\to 10\\cdot \\log_{10}(4) \\approx 6.02 dB$。截断白白损失约 1 bit 的有效精度。\n题 6（挑战）：0.1 的 FP32 舍入 #0.1 的二进制是 $0.000110011001100110011001100..._2$（0011 循环）。推导它的 FP32 尾数舍入为什么得到\u0026quot;第 23 位进位\u0026quot;，并说明存储值比 0.1 大还是小。\n题 6 解答 规格化后尾数（含隐含位）为 $1.100110011001100110011001100..._2$，截到第 24 位（隐含位 + 23 位）。第 24 位之后是 1，且非零尾随（\u0026quot;\u0026gt; half\u0026quot;），所以按 round-to-nearest 进位：尾数最后一位$0 \\to 1$。进位后存储值略大于 0.1（0.100000001490116119384765625 \u0026gt; 0.1）。如果恰好是 half（后面全 0），half-even 规则会起作用；这里不是 half。\n11. 延伸阅读 # MIT 6.5940 Lecture 5 开场部分（Class Central）：数据类型总览 David Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic（浮点必读，网上免费）：IEEE 754 的舍入、epsilon、误差分析 IEEE 754-2019 标准概述（Wikipedia 词条即可）：次正规数、NaN、round-half-even Mark Horowitz, \u0026ldquo;Computing\u0026rsquo;s Energy Problem (and what we can do about it)\u0026rdquo;, ISSCC 2014：数据搬运能量的数量级证据 下一篇： 02 量化问题的形式化与均匀量化理论——用本章的编码与误差工具，正式建立量化的数学框架。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-01-%E6%95%B0%E5%80%BC%E7%BC%96%E7%A0%81%E4%B8%8E%E8%AE%A1%E7%AE%97%E6%9C%BA%E8%A1%A8%E7%A4%BA%E5%9F%BA%E7%A1%80/","section":"笔记","summary":"量化的本质是决定一个数用多少 bit、以什么格式表示。本文从信息论、整数补码、IEEE 754 浮点位布局讲到六种舍入模式，解释量化为什么用 round-half-even，以及截断噪声为什么是舍入的 4 倍。","title":"INT8 和 FP16 有什么区别？量化前的数值编码基础"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： 量化里的 FP16 和 INT8 到底差在哪｜下一篇： FP16、BF16、FP8、FP4 有什么区别\n对应：MIT 6.5940 Lecture 5（Quantization Part I）前半部分；Inference Engineering Ch 5 的数学基础。 学完本章你应该能：① 把任何量化方法归入\u0026quot;编码器 + 解码器 + 误差\u0026quot;的框架；② 徒手写出对称/非对称均匀量化的正向与反向公式；③ 推导并解释\u0026quot;每$bit \\approx 6 dB$\u0026quot;；④ 区分舍入误差与截断误差，并指出它们分别由什么造成；⑤ 理解为什么\u0026quot;范围利用率\u0026quot;是量化的第一性原理。\n目录（本章） # 本章目标 量化问题的一般形式 均匀（线性）量化 量化误差理论 量化器设计的四个旋钮 为什么神经网络能容忍量化 PTQ 与 QAT：两条路线的雏形 本章小结与\u0026quot;一句话记忆\u0026quot; 习题与解答 延伸阅读 1. 本章目标 #量化（quantization）在推理优化里承担的角色可以用一句话概括：在\u0026quot;表示一个数要花多少 bit\u0026quot;和\u0026quot;这个数被算错多少\u0026quot;之间做交易。\n本章不讨论任何具体模型，只建立一个严格的数学地基。后面的章节（04–08）全部是在这个地基上回答同一个问题：给定一个 LLM 的权重/激活/KV 分布，如何用最少的 bit、最小的质量损失把它表示出来，并且让硬件跑得快。\n2. 量化问题的一般形式 #2.1 定义 #令$r \\in \\mathbb{R}$为一个需要表示的实数（可以是权重 w、激活 a 或 KV cache 的值）。量化是这样一个映射：\n编码器（量化）$: f : \\mathbb{R} \\to Q, Q = \\{q_0, q_1, ..., q_{M-1}\\} \\subset \\mathbb{Z}, M = 2^b$ 解码器（反量化）$: g : Q \\to \\mathbb{R}, g(q_{i}) = \\hat{r}_i$\n其中 b 是位宽，$M = 2^b$是可表示的不同取值数量。量化后的数值集合 Q 远小于$\\mathbb{R}$，因此这是一个有损压缩过程：除了恰好落在某个$\\hat{r}_i$上的值，其余值都会引入误差$\\varepsilon = r - \\hat{r}$。\n信息论直觉：用一个 b bit 的码字表示一个连续量，等价于把实数轴切成$2^b$个区间，每个区间里的值都\u0026quot;坍缩\u0026quot;到同一个代表值。区间越粗（b 越小），每个值的失真越大。这就是率失真（rate-distortion）的雏形：rate（位宽）与 distortion（失真）不可兼得。\n2.2 在神经网络里的具体化 #一个线性层$y = Wx$在量化后变成：\n原始$: y = W x$ 量化$: \\hat{y} \\approx dequant(\\operatorname{quant}(W)) \\cdot dequant(\\operatorname{quant}(x))$\n$$ = \\hat{W} \\cdot \\hat{x} $$于是每一层的输出都携带了上一层权重和激活的量化误差。误差会沿网络传播（第 07/08 章会分析传播方式）。量化不要求$\\hat{W} = W$；目标是让整个模型的任务指标（perplexity、MMLU 分数……）退化到统计上与噪声不可区分。\n2.3 两种量化对象：数据分布 vs 计算 #论文里经常出现两组说法，容易混淆：\n说法 含义 weight-only quantization 只把权重存成低精度（W4A16 等），激活仍是高精度 W8A8 权重和激活都量化到 8-bit，矩阵乘在低精度 Tensor Core 上做 KV cache quantization 把解码时缓存的 Key/Value 张量降精度（省显存，08 章） 存 vs 算 权重可以\u0026quot;只省存储\u0026quot;（weight-only），也可以\u0026quot;省存储 + 加速计算\u0026quot;（W8A8） 为什么要区分\u0026quot;存\u0026quot;和\u0026quot;算\u0026quot;？因为推理的 decode 阶段是访存密集的：权重每用一次都要从 HBM 搬到寄存器，位宽减半 ≈ 带宽翻倍；而 prefill 阶段是计算密集的，需要低精度 Tensor Core 的 FLOPS 翻倍才有效果（详见 03 章硬件部分）。这一区分决定了\u0026quot;只量化权重\u0026quot;还是\u0026quot;权重+激活一起量化\u0026quot;的选择。\n3. 均匀（线性）量化 #3.1 定义 #均匀量化（uniform / linear quantization）：所有量化层级等距排列，相邻两层间距恒为$\\Delta$（称为步长 step size）。\n两种最常用的形式：\n（a）对称量化（symmetric）：零点$z = 0$，量化值域对称：\n$$ \\begin{aligned} q \u0026= \\operatorname{clamp}(\\operatorname{round}(r / s), q_{\\min}, q_{\\max}) \\hat{r} \u0026= q \\cdot s \\end{aligned} $$其中$s = \\max|r| / (2^{b-1} - 1)$（常用，值域对称，0 有精确表示） 或$s = \\max|r| / 2^{b-1}$（个别 kernel 用，把$\\pm 2^{b-1}$都利用上）\n对 INT8：$q_{\\min} = -128$，$q_{\\max} = 127$；若用 $s = \\max|r| / 127$，则$q \\in [-127, 127]$，−128 不用。\n（b）非对称量化（affine / asymmetric）：零点$z \\ne 0$：\n$$ \\begin{aligned} s \u0026= (r_{\\max} - r_{\\min}) / (q_{\\max} - q_{\\min}) z \u0026= \\operatorname{round}(q_{\\min} - r_{\\min} / s) q \u0026= \\operatorname{clamp}(\\operatorname{round}(r / s) + z, q_{\\min}, q_{\\max}) \\hat{r} \u0026= (q - z) \\cdot s \\end{aligned} $$非对称量化把 [rmin, rmax] 完整映射到 [qmin, qmax]，不浪费整数网格。代价是：矩阵乘时每个量化值要减去 z（多一次加法），硬件实现略贵。\n3.2 mid-tread 与 mid-rise #对称量化器还可以按\u0026quot;零点是不是量化层级\u0026quot;分成两类：\n类型 零点 例子（3-bit） 特点 mid-tread 0 是一个量化值 $q \\in \\{-4, -3, -2, -1, 0, 1, 2, 3\\}$ 能精确表示 0；适合权重（0 语义重要，如稀疏权重） mid-rise 0 落在两级之间 $q \\in \\{-4, -3, -2, -1, 1, 2, 3, 4\\}$ 偶数个层级，无精确 0；适合满量程正弦类信号 神经网络里默认选 mid-tread：权重里的 0 有语义（很多权重本来就接近 0，量化后变成 0 可以配合稀疏性）。\n3.3 为什么默认用均匀量化 #均匀量化的实现极其简单，完全贴合硬件：\n量化：一次除法 + round + clamp； 反量化：一次乘法； 矩阵乘：整数乘加（或 FP8 低精度 Tensor Core），累加器用 FP32，几乎不损失累加精度。 非均匀量化（如 k-means 量化、对数量化）用更少的码字逼近真实分布，但推理时需要查表或特殊解码，位宽不整齐、内存布局不友好。现代 LLM 量化论文（GPTQ/AWQ/QuIP#）基本都回到\u0026quot;均匀网格 + 更聪明的网格选择/缩放\u0026quot;，只是把功夫下在 scale 和 outlier 上。\n一句话：均匀量化 = \u0026ldquo;等间距网格\u0026rdquo;；非均匀 = \u0026ldquo;按分布密度布点\u0026rdquo;。硬件喜欢前者，精度喜欢后者，所以业界在两者之间折中（见 04 章粒度、06 章 QuIP# 的格码本）。\n3.4 伪代码（与 MIT Lab 2 对齐） # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 def get_quantized_range(b): \u0026#34;\u0026#34;\u0026#34;对称整数量化范围，如 b=8 -\u0026gt; (-128, 127)\u0026#34;\u0026#34;\u0026#34; return -(2 ** (b - 1)), 2 ** (b - 1) - 1 def quantize_symmetric(r, b, s=None): \u0026#34;\u0026#34;\u0026#34;r: 实数张量; b: 位宽; s: 缩放因子（None 则从数据算）\u0026#34;\u0026#34;\u0026#34; qmin, qmax = get_quantized_range(b) if s is None: s = max(abs(r)) / (2 ** (b - 1) - 1) # 对称缩放 q = round_(r / s) # 逐元素 round q = clamp(q, qmin, qmax) return q, s def dequantize_symmetric(q, s): return q * s def quantize_affine(r, b, rmin=None, rmax=None): qmin, qmax = get_quantized_range(b) if rmin is None: rmin = min(r) if rmax is None: rmax = max(r) s = (rmax - rmin) / (qmax - qmin) z = round(qmin - rmin / s) q = clamp(round(r / s) + z, qmin, qmax) return q, s, z def dequantize_affine(q, s, z): return (q - z) * s （round_ 用 banker\u0026rsquo;s rounding 或 round-half-away-from-zero 都可，工程上注意与 kernel 一致即可；MIT Lab 2 的实现与此等价。）\n3.5 数值算例 1：8-bit 对称量化 #输入：\n$$ r = [0.52, -1.31, 2.05, -0.87], b = 8, q_{\\max} = 127 $$计算：\n$$ \\begin{aligned} s \u0026= 2.05 / 127 \\approx 0.01614 r/s \u0026= [32.21, -81.16, 127.00, -53.90] q \u0026= [32, -81, 127, -54] \\hat{r} \u0026= [0.5165, -1.3075, 2.0500, -0.8717] \\varepsilon \u0026= r - \\hat{r} = [0.0035, -0.0025, 0, 0.0017] \\end{aligned} $$最大误差$|\\varepsilon |\\max \\approx 0.0035 \u003c \\Delta /2 = s/2 \\approx 0.00807 ✓$（满足舍入误差上界，因为所有值都在量化范围内，没有截断）。\n3.6 数值算例 2：4-bit 对称量化（同样的数据） #$b = 4, q_{\\max} = 7$（对称时$2^{4-1}-1 = 7$）\n$$ \\begin{aligned} s \u0026= 2.05 / 7 \\approx 0.2929 r/s \u0026= [1.78, -4.47, 7.00, -2.97] q \u0026= [2, -4, 7, -3] \\hat{r} \u0026= [0.5857, -1.1714, 2.0500, -0.8786] \\varepsilon \u0026= [-0.0657, -0.1386, 0, 0.0086] \\end{aligned} $$最大误差$|\\varepsilon |\\max \\approx 0.1386$，仍是$\\Delta /2 = s/2 \\approx 0.1464$以内。位宽从 8 降到 4，误差上限扩大了约 16 倍（$\\Delta$放大了 16 倍：$0.01614 \\to 0.2929$）。 注意：噪声功率理论上是$4^{4} = 256$倍（−24 dB），但这里样本只有 4 个数，均匀噪声假设不成立，实际比值会偏离——这正是\u0026quot;统计模型需要足够多样本\u0026quot;的例子（见 4.2）。\n3.7 数值算例 3：非对称量化\u0026quot;省位\u0026quot; #考虑 ReLU 之后的激活，全部非负：\n$$ r = [0.1, 0.9, 0.05, 2.0] $$对称 4-bit：$s = 2.0/7 \\approx 0.2857$，整数网格覆盖$[-2.0, 2.0]$，但数据只用了一半$\\to$量化层级浪费一半：\n$$ q = [0, 3, 0, 7] \\to \\hat{r} = [0, 0.857, 0, 2.0] $$非对称 4-bit：$s = (2.0 - 0.05)/15 = 0.13$，整数网格覆盖$[0.05, 2.0]$：\n$$ q = [1, 7, 0, 15] \\to \\hat{r} = [0.130, 0.910, 0, 1.950] $$误差从对称时的最大 0.1 降到约 0.05。结论：分布不对称时，非对称量化等于免费拿回被浪费的位——这是后面 SmoothQuant/激活量化的基础直觉之一。\n4. 量化误差理论 #4.1 误差分解：舍入 + 截断 #量化误差由两部分组成：\n$$ \\varepsilon = r - \\hat{r} = \\varepsilon_{\\text{round}} + \\varepsilon_{\\text{clip}} $$ 舍入误差$\\varepsilon_{\\text{round}}$：当 r 落在量化范围 [rmin, rmax] 内时，r 被就近映射到最近层级，误差≤ $\\Delta /2$。 截断误差$\\varepsilon_{\\text{clip}}$：当 r 超出 [rmin, rmax] 时，被 clamp 到边界，误差= $|r - r_{\\min}|$或 |r − rmax|，可以任意大，与位宽无关。 这是整个量化理论里最重要的一个划分，值得停下来想清楚：\n位宽决定\u0026quot;格子细不细\u0026quot;（舍入误差）；范围决定\u0026quot;边界在哪\u0026quot;（截断误差）。 大多数翻车事故来自截断误差——某个 outlier 值把范围撑得极大，导致大部分正常值的有效位宽被稀释，或者干脆被 clamp 掉。\nLLM 激活里恰好存在大量 outlier（少数维度值巨大），这正是 LLM.int8()、SmoothQuant、AWQ 全部要解决的同一个敌人（04、06、07 章）。\n4.2 加性噪声模型 #当 r 在量化范围内且值域被\u0026quot;充分激励\u0026quot;（样本足够多、分布不极端）时，可以把量化器建模为：\n$$ \\hat{r} = r + e, e \\sim Uniform(-\\Delta /2, \\Delta /2) $$两个性质：\n$E[e] = 0$（无偏） $Var[e] = \\Delta ^{2} / 12$（均匀分布方差：$\\int x^{2}/\\Delta dx over [-\\Delta /2, \\Delta /2]$）\n推导：均匀分布在$[-\\Delta /2, \\Delta /2]$的方差= $(\\Delta /2 - (-\\Delta /2))^{2}/12 = \\Delta ^{2}/12$。$\\Delta ^{2}/12$是量化噪声的教科书公式，后面所有 SNR 计算都从它出发。\n这个模型成立的条件是：舍入误差在各区间内均匀分布（对充分随机的信号近似成立）。小样本、周期性信号、有截断时都不成立——这也是为什么例 2 的噪声功率与理论有偏差。\n4.3 SNR 推导：每 bit ≈ 6 dB #设定：b-bit 均匀量化器（mid-rise，$2^b$个层级）覆盖满量程 [−A, A]；信号 r 在 [−A, A] 上均匀分布。\n步长：\n$$ \\Delta = 2A / 2^b $$信号方差（均匀分布）：\n$$ \\sigma _s^{2} = (2A)^{2} / 12 = A^{2} / 3 $$噪声方差（4.2 的公式）：\n$$ \\sigma _e^{2} = \\Delta ^{2} / 12 = (2A / 2^b)^{2} / 12 = A^{2} / (3 \\cdot 4^b) $$信噪比：\n$$ \\begin{aligned} SNR \u0026= \\sigma _s^{2} / \\sigma _e^{2} = (A^{2}/3) / (A^{2}/(3\\cdot 4^b)) = 4^b SNR(dB) \u0026= 10\\cdot \\log_{10}(4^b) = b \\cdot 10\\cdot \\log_{10}(4) \\approx 6.02 \\cdot b dB \\end{aligned} $$结论：位宽每增加 1 bit，信噪比提升约 6 dB（噪声功率降为原来的 1/4）。 这就是\u0026quot;6 dB per bit\u0026quot;的来历。\n两个常用的变体（推导完全相同，只是信号方差不同）：\n信号模型 信号方差$\\sigma _s^{2}$ SNR(dB) 满量程均匀分布 $A^{2}/3$ 6.02·b 满量程正弦（振幅 A） $A^{2}/2$ 6.02·b + 1.76 半量程均匀分布（只用到$[-A/2, A/2]$） $A^{2}/12$ 6.02·(b−1) 最后一行非常关键：量化范围只用一半，等于白丢 1 bit。 推广：如果信号实际只占量化范围的$1/2^k$，就损失约 k·6 dB（k 个有效位）。这把\u0026quot;范围利用率\u0026quot;和\u0026quot;有效位宽\u0026quot;直接挂钩——04 章 outlier 问题的数学根源就在这里。\n4.4 直觉：1 bit 到底意味着什么 # 噪声功率：×1/4（6 dB 约等于\u0026quot;音量减半\u0026quot;） 权重矩阵：存储减半、访存带宽等效翻倍 计算：低精度 Tensor Core FLOPS 翻倍 所以\u0026quot;量化降一级 30–50% 性能提升\u0026quot;（Inference Engineering Ch5 的结论）的账是：少一半的存储/带宽/计算精度，换近似翻倍的吞吐，代价是 6 dB 的噪声预算。\n5. 量化器设计的四个旋钮 #一个均匀量化器由四个旋钮完全确定，后面所有论文都是在调这四个旋钮：\n5.1 位宽 b #决定噪声上限（6 dB/bit）和压缩率。INT8 是默认起点；4-bit 是当前 LLM 权重的激进甜点；1.58-bit（BitNet）是极限探索。\n5.2 范围 [rmin, rmax]（等价于 s、z） #决定截断误差与范围利用率。范围怎么选？从校准数据（calibration set）统计：\n朴素：$\\min/\\max \\to$对 outlier 极敏感（范围被撑大，有效位宽被稀释） 稳妥：分位数（如 99.99% 分位）$\\to$牺牲少量截断误差，换正常值更高的精度 更细：per-channel / per-group 分别选范围（04 章）\n5.3 对称 vs 非对称 #见 3.7：分布是否含符号、是否接近 0 决定选择。硬件上对称更便宜（无 z 减法），非对称更省位。\n5.4 粒度（granularity） #一个 scale 覆盖多少个元素：\nper-tensor（整层一个 s）$\\to per-channel$（每行/列一个 s）$\\to per-group$（每 G 个元素一个 s）\n粒度越细，对分布适应越好、误差越小，但 scale 本身要占存储、kernel 要处理非均匀布局。粒度是\u0026quot;精度 vs 开销\u0026quot;的连续光谱，04 章单独展开。\n6. 为什么神经网络能容忍量化 #既然每个数都被污染了 6–24 dB 的噪声，为什么网络还能工作？四个层次的解释：\n冗余性：模型参数量远超信息需求。一个 70B 模型的大部分权重对输出的影响极小，删掉/量化它们几乎不可感知（这也是剪枝 work 的原因，MIT 6.5940 Lecture 3/4）。 平均化效应：单个数被污染影响小，很多数一起被污染时，误差在求和/求平均中部分抵消（随机误差的 √N 平均）。线性层的输出是成千上万个乘积之和，误差不是简单叠加。 鲁棒的优化目标：训练时 loss 已经对权重噪声有一定容忍度；QAT 更进一步让模型\u0026quot;学着忍受\u0026quot;量化噪声（09 章）。 不同张量的敏感度不同：权重量化误差是\u0026quot;静态污染\u0026quot;，可以用校准数据事后补偿（GPTQ/AWQ）；激活是\u0026quot;动态污染\u0026quot;，逐 token 变化，更难对付；KV cache 误差会跨 token 累积（08 章）；attention/softmax 对数值范围极其敏感。于是有了 Inference Engineering Ch5 的敏感性排序： 权重（最不敏感）\u0026lt; 激活 \u0026lt; KV cache \u0026lt; attention/softmax（最敏感）\n这个排序决定了后文的攻坚顺序：先量化权重（05/06），再碰激活（07），谨慎处理 KV（08），最后才考虑 attention/softmax 这类敏感算子（11）。\n7. PTQ 与 QAT：两条路线的雏形 #7.1 PTQ（Post-Training Quantization） #训练完成后直接量化：\n流程：加载 FP16/BF16 权重$\\to$用少量校准数据统计范围$\\to$量化$\\to$部署 优点：不需要训练、不需要原始训练数据、几小时内完成 缺点：误差\u0026quot;事后发生\u0026quot;，模型没有机会适应；只能靠更好的量化算法弥补\n本系列 05–08 章全部是 PTQ 算法（RTN/GPTQ/AWQ/SmoothQuant/KIVI 等）。\n7.2 QAT（Quantization-Aware Training） #训练过程中就模拟量化误差：\n流程：前向时把权重/激活\u0026quot;假装\u0026quot;量化（$\\operatorname{quantize} \\to \\operatorname{dequantize}$）$\\to$反向传播更新 关键：量化是分段常数函数，梯度几乎处处为$0 \\to$用 STE（straight-through estimator）把梯度近似传过去 优点：质量上限高，模型学会了容忍噪声 缺点：需要训练数据与算力\n09 章会完整推导 STE 并比较 PTQ/QAT 的精度-成本曲线。\n现在的工程常态：先 PTQ 用默认配方（FP8/W8A8）上线，质量不达标再升级（更好的 PTQ 算法$\\to KV$量化验证$\\to$局部$QAT \\to$全量 QAT）。不要一上来就 QAT。\n8. 本章小结与\u0026quot;一句话记忆\u0026quot; # 量化 = 有损压缩：$2^b$个码字表示实数轴，b 决定格子的粗细。 均匀量化 = 等距网格：对称（$z=0$，省事）vs 非对称（$z\\ne 0$，省位）；mid-tread 保 0。 误差 = 舍入 + 截断：位宽管舍入（$\\Delta /2$上界），范围管截断（无上界）。outlier 主要制造截断误差。 每$bit \\approx 6 dB$：噪声功率 ×1/4；量化范围只用一半 = 白丢 1 bit。 四个旋钮：位宽、范围、对称性、粒度——所有论文都在调这四个旋钮。 敏感性排序：权重 \u0026lt; 激活 \u0026lt; KV cache \u0026lt; attention，决定进攻顺序。 一句话记忆：\u0026ldquo;先选格子粗细（b），再选格子放哪（范围），最后决定谁跟谁共用一个格子（粒度）。\u0026rdquo;\n9. 习题与解答 #题 1（手算）：对称量化 #对$r = [3.2, -1.7, 0.05, -4.9]$：\n(a) 用 8-bit 对称量化，写出 s、q、$\\hat{r}$、最大误差。 (b) 用 4-bit 对称量化，重复 (a)。 (c) 比较两者的$\\Delta$和最大误差，验证\u0026quot;位宽减 4，$\\Delta$放大 16 倍\u0026quot;。\n题 1 解答 (a) $s = 4.9/127 \\approx 0.03858$；$r/s \\approx [82.9, -44.1, 1.3, -127.0] \\to q = [83, -44, 1, -127]$；$\\hat{r} \\approx [3.202, -1.698, 0.039, -4.900]$；$|\\varepsilon |\\max \\approx 0.0113 \u003c s/2 \\approx 0.0193$。\n(b) $s = 4.9/7 = 0.7$；$r/s \\approx [4.57, -2.43, 0.071, -7.0] \\to q = [5, -2, 0, -7]$；$\\hat{r} = [3.5, -1.4, 0, -4.9]$；$|\\varepsilon |\\max = 0.3$。\n(c) $\\Delta _8 = 2s_8 \\approx 0.0772$，$\\Delta _4 = 2s_4 = 1.4$；$1.4/0.0772 \\approx 18.1$（小样本下略偏离理论 16，因为$127/7 \\approx 18.1——$注意这里对称量化用$2^{b-1}-1$作分母，所以严格说$\\Delta$比值是 127/7）。理论值用$2^{b-1}$作分母时为 16。两个约定都要会。\n题 2（推导）：6 dB/bit 的另一种推法 #不用均匀分布假设，直接从$\\Delta$出发：证明把位宽从 b 增加到 b+1（范围不变），量化噪声功率降为原来的 1/4，SNR 提升 6 dB。\n题 2 解答 范围 [−A, A] 不变时，$\\Delta _{b+1} = 2A/2^{b+1} = \\Delta _b / 2$。噪声功率$\\propto \\Delta ^{2}$，所以$\\sigma _e^{2}(b+1) = \\sigma _e^{2}(b)/4$。SNR(dB) 提升= $10\\cdot \\log_{10}(4) \\approx 6.02 dB$。与分布无关，只依赖\u0026quot;均匀量化 + 范围固定 + 无截断\u0026quot;三个假设。\n题 3（思考）：mid-tread vs mid-rise #为什么权重量化几乎总是用 mid-tread？如果权重矩阵有 95% 的元素是 0，两种量化器分别会发生什么？\n题 3 解答 mid-tread 的 0 是精确量化层级：$0 \\to 0$，无误差，且与稀疏性天然兼容。mid-rise 的 0 会被量化到$\\pm \\Delta /2$，95% 的元素全部产生$\\pm \\Delta /2$的误差，噪声功率会非常高，而且破坏稀疏结构（0 变成非 0）。所以对称整数量化默认 mid-tread。\n题 4（编程，建议在 MIT Lab 2 环境里做） #实现 $\\text{quantize\\_symmetric}$ / $\\text{quantize\\_affine}$ / dequantize（3.4 的伪代码），然后：\n(a) 对 N(0,1) 随机张量（$N=100000$）测$SQNR = 10\\cdot \\log_{10}(\\sum r^{2}/\\sum (r-\\hat{r})^{2})$，位宽 4/6/8/10/12，画 SQNR vs b，验证斜率≈ $6 dB/bit$。 (b) 把同样的张量先放大 100 倍（模拟 outlier 撑大范围），再量化到 8-bit，观察 SQNR 掉了多少 dB，并解释（对应 4.3 的\u0026quot;半量程 −6 dB\u0026quot;）。 (c) 对比对称与非对称量化在$[0, 5]$均匀分布上的 SQNR（对应 3.7）。\n题 4 解答要点 (a) 满量程均匀信号的 SQNR 应近似 6.02·b dB；N(0,1) 是高斯，非满量程均匀，斜率仍约 6 dB/bit，但常数项不同（高斯重尾，偶有截断）。 (b) 放大 100 倍后范围$[-100\\sigma , 100\\sigma ]$，正常值只占很小比例$\\to$有效位宽减少$\\log_2(100)\\approx 6.6 bit$，SQNR 掉约 40 dB（放大倍数越大越明显）。 (c) 对称量化覆盖$[-5,5]$，一半网格浪费$\\to$有效位宽 −1 bit，SQNR 比非对称低约 6 dB。\n题 5（挑战）：范围利用率的数学 #证明：若信号均匀分布在$[-A/2, A/2]$，而量化器范围是 [−A, A]，则量化后等效于用 b−1 bit 量化满量程信号（即$SQNR = 6.02(b-1) dB$）。\n题 5 解答 $\\sigma _s^{2} = (A/2)^{2}/3 = A^{2}/12$；$\\sigma _e^{2}$不变（$\\Delta$由量化器范围决定）= $A^{2}/(3\\cdot 4^b)$；$SNR = (A^{2}/12)/(A^{2}/(3\\cdot 4^b)) = 4^b/4 = 4^{b-1} \\to 6.02(b-1) dB$。范围利用率 k 分之$1 =$丢 log2(k) 个有效位。\n10. 延伸阅读 # MIT 6.5940 Lecture 5 – Quantization Part I（Fall 2024，Class Central）：线性量化、bitwidth、PTQ 总览 MIT 6.5940 Lab 2：Quantization：linear quantize / k-means 量化的动手实现（对应本系列习题环境） Inference Engineering Ch 5：教材正文（格式总览、敏感性排序、质量评估） Gersho \u0026amp; Gray, Vector Quantization and Signal Compression：均匀量化误差理论的经典教材（$\\Delta ^{2}/12$、6 dB/bit 的出处） 上一篇： 01 数值编码与计算机表示基础——整数/浮点/舍入/截断的计算机表示，本章的数学工具都建立在其上 下一篇：[03 数值格式：FP16/BF16/FP8/FP4/MXFP/NVFP4 与硬件]——把\u0026quot;格子\u0026quot;具体到硬件支持的浮点格式，回答\u0026quot;为什么 FP8 是甜点、BF16 为什么适合训练、FP4 为什么必须配块缩放\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-02-%E9%87%8F%E5%8C%96%E9%97%AE%E9%A2%98%E5%BD%A2%E5%BC%8F%E5%8C%96%E4%B8%8E%E5%9D%87%E5%8C%80%E9%87%8F%E5%8C%96%E7%90%86%E8%AE%BA/","section":"笔记","summary":"把任意量化方法拆成编码器、解码器、误差三部分，推导对称与非对称均匀量化的正向与反向公式，解释「位宽每减 1、SNR 涨约 6 dB」，并说明为什么范围利用率是量化的第一性原理。","title":"量化误差是怎么算出来的？均匀量化公式推导"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： 量化误差是怎么算出来的｜下一篇： 量化粒度怎么选\n对应：Inference Engineering Ch5 的 Number Formats 部分；NVIDIA/Arm/Intel《FP8 Formats for Deep Learning》白皮书；OCP Microscaling Formats (MX) 规范；MIT 6.5940 Lecture 5 的数据类型总览。 学完本章你应该能：① 从位布局推导任意浮点格式的最大值、最小正常值、machine epsilon；② 解释 E4M3 与 E5M2 的区别及各自适用场景；③ 说明 MXFP8/NVFP4 的\u0026quot;块缩放\u0026quot;到底解决了什么问题；④ 用带宽模型手算\u0026quot;70B 模型 decode 每 token 至少多少毫秒\u0026quot;；⑤ 论证\u0026quot;FP8/MXFP8 是生产甜点\u0026quot;。\n目录（本章） # 本章目标 从 IEEE 754 到推理格式：一张家族谱系 16-bit 的两种哲学：FP16 与 BF16 FP8 深入：E4M3 与 E5M2 FP4 与块缩放：NVFP4、MXFP4 Microscaling（MX）格式：共享指数缩放 硬件：Tensor Core、FLOPS 与带宽模型 格式选择决策框架：为什么 FP8 是甜点 格式速查表 本章小结 习题与解答 延伸阅读 1. 本章目标 #01 章我们建立了\u0026quot;浮点 = 符号位 + 偏置指数 + 尾数，指数换范围、尾数换精度\u0026quot;的框架；02 章建立了\u0026quot;每$bit \\approx 6 dB$、范围利用率决定有效位宽\u0026quot;的误差理论。本章把这两个框架套到真实的推理格式上，并回答三个问题：\n每种格式的位布局长什么样，它的最大值/精度/适用范围怎么算？ 为什么推理工程给出的格式表里，FP8 是\u0026quot;质量/速度甜点\u0026quot;、FP4 是\u0026quot;激进选项\u0026quot;、NVFP4 是\u0026quot;FP4 里精度最好\u0026quot;？ 位宽到底如何变成毫秒和 token/s？（带宽模型） 2. 从 IEEE 754 到推理格式：一张家族谱系 #常见的推理格式可以放进下面这张谱系（按\u0026quot;数据如何编码\u0026quot;分类）：\n表示一个实数 │ ┌──────────────┼──────────────────┐ 整数/定点 浮点（指数+尾数） 混合/块缩放 INT8/INT4 FP16/BF16/FP8/FP4 MXFP8/MXFP4/NVFP4 等距网格 每元素独立指数 块共享指数缩放 动态范围差 动态范围好 动态范围好 + 省位 关键认知：\n整数/定点：网格等距，动态范围完全由位宽决定。outlier 一旦出现，整层范围就被撑大，正常值的有效位宽被稀释（02 章）。 浮点：每个值自带指数，能跨数量级表示数值。这就是 Inference Engineering 说的\u0026quot;exponent gives higher dynamic range than integers, better representing outliers\u0026quot;。 块缩放（block scaling / microscaling）：为了在低位数里保留动态范围又不为每个值付指数位的代价，让一组元素共享一个缩放因子。这是 MXFP8/MXFP4/NVFP4 的设计哲学；Blackwell 原生支持的就是这类格式。 3. 16-bit 的两种哲学：FP16 与 BF16 #3.1 位布局与数值表 # 格式 S E M（存储） bias 最大正常值 最小正常值 $\\varepsilon$ FP16 1 5 10 15 65,504 $2^{-14} \\approx 6.1e-5$ $2^{-10} \\approx 9.8e-4$ BF16 1 8 7 127 ≈ $3.39e38$（同 FP32） $2^{-126}$（同 FP32） $2^{-7} \\approx 7.8e-3$ 推导示例（FP16 最大值）：\nFP16 指数域$e \\in [1, 30]$，最大正常指数真值= $30 - 15 = 15$ 最大尾数= $1.1111111111_{2} = 2 - 2^{-10}$ 最大值= $(2 - 2^{-10}) \\times 2^{15} = 1.9990234375 \\times 32768 = 65,504$\n3.2 为什么训练用 BF16、推理默认 FP16 #训练（尤其预训练）： 梯度跨多个数量级（$10^{-6} \\sim 10^{2}$），范围比精度重要$\\to BF16$（指数$8 bit = FP32$的范围） 代价：尾数 7 bit，相对精度只有$\\sim 0.8\\%$，但训练有 FP32 master weights 兜底\n推理： 权重/激活值域已知且稳定（通常$\\pm$几十），范围够用$\\to FP16$（尾数 10 bit，精度高） 代价：范围小，遇到极端 outlier 会溢出（max 65,504）\n推理要精度、训练要范围，所以两者分工。\n顺带一提 TF32：Ampere 训练用的 19-bit 格式（8 位指数 + 10 位尾数），是 FP32 输入的\u0026quot;截断版\u0026quot;，用于加速矩阵乘。它不是推理格式，但体现了同一 tradeoff。\n4. FP8 深入：E4M3 与 E5M2 #4.1 位布局 #FP8 是 NVIDIA/Arm/Intel 2022 年联合发布的白皮书格式（arXiv:2209.05433），两种变体：\nE4M3：S(1) + E(4) + M(3) 指数偏置 7 E5M2：S(1) + E(5) + M(2) 指数偏置 15\n名字里的 E×M× 就是\u0026quot;指数位数 × 尾数位数\u0026quot;——看到任何格式名，第一反应就是套 01 章的总纲：指数位多$\\to$范围大精度低；尾数位多$\\to$精度高范围小。\n4.2 E4M3 数值推导（完整） #$bias = 7$，指数域$e \\in [0, 15]$\n规格化数（$1 \\le e \\le 14$）： 最小正常值= $1.0 \\times 2^{1-7} = 2^{-6} \\approx 0.0156$ 常规最大正常值= $(2 - 2^{-3}) \\times 2^{14-7} = 1.875 \\times 128 = 240$\nE4M3FN 的扩展（没有 Infinity）： $e = 15$时，$m = 000\\sim 110$仍作为有限数： 最大值= $1.11_{2} \\times 2^{15-7} = 1.75 \\times 256 = 448$ $m = 111$保留给 NaN（FP8 无 ∞）\n次正规数：最小次正规= $2^{-6} \\times 2^{-3} = 2^{-9} \\approx 1.95e-3$ 相对精度：$2^{-3} = 12.5\\%$\n4.3 E5M2 数值推导 #$bias = 15$，指数域$e \\in [0, 31]$\n规格化数（$1 \\le e \\le 30$）： 最小正常值= $2^{1-15} = 2^{-14} \\approx 6.1e-5$ 最大值= $(2 - 2^{-2}) \\times 2^{30-15} = 1.75 \\times 32768 = 57,344$\ne = 31：m = 0 $\\to$ $\\pm$ $\\infty$ ；m $\\ne$ 0 $\\to$ NaN\n相对精度：$2^{-2} = 25\\%$\n4.4 E4M3 vs E5M2 怎么选 # E4M3 E5M2 指数/尾数 4 / 3 5 / 2 最大值 448 57,344 最小正常值 $2^{-6}$ $2^{-14}$ 相对精度 12.5% 25% 特殊值 无 ∞（NaN 唯一） $\\pm \\infty$、NaN 白皮书建议 权重与激活（前向） 梯度（反向）与需要大范围的场景 直觉：权重/激活的值集中在$\\pm$几十，精度更重要$\\to E4M3$；梯度的数量级波动大，范围更重要$\\to E5M2$。\nFP8 与 INT8 的本质区别：FP8 的指数位让它在不增加位宽的情况下保留了动态范围。量化 LLM 时同样的 8 bit，FP8 对 outlier 的容忍度远高于 INT8——这是\u0026quot;FP8 甜点\u0026quot;的第一个论据。\n5. FP4 与块缩放：NVFP4、MXFP4 #5.1 裸 FP4（E2M1）：16 种取值 #FP4 元素格式 E2M1（1 符号 + 2 指数 + 1 尾数，bias 1）的全部取值：\n$\\pm 0$，$\\pm 0.5$，$\\pm 1$，$\\pm 1.5$，$\\pm 2$，$\\pm 3$，$\\pm 4$，$\\pm 6$（共 16 种，含符号）\n推导：$e=0$次正规 0.5；$e=1 \\to 1$、1.5；$e=2 \\to 2$、3；$e=3$（无 ∞ 时扩展）$\\to 4$、6。\n裸 FP4 的问题：最大值只有 6，且层与层之间数值尺度差异巨大（不同层激活的典型幅度可以差几个数量级）。直接对整层用同一个 FP4 格式，绝大多数值要么溢出要么精度被浪费。\n5.2 块缩放：让 FP4 能用 #解决方案是给一小块元素配一个缩放因子：\n存储：每个元素 4 bit（E2M1） 每 16 或 32 个元素共享 1 个 block scale（8/16 bit） 解码：$\\hat{r} = \\text{element\\_value} \\times \\text{block\\_scale}$\n这样既保留了浮点的动态范围（scale 覆盖数量级），又把元素压到 4 bit。\n5.3 NVFP4：NVIDIA 的 Blackwell 4-bit 方案 #元素：E2M1（4 bit） 块大小：16（比 MXFP4 的 32 更细） 块缩放：FP8 E4M3（8 bit，非 2 的幂$\\to$更精细） 张量缩放：额外一个 FP32 scale 硬件：Blackwell 原生\nNVIDIA 官方博客（2025-06）给出的动机：块从 32 缩到 16，缩放因子能更\u0026quot;贴身\u0026quot;地适配局部动态范围；块缩放用 E4M3 而不是纯 2 的幂，进一步减少量化误差。这就是 Inference Engineering 表格里\u0026quot;$NVFP4 = Best FP4 accuracy (block size 16)$\u0026ldquo;的依据。\n5.4 MXFP4：开放标准版 #元素：E2M1（4 bit） 块大小：32 块缩放：E8M0（8 bit 纯指数，2 的幂） 标准：OCP Microscaling Formats\nMXFP4 的 scale 是 2 的幂（E8M0，见 6.2），实现更简单、更省（不用归一化尾数），但缩放粒度不如 NVFP4 的 E4M3 精细。\nNVFP4 MXFP4 元素 E2M1 E2M1 块大小 16 32 块缩放 FP8 E4M3 E8M0（2 的幂） 额外缩放 FP32 张量 scale 无 标准 NVIDIA 专有 OCP 开放标准 6. Microscaling（MX）格式：共享指数缩放 #6.1 设计动机 #回顾浮点格式的本质：每个值花 bit 存自己的指数。位数越低，指数越贵（FP4 里 2 个指数位占了 50% 的预算）。\nMicroscaling 的思路：把指数从每个值移到一块值上共享：\n传统浮点：每个值 = 尾数 + 自己的指数 MX 格式： 每个值 = 尾数（低精度元素）+ 整块共享的指数（E8M0 scale）\n6.2 E8M0：纯指数缩放 #$E8M0 = 8 bit$，无符号、无尾数：$s = 2^{e - 127}$，$e \\in [0, 255]$ 只表达 2 的幂次缩放，不参与\u0026quot;值\u0026quot;本身\n6.3 MXFP8 / MXFP6 / MXFP4 #OCP MX 规范定义了三种主力格式：\n格式 元素 块大小 scale MXFP8 E4M3 E4M3 32 E8M0 MXFP8 E5M2 E5M2 32 E8M0 MXFP6 E3M2 / E2M3 32 E8M0 MXFP4 E2M1 32 E8M0 Blackwell（SM 100+）原生加速 MX 格式的点积。\n6.4 MX 为什么精度更好 #同一个张量里，不同区域的数量级可能差很远。MX 让每 32 个元素独立适配自己的数量级，等效于\u0026quot;per-block 的指数\u0026rdquo;：\nper-tensor FP8：整层一个数量级$\\to$局部小值被大值\u0026quot;吃掉精度\u0026quot; MXFP8：每块一个$E8M0 \\to$局部数量级自动对齐$\\to$有效精度接近\u0026quot;每块独立 FP8\u0026quot;\n代价：scale 要额外存储（每 32 元素$8 bit \\to$每元素 0.25 bit 开销）和计算（解码时乘一次）。这是 Inference Engineering 里\u0026quot;$MXFP8 = FP8$的精度升级版\u0026quot;的技术含义。\n7. 硬件：Tensor Core、FLOPS 与带宽模型 #7.1 Tensor Core 简史：精度下降的驱动力 #Pascal (2016)：FP16 Tensor Core 登场（推理默认 FP16 的硬件起点）\nAmpere (2020)：TF32 / BF16 / INT8\nHopper (2022)：FP8（E4M3/E5M2），FLOPS 翻倍 Blackwell (2024)：FP4 / MXFP8 / MXFP4 原生\n关键事实：位宽减半，Tensor Core 的密集吞吐约翻倍：\nH100 SXM：FP16 $\\approx$ 989 TFLOPS（dense），FP8 $\\approx$ 1979 TFLOPS\nB200：$FP8 \\approx 4.5 PFLOPS$，$FP4 \\approx 9 PFLOPS$（约 2 倍 FP8）\n这就是\u0026quot;prefill 阶段量化降一级、FLOPS 翻倍\u0026quot;的出处。\n7.2 decode 带宽模型：位宽 = 毫秒 #decode 阶段每个 token 都要把权重从 HBM 搬一遍。设模型参数量 N，权重位宽 B bit，带宽 BW：\n每 token 权重搬运时间= $N \\times B/8 / BW$\n70B 模型、H100（$BW \\approx 3.35 TB/s$）： FP16：$70e9 \\times 2 / 3.35e12 \\approx 41.8 ms/token \\to$上限$\\sim 24 tok/s$ FP8 ：$70e9 \\times 1 / 3.35e12 \\approx 20.9 ms/token \\to$上限$\\sim 48 tok/s$ FP4 ：$70e9 \\times 0.5 / 3.35e12 \\approx 10.5 ms/token \\to$上限$\\sim 96 tok/s$\n三个结论：\ndecode 是访存密集的：算力根本不是瓶颈，HBM 带宽才是；量化权重 = 直接减搬运量。 每降一级，等效带宽约翻倍：这与 Inference Engineering 的\u0026quot;30–50% 性能提升/级\u0026quot;一致（实际还有 kernel 开销、激活和 KV 的带宽，所以是 30–50% 而不是 100%）。 FP4 的收益在 decode 端最大：这也是为什么权重量化（W4A16/W4A8）在服务端如此流行。 7.3 prefill 计算模型：位宽 = FLOPS #推理 forward 每 token 的$FLOPs \\approx 2N$（N 为参数量；乘法 + 加法各一次）：\n70B 模型、2048 token 的 prefill：\n$$ \\text{FLOPs} \\approx 2 \\times 70e9 \\times 2048 \\approx 287 \\text{ TFLOP} $$按理论峰值，H100 FP16（989 TFLOPS）≈ 0.29 s；FP8（1979 TFLOPS）≈ 0.145 s\n这就是\u0026quot;prefill 是计算密集、量化降一级 FLOPS 翻倍、prefill 时间减半\u0026quot;的出处。\n把 7.2 和 7.3 放在一起，就得到推理工程的完整图景：量化对 prefill 的作用在计算单元（FLOPS 翻倍），对 decode 的作用在数据通路（带宽翻倍）。两者的共同分母都是\u0026quot;位宽\u0026quot;。\n8. 格式选择决策框架：为什么 FP8 是甜点 #综合 01–03 章，把候选格式放进\u0026quot;质量 × 速度 × 风险\u0026quot;坐标系：\n格式 位宽 相对速度 相对精度 质量风险 适用 FP16 16 1x 高 无 默认推理基线 BF16 16 $\\sim 1x$ 中（范围大） 低 训练 / 高动态范围 FP8（E4M3） 8 $\\sim 1.5x$ 中 低 生产甜点 MXFP8 8 $\\sim 1.5x$ 中高 低 精度敏感的生产场景 FP4 4 $\\sim 2x$ 低 高 激进压缩 NVFP4 4 $\\sim 2x$ 低中 中高 Blackwell 上的 4-bit 首选 \u0026ldquo;FP8 是甜点\u0026quot;的三个论据：\n质量：E4M3 的取值范围见 4.2（$2^{-6}$ 到 448）；配合 SmoothQuant（07 章）的 W8A8 在主流 LLM 上几乎无损。 速度：prefill 2 倍 FLOPS、decode 2 倍带宽（7.2/7.3），端到端约 1.5x（取决于 kernel 与负载）。 风险可控：权重 + 激活量到 FP8、KV cache 谨慎处理、attention 保持原精度——这是 Inference Engineering 的 Key Takeaway，也是当前生产共识。 FP4 的定位：在 Blackwell 上、质量评测通过的前提下做激进压缩（省 75% 权重显存）。NVFP4 优先于裸 FP4/MXFP4（块更细、scale 更精）。\n9. 格式速查表 # 格式 S E M bias 最大值 最小正常值 最小次正规 $\\varepsilon$ 可表示取值 FP16 1 5 10 15 65,504 $2^{-14}$ $2^{-24}$ $2^{-10}$ 65,536 BF16 1 8 7 127 $\\sim 3.4e38$ $2^{-126}$ $2^{-133}$ $2^{-7}$ 65,536 FP8 E4M3 1 4 3 7 448 $2^{-6}$ $2^{-9}$ $2^{-3}$ 256 FP8 E5M2 1 5 2 15 57,344 $2^{-14}$ $2^{-16}$ $2^{-2}$ 256 FP4 E2M1 1 2 1 1 6 1 — $2^{-1}$ 16 MXFP8 1 4/5 3/2 块共享 同 FP8 × 块 scale — — 同 FP8 256 × 块 NVFP4 1 2 1 块共享 6 × 块 scale — — $2^{-1}$ 16 提示：FP16/BF16 的\u0026quot;可表示取值 65,536\u0026quot;是位模式数（含$NaN/Inf/\\pm 0$），不是有效实数个数；FP8/FP4 同理。表格来自 Inference Engineering，语义是\u0026quot;码本大小上限\u0026rdquo;。\n10. 本章小结 # 浮点 = 符号 + 偏置指数 + 尾数；指数位买动态范围，尾数位买精度——所有格式差异都能从这推导。 FP8 E4M3（权重/激活）与 E5M2（梯度）是同一预算的两种分配；E4M3FN 最大值 448、无 ∞。 FP4 必须配块缩放：NVFP4（块 16 + E4M3 scale）比 MXFP4（块 32 + E8M0）精度更好。 MX 格式把指数从\u0026quot;每值\u0026quot;改成\u0026quot;每块\u0026quot;，是低位数保留动态范围的优雅方案（Blackwell 原生）。 位宽 × 硬件 = 性能：decode 带宽模型（$140GB/3.35TB/s \\approx 42ms$）与 prefill 计算模型（2N FLOPs/token）是量化的两个收益来源。 FP8/MXFP8 是生产甜点：质量几乎无损、速度约 1.5x、风险可控；FP4/NVFP4 是 Blackwell 上的激进选项。 11. 习题与解答 #题 1（推导）：MXFP8 的块开销 #MXFP8 块大小 32、scale 为 E8M0（8 bit）。计算每元素存储开销，以及相对 8-bit 数据的百分比开销。\n题 1 解答 每元素 scale 开销= $8/32 = 0.25 bit$；相对数据本身（8 bit）：$0.25/8 = 3.125\\%$。 结论：MX 格式用$\\sim 3\\%$的存储开销换来每块独立的动态范围，性价比很高。\n题 2（计算）：H100 上的 decode 上限 #H200 带宽 4.8 TB/s，跑 405B FP8 模型。decode 每 token 的最小搬运时间是多少？上限 TPS 是多少？\n题 2 解答 $405e9 \\times 1 byte / 4.8e12 \\approx 84.4 ms/token \\to$上限≈ $11.8 tok/s$。这是纯带宽下限，实际还有 KV cache 读写、激活、kernel 开销，只会更低。这也是为什么 400B 级模型必须上多卡张量并行（10/11 章）。\n题 3（手算）：E4M3 的 min normal / max #不用查表，从位布局推导 E4M3 的：min normal、max、min subnormal。\n题 3 解答 $bias=7$。$\\min normal = 2^{1-7} = 2^{-6}$。max（E4M3FN，$e=15$，$m=110$）= $1.11_{2} \\times 2^{15-7} = 1.75\\times 256 = 448$。$\\min subnormal = 2^{-6} \\times 2^{-3} = 2^{-9}$。（注意$e=15$且$m=111$是 NaN；$m=000\\sim 110$是有限数。）\n题 4（思考）：为什么训练不直接用 FP8 E4M3 #既然 FP8 推理这么好，训练（前向+反向）为什么主流还是 BF16/FP32？\n题 4 解答 训练梯度跨多个数量级，E4M3 最大 448、精度 12.5%，梯度容易溢出/欠精度；反向的梯度用 E5M2 也仍然太粗，且训练需要 FP32 master weight 做优化器状态。推理只有前向、值域可控、可校准，所以 FP8 够用。FP8 训练（如 DeepSeek-V3）能跑，但需要大量工程（loss scaling、分块缩放）才稳定。\n题 5（编程）：格式模拟 #用 Python 实现一个通用 FP 格式模拟器（输入 E、M、bias、是否有 ∞），输出$\\max/\\min normal/\\min subnormal/\\varepsilon$，并用它复现 03 章速查表。\n题 5 解答要点 核心公式：$\\max = (2 - 2^{-M}) \\times 2^{emax - bias}$；$\\text{min\\_normal} = 2^{1 - bias}$；$\\text{min\\_subnormal} = 2^{1-bias-M}$；$\\varepsilon = 2^{-M}$。注意 E4M3FN 的$emax=15$特例（无 ∞），$E5M2 emax=30$。跑完应得到 448 / 57344 / 6.1e−5 等速查表数值。\n12. 延伸阅读 # FP8 Formats for Deep Learning（NVIDIA/Arm/Intel，arXiv:2209.05433）：E4M3/E5M2 规格与使用建议的权威来源 OCP Microscaling Formats (MX) Specification：MXFP8/MXFP4 的正式规范 Introducing NVFP4 for Efficient and Accurate Low-Precision Inference（NVIDIA 官方博客）：NVFP4 块 16 + E4M3 缩放的动机 Inference Engineering Ch5：格式总览表与\u0026quot;FP8 甜点\u0026quot;结论 上一篇： 02 量化问题的形式化与均匀量化理论；下一篇： 04 量化粒度、校准与离群值——把\u0026quot;格式选好了\u0026quot;变成\u0026quot;每个张量的 scale 怎么选、outlier 怎么对付\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-03-%E6%95%B0%E5%80%BC%E6%A0%BC%E5%BC%8F%E4%B8%8E%E7%A1%AC%E4%BB%B6/","section":"笔记","summary":"从位布局推导 FP16/BF16/FP8（E4M3、E5M2）/FP4/MXFP8/NVFP4 的动态范围与精度，说明 E4M3 和 E5M2 各自适合什么场景、块缩放到底解决了什么问题，并用带宽模型手算 70B 模型 decode 每 token 的最少耗时。","title":"FP16、BF16、FP8、FP4 有什么区别？该选哪种数值格式"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： FP16、BF16、FP8、FP4 有什么区别｜下一篇： RTN 和 GPTQ 有什么区别\n对应：Inference Engineering Ch5 的 \u0026ldquo;Granularity matters\u0026rdquo; 部分；LLM.int8() 的 outlier 分析；MIT 6.5940 Lecture 5 的逐层/逐通道量化内容。 学完本章你应该能：① 解释 per-tensor / per-channel / per-group 的差别，并手算各自的有效位宽与存储开销；② 说出校准是什么、校准集怎么选、常见统计量（min/max、分位数、熵、MSE）的取舍；③ 复述 LLM.int8() 的 outlier 统计结论（6.0、25%、6%、6.7B、0.1%、75%）并解释为什么 outlier 致命；④ 把\u0026quot;粒度 × 校准 × outlier\u0026quot;三条线串成一张决策表。\n目录（本章） # 本章目标 从 02 章到本章：范围利用率是主线 粒度光谱：per-tensor / per-channel / per-group 有效位宽与存储开销：动手算 校准（Calibration） 离群值问题（Outliers） 敏感性分析：谁更怕量化 决策表：什么时候用哪种组合 本章小结 习题与解答 延伸阅读 1. 本章目标 #同一套 FP8/INT4 网格，scale 覆盖多大范围、怎么选、遇到 outlier 怎么办，决定量化后还剩多少有效精度。这三个问题分别落在粒度、校准和 outlier 上。\n03 章：格式（FP8 / FP4 / MXFP…）$\\to$码本结构 04 章：粒度（tensor / channel / group）$\\to$码本拆成几份、每份自己的 scale 校准（怎么选 scale）$\\to$码本对齐真实分布 outlier（分布里的\u0026quot;刺\u0026quot;）$\\to$为什么要拆、为什么难选\n2. 从 02 章到本章：范围利用率是主线 #02 章算过：量化范围只用了$1/2^k$，有效位宽就损失 k bit。本章所有内容都是这句话的三个推论：\n粒度：一个 scale 管的元素越少，每个元素越可能\u0026quot;接近自己的范围\u0026quot;$\\to$范围利用率高。 校准：scale 选得好不好，直接决定范围利用率；选 min/max 还是分位数，是在\u0026quot;截断风险\u0026quot;和\u0026quot;有效位宽\u0026quot;之间取舍。 outlier：outlier 把范围撑大，把正常值挤进一小块网格$\\to$范围利用率灾难性下降。 3. 粒度光谱：per-tensor / per-channel / per-group #3.1 三个层次 #设权重矩阵$W \\in \\mathbb{R}^{C_{\\text{out}} \\times C_{\\text{in}}}$：\n粒度 一个 scale 覆盖 数量 典型适用 per-tensor 整个张量 1 小模型、FP8 W8A8 的激活 per-channel（权重） 每个输出通道一行 $C_{\\text{out}}$ 4-bit 权重的默认起点 per-channel（激活） 每个输入通道一列 $C_{\\text{in}}$ 激活量化常用 per-group 每 G 个连续元素 $C_{\\text{out}} \\times C_{\\text{in}} / G$ 4-bit 权重的主流（$G=32/64/128$） 图示（权重 W，行 = 输出通道）：\nper-tensor： per-channel： per-group（G=2）： ┌─────────────┐ ┌─────┬─────┬─────┐ ┌──┬──┬──┬──┬──┬──┐ │ 同一 scale │ │ s1 │ s1 │ s1 │ │s1│s1│s2│s2│s3│s3│ │ s 覆盖全部 │ │ s2 │ s2 │ s2 │ │s4│s4│s5│s5│s6│s6│ │ │ │ s3 │ s3 │ s3 │ │… │… │… │… │… │… │ └─────────────┘ └─────┴─────┴─────┘ └──┴──┴──┴──┴──┴──┘ 3.2 为什么权重按\u0026quot;输出通道\u0026quot;、激活按\u0026quot;输入通道\u0026quot; #矩阵乘$Y = WX$，Y 的第 j 行由 W 的第 j 行与 X 的所有列相乘：\n$$ Y[j, :] = W[j, :] \\cdot X $$ 权重 W 的第 j 行只影响输出的第 j 行$\\to$每行一个 scale 是\u0026quot;误差只影响自己那行输出\u0026quot;的最细合理划分。 激活 X 的第 i 列与 W 的所有行相乘$\\to$每列一个 scale 是同理。 粒度再细（per-element）就退化回\u0026quot;不用量化\u0026quot;了。\n3.3 group 量化：per-channel 的\u0026quot;中间态\u0026quot; #per-channel 在通道数少时（如某些投影层$C_{\\text{in}}$只有几百）仍然太粗。group 量化把一行切成若干段，每段（如 128 个元素）一个 scale：\n$INT4 + group=128$：每个 scale 管 128 个权重\n这是 GPTQ/AWQ 的默认形态（通常 group 128 + FP16 scale，或 group 32/64 用于激进场景）。\n4. 有效位宽与存储开销：动手算 #4.1 有效位宽公式 #$$ b_{\\text{eff}} = b + \\text{scale\\_bits} / G $$其中 b 是数据位宽，G 是每个 scale 覆盖的元素数。直觉：scale 是\u0026quot;额外的位\u0026quot;，摊到每个元素头上。\n4.2 数值表（b = 4） # 粒度 G scale 格式 $b_{\\text{eff}}$ 相对纯 4-bit 的存储开销 per-tensor 全部 FP32 ≈ $4.000$ $\\sim 0\\%$ per-channel（$C=4096$） 4096 FP16 ≈ $4.004$ 0.1% per-group 256 FP16 4.0625 1.6% per-group 128 FP16 4.125 3.1% per-group 64 FP16 4.25 6.3% per-group 32 FP16 4.5 12.5% per-group 16 FP16 5.0 25% 算例（$group=128$、FP16 scale）：\n每个 128 元素块：128×4 bit 数据$+ 16 bit scale = 528 bit$ 每元素平均= $528/128 = 4.125 bit$\n关键 tradeoff：group 越小，质量越好、开销越大。4-bit 权重量化常见的选择是 $group=128$（质量/开销平衡） 和$group=32$（更激进，质量仍可接受）。\n4.3 一个常见误区 #\u0026ldquo;4-bit 模型 = 正好 4 倍压缩\u0026quot;是错的。真实的模型文件大小要看有效位宽：\n70B 模型： 纯$FP16 = 140 GB$ $INT4 group=128 = 70e9 \\times 4.125/8 \\approx 36.1 GB$（不是 35 GB）\n$$ INT4 group=32 = 70e9 \\times 4.5/8 \\approx 39.4 GB $$这也是为什么估算器/模型卡片的\u0026rdquo;$4-bit = 75\\%$节省\u0026quot;是理想值，实际要加 scale 开销。\n5. 校准（Calibration） #5.1 什么是校准 #校准 = 用一小部分代表数据跑一遍模型，统计每层权重/激活的分布，从而确定量化参数（scale、zero-point、范围）：\n流程：\n选校准集（通常$128\\sim 512$条样本） 前向传播，记录每层输入激活 X（和需要时的权重分布） 按某种统计量计算 scale / 范围 量化并验证 注意：校准是\u0026quot;无梯度\u0026quot;的，只统计分布，不更新权重。GPTQ/AWQ 的\u0026quot;校准集\u0026quot;就是这个东西。\n5.2 校准集怎么选 #标准做法（GPTQ/AWQ 论文）：从预训练语料里取$\\sim 128$条、每条 2048 token 的序列。\n选集的三个原则：\n覆盖任务分布：做代码任务就用代码语料校准，别全用新闻语料。 避免单任务过拟合：AWQ 特意从预训练数据取校准集，避开目标任务数据，防止量化参数\u0026quot;记住\u0026quot;评测集。 规模适中：128 条左右足够统计分布；太多没用，太少噪声大。 5.3 统计量选择：min/max vs 分位数 vs 熵 vs MSE #给定一组校准激活，scale 怎么定？\n方法 规则 优点 缺点 min/max $s = \\max\\vert x\\vert / 2^{b-1}$ 无截断 被 outlier 撑大，有效位宽被稀释 分位数 $s = P99.99 / 2^{b-1}$ 抗 outlier 需要选分位点（99.9%? 99.99%?） 熵（entropy） 最小化量化前后分布 KL 散度（TensorRT 的做法） 直接对齐分布 计算重、实现复杂 MSE 最优（ACIQ 等） 最小化$E[(x-\\hat{x})^{2}]$ 理论最优 需要分布假设/搜索 工程上的默认：权重用 min/max（权重 outlier 少），激活用分位数（如 99.99% / 99.999%）。neural-compressor 等工具里 SmoothQuant 的默认分位点就是 99.999%。\n5.4 校准与验证要分开 #校准集：用于选 scale（训练量化器） 验证集：用于测量化质量（perplexity / 基准 / 自定义评测，10 章）\n用评测集当校准集是作弊：量化参数会\u0026quot;记住\u0026quot;评测数据，验证分数虚高，上线后现原形。\n5.5 常见陷阱 # 校准集只有几十条$\\to scale$噪声大 校准集与部署流量分布差异大（聊天模型用文档语料校准）$\\to$上线退化 只校准权重不校准激活$\\to W8A8$时激活 scale 拍脑袋 复现性：库与库之间 round/百分位实现不同，量化结果不可比 6. 离群值问题（Outliers） #6.1 LLM.int8() 的观测（论文核心数字） #Dettmers et al.（2022）系统统计了 Transformer 激活的 outlier：\noutlier 定义：$|activation| \\ge 6.0$，且出现在≥ $25\\%$的层、≥ $6\\%$的序列维度\n关键发现：\n规模相变：$\\sim 6.7B$参数之前没有系统性 outlier；超过后，outlier 出现在所有层 outlier 出现后：在约 75% 的序列维度上持续存在（同维度反复出现） outlier 占比极小：约 0.1% 的特征 outlier 维度数量少：13B 以下模型通常≤ $7$个维度 作用关键：这些 outlier 对 softmax 的大概率输出至关重要（不是噪声） 6.2 为什么 outlier 对量化是致命的 #回到 02 章的模型：outlier 让 max|X| 巨大（比如 1000+），而 99.99% 的正常值在$\\pm 60$内：\n8-bit 对称量化，$s = \\max|X|/127 = 1000/127 \\approx 7.87$ 正常值$\\pm 60$只用到$\\pm 60/7.87 \\approx \\pm 7.6$个量化层级$\\to$有效位宽≈ $\\log_2(16) \\approx 4 bit$\noutlier 用 0.1% 的特征，偷走了正常值$\\sim 4 bit$的有效精度。 这正是 LLM.int8()、SmoothQuant、AWQ、per-group 全部要解决的问题。\n6.3 SmoothQuant 的补充统计 #SmoothQuant 论文（Xiao et al., 2023）对 OPT-175B 的统计给出同样的形状：激活分布是\u0026quot;尖峰 + 重尾\u0026quot;，极少数特征维度的最大值远超主体。min/max 校准会把这些维度之外的值挤进很粗的网格，这也是 07 章单独处理激活量化的原因。\n6.4 对付 outlier 的四种策略（本系列路线图） # 策略 思路 代表方法 章节 分离 把 outlier 单独留在高精度 LLM.int8() 混合精度分解 07 迁移 把量化难度从激活搬到权重 SmoothQuant 07 保护 识别并保护显著通道/权重 AWQ 06 细分 用更细的网格容纳局部动态范围 per-group、MXFP8 04、03 7. 敏感性分析：谁更怕量化 #7.1 层与模块之间的差异 #Inference Engineering 的敏感性排序（02 章已提）：\n权重（线性层）\u0026lt; 激活 \u0026lt; KV cache \u0026lt; attention（softmax）\n更细的观察（GPTQ 论文与后续工作）：\nattention 的投影层比 FFN 更敏感（信息压缩集中）；量化时通常优先给 attention 层更多位/更细粒度。 首层与末层更敏感（输入输出直接参与表示）；中间层相对鲁棒。 softmax 之前的 QK 点积对误差敏感（指数运算放大误差）——生产上常用 FP16/FP8，不轻易上 INT4。 7.2 通道之间的差异：激活幅度 = 重要性 #AWQ 的核心观察：某个权重通道的重要性与对应输入激活的幅度强相关：\n输入通道 j 的激活幅度大$\\to$权重 W[:, j] 对输出贡献大$\\to$量化误差影响大\n所以 AWQ 用 $s_{j} = (\\max|X_{j}|)^\\alpha$（$\\alpha$ 网格搜索）给重要通道配更精细的缩放，把误差预算花在重要的地方（06 章 3.4 推导缩放为什么能减误差）。\n7.3 Hessian 视角：二阶信息衡量敏感性 #GPTQ 用每层输入的$Hessian H = 2XX^T + \\lambda I$衡量\u0026quot;量化哪个权重代价最小\u0026quot;：\n损失增量≈ $(w_{q} - \\hat{w}_q)^{2} / (2[H^{-1}]_qq)$（05 章完整推导）\n一阶统计（激活幅度）衡量通道重要性，二阶统计（Hessian）衡量移除某个权重的损失增量；两者都给出了不均匀分配位宽的依据。\n8. 决策表：什么时候用哪种组合 # 场景 推荐粒度 scale 格式 校准统计量 FP8 W8A8 权重 per-channel FP32（fold 到 kernel 里） min/max FP8 W8A8 激活 per-tensor FP32 分位数 99.99% INT4 权重（GPTQ/AWQ） $group=128$ FP16 min/max（权重 outlier 少） 激进 3-bit / 2-bit $group=32$或更细 FP16/FP8 分位数 + 校准集优化 KV cache（08 章） per-channel（K）/ per-token（V） 每 token/通道 scale 分位数 Blackwell FP4/MX per-group（16/32） E4M3 / E8M0 分位数 经验法则：\n权重不怕 min/max，激活必须防 outlier（分位数）。 4-bit 权重默认$group=128$；质量不够时先把 group 降到 32，再考虑换方法。 per-tensor 只配 FP8 或 MX（有指数位托底）；INT4 用 per-tensor 基本必炸。 校准集永远不能等于评测集。 9. 本章小结 # 粒度 = 范围利用率：$per-tensor \\to per-channel \\to per-group$，粒度越细误差越小、开销越大。 有效位宽$b_{\\text{eff}} = b + \\text{scale\\_bits}/G$：$group=128$的 INT4 实际是 4.125 bit，别按 4.0 算容量。 校准 = 用代表数据选 scale：校准集要覆盖任务、与评测分离；激活用分位数，权重可用 min/max。 outlier 是头号敌人：0.1% 的特征偷走$\\sim 4 bit$有效精度（§6.1 的 LLM.int8 统计）；四种对策 = 分离/迁移/保护/细分。 不均匀对待权重：AWQ 按激活幅度保护重要通道，GPTQ 按 Hessian 挑代价最小的量化顺序；两者都要用校准集估计输入统计，校准分布偏了，保护方向就偏了。 10. 习题与解答 #题 1（计算）：有效位宽 #$INT4 + group=64 + FP8 scale$的有效位宽和相对存储开销是多少？对比$group=128 + FP16$。\n题 1 解答 $group=64 + FP8$：$b_{\\text{eff}} = 4 + 8/64 = 4.125 bit$；开销= $8/64 = 0.125 bit/$元素 = 相对 4-bit 数据 3.125%。 $group=128 + FP16$：$b_{\\text{eff}} = 4 + 16/128 = 4.125 bit$；开销= $3.125\\%$。 两者有效位宽相同——FP8 scale 用一半位宽做到相同粒度开销，所以新 kernel 偏好 FP8 scale。\n题 2（思考）：outlier 的量化伤害 #激活 99.99% 在$\\pm 60$，$\\max=1000$。8-bit 对称量化（$s=\\max/127$）下，正常值的有效位宽大约是多少？\n题 2 解答 正常值范围$\\pm 60$只占$\\pm 1000$的 6%；量化层级数≈ $2\\times 60/(1000/127) \\approx 15.2 \\to$有效位宽≈ $\\log_2(15) \\approx 3.9 bit$。8-bit 实际只剩不到 4 bit 的有效精度，这正是 outlier 的\u0026quot;偷位\u0026quot;效应。\n题 3（设计）：校准集 #你要给一个代码生成模型做 INT4 量化。设计校准集：来源、条数、每条约多长、要避免什么。\n题 3 解答要点 来源：高质量代码语料（多语言/多框架，含少量文档注释混合数据）；128 条 × 2048 token；避免只用单语言/单框架；避免用评测集（如 HumanEval 样本）——那是验证集。量化后用代码相关 benchmark + 自定义任务验证（10 章）。\n题 4（推导）：per-channel vs per-tensor 的误差比 #某层权重 W 有 4096 行，每行范围不同：一半行范围$[-1,1]$，一半$[-100,100]$。per-tensor min/max 下，$[-1,1]$那半行的量化步长是 per-channel 的多少倍？有效位宽损失多少？\n题 4 解答 per-tensor 的$s = 100/127$；per-channel 对$[-1,1]$行的$s = 1/127$。步长比= $100$（≈ $2^{6.6}$）$\\to$那半行损失约 6.6 bit 有效精度。这就是\u0026quot;per-channel 在通道范围差异大时是免费的精度\u0026quot;。\n题 5（编程）：校准统计量对比 #构造分布：N(0,1) 的 99.99% + 少量$\\pm 1000 outlier$。比较 min/max、P99.99、P99.999 三种 scale 下的 8-bit SQNR。\n题 5 解答要点 min/max 会被 outlier 撑大（SQNR 低）；P99.99 忽略最极端 0.01%，正常值有效位宽高，但 outlier 本身被截断；P99.999 介于两者之间。结果应验证：outlier 存在时，分位数校准显著优于 min/max，具体分位点按\u0026quot;截断代价 vs 有效位宽\u0026quot;权衡。\n11. 延伸阅读 # LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale（arXiv:2208.07339）：outlier 统计与混合精度分解 SmoothQuant（arXiv:2211.10438）：激活分布统计（$\\pm 60 / 1000+$）与$\\alpha$迁移 AWQ（arXiv:2306.00978）：$s = \\max|X|^\\alpha$ 通道缩放与校准集设计 GPTQ（arXiv:2210.17323）：128 条 × 2048 token 校准集的标准用法 上一篇： 03 数值格式与硬件；下一篇：[05 权重量化 I：RTN 与 GPTQ]——把\u0026quot;选 scale\u0026quot;升级成\u0026quot;量化后全局补偿误差\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-04-%E9%87%8F%E5%8C%96%E7%B2%92%E5%BA%A6%E6%A0%A1%E5%87%86%E4%B8%8E%E7%A6%BB%E7%BE%A4%E5%80%BC/","section":"笔记","summary":"per-tensor、per-channel、per-group 的有效位宽和存储开销差多少？校准集怎么选、统计量用 min/max 还是分位数？本文用 LLM.int8() 的离群值统计说明 INT8 什么情况下会崩，并给出粒度、校准、outlier 的决策表。","title":"量化粒度怎么选？为什么离群值会让 INT8 精度崩掉"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： 量化粒度怎么选｜下一篇： AWQ 量化原理是什么\n对应：GPTQ 论文（arXiv:2210.17323，ICLR 2023）；OBQ（Frantar \u0026amp; Alistarh 2022）；OBS（Hassibi et al. 1993）；MIT 6.5940 Lecture 5。 学完本章你应该能：① 说明 RTN 为什么在 4-bit 会翻车；② 从\u0026quot;最小化逐元素误差\u0026quot;升级到\u0026quot;最小化层输出误差\u0026quot;；③ 完整推导 OBS/OBQ 的最优补偿公式$\\delta F = -(w_{q} - \\hat{w}_q)/[H^{-1}]_{qq} \\cdot H^{-1}_{:,q}$；④ 说清 GPTQ 的三个工程化观察（顺序无关、行并行、Cholesky）及其复杂度含义；⑤ 手算一个 2×2 的补偿例子。\n目录（本章） # 本章目标 问题设定：weight-only 量化 RTN：最朴素的基线 目标函数升级：从逐元素误差到输出误差 OBS：删除一个权重的代价 OBQ：把\u0026quot;删除\u0026quot;换成\u0026quot;量化\u0026quot; GPTQ：把 OBQ 规模化 手算例：补偿是怎么发生的 GPTQ 的局限与后续 本章小结 习题与解答 延伸阅读 1. 本章目标 #04 章的粒度和校准，解决的仍是\u0026quot;每个权重独立舍入到哪个网格点\u0026quot;，误差由该权重自己承担。OBQ/GPTQ 换了一个问题：\n量化必然引入误差；能不能让还没被量化的权重，去补偿已经被量化权重的误差？\n这就是 OBQ/GPTQ 的核心思想：量化一个、全局补偿。后面的 AWQ 用激活幅度缩放替代二阶补偿，QuIP# 先改变权重分布再量化；本章的目标函数和 OBS 推导是理解它们的起点。\n2. 问题设定：weight-only 量化 #2.1 场景 #权重量化（W4A16 / W4A8）只压缩权重，激活保持高精度。权重位宽减半，模型文件和解码时的权重搬运一起减半（03 章模型）；计算上，W4A8 可以配合低精度激活，W4A16 则仍是高精度激活。推理服务通常先量化权重：权重分布静态、outlier 少，收益直接，风险也最低。\n2.2 形式化 #设一层权重$W \\in \\mathbb{R}^{d_{\\text{row}} \\times d_{\\text{col}}}$，输入激活$X \\in \\mathbb{R}^{d_{\\text{col}} \\times N}$（N 个校准样本），量化后 $\\hat{W}$。目标：\n$$ \\min \\|WX - \\hat{W}X\\|^{2}_F $$约束：$\\hat{W}$ 的每个元素属于量化网格（如 INT4 + group scale）\n注意目标函数里没有单独惩罚逐元素误差——我们关心的是层输出（进而整个模型）的误差。\n3. RTN：最朴素的基线 #3.1 定义 #RTN（Round-to-Nearest）：对每个权重独立做\u0026quot;就近舍入到量化网格\u0026quot;：\n$$ \\hat{W}_ij = \\operatorname{clamp}(\\operatorname{round}(W_{\\text{ij}} / s_{\\text{channel}}), q_{\\min}, q_{\\max}) \\times s_{\\text{channel}} $$scale 可以是 per-channel 或 per-group（04 章）。实现成本几乎为零。\n3.2 为什么 4-bit 会翻车 #RTN 的三个盲区：\n忽略分布形状：只保证每个权重离自己最近的网格点，不保证整体输出误差小。 忽略层间作用：每层独立量化，误差沿层累积（02 章）。 忽略 outlier 关联：RTN 不利用\u0026quot;哪些通道重要\u0026quot;（04 章的激活幅度）和\u0026quot;哪些权重动起来代价小\u0026quot;（Hessian）。 实验事实：$FP16 \\to INT8 RTN$通常无损；INT4 RTN 在 7B 以上模型明显掉点；INT3 以下基本不可用。\n4. 目标函数升级：从逐元素误差到输出误差 #考虑量化 W 中第 q 个输入通道上的一个权重 $w_q$（每一行独立处理）对输出的影响。设 $L(W) = \\frac{1}{2}\\|WX - \\hat{W}X\\|^{2}_F$（$\\frac{1}{2}$ 便于求导）。\n把 L 在最优权重处做二阶泰勒展开（最优处梯度$g = 0$）：\n$$ \\Delta L \\approx \\frac{1}{2} \\delta w^{T} H \\delta w $$其中 H 是 Hessian。对矩阵乘的 MSE 目标：\n$H = \\partial ^{2}L/\\partial w^{2} = X X^{T}$（对列向量形式的权重；$\\frac{1}{2}$消掉 2）\nGPTQ 论文记为$H = 2XX^{T}$（不写$\\frac{1}{2}$），并加阻尼项：\n$$ H = 2 X X^{T} + \\lambda I, \\lambda = 0.01 \\times \\operatorname{mean}(\\operatorname{diag}(2XX^{T})) $$H 的直觉：H 编码了\u0026quot;输入各通道之间的相关性\u0026quot;。H 的对角线 = 每个输入通道的激活能量（谁更重要）；非对角线 = 通道间的相关（误差能否被别处补偿）。\nH 的维度是$d_{\\text{col}} \\times d_{\\text{col}}$（按输入通道），与参数量无关。一层 12288 通道$\\to H$约$12288^{2} \\times 4 B \\approx 600 MB$，可接受。\n5. OBS：删除一个权重的代价 #OBS（Optimal Brain Surgeon, Hassibi et al. 1993）问：删掉一个权重，如何调整其余权重让损失恢复最多？\n设我们要把$w_{q}$设成目标值$\\hat{w}_q$（删除= $\\hat{w}_q = 0$），约束：\n$$ e_{q}^{T} \\delta w = \\hat{w}_q - w_{q} $$其中$e_{q}$是第 q 个单位向量（$\\delta w$只在第 q 个分量上取定值）。求：\n$$ \\begin{aligned} min_\\delta w \\frac{1}{2} \\delta w^{T} H \\delta w s.t. e_{q}^{T} \\delta w \u0026= \\hat{w}_q - w_{q} \\end{aligned} $$用拉格朗日乘子法：\n$$ \\begin{aligned} L \u0026= \\frac{1}{2} \\delta w^{T} H \\delta w + \\lambda (e_{q}^{T} \\delta w - (\\hat{w}_q - w_{q})) \\partial L/\\partial \\delta w \u0026= H \\delta w + \\lambda e_{q} = 0 \\to \\delta w = -\\lambda H^{-1} e_{q} \\end{aligned} $$代入约束：$e_{q}^{T} \\delta w = -\\lambda [H^{-1}]_{qq} = \\hat{w}_q - w_{q}$\n$$ \\to \\lambda = -(\\hat{w}_q - w_{q}) / [H^{-1}]_{qq} $$于是最优调整：\n$$ \\delta w = (\\hat{w}_q - w_{q}) / [H^{-1}]_{qq} \\times H^{-1}_{:,q} $$写成论文里的形式（只更新未处理权重 F）：\n$$ \\delta F = -(w_{q} - \\hat{w}_q) / [H^{-1}]_{qq} \\times H^{-1}_{:,q} $$对应的最小损失增量：\n$$ \\Delta L_{\\text{min}} = \\frac{1}{2} (w_{q} - \\hat{w}_q)^{2} / [H^{-1}]_{qq} $$三个关键结论：\n补偿量正比于$H^{-1}$的第 q 列：误差往\u0026quot;与 q 相关性强\u0026quot;的权重上摊。 分母$[H^{-1}]_{qq}$越小，量化 q 的代价越大：$H^{-1}$ 对角小意味着该输入方向的曲率大，其他权重补不回来。 $\\Delta L$公式给了敏感性度量：哪个权重量化最便宜，一目了然。 6. OBQ：把\u0026quot;删除\u0026quot;换成\u0026quot;量化\u0026quot; #OBQ（Optimal Brain Quantizer, Frantar \u0026amp; Alistarh 2022）把 OBS 的\u0026quot;删掉\u0026quot;换成\u0026quot;量化到$\\hat{w}_q$\u0026quot;：\n算法（逐权重）：\n计算$H^{-1}$（含阻尼$\\lambda$） 对每个待量化权重 q： a. 计算量化误差$\\text{err}_q = w_{q} - \\operatorname{quant}(w_{q})$ b. 更新其余未量化权重：$\\delta F = -\\text{err}_q / [H^{-1}]_{qq} \\times H^{-1}_{:,q}$ c. 记录量化后的值 d. 更新$H^{-1}$（去掉第 q 维，rank-1 修正） 贪心顺序：每次选$\\Delta L = \\frac{1}{2} \\text{err}_q^{2} / [H^{-1}]_{qq}$最小的 q 贪心顺序的含义：先量化\u0026quot;代价最小\u0026quot;的权重，让后面的补偿空间最大化。\n复杂度：每量化一个权重要更新整列$H^{-1}$（$O(d_{\\text{col}}^{2})$），共$d_{\\text{row}} \\times d_{\\text{col}}$个权重$\\to$$O(d_{\\text{row}} \\cdot d_{\\text{col}}^{3})$。对$4096^{2}$的层都嫌慢，更别说$12288^{2}$。\n7. GPTQ：把 OBQ 规模化 #GPTQ（Frantar et al. 2023）基于三个观察把 OBQ 变成可落地的算法：\n7.1 观察一：量化顺序几乎不影响结果 #论文实验发现：对 LLM 权重，贪心选序和固定顺序的结果几乎一样。于是：\n去掉贪心：按固定列顺序量化（如从左到右） 省掉：每次比较所有候选权重的$\\Delta L$（$O(d_{\\text{col}})$的排序开销）\n7.2 观察二：行之间可以并行 #补偿公式$\\delta F = -\\text{err}_q/[H^{-1}]_{qq} \\times H^{-1}_{:,q}$里，H 和$H^{-1}$只依赖输入 X，不依赖权重行。所以 W 的$d_{\\text{row}}$行共享同一套$H^{-1}$，各行独立量化、独立补偿，可以并行。\n7.3 观察三：Cholesky 一次性分解 #$H^{-1}$只需要算一次，并且用 Cholesky 分解$H^{-1} = LL^{T}$缓存起来；量化时按 128 列一块批量更新，避免逐列更新$H^{-1}$：\n复杂度：$O(d_{\\text{col}}^{3})$（一次 Cholesky）$+ O(d_{\\text{row}} \\cdot d_{\\text{col}}^{2})$（批量补偿）\n$$ \\approx O(d_{\\text{row}} \\cdot d_{\\text{col}}^{2}) $$对比 OBQ：$O(d_{\\text{row}} \\cdot d_{\\text{col}}^{3})$\n7.4 GPTQ 伪代码（逐层） #输入：权重 W（d_row × d_col），校准激活 X（d_col × N），位宽 b，分组大小 G for layer in model: H = 2 X Xᵀ + λI # λ = 0.01·mean(diag(2XXᵀ)) H_inv = cholesky_inverse(H) # 一次分解，H⁻¹ = LLᵀ W_hat = W.clone() for block in range(0, d_col, 128): for q in block: # 固定顺序 w_q = W[:, q] ŵ_q = quantize_group(w_q, b, G) # 分组 RTN err = w_q − ŵ_q W_hat[:, q] = ŵ_q # 补偿本块内剩余列 W[:, block 中 q 之后] −= (err / H_inv[q,q])[:, None] × H_inv[q, 剩余列][None, :] # 用 Cholesky 因子批量补偿块之后的列 W[:, block_end:] −= batch_update(W, W_hat, H_inv, block) # 替换层权重为 W_hat（连同 scale 一起保存） （具体实现见 GPTQ 官方仓库；这里保留核心数学结构，块内/块间的 Cholesky 批量更新细节略去。）\n7.5 数值与业界地位 # 一次量化 OPT-175B / BLOOM-176B 约 4 GPU 小时（A100）。 $INT4 + group=128$：perplexity 与 FP16 差异在噪声范围附近（论文 Table 2；具体值因模型而异）。 INT3：仍可用，但已有可感知退化；INT2：明显退化（催生了 QuIP#，06 章）。 落地：vLLM、TensorRT-LLM、HuggingFace（AutoGPTQ、GPTQModel）均有生产级 kernel。 8. 手算例：补偿是怎么发生的 #设一层只有一行权重$W = [2.0, 1.0]$（$d_{\\text{row}}=1$，$d_{\\text{col}}=2$），校准激活：\n$$ X = [[1.0, 0.5], $$ [0.5, 1.0]] # 两个样本、两个输入通道，正相关 计算 H（用 GPTQ 的记法，忽略$\\frac{1}{2}$）：\n$$ \\begin{aligned} H \u0026= 2 X X^{T} = 2 \\times [[1.25, 1.0], [1.0, 1.25]] \u0026= [[2.5, 2.0], [2.0, 2.5]] H^{-1} \u0026= (1/2.25) \\times [[2.5, -2.0], [-2.0, 2.5]] \u0026= [[1.111, -0.889], [-0.889, 1.111]] \\end{aligned} $$现在量化第 0 列：$w_0 = 2.0 \\to \\hat{w}_0 = 1.0$（假设网格$step=1$）：\n$$ \\begin{aligned} err_0 \u0026= 2.0 - 1.0 = 1.0 \\delta w_1 \u0026= -err_0 / [H^{-1}]_{00} \\times [H^{-1}]_{01} \u0026= -1.0 / 1.111 \\times (-0.889) = +0.80 w_1 \u0026= 1.0 + 0.80 = 1.80 \\end{aligned} $$解读：$w_0$被量化小了 1.0，但输入通道 0 和 1 正相关（x₀ 大时 x₁ 通常也大），所以把$w_1$调大 0.8 可以部分抵消输出的损失。\n该步的损失增量：\n$$ \\Delta L = \\frac{1}{2} err_{0}^{2} / [H^{-1}]_{00} = \\frac{1}{2} \\times 1.0 / 1.111 \\approx 0.45 $$如果两个通道完全独立（H 对角），$[H^{-1}]_{01} = 0 \\to \\delta w_1 = 0$，补偿失效——补偿能力来自输入通道之间的相关性。\n9. GPTQ 的局限与后续 #9.1 局限 # 二次假设：目标函数只在最优附近近似二次；量化误差大（低 bit）时，补偿公式不再最优。 校准集依赖：H 来自校准数据；校准集分布偏了，H 就偏了。 需要重建（reconstruction）：逐层前向 + 线性代数，量一次要几分钟到几小时（远慢于 RTN 的几秒）。 没有用激活幅度信息：H 用到了激活的二阶统计，但 AWQ 证明\u0026quot;一阶幅度 + 简单缩放\u0026quot;在很多场景同样有效且更省。 9.2 方法谱系位置 #RTN（零补偿，最简单） ↓ 加入二阶补偿 GPTQ（量化一个、全局补偿） ├─ AWQ（换成\u0026#34;激活幅度缩放\u0026#34;补偿，更简单，06 章） └─ QuIP#（先\u0026#34;洗牌\u0026#34;再量化，2-bit 天花板更高，06 章） 10. 本章小结 # RTN 是最朴素基线：逐元素独立舍入，4-bit 翻车。 目标函数：$\\min \\|WX - \\hat{W}X\\|_F^2$；误差按整层输出计，逐元素误差不进入目标。 二阶工具：$H = 2XX^{T} + \\lambda I$编码输入通道的相关性；$H^{-1}$决定补偿方向。 OBS/OBQ 公式：$\\delta F = -(w_{q} - \\hat{w}_q)/[H^{-1}]_{qq} \\cdot H^{-1}_{:,q}$；$\\Delta L = \\frac{1}{2}(w_{q}-\\hat{w}_q)^{2}/[H^{-1}]_{qq}$。 GPTQ 三件套：固定顺序（贪心没必要）+ 行并行（H 共享）+ Cholesky 批量更新$\\to O(d_{\\text{row}}\\cdot d_{\\text{col}}^{2})$，175B 模型 4 GPU 小时。 补偿的来源：输入通道相关，未量化的权重可以吸收已量化权重的误差。 11. 习题与解答 #题 1（推导）：OBS 公式 #重新推导$\\delta F = -(w_{q} - \\hat{w}_q)/[H^{-1}]_{qq} \\times H^{-1}_{:,q}$，写出拉格朗日函数、驻点条件和$\\lambda$的求解。\n题 1 解答 $L = \\frac{1}{2}\\delta w^{T}H\\delta w + \\lambda (e_{q}^{T}\\delta w - (\\hat{w}_q-w_{q}))$。驻点：$H\\delta w + \\lambda e_{q} = 0 \\to \\delta w = -\\lambda H^{-1}e_{q}$。约束：$-\\lambda [H^{-1}]_{qq} = \\hat{w}_q - w_{q} \\to \\lambda = -(\\hat{w}_q-w_{q})/[H^{-1}]_{qq}$。代回：$\\delta w = (\\hat{w}_q-w_{q})/[H^{-1}]_{qq}\\cdot H^{-1}_{:,q}$。写成$-(w_{q}-\\hat{w}_q)/[H^{-1}]_{qq}\\cdot H^{-1}_{:,q}$等价。\n题 2（手算）：补偿方向 #延续 8 节的例子，若激活改为负相关$X = [[1, -0.5], [-0.5, 1]]$，量化$w_0 = 2.0 \\to 1.0$后，$w_1$应该怎么调？直觉上为什么？\n题 2 解答 $H = 2[[1.25, -1],[-1, 1.25]]$，$H^{-1} = (1/2.25)[[2.5, 1],[1, 2.5]]$。$\\delta w_1 = -1.0/1.111 \\times 0.889 = -0.80 \\to w_1 = 0.20$。 直觉：通道 0 与 1 负相关（x₀ 大时 x₁ 小），$w_0$被调小后，输出偏低主要发生在 x₀ 大的样本，此时 x₁ 小，所以$w_1$也要调小（而不是调大）才能匹配。\n题 3（思考）：H 的 λ 阻尼 #为什么 GPTQ 要在 H 的对角加$\\lambda = 0.01\\cdot \\operatorname{mean}(\\operatorname{diag}(H))$？\n题 3 解答 校准数据里某些输入方向可能能量极低（近乎零方差），导致 H 奇异、$H^{-1}$爆炸；加阻尼项让 H 正定、数值稳定（ridge 回归的思路）。$\\lambda$取对角线均值的 1% 是经验值：太小不起作用，太大扭曲补偿。\n题 4（编程）：小规模 GPTQ 核心 #实现 8 节的例子（$W=[2,1]$，X 正相关），并验证：量化 col0 后$w_1$的更新、$\\Delta L$；再实现\u0026quot;无补偿\u0026quot;版本对比层输出误差 ‖WX−ŴX‖。\n题 4 解答要点 有补偿：$\\hat{W} = [1, 1.8]$，输出误差$\\|(W-\\hat{W})X\\|^{2} = \\|[1, -0.8]X\\|^{2}$（X 两列），应显著小于无补偿$\\hat{W}=[1,1]$的误差。再验证$\\Delta L \\approx 0.45$与手算一致。\n题 5（开放）：GPTQ 与 AWQ 的取舍 #读 AWQ 论文后回答：为什么 AWQ 声称\u0026quot;无需重建、几分钟量化\u0026quot;，却能在 4-bit 追平 GPTQ？它把\u0026quot;二阶补偿\u0026quot;换成了什么？（提示：04 章 7.2 的激活幅度。）\n题 5 解答要点 AWQ 观察到\u0026quot;通道重要性 ∝ 激活幅度\u0026quot;，用$s=(\\max|X|)^\\alpha$的 per-channel 缩放直接保护重要通道，等效于把误差预算定向到不敏感处，不需要逐权重求解。代价：没有真正的\u0026quot;误差补偿\u0026quot;，2-bit 以下不如 QuIP#。详见 06 章。\n12. 延伸阅读 # GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers（arXiv:2210.17323）：本章主文献 OBQ：Optimal Brain Compression: A Framework for Accurate Post-Training Quantization and Pruning（Frantar \u0026amp; Alistarh, NeurIPS 2022） OBS：Hassibi, Stork \u0026amp; Wolff, Optimal Brain Surgeon and general network pruning（1993）：二阶补偿的源头 GPTQ 官方代码：块更新与 Cholesky 的工程实现 上一篇： 04 量化粒度、校准与离群值；下一篇：[06 权重量化 II：AWQ、SqueezeLLM、QuIP#]——三种\u0026quot;不用重建\u0026quot;或\u0026quot;2-bit 更强\u0026quot;的路线。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-05-%E6%9D%83%E9%87%8D%E9%87%8F%E5%8C%96i-rtn%E4%B8%8Egptq/","section":"笔记","summary":"RTN 直接四舍五入，实现最简单但 4-bit 下误差明显；GPTQ 把目标从「最小化逐元素误差」升级为「最小化层输出误差」，用 OBS/OBQ 的二阶补偿逐列校正。本文完整推导补偿公式并手算一个 2×2 例子。","title":"RTN 和 GPTQ 有什么区别？权重量化方法怎么选"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： RTN 和 GPTQ 有什么区别｜下一篇： 激活量化为什么比权重量化难\n对应：AWQ（arXiv:2306.00978，MLSys 2024 Best Paper）；SqueezeLLM（arXiv:2306.07629，ICML 2024）；QuIP#（arXiv:2402.04396，ICML 2024）；MIT 6.5940 Lecture 5。 学完本章你应该能：① 复述 AWQ 的核心观察（1% 显著权重、按激活幅度而非权重幅度识别）并推导\u0026quot;缩放减误差\u0026quot;的公式；② 说清 AWQ 与 GPTQ 的取舍（无重建 vs 二阶补偿）；③ 讲出 SqueezeLLM 的两板斧（敏感度非均匀量化 + 稠密/稀疏分解）；④ 讲出 QuIP# 为什么能到 2-bit（Hadamard 非相干 + E8 格码本）。\n目录（本章） # 本章目标 为什么还需要\u0026quot;第二种\u0026quot;权重量化 AWQ：激活感知的权重量化 SqueezeLLM：敏感度非均匀量化 + 稠密/稀疏分解 QuIP#：先洗牌、再用格码本 三方法对比 本章小结 习题与解答 延伸阅读 1. 本章目标 #GPTQ 的精度来自逐层重建：缓存激活、解 Hessian、逐列补偿。代价是重建慢、依赖校准集，2-bit 仍然崩。下面三条路线分别针对其中一个约束：\n$AWQ \\to$不重建，几分钟完成；用\u0026quot;激活幅度\u0026quot;代替 Hessian $SqueezeLLM \\to$用敏感度 + 非均匀量化 + outlier 分离，冲 3-bit QuIP#$\\to$用\u0026quot;非相干变换\u0026quot;把误差变成白噪声，冲 2-bit\n2. 为什么还需要\u0026quot;第二种\u0026quot;权重量化 #GPTQ 的问题（论文原话与后续实验）：\n重建开销：逐层缓存激活 + 线性代数求解，对\u0026quot;快速试错\u0026quot;不友好。 校准集过拟合：GPTQ 在重建时最小化校准集上的损失，可能把权重\u0026quot;扭曲\u0026quot;成只对校准分布最优，在分布外（指令微调模型、多模态）掉点。AWQ 论文专门拿这个做对比（其 Figure 8）。 2-bit 崩：二次假设在大误差下失效（05 章 9.1）。 AWQ 的起点是另一个问题：权重重要性不相等，而且\u0026quot;谁重要\u0026quot;要由输入激活判断，不由权重本身的大小决定。\n3. AWQ：激活感知的权重量化 #3.1 观察一：1% 的显著权重决定成败 #AWQ 论文做了个实验：INT3（$group=128$）量化后，把部分通道保留为 FP16（混合精度），看保留谁最有效：\nOPT-13B, INT3-g128, WikiText-2 PPL（FP16 基线 10.13）： 全量化（RTN）$\\to 46.04$ 保留 1% 通道为 FP16（按激活幅度选）$\\to 10.51 \\leftarrow$几乎无损 保留 1% 通道为 FP16（按权重幅度选）$\\to 48.96 \\leftarrow$没用 保留 1% 通道为 FP16（随机选）$\\to 42.00 \\leftarrow$没用\n结论：显著通道只有$\\sim 1\\%$（甚至 0.1%），必须按输入激活的幅度识别——激活大的通道处理的是重要特征。\n3.2 观察二：混合精度硬件不友好，但可以\u0026quot;数学等效\u0026quot; #混合精度（1% FP16 + 99% INT3）在硬件上很难做（内存布局、kernel 分支）。AWQ 的替代：用 per-channel 缩放模拟\u0026quot;保护\u0026quot;的效果，而不真正保留 FP16。\n3.3 核心推导：缩放为什么能减误差 #考虑一组权重 w 和激活 x。对称量化（组内$scale \\Delta = \\max|w|/2^{N-1}$）：\n原始：$Q(w)\\cdot x = \\Delta \\cdot \\operatorname{Round}(w/\\Delta )\\cdot x$ 缩放：$Q(w\\cdot s)\\cdot (x/s) = \\Delta ′\\cdot \\operatorname{Round}(ws/\\Delta ′)\\cdot x\\cdot (1/s)$\n两个经验事实（论文 Table 2 背后的分析）：\n$RoundErr(\\cdot ) \\approx 0.25$（均匀分布在$[0, 0.5]$），缩放不改变它 缩放单个（少数）元素通常不改变组的$\\max \\to \\Delta ′ \\approx \\Delta$ 于是误差：\n原始误差≈ $\\Delta \\cdot 0.25\\cdot x$ 缩放后误差≈ $\\Delta ′\\cdot 0.25\\cdot x\\cdot (1/s) \\approx \\Delta \\cdot 0.25\\cdot x/s$\n结论：把显著通道的权重放大 s 倍、激活除以 s，在组内 max 基本不变的前提下，显著通道的量化误差约缩小 1/s。 这就是\u0026quot;等效保护\u0026quot;。\n代价：s 太大时，被放大的通道会成为组的 max（$\\Delta ′ \u003e \\Delta$），反而伤到同组其他通道。论文在 OPT-6.7B INT3-g128 上扫 s：\ns $\\Delta ′\\ne \\Delta$的比例 平均$\\Delta ′/\\Delta \\cdot (1/s)$ Wiki-2 PPL 1 0% 1.0 23.54 1.25 2.8% 0.804 12.87 1.5 4.4% 0.676 12.48 2 8.2% 0.519 11.92 4 21.2% 0.303 12.36 甜点在$s \\approx 2$：显著通道误差减半，同时只有$\\sim 8\\%$的组被\u0026quot;顶到新 max\u0026quot;。\n3.4 算法：怎么选 s # 用校准集前向，记录每层输入激活 X 对每个输入通道 j：$s_{j} = (\\max|X_{j}|)^\\alpha$ 网格搜索$\\alpha \\in \\{0, 0.05, ..., 1\\}$，选使量化后校准损失最小的$\\alpha$* 应用：$W \\leftarrow W\\cdot \\operatorname{diag}(s)$，$X \\leftarrow X\\cdot \\operatorname{diag}(s)^{-1}$（权重放大、激活缩小） 对缩放后的 W 做常规 group 量化（$group=128$） 要点：\n无梯度、无重建：量化一个 70B 模型只要几分钟（GPU），远快于 GPTQ。 scale 折叠：s 在推理时被折叠进 per-group 的 scale，几乎零开销（TinyChat 的 kernel 做了这件事）。 校准集过拟合风险低：因为只用了激活的 max（一阶统计），不求解权重。 3.5 结果与落地 # 4-bit（W4A16）在 LLaMA/OPT 全系列追平或超过 GPTQ；3-bit 显著优于 RTN/GPTQ。 指令微调模型（Vicuna）与多模态模型（OpenFlamingo）表现好（泛化优势）。 TinyChat 框架：桌面/移动 GPU 上比 HF FP16 快 3.2–3.3x；Llama-2-70B 跑在 Jetson Orin 上。 HuggingFace Transformers、TensorRT-LLM、vLLM、LMDeploy 等都有 AWQ 实现。 3.6 AWQ vs GPTQ # GPTQ AWQ 机制 Hessian 二阶补偿（05 章） 激活幅度 per-channel 缩放 重建 需要 不需要 量化时间 小时级（175B） 分钟级 校准集过拟合风险 有 低 2-bit 表现 崩 崩 硬件友好性 需要特殊 kernel（重排） scale 折叠，天然友好 核心风险 分布外退化 只保护\u0026quot;幅度\u0026quot;大的通道，忽略相关性 想直接看\u0026quot;我该选哪个\u0026quot;的判据、以及 GPTQ/AWQ 与 GGUF 的区别，见 AWQ 和 GPTQ 有什么区别？4-bit 权重量化怎么选。\n4. SqueezeLLM：敏感度非均匀量化 + 稠密/稀疏分解 #4.1 动机 #均匀量化的两个先天问题（02/04 章）：① 权重分布不均匀，等距网格浪费码字；② outlier 权重视觉上少、影响上大。SqueezeLLM 用非均匀量化 + 稀疏分离同时解决。\n4.2 敏感度：谁值得更精细的网格 #沿用 OBS/GPTQ 的二阶思想，对每个权重算敏感度：\n$$ S_{\\text{ij}} = w_{\\text{ij}}^{2} / (2\\cdot [H^{-1}]_ii) $$（H 是层输入的 Hessian 对角近似；公式来源与 05 章$\\Delta L = \\frac{1}{2}(w-\\hat{w})^{2}/[H^{-1}]_{qq}$同源。）\n敏感度高的权重：量化它的损失大$\\to$值得\u0026quot;特殊照顾\u0026quot;。\n4.3 敏感度感知的非均匀量化 #SqueezeLLM 改用 k-means 聚类，在敏感度高的区域多放码字：\n计算每个权重的敏感度$S_{\\text{ij}}$ 用敏感度加权的 k-means 找$2^b$个聚类中心（码本） 每个权重用最近的码字表示，索引存储 效果：分布集中处（通常也是敏感处）码字密，尾部稀疏。\n4.4 稠密-稀疏分解：outlier 的最终归宿 #即使有非均匀码本，极少数 outlier 仍会撑大所在组的量化范围。SqueezeLLM 把它们物理分离：\n权重 = 稠密部分（99%+，低比特量化，如 3/4-bit） + 稀疏部分（$\\sim 0.01\\%-0.1\\%$，直接存 FP16 原值）\n稀疏部分用稀疏矩阵存储（索引 + 值），存储开销很小（0.1% × 16 bit vs 99.9% × 3 bit）。推理时两条路径分别算，再相加。\n4.5 结果 # 3-bit 追平 FP16（LLaMA-7B/13B/30B，WikiText-2 PPL），超过 GPTQ 3-bit。 4-bit 与 FP16 基本无差，是\u0026quot;4-bit 权重的强基线\u0026quot;之一。 与 AWQ 思路互补：AWQ 保护\u0026quot;通道\u0026quot;，SqueezeLLM 保护\u0026quot;个体权重\u0026quot;。 5. QuIP#：先洗牌、再用格码本 #5.1 动机：2-bit 为什么崩 #2-bit 只有 4 个码字，均匀量化等于\u0026quot;一个阈值切 4 段\u0026quot;。误差变成结构性失真，均匀网格的局部近似失效，权重里的离群值尤其吃亏。要降到 2-bit，得让权重分布\u0026quot;对量化友好\u0026quot;。\n5.2 非相干处理（Incoherence Processing） #QuIP 系列（Chee et al. 2023）的关键概念：量化误差取决于权重与单位向量的\u0026quot;内积集中度\u0026quot;。如果权重矩阵相干（少数大分量），量化误差就集中在少数方向；如果非相干（分量均匀），量化误差像白噪声一样分散，对输出的伤害最小。\n做法：用**随机 Hadamard 变换（RHT）**给权重\u0026quot;洗牌\u0026quot;：\n$$ W \\leftarrow D_{1} H W H D_{2} $$（D 是随机对角符号，H 是 Hadamard 矩阵；变换可逆、计算 O(n log n)，且可以折叠到相邻层）\n洗牌后：权重各分量幅度趋于均匀$\\to$量化误差各向同性$\\to 2-bit$从\u0026quot;结构性破坏\u0026quot;变成\u0026quot;噪声级扰动\u0026quot;。\n5.3 E8 格码本：2-bit 的最优打包 #单纯标量量化（每权重独立找最近点）在 2-bit 下浪费严重。QuIP# 用 8 维格（lattice）码本：\n把 8 个权重打包成一个 8 维向量 用 E8 格（8 维空间里 packing 最优的格之一）的码字近似\nE8 格的性质：码字间的最小距离在 8 维格中最大$\\to$同样的位预算下失真最小（经典编码理论的结论）。推理时用查表（LUT）快速解码。\n5.4 结果 # 2-bit 达到论文报告时的 SOTA（LLaMA-2 70B 2-bit PPL 接近 3-bit GPTQ）。 3-bit/4-bit 也强，但优势主要体现在 2-bit 极限区间。 代价：实现复杂度高（Hadamard 变换、格解码、LUT kernel），生态采用晚于 GPTQ/AWQ。 6. 三方法对比 # GPTQ AWQ SqueezeLLM QuIP# 补偿机制 Hessian 二阶更新 激活幅度缩放 敏感度码本 + 稀疏分离 非相干变换 + 格码本 是否需要重建 是 否 是（k-means） 是（优化） 量化时间 小时级 分钟级 中等 中等 甜点位宽 3–4 bit 4 bit 3–4 bit 2–3 bit 校准数据 需要 需要（只需激活统计） 需要 需要 硬件实现 中 低（scale 折叠） 中 高（LUT/Hadamard） 生态 vLLM/TensorRT/HF vLLM/TensorRT/HF 部分 研究为主 一句话选型： 量化时间优先、要求生态成熟$\\to AWQ$（W4A16 事实标准） 要 3-bit 极限质量$\\to SqueezeLLM / GPTQ$ 要 2-bit 探索$\\to QuIP$#\n7. 本章小结 # AWQ：1% 显著权重（按激活幅度）决定成败；用 $s = \\max|X|^\\alpha$ 缩放，数学上等效\u0026quot;保护\u0026quot;，无重建、分钟级、硬件友好——W4A16 的事实标准。 SqueezeLLM：敏感度（Hessian 对角）驱动非均匀码本 + outlier 稀疏分离，3-bit 追平 FP16。 QuIP#：Hadamard 把权重洗成\u0026quot;非相干\u0026quot;（误差白噪声化）+ E8 格码本打包，2-bit 极限区间 SOTA。 三条路线的取舍：AWQ 按通道保护（粒度粗、无重建），SqueezeLLM 按个体权重保护（需要稀疏 kernel），QuIP# 先把分布变得对 2-bit 友好（Hadamard 变换 + 格解码，实现最复杂）。 8. 习题与解答 #题 1（推导）：AWQ 的误差公式 #从$Q(w\\cdot s)\\cdot (x/s) = \\Delta ′\\cdot \\operatorname{Round}(ws/\\Delta ′)\\cdot x/s$出发，写出误差表达式，并解释$\\Delta ′\\approx \\Delta$时为什么误差约缩小 1/s。\n题 1 解答 真实输出 w·x；量化输出$\\Delta ′\\cdot \\operatorname{Round}(ws/\\Delta ′)\\cdot x/s$。误差= $|w - \\Delta ′\\cdot \\operatorname{Round}(ws/\\Delta ′)/s|\\cdot x = (\\Delta ′/s)\\cdot RoundErr(ws/\\Delta ′)\\cdot x$。若$\\Delta ′\\approx \\Delta$：误差≈ $\\Delta \\cdot RoundErr\\cdot x/s$，即原始误差（$\\Delta \\cdot RoundErr\\cdot x$）除以 s。\n题 2（思考）：为什么 s 不能无限大 #用 3.3 的表格解释：$s=4$时\u0026quot;平均误差更小（0.303）\u0026quot;，为什么 PPL 反而回升？\n题 2 解答 $s=4$时 21.2% 的组被缩放后的权重顶出新 max（$\\Delta ′\u003e\\Delta$），同组非显著通道的网格变粗，误差上升；显著通道省下的误差 \u0026lt; 非显著通道失去的误差，总损失变大。缩放是\u0026quot;转移误差预算\u0026quot;，不是\u0026quot;消灭误差\u0026quot;。\n题 3（对比）：AWQ vs SqueezeLLM 的保护粒度 #同样是\u0026quot;保护重要的东西\u0026quot;，AWQ 和 SqueezeLLM 的保护对象和粒度有什么不同？\n题 3 解答 AWQ 按输入通道（激活幅度大 = 通道重要），整体缩放该通道；SqueezeLLM 按单个权重（Hessian 敏感度大 = 个体重要），非均匀码本 + 稀疏 FP16 分离。AWQ 粒度粗但零开销、硬件友好；SqueezeLLM 粒度细但需要稀疏 kernel。\n题 4（推导）：QuIP# 为什么有效 #用\u0026quot;误差方向\u0026quot;的语言解释：为什么把权重矩阵变得非相干，能降低量化对输出的破坏？\n题 4 解答要点 输出= $Wx$，量化误差$\\varepsilon$对输出的影响= $\\varepsilon ^{T}x$。相干矩阵的$\\varepsilon$集中在少数坐标（与 x 的少数分量强相关），伤害大且不可预测；非相干后$\\varepsilon$的各分量独立、幅度均匀，与 x 的内积像随机噪声，期望影响小、可被后续层平均掉。这就是\u0026quot;把结构性误差变成白噪声\u0026quot;。\n题 5（实践）：给一个 7B 模型选权重量化方案 #场景：要在手机端跑 7B 聊天模型，量化时间预算 30 分钟，生态要成熟。选 AWQ 还是 GPTQ？为什么？如果要 2-bit 进一步省内存呢？\n题 5 解答要点 选 AWQ：分钟级、无重建、TinyChat/llama.cpp 生态成熟、指令微调模型泛化好。2-bit 则 QuIP# 类方法更合适（质量最好），但要接受 kernel 不成熟；工程上通常仍留在 3–4-bit（AWQ/SqueezeLLM）。\n9. 延伸阅读 # AWQ（arXiv:2306.00978）：本章主文献；官方代码 SqueezeLLM（arXiv:2306.07629） QuIP#（arXiv:2402.04396）；QuIP 原版（NeurIPS 2023） AWQ 深度解读（GeneralCompute）：公式与实现的对照 上一篇： 05 权重量化 I：RTN 与 GPTQ；下一篇：[07 激活量化：LLM.int8() 与 SmoothQuant]——把战场从权重扩展到激活（W8A8）。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-06-%E6%9D%83%E9%87%8D%E9%87%8F%E5%8C%96ii-awq-squeezellm-quip/","section":"笔记","summary":"AWQ 的核心观察是只有约 1% 的权重显著，而且要看激活幅度而不是权重幅度，再通过逐通道缩放把误差压下去。本文推导缩放减误差公式，对比 AWQ、GPTQ、SqueezeLLM、QuIP# 的无重建与二阶补偿取舍。","title":"AWQ 量化原理是什么？和 GPTQ、SqueezeLLM 怎么选"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： AWQ 量化原理是什么｜下一篇： KV Cache 量化怎么做\n对应：LLM.int8()（arXiv:2208.07339，NeurIPS 2022）；SmoothQuant（arXiv:2211.10438，ICML 2023）；MIT 6.5940 Lecture 5。 学完本章你应该能：① 说明激活量化比权重量化难在哪（动态、per-tensor、outlier）；② 讲清 LLM.int8() 的 vector-wise 量化与混合精度分解，并说出它依赖的 outlier 统计结论（04 章 6.1）；③ 推导 SmoothQuant 的等效变换和$s_{j}$公式，解释$\\alpha$的语义；④ 说清\u0026quot;scale 折叠\u0026quot;为什么让 W8A8 零运行时开销。\n目录（本章） # 本章目标 为什么激活量化更难 LLM.int8()：outlier 分离的 INT8 推理 SmoothQuant：把量化难度迁移到权重 W8A8 的工程细节 从 INT8 到 FP8：激活量化的现代形态 本章小结 习题与解答 延伸阅读 1. 本章目标 #权重压到 4-bit 之后，prefill 仍要跑 FP16 激活；只有把激活也压到 INT8，prefill 才能用上 INT8 Tensor Core 的 2 倍算力。障碍是激活里的系统性 outlier，权重量化没有这个问题。\n两条路线的分工：\n$LLM.int8() \\to$承认 outlier 无法量化：把 outlier 列单独留在 FP16 算 $SmoothQuant \\to$否认 outlier 必须存在：用等效变换把难度搬到权重上\n2. 为什么激活量化更难 #2.1 三个结构性差异（vs 权重） # 权重 W 激活 X 何时量化 离线，可慢慢校准 推理时动态量化（每个 batch 的分布会变） scale 粒度 可 per-channel（04 章） 主流 per-tensor（per-channel 激活 kernel 贵） outlier 少且可分离 系统性存在且幅度大 2.2 outlier 的具体样子（SmoothQuant 论文对 OPT-175B 的统计） #04 章 6.2 算过激活的\u0026quot;偷位\u0026quot;效应：per-tensor min/max 下，正常值只剩约 4 bit 有效精度，范围全被少数 outlier 占掉。这就是 W8A8 迟迟不能落地的原因。\n3. LLM.int8()：outlier 分离的 INT8 推理 #3.1 目标与设定 #LLM.int8()（Dettmers et al., 2022）的目标：INT8 跑 175B 模型，perplexity 与 FP16 完全一致，同时内存减半。\n三个关键设计：\n3.2 设计一：vector-wise 量化 #LLM.int8() 的粒度取在 per-tensor 和 per-element 之间，即 vector-wise 量化：\n权重：每\u0026quot;行\u0026quot;（每个输出神经元）一个 scale 激活：每\u0026quot;列\u0026quot;（每个输入特征维度）一个 scale\n行/列级的 scale 让量化范围贴近每行每列的真实分布，误差显著小于 per-tensor，又比 per-element 便宜。\n3.3 设计二：发现 outlier 是\u0026quot;特征维度\u0026quot;现象 #04 章 6.1 的统计对 LLM.int8() 有三个直接含义：\noutlier 集中在约 0.1% 的特征维度上，可以按列整体抽出，不必逐元素判断。 13B 以下模型通常不超过 7 个这样的维度，按列抽取的 FP16 路径规模可控。 outlier 对 softmax 的大概率输出至关重要，不能截断丢弃，只能保留高精度。 这些维度对所有 token 一致，这是\u0026quot;把 outlier 列抽出来单独算\u0026quot;的依据。\n3.4 设计三：混合精度分解（Mixed-Precision Decomposition） #对每一层的矩阵乘：\n$$ Y = WX $$= $W [X_{\\text{low}} ; X_{\\text{outlier}}]$（按列拆开激活） = $[W_{\\text{low}} \\cdot X_{\\text{low}}]$（INT8 矩阵乘，大部分计算） $+ [W_{\\text{outlier}} \\cdot X_{\\text{outlier}}]$（FP16 矩阵乘，outlier 列）\n流程：\n前向时统计该层激活 X，找出 |x| \u0026gt; 6.0 的列（outlier 维度） $X_{\\text{low}}$、$W_{\\text{low}}$ → INT8 GEMM（vector-wise scale） $X_{\\text{outlier}}$、$W_{\\text{outlier}}$ → FP16 GEMM 两部分结果相加$\\to$输出 由于 outlier 维度很少，FP16 路径只占$\\sim 0.1\\%$的计算和内存。\n3.5 结果与局限 #结果：OPT-175B 在 INT8 下 perplexity 与 FP16 一致；权重+激活内存约减半。\n局限：\n小模型反而慢：outlier 检测 + 矩阵拆分 + 两条 GEMM 路径的调度开销，在小模型/短序列上可能超过收益（论文报告 6.7B 以下速度没有优势）。 含 FP16 路径：outlier 列仍要走 FP16 GEMM，峰值 FLOPS 收益打折，不能按纯 INT8 Tensor Core 估算。 阈值经验性：6.0 是统计出来的，不同模型/分布要重新验证。 4. SmoothQuant：把量化难度迁移到权重 #4.1 动机 #LLM.int8() 用\u0026quot;分离\u0026quot;绕开 outlier；SmoothQuant 问：能不能让激活根本没有 outlier？\n关键观察：权重容易量化（值域小、可 per-channel），激活难量化（outlier 撑大 per-tensor 范围）。那就用数学上完全等价的变换，把\u0026quot;激活的量化难度\u0026quot;搬到\u0026quot;权重\u0026quot;上去。\n4.2 等效变换推导 #对线性层$Y = WX$，对每个输入通道 j 引入缩放因子$s_{j}$：\n$$ Y = WX = (W \\cdot \\operatorname{diag}(s)) \\cdot (\\operatorname{diag}(s)^{-1} \\cdot X) $$即：\n$W' = W \\cdot \\operatorname{diag}(s)$（权重按通道放大） $X' = \\operatorname{diag}(s)^{-1} \\cdot X$（激活按通道缩小）\n输出完全不变——这是恒等变换，只是把数值挪了位置。\n4.3 平滑因子公式与 α 的语义 #$$ s_{j} = \\max|X_{j}|^\\alpha / \\max|W_{j}|^{1-\\alpha}, \\alpha \\in [0, 1] $$$\\alpha$是\u0026quot;迁移强度\u0026quot;：\n$\\alpha = 0$：$s = 1/\\max|W_{j}| \\to$只归一化权重，不迁移（退化） $\\alpha = 0.5$：一半一半（OPT/BLOOM 的通用甜点） $\\alpha = 1$：$s = \\max|X_{j}| \\to$激活被完全归一化，难度全部搬到权重\n论文结论：OPT/BLOOM 取$\\alpha =0.5$最佳；激活更难量化的 GLM-130B 需要更大的$\\alpha$（0.8）。\n直觉：激活 outlier 通道（$\\max|X_{j}|$ 巨大）对应 $s_{j}$ 巨大，该通道激活被除以 s 后回到正常量级，outlier 则随缩放搬到权重侧。权重按 per-channel 量化，通道之间的尺度差异各自独立处理；激活按 per-tensor 量化，一个通道的 outlier 会污染整层。\n4.4 为什么零运行时开销：scale 折叠 #推理时不需要真的先乘 s 再量化：\n量化激活：$q_{x} = \\operatorname{round}(X'/s_{x}) = \\operatorname{round}(X/(s_{x}\\cdot s)) \\to s$并进激活的 per-tensor scale 量化权重：$q_{w} = \\operatorname{round}(W'/s_{w}) = \\operatorname{round}(W\\cdot s/s_{w}) \\to s$并进权重的 per-channel scale 反量化输出：$\\hat{Y} = (q_{w}\\cdot s_{w}') \\cdot (q_{x}\\cdot s_{x}')$，$s_{w}' = s_{w}/s$，$s_{x}' = s_{x}\\cdot s$\ns 被折叠进激活和权重的 scale 里，推理时多一次乘法都没有。 这也是 SmoothQuant 能无缝进 TensorRT-LLM/vLLM 的原因。\n4.5 算法流程 # 校准：用校准集前向，统计每层$\\max|X_{j}|$与$\\max|W_{j}|$ 选$\\alpha$（默认 0.5，或按验证集扫描） 计算$per-channel s_{j}$，生成$W' = W\\cdot s$，记录 X 的 per-tensor scale 对 W\u0026rsquo; 做 per-channel INT8 量化、X 做 per-tensor INT8 量化 部署：INT8 GEMM + 折叠后的 scale 4.6 结果 # OPT-175B / BLOOM-176B / GLM-130B / LLaMA 全系列 W8A8 近无损（perplexity 差异在噪声范围）。 在优化 kernel 上比 FP16 快约 1.5x（计算密集的 prefill 收益明显）。 被 NVIDIA TensorRT-LLM（INT8 W8A8）等生产引擎采用。 5. W8A8 的工程细节 #5.1 INT8 GEMM 的数据流 # X 量化：$per-tensor scale s_{x}$（在线，一两个 kernel） W 量化：$per-channel scale s_{w}$（离线，含 SmoothQuant 的 s 折叠） INT8 矩阵乘：$q_{w} \\cdot q_{x}$（INT8 Tensor Core，累加器 INT32/FP32） 反量化：$Y \\approx (q_{w} \\cdot q_{x}) \\cdot (s_{w} \\otimes s_{x})$（逐通道乘回） 5.2 动态量化的成本 #激活量化必须在线完成（每层前向时算$\\max|X| \\to scale \\to \\operatorname{round}$）。对 per-tensor 来说只是两次 scan/round 的 kernel，开销很小；per-channel 激活量化 kernel 复杂得多，所以 W8A8 默认激活 per-tensor。\n5.3 累加器精度 #INT8×INT8 的乘积累加必须用 INT32/FP32，否则溢出。量化的是输入和权重，累加器始终高精度——这是量化推理能保持质量的关键工程细节。\n6. 从 INT8 到 FP8：激活量化的现代形态 #03 章讲过：FP8 E4M3 自带 4 位指数，动态范围远好于 INT8。因此现代 W8A8 常用 FP8：\nINT8 方案：SmoothQuant（把 outlier 抚平）$\\to$需要$\\alpha$校准 FP8 方案：E4M3 天然容忍部分$outlier \\to$校准更省事\nSmoothQuant 的迁移在 FP8 上仍有用：FP8 激活仍有 outlier（只是阈值变宽），而 E4M3 的尾数只有 3 bit，精度预算更紧张。TensorRT-LLM / vLLM 的 FP8 方案里仍然常见\u0026quot;SmoothQuant 式迁移 + FP8\u0026quot;的组合。\n7. 本章小结 # 激活量化难：动态、per-tensor、outlier（04 章 6.2 的\u0026quot;偷位\u0026quot;算例）。 LLM.int8()：vector-wise 量化 + outlier 混合精度分解；outlier 集中在少数特征维度这一统计事实是它的设计基础（04 章 6.1）；无损但工程复杂、小模型不快。 SmoothQuant：恒等变换 (W·s)(X/s) 把难度从激活搬到权重；$s_{j} = \\max|X|^\\alpha /\\max|W|^{1-\\alpha}$，$\\alpha$控制迁移强度；scale 折叠$\\to$零运行时开销；W8A8 近无损、$\\sim 1.5x$。 工程约束：累加器必须高精度；激活量化在线做、权重离线做；scale 能折叠就折叠。 8. 习题与解答 #题 1（推导）：SmoothQuant 恒等变换 #证明$Y = (W\\cdot \\operatorname{diag}(s))\\cdot (\\operatorname{diag}(s)^{-1}\\cdot X)$与$Y = WX$完全相等，并说明为什么变换后激活更容易量化。\n题 1 解答 $(W\\cdot \\operatorname{diag}(s))\\cdot (\\operatorname{diag}(s)^{-1}\\cdot X) = W\\cdot \\operatorname{diag}(s)\\cdot \\operatorname{diag}(s)^{-1}\\cdot X = W\\cdot I\\cdot X = WX$。 激活更容易：outlier 通道 j 的$s_{j}$大，$X_{j}/s_{j}$被缩小到正常量级；权重$W_{j}\\cdot s_{j}$变大，但权重是 per-channel 量化，通道间尺度差异不影响相对精度。\n题 2（计算）：α 的边界 #写出$\\alpha =0$、$\\alpha =1$时$s_{j}$的表达式，并分别说明它们对应\u0026quot;完全不迁移\u0026quot;和\u0026quot;完全迁移\u0026quot;。\n题 2 解答 $\\alpha =0$：$s_{j} = 1/\\max|W_{j}|$（只归一化权重通道，激活不动）；$\\alpha =1$：$s_{j} = \\max|X_{j}|$（激活被完全归一化到$\\pm 1$，难度全部进权重）。$\\alpha =0.5$是几何中点，两种难度均衡。\n题 3（对比）：LLM.int8 vs SmoothQuant #填表：量化对象、outlier 处理方式、是否有 FP16 路径、是否需校准、适用位宽。\n题 3 解答 LLM.int8() SmoothQuant 量化对象 权重+激活（INT8） 权重+激活（INT8/FP8） outlier 处理 分离到 FP16 路径 迁移到权重 FP16 路径 有（outlier 列） 无（全 INT8/FP8） 校准 不需要 需要（统计 max，选$\\alpha$） 适用位宽 8-bit 8-bit（FP8 变体更常用） 题 4（思考）：为什么 SmoothQuant 的权重扛得住 outlier #权重被乘以巨大 s 后，\u0026ldquo;outlier 搬家\u0026quot;到权重。为什么 per-channel 量化下这不伤害权重精度？\n题 4 解答 per-channel 量化对每个通道独立选 scale（04 章）：通道 j 的 scale 由该通道自己的 max 决定。$W_{j}\\cdot s_{j}$再大，也只是把该通道的量化范围整体放大，通道内相对精度不变。而激活是 per-tensor 量化，一个通道的 outlier 会污染整层——所以\u0026quot;难度搬家\u0026quot;只对权重无损。\n题 5（编程）：复现 SmoothQuant 的 α 扫描 #构造 W（2×2）、X（2×N，含一个 outlier 通道），对$\\alpha \\in \\{0, 0.5, 1\\}$计算平滑后的量化（INT8 per-channel 权重、per-tensor 激活）SQNR，验证$\\alpha =0.5$附近最好。\n题 5 解答要点 实现$s_{j} = \\max|X_{j}|^\\alpha /\\max|W_{j}|^{1-\\alpha}$，量化 W·s（per-channel）与 X/s（per-tensor），反量化并算 ‖WX−ŴX̂‖。$\\alpha =0$时激活量化被 outlier 打爆；$\\alpha =1$时权重误差增大；$\\alpha =0.5$通常折中最优。可用真实 LLM 激活分布（如校准一层的激活）验证更贴近论文结论。\n9. 延伸阅读 # LLM.int8()（arXiv:2208.07339）：vector-wise + 混合精度分解 SmoothQuant（arXiv:2211.10438）：迁移公式、$\\alpha$扫描、scale 折叠 SmoothQuant 官方代码：INT8 GEMM kernel 与校准实现 上一篇： 06 权重量化 II；下一篇：[08 KV Cache 量化：KIVI 与误差累积]——第三个量化对象：把长上下文里的显存大头压下来。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-07-%E6%BF%80%E6%B4%BB%E9%87%8F%E5%8C%96-llm-int8%E4%B8%8Esmoothquant/","section":"笔记","summary":"权重是静态的，激活是动态的还会出现极大的离群值，所以 W8A8 比 weight-only 难得多。本文讲 LLM.int8() 的向量级量化与混合精度分解、SmoothQuant 的等效变换与 s_j 公式推导，以及缩放折叠为什么让 W8A8 零运行时开销。","title":"激活量化为什么比权重量化难？LLM.int8() 与 SmoothQuant 原理"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： 激活量化为什么比权重量化难｜下一篇： QAT 什么时候才值得做\n对应：KIVI（arXiv:2402.02750，ICML 2024）；Inference Engineering Ch5 的敏感性排序（$KV cache =$中等敏感、误差逐 token 累积）；vLLM PagedAttention 背景。 学完本章你应该能：① 手算任意模型的 KV cache 显存公式与实例；② 解释\u0026quot;KV 误差为什么滚雪球\u0026quot;；③ 复述 KIVI 的两个核心洞察（K 按通道、V 按 token）及其理由；④ 说出 KIVI 的实现要点（非对称 2-bit、流式量化、FP16 缓冲）与结果（2-bit 近无损、4x 省显存）。\n目录（本章） # 本章目标 为什么 KV cache 是下一个量化对象 KV 误差为什么\u0026quot;滚雪球\u0026quot; 设计空间：量化什么、用什么粒度 分布分析：K 稳定、V 多变 KIVI 算法 结果与边界 与 KV 优化的其他手段的关系 本章小结 习题与解答 延伸阅读 1. 本章目标 #权重和激活都有量化路径之后，长上下文推理的显存预算还剩一个大头：KV cache。它随 seq_len 线性增长，量化误差还会跨 token 累积。04 章 7.1 的敏感性排序把 KV cache 放在中间：中等敏感，但必须谨慎。\n2. 为什么 KV cache 是下一个量化对象 #2.1 KV cache 是什么 #解码时，每个 token 的注意力 Key/Value 向量被缓存，供后续所有 token 复用：\nKV cache 张量：K、V 各一个，形状$[n_{\\text{layers}}, n_{\\text{kv\\_heads}}, \\text{seq\\_len}, \\text{head\\_dim}]$\n显存公式（FP16）：\n$$ Bytes = 2 \\times n_{\\text{layers}} \\times n_{\\text{kv\\_heads}} \\times \\text{head\\_dim} \\times \\text{seq\\_len} \\times 2 $$2.2 实例：Llama-2-70B #n_layers = 80，n_kv_heads = 8（GQA），head_dim = 128，FP16\n每 token：$2 \\times 80 \\times 8 \\times 128 \\times 2 B = 327,680 B \\approx 0.31 MB$\n32K 上下文$\\to \\approx 10.7 GB$ 128K 上下文$\\to \\approx 43 GB$\n对比 70B 权重：FP16 是 140 GB，FP8 是 70 GB。32K 上下文时 KV 的 10.7 GB 还不算大；128K 的 43 GB 已接近 FP8 权重，上下文再长就会超过它。decode 每一步还要读全量 KV，带宽随 seq_len 线性增长。\n2.3 两个收益 #省显存$\\to$同样的 GPU 能塞更大 batch / 更长上下文 省带宽$\\to decode$读 KV 的时间减少（和权重带宽同源）\n3. KV 误差为什么\u0026quot;滚雪球\u0026quot; #权重量化误差是静态的：量化一次，误差固定，而且有 GPTQ 这类逐层重建方法可以补偿。\nKV 误差是动态累积的：\ntoken t 写入时被量化$\\to$带误差的$K_{t}$、$V_{t}$进入 cache 之后每个 token（t+1, t+2, …）都要读$K_{t}$、$V_{t}$算注意力 误差不消失，还参与所有后续 softmax/输出计算 每一层、每一步都在重复使用这些被污染的缓存$\\to$误差逐 token 累积 更微妙的是 softmax：QK 分数一旦被量化噪声扰动，softmax 的指数放大会把\u0026quot;小扰动\u0026quot;变成\u0026quot;注意力权重偏差\u0026quot;，进而直接改变输出分布。这就是 Inference Engineering 说\u0026quot;errors compound token-to-token\u0026quot;的机理。\n4. 设计空间：量化什么、用什么粒度 #KV 量化有四个自由参数：\n维度 选项 直觉 量化对象 K 或 V 或两者 K 影响 softmax 分数，V 直接进输出 粒度 per-token / per-channel / per-tensor 与 04 章同构 位宽 2/4/8-bit 每 bit 省 2 倍显存 对称性 对称 / 非对称 分布是否有偏 朴素方案（per-tensor 4-bit）为什么不行：KV 的通道/时间分布差异大，per-tensor 范围利用率低（04 章），且 V 的分布随时间漂移。\n5. 分布分析：K 稳定、V 多变 #KIVI 的设计依据来自两组分布统计：\n5.1 Key 的分布：跨 token 稳定、按通道有规律 #Key 张量：$shape [tokens, heads, \\text{head\\_dim}]$\n发现 1：同一通道（dim 维度）的 key 值跨 token 分布稳定（模式固定） 发现 2：不同通道的量级/偏斜差异大（有通道级 outlier）\n含义：按通道选 scale（per-channel）是准的，而且 scale 可以\u0026quot;持续更新\u0026quot;而不怕时间漂移\n5.2 Value 的分布：随时间漂移 #Value 张量：同一通道的 value 分布随 token 变化明显\n含义：per-channel 的 scale 会\u0026quot;过期\u0026quot;；per-token 的 scale 才能跟上当前分布\n这是 KIVI 的命名式结论：K 按通道量化、V 按 token 量化。\n为什么不对称是合理的：\nQK 分数= $q\\cdot k$：key 的量化误差通过点积进入 softmax，需要稳定的通道级精度 V 直接加权进输出：value 的误差被注意力权重\u0026quot;平均\u0026quot;，per-token 精度更划算\n6. KIVI 算法 #6.1 方案总览 #K cache：2-bit，per-channel 非对称量化（每 head 每通道一个 scale + zero-point） V cache：2-bit，per-token 非对称量化（每个 token 一个 scale + zero-point） 免调参：不需要微调，即插即用\n6.2 流式实现要点 #KV 是在线生成的（一个 token 一个 token 写），所以量化必须流式：\n保留一小段最近的 token 在 FP16 缓冲（避免反复量化、保证近期精度） K：以一小段 token 为单元，统计该段每个通道的$\\max/\\min \\to per-channel$非对称量化$\\to$写 2-bit V：每 token 到达即按该 token 自己的 max/min 量化（per-token） 解码时：2-bit 数据按需反量化回 FP16 参与 attention 实现细节（块大小、缓冲长度）是工程参数，见 KIVI 官方代码。\n6.3 为什么 2-bit 还能近无损 # 粒度对：K 的通道规律 + V 的 token 适配，让 2-bit 网格利用率高 非对称：KV 分布往往有偏，zero-point 把网格对准分布（01 章 3.7） 误差去处：V 误差被注意力权重平均；K 误差虽然进 softmax，但通道级精度保住了主要结构 免调参不意味着免验证：论文在多个模型上逐长度验证 PPL 差异落在噪声内 7. 结果与边界 #7.1 论文结果 # 模型：Llama-2 7B/13B/70B、OPT、Mistral 等。 质量：2-bit KV 在论文测试长度（数千到上万 token）下 perplexity 与 FP16 差异在噪声范围内；4-bit 更稳。 内存：KV 省 4 倍$\\to$同一 GPU 可支持更大 batch 或更长上下文。 即插即用：无需微调、无需额外校准训练。 7.2 边界与生产建议 # 2-bit 是 KIVI 的展示重点；生产上 KV 量化通常从 4-bit 或 FP8 起步，先跑长上下文评测 超长上下文（几十万 token）下误差累积更明显，需要按实际长度验证 与 GQA 天然兼容（KV head 少，量化对象更少） vLLM / TensorRT-LLM 已提供 KV cache 的 FP8/INT8 量化选项 8. 与 KV 优化的其他手段的关系 #KV 优化有多个方向，量化只是其中一块：\n手段 思路 与量化的关系 PagedAttention（vLLM） 显存管理（分页，避免碎片/预分配浪费） 正交，可叠加 前缀缓存 / KV 复用 相同前缀只算一次 正交，可叠加 淘汰（H2O / StreamingLLM） 丢不重要的旧 token 可叠加；量化省所有 token 的位 ThinK 裁剪 key 的冗余通道 可与 KIVI 叠加（论文报告过） KV 量化（KIVI 等） 每个 KV 用更少 bit 本章主题 工程排序：先做 PagedAttention + 前缀缓存（无损、成熟），再考虑 KV 量化（有损但收益大），最后才考虑淘汰（改变语义）。\n9. 本章小结 # KV 是长上下文的显存大头：公式 2·L·H·d·S·bytes，$70B @32K \\approx 10.7 GB$。 误差滚雪球：KV 被反复读取，softmax 放大扰动$\\to$逐 token 累积。 K 按通道、V 按 token：K 分布稳定（通道模式），V 分布漂移（随时间变）——KIVI 的全部设计都从这里来。 2-bit 非对称 + 流式量化 + 免调参：即插即用，4x 省显存，近无损。 生产建议：4-bit/FP8 起步、按实际长度评测、与 PagedAttention/前缀缓存叠加；2-bit 的收益要在实际上下文长度上验证后再上线。 10. 习题与解答 #题 1（计算）：KV 显存 #模型：64 层、4 个 KV head、$\\text{head\\_dim} 128$。计算 FP16 与 2-bit 下 64K 上下文的 KV 显存。\n题 1 解答 每$token = 2\\times 64\\times 4\\times 128\\times 2 = 131,072 B = 128 KB$。 $64K = 65536 token \\to FP16 \\approx 8.59 GB$；$2-bit \\approx 2.15 GB$（省 4 倍）。\n题 2（思考）：误差为什么逐 token 累积 #用\u0026quot;KV 被读多少次\u0026quot;回答：第 t 个 token 写入的$K_{t}$，在序列长度为 T 时会被后续多少步读取？量化误差因此被放大多少次？\n题 2 解答 $K_{t}$被 token t+1 … T 每一步读取，共 T−t 次；每次读取都参与一层 attention 且可能影响后续所有 token 的生成（输出 token 会继续影响后面）。所以误差既被\u0026quot;重复使用\u0026quot;，又被\u0026quot;传播放大\u0026quot;——这就是累积。\n题 3（设计）：为什么 V 不用 per-channel #如果 V 也用 per-channel（scale 用前 1000 个 token 统计），长对话后 V 分布漂移，会发生什么？\n题 3 解答 scale 过期：新 token 的 V 分布可能远超/远低于旧 scale 覆盖范围$\\to$大量截断或有效位宽浪费（02 章）；per-token scale 始终跟当前 token 对齐，截断可控。K 因为分布稳定才敢用 per-channel。\n题 4（编程）：per-token vs per-channel 对比 #生成随时间漂移的 V 数据（前一半 N(0,1)，后一半 N(10,1)），比较 per-token 与 per-channel（用前半统计）2-bit 量化的总误差。\n题 4 解答要点 per-channel 的 scale 固定$\\to$后一半全部落在网格边缘/外，误差大；per-token 每 token 自适应，误差接近理论最优。验证 KIVI 的结论：分布漂移时 per-token 完胜。\n题 5（开放）：KV 量化的验收 #给 KV 2-bit 方案设计验收实验：模型、长度、指标、对照组各是什么？\n题 5 解答要点 模型：生产用模型（如 70B 级）；长度：覆盖线上最大上下文（如 32K/128K）；指标：perplexity（WikiText-2 长段）+ 长上下文任务（如 RULER/大海捞针）+ 自定义业务评测；对照组：FP16 KV 与 4-bit KV，跑多遍确认差异在噪声内（10 章的方法论）。\n11. 延伸阅读 # KIVI（arXiv:2402.02750）：本章主文献；代码 PagedAttention（vLLM 论文，arXiv:2309.06180）：KV 显存管理（正交手段） ThinK（ICLR 2025）：key 通道剪枝 + KIVI 叠加 上一篇： 07 激活量化；下一篇：[09 QAT 与训练内量化：STE、QLoRA、BitNet b1.58]——从\u0026quot;事后补偿\u0026quot;转向\u0026quot;让模型学会忍受量化\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-08-kv-cache%E9%87%8F%E5%8C%96%E4%B8%8Ekivi/","section":"笔记","summary":"KV Cache 是长上下文推理的显存大头，而 KV 量化误差会逐 token 累积。本文手算 KV 显存公式，讲 KIVI 的两个核心洞察（Key 按通道量化、Value 按 token 量化）与非对称 2-bit 流式量化实现，并辨析 KV 量化与 KV 压缩的区别。","title":"KV Cache 量化怎么做？KIVI 与「量化还是压缩」的区别"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： KV Cache 量化怎么做｜下一篇： 量化后精度掉了怎么定位\n对应：STE（Bengio et al. 2013；直通估计器）；QLoRA（arXiv:2305.14314，NeurIPS 2023）；BitNet b1.58（arXiv:2402.17764）；MIT 6.5940 Lecture 6（Quantization Part II）。 学完本章你应该能：① 说明量化函数为什么不可导、STE 怎么绕过去，并手推一个反向传播例子；② 讲清 QLoRA 的三件套（NF4、双重量化、paged optimizer）和\u0026quot;量化基座 + LoRA 适配器\u0026quot;的架构；③ 说出 BitNet b1.58 的三值化设计（{-1,0,+1}、1.58 bit、无乘法）与性能结论；④ 对比 PTQ/QAT/QLoRA/BitNet 四条路线的适用场景。\n目录（本章） # 本章目标 为什么需要训练侧参与 STE：让量化可训练 QAT 的标准流程与代价 QLoRA：量化 × 微调 BitNet b1.58：为 1-bit 而生的架构 四条路线对比 本章小结 习题与解答 延伸阅读 1. 本章目标 #04–08 章全是 PTQ（训练后量化）：模型训练完，再想办法把误差压下去。本章转向训练侧：让模型在训练时就\u0026quot;学会忍受\u0026quot;量化。这会回答一个 PTQ 答不了的问题：\n如果量化到 4-bit 以下、甚至 1.58-bit，什么方法还能保住质量？\n训练侧三条路线的分工：\nQAT（STE）$\\to$标准做法：前向模拟量化，反向用直通估计器 $QLoRA \\to$量化基座 + 高精度 LoRA 适配器：4-bit 微调超大模型 $BitNet b1.58 \\to$架构级：三值权重 + 无乘法矩阵乘，从头训练\n2. 为什么需要训练侧参与 #PTQ 的隐含假设：量化只是给训练好的权重加噪声，模型必须\u0026quot;生受\u0026quot;。位宽越低，这个假设越不成立：\n4-bit：PTQ 还能靠 GPTQ/AWQ 补救 3-bit：只有少数方法勉强（SqueezeLLM） 2-bit：PTQ 基本失守（QuIP# 靠\u0026quot;洗牌\u0026quot;续命） 1.58-bit：必须从训练时就让模型适应\nQAT 的核心思想：在训练前向里\u0026quot;假量化\u0026quot;（$\\operatorname{quantize} \\to \\operatorname{dequantize}$），让 loss 直接看到量化噪声，梯度因此学会往\u0026quot;量化后依然好\u0026quot;的方向更新。\n3. STE：让量化可训练 #3.1 问题：量化函数几乎处处不可导 #对称量化的前向：\n$$ \\hat{x} = \\operatorname{clamp}(\\operatorname{round}(x/s), q_{\\min}, q_{\\max}) \\cdot s $$round 是分段常数函数：除了跳变点，导数处处为 0。如果直接反向传播，梯度全为零，训练根本动不了。\n3.2 直通估计器（Straight-Through Estimator） #STE 的做法：前向照常量化，反向把量化器当成恒等函数：\n前向：$\\hat{x} = \\operatorname{clamp}(\\operatorname{round}(x/s), q_{\\min}, q_{\\max}) \\cdot s$ 反向：$\\partial L/\\partial x \\approx \\partial L/\\partial \\hat{x}$（在量化范围内）\n直觉：量化误差（几十分之一）相对梯度噪声是小事，梯度\u0026quot;假装\u0026quot;没有量化，直接穿过；模型因此既能正常更新，又在前向里尝到量化的苦头。\n3.3 手推一个反向传播例子 #设$x = 2.3$，$s = 1$（简化），前向：\n$$ \\hat{x} = \\operatorname{round}(2.3) = 2 $$反向时 STE 令：\n$$ \\partial L/\\partial x = \\partial L/\\partial \\hat{x} \\times 1 = \\partial L/\\partial \\hat{x} $$对比精确导数（0）与 STE（1）：STE 保留了\u0026quot;x 增大应该影响输出\u0026quot;的信息，哪怕量化的跳变把局部导数掩盖了。\n边界处理：x 超出 [qmin·s, qmax·s] 时，clamp 把梯度截到边界（或直接传 0），防止训练把权重推到饱和区。\n3.4 进阶：可学习 scale（LSQ 思路） #标准 STE 的 s 是超参；LSQ（Learned Step Size）把 s 也变成可学习参数：\n$\\partial L/\\partial s = \\partial L/\\partial \\hat{x} \\times (\\partial \\hat{x}/\\partial s)$（用 STE 近似）\n训练中学到的 s 比手调更贴合数据，QAT 质量进一步上升。\n4. QAT 的标准流程与代价 #4.1 流程 # 取预训练模型 在所有线性层/注意力层插入 fake-quant（quantize+dequantize） 用任务数据微调（几百到几千步），前向带量化、反向 STE 训练结束：把 fake-quant 替换成真量化权重部署 4.2 与 PTQ 的成本对比 # PTQ QAT 训练数据 不需要（只需校准集） 需要 算力 分钟$\\sim$小时 小时$\\sim$天 质量上限 低（模型生受） 高（模型适应） 位宽下限 $\\sim 3-bit$（极限 2-bit） 2-bit 可行、1.58-bit 可行 工程复杂度 低 中（训练管线改造） 工程策略：先 PTQ 上线；质量不达标时先换更好的 PTQ（AWQ/QuIP#）；最后才考虑局部 QAT。\n5. QLoRA：量化 × 微调 #5.1 动机 #大模型微调最贵的是优化器状态和梯度（动辄几十 GB）。QLoRA 的思路：基座模型用 4-bit 冻结存储，只训练注入的高精度 LoRA 适配器。\n5.2 三件套 #① NF4：4-bit NormalFloat（信息论最优码本）\n普通 INT4/FP4 的网格对权重分布不是最优。NF4 用标准正态分布的分位数做码本：\n16 个码字= $7$个负值 + 0 + 8 个正值（非对称） 码字位置由 N(0,1) 的分位数决定$\\to$信息论上对近似正态的权重最优\n相比均分网格，同样的 4-bit 在权重分布最密集的地方码字更密。\n② 双重量化（Double Quantization）\nNF4 每个 block（64 个元素）配一个 FP32 scale。这些 scale 本身也可以量化：\n第一层：NF4 权重（4-bit） + FP32 block scale 第二层：把 64 个 FP32 scale 再量成 FP8（每组 256 个 scale 共享一个 FP32 二级 scale） 收益：平均每参数省约 0.37 bit\n③ Paged Optimizer\n优化器状态峰值（如长序列的梯度 checkpoint）会瞬间爆显存；用 GPU 统一内存的分页机制把峰值\u0026quot;换页\u0026quot;出去，避免 OOM。\n5.3 架构：量化基座 + LoRA #基座：NF4 冻结（4-bit，前向时反量化到 BF16 计算） LoRA：低秩适配器（A、B 两个小矩阵），BF16 可训练 输出：$Y = W_4bit\\cdot X + (B\\cdot A)\\cdot X$\n5.4 结果 # 65B 模型在单张 48GB GPU 上微调（此前需要多卡/数百 GB）。 Guanaco-65B 达到 ChatGPT 在 Vicuna benchmark 上 99.3% 的水平。 微调质量与 16-bit LoRA 相当（论文在多项任务上验证）。 6. BitNet b1.58：为 1-bit 而生的架构 #6.1 三值权重 #BitNet b1.58 把每个权重限制为三个值：\n$$ w \\in \\{-1, 0, +1\\} $$每个权重 1.58 bit（= $\\log_2(3)$）\n与 BitNet b1（二值 {-1,+1}）相比，多了 0：\n0 的价值：\n更接近真实权重分布（很多权重本来就接近 0） 隐含稀疏性（部分权重\u0026quot;关闭\u0026quot;） 相同模型大小下质量显著提升，达到与 FP16 相当 6.2 无乘法矩阵乘 #三值权重与激活相乘：\n$$ y = \\sum w_{i} \\cdot x_{i}, w_{i} \\in \\{-1, 0, +1\\} $$$\\to$只需要加法和减法，不需要乘法！\n实现（BitNet.cpp 等）：激活先量化为 8-bit，再用三值权重的符号决定加/减。论文估算（7nm）：矩阵乘算术能耗约为 FP16 的 1/71.4。\n6.3 训练：从头 QAT #BitNet 不能从 FP16 模型\u0026quot;转换\u0026quot;而来，必须从零训练：\n权重初始化为 FP16，前向时三值化（round 到 {-1,0,+1}）+ 缩放因子 反向用 STE（第 3 节） 激活 8-bit 量化（类似 SmoothQuant 的思路） 训练稳定后，部署时只剩加/减 6.4 结果 #质量：相同模型大小与训练 token 下，匹配 FP16 LLaMA 的 perplexity 与下游任务 速度：比同规模 FP16 快约 2.71x（论文估计） 内存：约省 3.55x 规模效应：模型越大，收益越明显\n7. 四条路线对比 # PTQ QAT QLoRA BitNet b1.58 是否需要训练 否 是（微调） 是（LoRA） 是（从头） 数据需求 校准集 任务数据 任务数据 海量预训练数据 位宽 3–4-bit 起步 2-bit 4-bit 基座 1.58-bit 质量上限 低 高 高（受限于基座） 高（重新训练） 训练成本 分钟$\\sim$小时 小时$\\sim$天 单卡小时级 预训练级 典型用途 生产推理默认 低比特精度冲刺 单卡微调大模型 未来架构探索 选型： 部署已有模型$\\to PTQ$（AWQ/GPTQ） 部署 + 质量不够$\\to$局部 QAT 要微调大模型$\\to QLoRA$ 要 1-bit 极限$\\to BitNet$（接受重训成本）\n8. 本章小结 # STE：前向量化、反向恒等——让不可导的量化变得可训练（配合 LSQ 可学 scale）。 QAT：模型在训练中\u0026quot;学会忍受\u0026quot;量化，质量上限高于 PTQ，代价是数据和算力。 QLoRA：NF4 分位数码本 + 双重量化 + paged optimizer，量化基座 + BF16 LoRA，单卡微调 65B。 BitNet b1.58：三值权重 {-1,0,+1}（1.58 bit）、无乘法矩阵乘、从头 QAT，质量匹敌 FP16、能耗降一个数量级。 一条主线：位宽越低，越需要\u0026quot;训练侧参与\u0026quot;——从 PTQ 的补救，到 QAT 的适应，再到 BitNet 的架构重构。 9. 习题与解答 #题 1（手算）：STE 反向 #$x = 3.7$，$s = 1$，前向$\\hat{x} = \\operatorname{round}(3.7) = 4$。若$\\partial L/\\partial \\hat{x} = 0.5$，STE 下$\\partial L/\\partial x$是多少？真实导数是多少？为什么 STE 可用？\n题 1 解答 STE：$\\partial L/\\partial x = 0.5$。真实导数：round 在$x=3.7$处导数为 0。STE 可用因为它保留\u0026quot;增大 x 会增大输出\u0026quot;的方向信息；量化跳变点的局部导数（0 或 ∞）对训练没有统计意义，且训练中大量样本的 STE 期望近似于真实梯度。\n题 2（推导）：1.58 bit 怎么来的 #证明三值权重每参数 1.58 bit，并解释为什么它比\u0026quot;1-bit + 稀疏位\u0026quot;的混合更省。\n题 2 解答 三个等概率状态需要$\\log_2(3) \\approx 1.585 bit$。若用\u0026quot;1 bit 符号 + 1 bit 是否为零\u0026quot;则需要 2 bit（且 4 个码字浪费 1 个）。三值直接编码是最紧凑的表示。\n题 3（对比）：NF4 vs INT4 #为什么 NF4 的码本对 LLM 权重通常优于均匀 INT4？\n题 3 解答 LLM 权重近似零均值正态分布：大量值集中在 0 附近。均匀网格在 0 附近只有少量码字（02 章\u0026quot;范围利用率\u0026quot;）；NF4 用标准正态分位数布点，0 附近码字密、尾部疏，同样的 16 个码字信息量更大。\n题 4（设计）：给 BitNet 写部署要点 #BitNet 推理时，矩阵乘的乘法器可以完全去掉吗？还有哪些地方仍是乘法/高精度？\n题 4 解答要点 权重×激活的乘法可退化为加/减（按权重符号），但：① 激活仍要 8-bit 量化（需要 scale 乘法）；② 归一化、残差、输出投影仍可能是高精度；③ 注意力（softmax、QK）仍需乘法。所以\u0026quot;无乘法\u0026quot;主要指权重矩阵乘主体，不是全模型。\n题 5（开放）：量化 + 微调的组合矩阵 #画出\u0026quot;位宽 × 是否训练\u0026quot;的 2×3 矩阵（4-bit/2-bit/1.58-bit × PTQ/QAT/从头训练），各填一个代表方法与一句话判断。\n题 5 解答要点 4-bit：AWQ（PTQ）✓ 生产可用；QAT 4-bit（更稳）；从头 4-bit（少见）。 2-bit：QuIP#（PTQ，极限）；QAT 2-bit（可行）；BitNet 类（更适合）。 1.58-bit：PTQ 无解；QAT 勉强；BitNet b1.58（唯一成熟路线）。 结论：位宽越低，横轴（训练参与度）必须越大。\n10. 延伸阅读 # QLoRA（arXiv:2305.14314）：NF4、双重量化、paged optimizer The Era of 1-bit LLMs: BitNet b1.58（arXiv:2402.17764） BitNet.cpp：三值权重的 CPU 推理实现（加/减内核） Bengio et al., Estimating or Propagating Gradients Through Stochastic Neurons（2013）：STE 的源头 上一篇： 08 KV Cache 量化；下一篇：[10 质量评估方法论]——学完所有方法，怎么科学地判断\u0026quot;量化有没有搞砸\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-09-qat%E4%B8%8E%E8%AE%AD%E7%BB%83%E5%86%85%E9%87%8F%E5%8C%96-ste-qlora-bitnet/","section":"笔记","summary":"量化函数不可导，STE 用直通估计器把梯度放过去。本文手推一个完整的反向传播例子，讲清 QLoRA 的 NF4、双重量化与 paged optimizer，解释 BitNet b1.58 的三值化设计，并对比 PTQ/QAT/QLoRA/BitNet 四条路线各自适用什么场景。","title":"QAT 什么时候才值得做？PTQ、QLoRA、BitNet 路线对比"},{"content":"Answer #Most of the KV cache is reserved or fragmented, not live tokens. The vLLM paper, as cited in the Chinese note, measured 20.4%–38.2% effective KV memory when nothing manages it. The waste is reservation for the maximum length, internal fragmentation inside an allocation, and external fragmentation between requests.\nPagedAttention gives each sequence logical blocks and maps them to physical blocks through a block table, the same idea as virtual memory. Copy-on-write lets beam search and parallel samples share a prefix until they diverge. It does not replace FlashAttention: one places KV in memory, the other computes attention without writing the score matrix.\nWhat this page is not #There is no new utilization number here. The 20.4%–38.2% range is the paper’s measurement, quoted from the Chinese chapter.\n","date":null,"permalink":"https://doraemeng.dev/en/pagedattention/","section":"页面","summary":"The vLLM paper measured 20.4%–38.2% effective KV memory without a manager. PagedAttention maps logical blocks to physical blocks so reservation and fragmentation stop holding the rest of the cache.","title":"How does PagedAttention save KV-cache memory?"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： QAT 什么时候才值得做｜下一篇： 量化模型怎么部署到 vLLM\n对应：Inference Engineering Ch5 的 \u0026ldquo;Measuring Quality Impact\u0026rdquo;；SWE-bench（arXiv:2310.06770）；MMLU；GPTQ/AWQ/KIVI 论文的评测协议。 学完本章你应该能：① 写出 perplexity 的定义并解释它的优缺点；② 设计一套\u0026quot;三层评测\u0026quot;（$PPL \\to$智能基准$\\to$自定义评测）的验收协议；③ 理解\u0026quot;与噪声不可区分\u0026quot;的操作化含义（多次运行、配对比较、置信区间）；④ 列出量化评测的常见陷阱。\n目录（本章） # 本章目标 核心原则：找\u0026quot;与噪声不可区分\u0026quot;的差异 第一层：Perplexity（最简） 第二层：智能基准（MMLU、SWE-bench 等） 第三层：自定义评测（最准） 统计显著性：怎么判断\u0026quot;没变\u0026quot; 验收协议：关卡式流程 陷阱清单 本章小结 习题与解答 延伸阅读 1. 本章目标 #前 8 章讲了\u0026quot;怎么量化\u0026quot;，本章讲怎么证明量化没有搞砸。Inference Engineering 的一句话是本章的总纲：\n\u0026ldquo;In every case, you\u0026rsquo;re looking for differences indistinguishable from noise.\u0026quot;（所有情况下，你要找的都是与噪声不可区分的差异。）\n2. 核心原则：找\u0026quot;与噪声不可区分\u0026quot;的差异 #量化评测要回答的是\u0026rdquo;这个变化能解释为随机噪声吗\u0026quot;；为什么这么严格：\n评测本身有噪声（采样、温度、并行浮点非确定）。 量化引入的是\u0026quot;系统性\u0026quot;误差——它可能恰好落在噪声范围内，也可能超出。 验收目标是\u0026quot;量化后任务质量与原模型无实质差异\u0026quot;。 操作化：量化模型与 FP16 基线在同一批样本、同一随机种子下做配对比较；重复多次，看差值是否落在噪声范围内。\n3. 第一层：Perplexity（最简） #3.1 定义 #对自回归模型，给定 token 序列$x = (x_{1}, …, x_{N})$：\n$$ PPL = \\exp( -(1/N) \\cdot \\sum log p(x_{i} | x_{","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-10-%E8%B4%A8%E9%87%8F%E8%AF%84%E4%BC%B0%E6%96%B9%E6%B3%95%E8%AE%BA/","section":"笔记","summary":"只跑一个 perplexity 数字不足以判断量化能不能上线。本文给出「困惑度 → 智能基准 → 自定义评测」的三层验收协议，解释「与噪声不可区分」如何操作化成多次运行与配对比较，并列出量化评测最容易踩的坑。","title":"量化后精度掉了怎么定位？perplexity 与评测怎么用"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜上一篇： 量化后精度掉了怎么定位\n对应：QServe / QoQ（arXiv:2405.04532，MLSys 2025）；FlashAttention-3（arXiv:2407.08691）；SageAttention（arXiv:2410.02367）；vLLM / TensorRT-LLM / llama.cpp。 学完本章你应该能：① 解释\u0026quot;量化算法好 ≠ 端到端快\u0026quot;的系统瓶颈（dequant、内存布局、kernel）；② 讲清 QServe 的 W4A8KV4 协同设计（为什么 W4A8 而不是 W4A4、KV4 为什么重要）；③ 说出主流引擎的量化支持地图；④ 给出\u0026quot;无损优先\u0026quot;的组合优化栈与部署决策树。\n目录（本章） # 本章目标 从算法到系统：三个隐形瓶颈 QServe：W4A8KV4 的算法-系统协同 注意力量化（前沿） 推理引擎的量化支持地图 组合优化栈：无损优先 部署决策树（含验收闭环） 本章小结 习题与解答 延伸阅读 1. 本章目标 #前面各章证明了\u0026quot;某种量化算法质量好\u0026quot;。本章回答最后一个问题：\n同一套量化方案，为什么在不同引擎里速度差几倍？怎么把量化装进生产系统，和其他优化组合？\n2. 从算法到系统：三个隐形瓶颈 #2.1 反量化（dequantization）开销 #低比特权重在 GPU 上不能直接算矩阵乘（FP4 只在 Blackwell 有），通常要：\n读入打包的 4-bit 权重 解包成 INT8/FP16 格式 乘 scale（dequant） 才能喂给 Tensor Core 如果第 2–3 步在寄存器/内存里反复做，省下的带宽可能被计算开销吃回去。\u0026ldquo;4-bit 权重= $2$倍速度\u0026quot;只在 kernel 把 dequant 做进流水线时才成立。\n2.2 内存布局与打包 #4-bit 不是字节对齐的（2 个$4-bit = 1$字节）。怎么把 4-bit 值塞进寄存器、怎么按 group 排列 scale，决定 kernel 效率。差的布局会让访存模式碎裂。\n2.3 kernel 覆盖 #量化收益只在\u0026quot;有对应 kernel 的层\u0026quot;兑现：\nW8A8 $\\to$ INT8 GEMM kernel（Ampere+）\n$W4A16 \\to INT4 weight-only kernel$（各家自定义） $W4A8KV4 \\to$专门的 4-bit GEMM + KV 4-bit attention（QServe）\n没有 kernel 的层退回 FP16，收益就漏掉一块。\n3. QServe：W4A8KV4 的算法-系统协同 #3.1 QoQ：W4A8KV4 量化方案 #QoQ（Quattuor-Octo-Quattuor，拉丁语 4-8-4）：\n权重：4-bit（group 128 或 per-channel），配合激活感知缩放（AWQ 式）做\u0026quot;渐进量化\u0026rdquo; 激活：8-bit（INT8/FP8）\nKV cache：4-bit\n质量：WikiText-2 PPL 与 FP16 几乎无差（近无损）\n\u0026ldquo;渐进量化\u0026rdquo;（progressive quantization）是关键算法设计：让 W4A8 GEMM 能在 INT8 Tensor Core 上执行（把 4-bit 权重解包成两个 INT8 或直接按 INT8 对齐布局），避免依赖 Blackwell 才有的 FP4 Tensor Core。\n3.2 两个\u0026quot;为什么\u0026quot; #为什么 W4A8，而不是 W4A4？\nW4A4 的 GEMM 主循环里，权重和激活都要解包/去量化，每步开销更大 W4A8：激活 8-bit 可直接进 INT8 Tensor Core，只有权重需要解包$\\to$主循环更干净 $\\to$端到端反而更快（QServe 论文专门分析了这个 tradeoff）\n为什么 KV4？\n大 batch 下 attention 占运行时 50%+（$batch=64$时） KV 4-bit 让 attention 的峰值性能翻倍（相对 KV8） $\\to W4A8KV4$是\u0026quot;权重省带宽 + 激活保计算 + KV 救 attention\u0026quot;的组合\n3.3 系统技术 # compute-aware weight reordering：按 kernel 的访存模式重排权重布局 register-level parallelism：把 dequant 摊进寄存器流水，隐藏开销 专用 attention kernel：4-bit KV 读取 + 反量化 + FP16 计算 3.4 性能 #相比当时工业界最强基线 TensorRT-LLM： 一般模型吞吐高 1.2–1.4x Qwen1.5-72B 高 2.4–3.5x L40S（低端卡）跑 QServe 的吞吐超过 A100 上 TensorRT-LLM（8 个模型里 6 个）\n结论：量化方案的收益上限由\u0026quot;算法 × kernel × 调度\u0026quot;共同决定。\n4. 注意力量化（前沿） #Inference Engineering 的默认建议：attention 留在原精度（softmax 太敏感）。但前沿工作在突破：\n方法 做法 状态 FlashAttention-3（2024） Hopper 上 FP8 attention + 异步拷贝 生产化中 SageAttention（2024） 8-bit 量化 Q/K/V，精度保持，图像/视频生成加速 研究+落地中 工程建议：\nFP8 attention 只在：① 有专用 kernel ② 长序列 attention 占比高 ③ 评测通过\n5. 推理引擎的量化支持地图 # 引擎 支持的量化 特点 vLLM AWQ、GPTQ、FP8(E4M3/E5M2)、MXFP8、FP4(Blackwell)、KV cache 量化 生态最广；PagedAttention；生产首选之一 TensorRT-LLM FP8、INT4/FP4、SmoothQuant W8A8、AWQ、KV 量化 NVIDIA 深度优化；部署灵活 SGLang 同上（复用多种后端） 高性能 + 结构化生成 llama.cpp GGUF：$Q2_K\\sim Q8_0$、IQ 系列、MXFP4 本地/边缘；格式事实标准 bitsandbytes / HF Transformers NF4/INT8（bitsandbytes）、GPTQ、AWQ、FP8 研究/微调（QLoRA） MLX（Apple） 4-bit 量化（MLX 生态） Apple Silicon 本地部署 选引擎的检查清单：\n我要的量化格式有没有实测过速度的 kernel 激活是否也量化（W8A8 还是只 W4A16） KV cache 量化是否可开关 长上下文、GQA、MoE 是否适配 是否支持我要的硬件（Hopper / Blackwell / 本地） 6. 组合优化栈：无损优先 #Inference Engineering Ch5 的关键提示：除了量化，那一章其他技术都是无损的。所以优化顺序：\n第一优先（无损）：\n前缀缓存 / KV 复用（相同前缀不算第二次） 推测解码（draft 模型多 token 猜测） PagedAttention 类显存管理 第二优先（有损但收益大）： 4. W8A8 FP8（权重+激活，01 章带宽/FLOPS 账本） 5. KV cache 4-bit/FP8（长上下文显存） 6. W4A8KV4（激进，Blackwell/QServe 类系统）\n最后（按需）： 7. 模型并行 / 预填充-解码解耦（另一套工程）\n7. 部署决策树（含验收闭环） #① 有 GPU 与模型$\\to$先跑 FP16 基线（速度/质量双基线） ② 质量必须无损$\\to$只用无损优化（缓存/推测解码） ③ 可以接受\u0026quot;验证过的\u0026quot;风险$\\to$ 默认配方：W8A8 FP8 + KV 4-bit/FP8，attention 留 FP16 激进：W4A8KV4（QServe）/ FP4（Blackwell） ④ 每档都走 10 章的 Gate 1–4 验收 ⑤ 不达标$\\to$降档：更细粒度$\\to$更高位宽$\\to$换方法$\\to$局部 QAT ⑥ 达标$\\to$灰度$A/B \\to$上线$\\to$监控长尾/长上下文\n8. 本章小结 # 算法好 ≠ 系统快：dequant、内存布局、kernel 覆盖是三个隐形瓶颈。 QServe 示范了协同设计：W4A8KV4（渐进量化让 4-bit 权重跑在 INT8 Tensor Core）+ 权重重排 + 寄存器级 dequant + KV4 attention；vs TensorRT-LLM 高 1.2–1.4x（72B 上 2.4–3.5x）。 attention 默认不动，FP8 attention 是前沿选项（FA3/SageAttention）。 引擎选择看 kernel 实测，不是看支持列表。 无损优化优先：缓存/推测解码先上，量化后上，并行/解耦最后。 9. 习题与解答 #题 1（思考）：为什么 4-bit 不一定快 #一个 naive 的 W4A16 kernel 比 W8A8 慢，可能的原因有哪些？\n题 1 解答 ① 4-bit 解包/去量化开销大（无原生 INT4 Tensor Core）；② 内存布局碎片化导致访存效率低；③ 激活 16-bit 让计算量不变，只是省了权重带宽，而带宽收益被 kernel 开销抵消；④ scale 折叠没做好，多了一轮乘法。\n题 2（设计）：给 70B 部署选型 #场景：H200（单卡 141GB）、70B 模型、32K 上下文、要求 PPL 无损 + 尽量快。给出方案组合与理由。\n题 2 解答要点 无损优先：前缀缓存 + PagedAttention。量化：W8A8 FP8（权重+激活近无损、FLOPS 翻倍）+ KV 4-bit（32K 上下文显存大头，08 章算过≈$10.7GB\\to 2.7GB$）。attention 留 FP16。引擎：vLLM 或 TensorRT-LLM（FP8 kernel 成熟）。验收：10 章 Gate 1–4。\n题 3（对比）：W4A16 vs W4A8KV4 #两者权重都是 4-bit，为什么端到端收益不同？\n题 3 解答 W4A16 只省权重带宽（decode 受益，prefill 计算仍是 16-bit）；W4A8KV4 的激活 8-bit 让 prefill 也用上低精度 Tensor Core（2x FLOPS），KV4 让 attention 带宽减半——三段（权重、激活、KV）都受益，端到端收益更高，但系统复杂度也更高。\n题 4（排错）：量化后速度没提升 #W8A8 量化部署后 TPS 没变，排查思路（至少 4 条）。\n题 4 解答要点 ① kernel 是否真的生效（profile 看算子的数据类型）；② 是否只有权重量化、激活还是 FP16（退化成 W8A16）；③ 是否被注意力/非量化算子占比掩盖（短序列时 attention 占比高）；④ 是否 batch 太小（带宽没打满）；⑤ 是否 KV/前缀缓存把瓶颈移到别处。\n题 5（开放）：量化 × 推测解码 #推测解码（无损）和量化（有损）叠加时，验收要注意什么？\n题 5 解答要点 两者独立验收后再做联合验收：① draft 模型与 target 量化是否引入接受率下降（量化误差影响 draft 一致性）；② 联合后的端到端质量仍要走 Gate 1–4；③ 速度收益要分别归因（量化省带宽、推测省步数），避免把噪声当收益。\n10. 延伸阅读 # QServe / QoQ（arXiv:2405.04532）；代码 FlashAttention-3（arXiv:2407.08691） SageAttention（arXiv:2410.02367） vLLM 量化文档；TensorRT-LLM；llama.cpp 上一篇： 10 质量评估方法论；本系列完结，回到 00 总览。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E9%87%8F%E5%8C%96%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-11-%E7%B3%BB%E7%BB%9F%E5%8D%8F%E5%90%8C%E4%B8%8E%E9%83%A8%E7%BD%B2/","section":"笔记","summary":"量化算法好不等于端到端快，反量化、内存布局和 kernel 实现会吃掉大部分收益。本文讲 QServe 的 W4A8KV4 协同设计为什么是 W4A8，给出 vLLM / TensorRT-LLM / llama.cpp 的量化支持地图，并给出一份部署决策树。","title":"量化模型怎么部署到 vLLM？QServe 与 FP8 Attention 实践"},{"content":"Answer #If two requests share a prefix, the KV for that prefix does not need to be prefilled again. Most servers drop the cache when the request ends. RadixAttention stores those KV tensors in a radix tree (edges can cover a run of tokens), evicts least-recently-used leaves first, and schedules the request with the longest cached prefix next.\nA hit rate \\(h\\) skips about that fraction of prefill compute. The Chinese note cites the SGLang paper’s comparison with vLLM, Guidance, and LMQL on A10G and A100: up to 6.4× throughput, up to 3.7× lower latency, hit rates 50%–99%, and manager overhead under 0.3% (0.2 s inside 74.3 s). A one-month Chatbot Arena deployment in that paper saw 74.1% hits and 1.7× lower average TTFT on Vicuna-33B, and 52.4% hits on LLaVA-NeXT-34B. Those figures are the paper’s, not a rerun on this site.\nWhen it does nothing #Long generations make decode the bill, and unrelated sessions share little. Early vLLM prefix sharing covered a single system prompt; the radix tree is what makes multi-level sharing (system, template, history, branches) automatic. A miss should stay cheap, which is why the paper argues it can be on by default.\n","date":null,"permalink":"https://doraemeng.dev/en/radixattention/","section":"页面","summary":"RadixAttention keeps KV for shared prefixes in a radix tree. The SGLang paper reports up to 6.4× throughput and 3.7× lower latency versus the systems in that paper, with under 0.3% overhead on a miss.","title":"What is RadixAttention, and when does prefix cache help?"},{"content":" 这 6 章回答同一个问题：怎样用更便宜的草稿和一次并行验证，让每次目标模型前向产出多个 token。01 章推导接受率与期望产出，02–05 章分别处理草稿的四种来源（独立小模型、Medusa 多头、EAGLE 特征、n-gram 检索），06 章处理组合与生产验收。与量化系列的分工见第 2 节。 格式与量化系列一致：形式化定义 → 数学推导 → 伪代码 → 数值算例 → 直觉解释 → 习题（含答案）→ 延伸阅读；公式使用 Markdown + LaTeX（$...$ / $$...$$）。\n1. 系列结构与来源映射 # 章节 文件 核心内容 对应来源 00 本文件 学习地图、符号约定、与量化系列的关系 — 01 01-问题形式化与接受率数学 自回归为什么慢、草稿+验证范式、接受率 α、期望 token 数 E[N] 推导、墙钟收益模型 Leviathan et al. 2023；Inference Engineering Ch5 02 02-原始推测解码：草稿模型与拒绝采样 完整算法、无损性定理、数值算例、草稿速度比与最优 K Leviathan et al. 2023；Chen et al. 2023 03 03-Medusa：多头解码 多头并行预测、树注意力、Medusa-1/2、草稿成本分析 Medusa（arXiv:2401.10774） 04 04-EAGLE：特征空间草稿 特征空间自回归、为什么接受率更高、EAGLE-2 EAGLE（arXiv:2401.15077）；EAGLE-2（arXiv:2406.16858） 05 05-n-gram/检索式与无模型路线 Lookahead Decoding、REST、Prompt Lookup Lookahead（arXiv:2307.09991）；REST（arXiv:2311.08252） 06 06-系统集成与生产验收 与量化/KV 缓存/批处理组合、吞吐与延迟权衡、验收协议 vLLM/TensorRT-LLM 实践；量化系列 10 章方法论 2. 与量化系列的关系：一张总表 # LLM 推理优化 / \\ 有损路线 无损路线 │ │ 量化（已写完 00-11） 推测解码（本系列） 权重/激活/KV 降精度 用草稿 + 验证换并行度 省显存、省带宽、省 FLOPS 不改变输出分布，只省墙钟时间 互补性：\n量化：让\u0026#34;每一步更快\u0026#34;（带宽减半、FLOPS 翻倍） 推测：让\u0026#34;需要的步数更少\u0026#34;（一步验证 K 个候选 token） 两者乘法叠加：量化后的每步成本 × 推测后的步数减少 = 端到端收益 决策框架（量化系列总览的延伸）：\n1. 无损优先：推测解码、前缀缓存、KV 复用——先上 2. 有损兜底：量化（W8A8 → W4A8KV4）——质量评测通过再上 3. 组合验收：推测 × 量化的联合收益要单独测（06 章） 3. 符号约定（全系列通用，沿用量化系列并新增） # 符号 含义 p 目标模型（大模型）的输出分布 q 草稿模型（小模型）的输出分布 α 每 token 接受概率 $\\alpha = \\sum_x \\min(p(x), q(x))$ β β = 1 − α（拒绝概率，也等于 TV 距离） K 每轮草稿 token 数 N 每轮实际产出 token 数（随机变量） T_p / T_q 目标/草稿每 token 解码时间 c 速度比 c = T_p / T_q TV(p, q) 全变差距离 $\\mathrm{TV}(p,q) = \\frac{1}{2}\\sum_x W4A8KV4 等 沿用量化系列记法 4. 阅读顺序 #01 形式化与接受率数学（本章公式是所有后续推导的地基） → 02 原始推测解码（算法 + 无损性定理） → 03 Medusa（草稿从哪来：模型自带多头） → 04 EAGLE（草稿从哪来：特征空间） → 05 无模型路线（n-gram / 检索） → 06 系统集成（怎么组合、怎么验收） 5. 配套资源 # 资源 用途 Fast Inference from Transformers via Speculative Decoding（Leviathan et al., arXiv:2211.17192） 原始论文：接受率公式、无损性、最优草稿规模 Accelerating LLM Inference with Staged Speculative Decoding（Chen et al., arXiv:2302.01318） 同期独立工作 Medusa（arXiv:2401.10774） 多头解码 EAGLE（arXiv:2401.15077） 特征空间草稿 EAGLE-2（arXiv:2406.16858） 动态草稿树 Lookahead Decoding（arXiv:2307.09991） / REST（arXiv:2311.08252） 无模型路线 Inference Engineering Ch5 教材正文（Speculative Decoding 一节） ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-00-%E6%80%BB%E8%A7%88%E4%B8%8E%E5%AD%A6%E4%B9%A0%E5%9C%B0%E5%9B%BE/","section":"笔记","summary":"量化是「有损换速度」，推测解码是「无损提速度」，两者是 LLM 推理优化互补的两条主线。这份总览给出 6 篇精读笔记的阅读顺序、每章要点与配套论文，帮你建立完整的推理加速决策框架。","title":"投机采样与推测解码：6 篇精读笔记总览"},{"content":" 系列导航：上篇系列 LLM 量化精读笔记总览｜ 推测解码精读笔记总览（共 6 篇）｜下一篇： 投机采样原理是什么\n对应：Leviathan et al., Fast Inference from Transformers via Speculative Decoding（2023）；Inference Engineering Ch5 的 Speculative Decoding 部分。 学完本章你应该能：① 说清自回归解码慢的结构性原因（因果依赖使 GPU 的并行能力被浪费）；② 用\u0026quot;草稿 + 并行验证\u0026quot;一句话解释推测解码为什么能加速；③ 从定义推导期望 token 数公式 $E[N] = (1-\\alpha^{K+1})/(1-\\alpha)$；④ 推导墙钟加速比公式并手算数值例；⑤ 解释\u0026quot;为什么推测解码是无损的\u0026quot;（拒绝采样的边际分布等于目标分布）。\n目录（本章） # 本章目标 自回归解码为什么慢：形式化 核心思想：草稿 + 并行验证 接受率数学：α 与 E[N] 墙钟收益模型：速度比 c 与最优 K 为什么无损：拒绝采样的边际分布定理 设计空间：α、K、c 三者如何决定收益 本章小结 习题与解答 延伸阅读 1. 本章目标 #量化系列回答\u0026quot;每一步怎么更快\u0026quot;，本系列回答\u0026quot;怎么用更少的步数生成同样的文本\u0026quot;。本章建立整个系列的数学地基——接受率 α 和期望 token 数 E[N]。\n2. 自回归解码为什么慢：形式化 #2.1 自回归的结构性约束 #LLM 按自回归方式生成：\n$$ x_{t+1} \\sim p(\\cdot \\mid x_1, \\dots, x_t) $$第 $t+1$ 个 token 依赖前 $t$ 个 token——严格串行：\n第 1 步：只算 1 个位置 第 2 步：只算 1 个位置（但前向里其实处理了 2 个位置的 KV） …… 每步只\u0026#34;新增\u0026#34;1 个 token 的预测 2.2 浪费在哪里 #每次前向，GPU 会并行计算所有 token 位置的表示（矩阵乘天生并行），但自回归只取最后一个位置的输出：\nGPU 实际算的：seq_len 个位置的全部激活 解码真正用的：最后 1 个位置的 logits → 计算利用率 ≈ 1/seq_len（序列越长越浪费） 更准确地说，decode 阶段是访存密集的（量化系列 03 章的带宽模型）：瓶颈在把权重从 HBM 搬到寄存器，而不是在\u0026quot;算\u0026quot;。但无论算还是搬，每步只为 1 个新 token 付费——这是自回归的根本开销。\n2.3 关键矛盾 #自回归的约束：token 之间存在因果依赖，必须串行决策 GPU 的能力：一次前向可以并行处理 K 个位置的输入 推测解码的思路：用便宜的草稿模型先\u0026quot;猜\u0026quot; K 个 token，再用昂贵的目标模型一次并行验证。如果草稿猜得准，一次目标前向就能产出多个 token。\n3. 核心思想：草稿 + 并行验证 #3.1 两个模型 #目标模型 p：大、准、慢（真正负责质量，输出分布必须由它决定） 草稿模型 q：小、快、不太准（猜，猜错了会被纠正） 3.2 一轮操作的流程（预览） #1. 草稿：用 q 自回归生成 K 个候选 token（K 步，每步很快） 2. 验证：把 K 个候选一次性喂给 p，一次前向得到 K+1 个位置的 logits 3. 接受：从左到右逐个检查候选是否\u0026#34;与 p 一致\u0026#34;（拒绝采样规则） 4. 纠正：第一个不一致的位置，从修正分布重采样一个 token 5. 产出：这一轮得到 N 个新 token（1 ≤ N ≤ K+1） 关键：验证只花一次目标前向（代价约等于正常解码一步），却可能换来最多 K+1 个 token。这就是加速的来源。\n3.3 先记三个量 #K：每轮草稿长度（典型 4~8） α：每个草稿 token 被接受的概率 c：目标模型每 token 耗时 / 草稿模型每 token 耗时（典型 5~20） 4. 接受率数学：α 与 E[N] #4.1 定义接受概率 α #设目标分布 p、草稿分布 q（同一时刻、同一前缀下）。草稿 token 按 q 采样，验证时以概率\n$$ \\min\\left(1, \\frac{p(x)}{q(x)}\\right) $$接受它（拒绝采样规则，第 6 节证明它保持分布）。于是无条件接受概率：\n$$ \\alpha = \\sum_x q(x) \\cdot \\min\\left(1, \\frac{p(x)}{q(x)}\\right) = \\sum_x \\min(p(x), q(x)) $$4.2 α 与 TV 距离的关系 #利用 $\\min(a,b) = \\frac{a+b-|a-b|}{2}$：\n$$ \\alpha = \\frac{1}{2}\\sum_x \\left(p(x)+q(x)-|p(x)-q(x)|\\right) = 1 - \\frac{1}{2}\\sum_x |p(x)-q(x)| $$即\n$$ \\alpha = 1 - \\mathrm{TV}(p, q) $$α 越接近 1，草稿与目标分布越一致。β = 1 − α 就是每 token 被拒绝的概率。\n4.3 期望 token 数 E[N] 的推导 #设每轮草稿 K 个 token，token 间相互独立（近似；严格版本对历史取条件期望，结论形式相同）。令 α 为单 token 接受概率。\n每轮产出 N 个 token。N 的分布由\u0026quot;前 $i-1$ 个草稿 token 都被接受、第 $i$ 个被拒绝（随后补 1 个修正 token）\u0026ldquo;或\u0026quot;全部 $K$ 个都被接受（随后从 $p$ 直接采 1 个 bonus token）\u0026ldquo;决定：\n$$ P(N = i) = \\alpha^{i-1}(1-\\alpha), \\quad i = 1, \\dots, K; \\qquad P(N = K+1) = \\alpha^{K} $$期望：\n$$ E[N] = \\sum_{i=1}^{K} i \\cdot \\alpha^{i-1}(1-\\alpha) + (K+1)\\alpha^K $$用等比数列求和 $\\sum_{i=1}^{K} i\\alpha^{i-1} = \\frac{1-(K+1)\\alpha^K + K\\alpha^{K+1}}{(1-\\alpha)^2}$，整理得：\n$$ E[N] = \\frac{1-\\alpha^{K+1}}{1-\\alpha} $$这是整个系列的\u0026quot;第一公式\u0026rdquo;。\n4.4 数值算例 #不同 α、K 下的期望每轮 token 数：\nα K=4 时 E[N] K=8 时 E[N] 0.5 1.94 1.996 0.6 2.31 2.47 0.7 2.77 3.20 0.8 3.36 4.33 0.9 4.10 6.13 验证一例（α=0.8, K=4）：\n$$ E[N] = \\frac{1-0.8^{5}}{1-0.8} = \\frac{1-0.32768}{0.2} = 3.36 $$直觉：α=0.8 时每轮平均产出 3.36 个 token，而目标只\u0026quot;真正解码\u0026quot;了 1 次。\n5. 墙钟收益模型：速度比 c 与最优 K #5.1 一轮的墙钟时间 #一轮时间 ≈ T_p + K·T_q = 一次目标验证 + K 步草稿 （目标验证一次前向处理 K+1 个位置，代价近似一次正常解码 T_p；草稿 K 步串行，每步 T_q。）\n5.2 加速比公式 #目标单独解码：每 token 耗时 $T_p$，每秒 $1/T_p$ 个 token。 推测解码：每轮 $E[N]$ 个 token，耗时 $T_p + K T_q$。\n$$ \\text{speedup} = \\frac{E[N]\\cdot T_p}{T_p + K\\cdot T_q} = \\frac{E[N]\\cdot c}{c + K}, \\quad c = \\frac{T_p}{T_q} $$5.3 数值算例 #设 c = 10（目标比草稿慢 10 倍），α = 0.8，K = 4：\n$$ E[N] = 3.36, \\quad \\text{speedup} = \\frac{3.36 \\times 10}{10+4} = 2.40 $$即墙钟约快 2.4 倍。再看不同组合：\nα c K E[N] speedup 0.8 10 4 3.36 2.40x 0.8 10 8 4.33 2.40x 0.9 10 8 6.13 3.40x 0.6 10 4 2.31 1.65x 0.8 5 4 3.36 1.87x 5.4 收益的两个边界 #上界：α → 1 时 $E[N] \\to K+1$，加速比 $\\to \\frac{(K+1)c}{c+K} \\to c$。推测解码最多快 c 倍——草稿与目标的速度比是天花板，这解释了为什么要选足够小/快的草稿。\n下界：α 太低时加速比 \u0026lt; 1（推测反而拖慢）。需要\n$$ E[N] \u003e 1 + \\frac{K}{c} $$5.5 最优 K #给定 α、c，加速比是 K 的函数：\n$$ f(K) = \\frac{c}{c+K}\\cdot\\frac{1-\\alpha^{K+1}}{1-\\alpha} $$求整数 K 最大化 f(K)。经验规律：\nα 高（0.8+）→ K 取大（8 甚至 16）收益仍增长 α 中（0.6~0.7）→ K 取 4~8 附近有峰值 c 小（草稿不够快）→ K 应该更小 6. 为什么无损：拒绝采样的边际分布定理 #6.1 问题 #草稿分布 q 和目标分布 p 不一致。为什么最后产出的 token 分布仍然严格等于 p？ 这使推测解码属于\u0026quot;无损\u0026quot;优化。\n6.2 拒绝采样规则 #从 $q$ 采样得到 $x$，然后以概率 $\\min(1, p(x)/q(x))$ 接受 $x$（直接输出）；否则从修正分布 $p_r$ 重采样：\n$$ p_r(x) = \\frac{\\max(0, p(x) - q(x))}{\\beta}, \\qquad \\beta = 1 - \\alpha $$6.3 边际分布验证 #输出 x 的概率 = 直接接受 x 的概率 + 被拒后重采样到 x 的概率：\n$$ P_{\\text{emit}}(x) = q(x)\\min\\left(1,\\frac{p(x)}{q(x)}\\right) + \\beta \\cdot p_r(x) $$分两种情形：\n$$ P_{\\text{emit}}(x) = \\begin{cases} q(x) + (p(x) - q(x)) = p(x), \u0026 p(x) \\ge q(x) \\\\ p(x) + 0 = p(x), \u0026 p(x) \u003c q(x) \\end{cases} $$统一写法：\n$$ P_{\\text{emit}}(x) = \\min(p(x), q(x)) + \\max(0, p(x)-q(x)) = p(x) $$结论：无论草稿多不准，输出分布都精确等于目标分布。 这是\u0026quot;无损\u0026quot;的数学保证。\n6.4 一个直觉 #拒绝采样把\u0026quot;q 猜错的那部分概率\u0026quot;按目标分布 p 重新分配，而不是丢弃：猜对的部分直接保留（min(p,q)），猜错的部分用 p−q 的残差补回来（max(0,p−q)），两者拼起来正好是 p。\n7. 设计空间：α、K、c 三者如何决定收益 #收益 = E[N](α, K) × c/(c+K) = 接受率 × 草稿开销 提高 α：草稿与目标越像越好（架构、训练数据、草稿规模）——02~05 章所有方法的主战场 提高 c：草稿越小越快（但太小 α 会掉）——权衡 调 K：在\u0026#34;多猜几次\u0026#34;与\u0026#34;多付草稿费\u0026#34;之间找峰值 8. 本章小结 # 自回归慢的结构性原因：每步只产出 1 个 token，GPU 的并行能力被因果依赖锁死。 推测解码 = 草稿 + 并行验证：草稿猜 K 个，目标一次验证，产出 E[N] 个。 第一公式：$E[N] = \\dfrac{1-\\alpha^{K+1}}{1-\\alpha}$，其中 $\\alpha = \\sum_x \\min(p(x), q(x)) = 1 - \\mathrm{TV}(p,q)$。 墙钟收益：$\\text{speedup} = \\dfrac{E[N]\\cdot c}{c+K}$；上限 c，α 太低会倒挂。 无损性：拒绝采样让边际分布严格等于 p。 9. 习题与解答 #题 1（推导）：期望 token 数 #从 P(N=i) 出发，完整推导 $E[N] = (1-\\alpha^{K+1})/(1-\\alpha)$。\n题 1 解答 $E[N] = \\sum_{i=1}^{K} i\\alpha^{i-1}(1-\\alpha) + (K+1)\\alpha^K$。利用 $\\sum_{i=1}^{K} i\\alpha^{i-1} = \\frac{1-(K+1)\\alpha^K+K\\alpha^{K+1}}{(1-\\alpha)^2}$，代入并通分：分子 = $1-(K+1)\\alpha^K+K\\alpha^{K+1}+(K+1)\\alpha^K-(K+1)\\alpha^{K+1} = 1-\\alpha^{K+1}$。得 $E[N] = (1-\\alpha^{K+1})/(1-\\alpha)$。\n题 2（计算）：加速比 #c = 8，α = 0.7。比较 K = 4 与 K = 8 的加速比，并求使加速比 \u0026gt; 1 所需的最小 α（K=4, c=8）。\n题 2 解答 α=0.7：EN = (1−0.7⁵)/0.3 = 2.77；speedup = 2.77×8/12 = 1.85x。EN = (1−0.7⁹)/0.3 = 3.20；speedup = 3.20×8/16 = 1.60x——K=4 反而更好（草稿费高）。加速比 \u0026gt; 1 需 E[N] \u0026gt; 1+K/c = 1.5；解 (1−α⁵)/(1−α) \u0026gt; 1.5，试 α=0.34：E[N]=1.51 ✓；α=0.33：E[N]=1.49 ✗（边界约 0.34）。\n题 3（推导）：TV 恒等式 #证明 $\\alpha = 1 - \\frac{1}{2}\\sum_x |p(x)-q(x)|$。\n题 3 解答 $\\min(a,b) = \\frac{a+b-|a-b|}{2}$，代入 $\\alpha = \\sum_x \\min(p,q)$：$\\alpha = \\frac{1}{2}\\sum p + \\frac{1}{2}\\sum q - \\frac{1}{2}\\sum|p-q| = 1 - \\mathrm{TV}(p,q)$。\n题 4（推导）：无损性 #写出拒绝采样输出分布，证明 $P_{\\text{emit}}(x) = p(x)$ 对任意 q 成立。\n题 4 解答 $P_{\\text{emit}}(x) = q(x)\\min(1, p(x)/q(x)) + \\beta\\cdot\\frac{\\max(0,p(x)-q(x))}{\\beta} = \\min(p,q) + \\max(0,p-q) = p(x)$。\n题 5（思考）：为什么说推测解码是\u0026quot;无损\u0026rdquo; #与量化相比，\u0026ldquo;无损\u0026quot;具体指什么？如果用户看到两次生成结果不同，怎么解释？\n题 5 解答要点 无损指输出分布严格等于目标模型的采样分布（对任意解码策略：贪心/采样都保持）。两次生成不同是因为采样本身有随机性，与是否用推测无关。注意：如果实现里\u0026quot;无条件接受第一个草稿 token\u0026rdquo;（加速常用技巧）或草稿/目标温度不一致，会破坏严格无损——工程上要区分\u0026quot;理论无损\u0026quot;与\u0026quot;实现近似\u0026quot;。\n题 6（编程）：模拟接受过程 #给定两个词表分布 p、q（如 100 维），实现：① 计算 α；② 模拟 10000 轮草稿-验证（K=4），统计每轮产出 token 数的均值，与公式对比。\n题 6 解答要点 ① α = Σ min(p,q)。② 每轮：从 q 采样 K 个 token，逐个以 min(1,p(x)/q(x)) 接受；第一个拒绝处从残差分布 max(0,p−q)/β 重采样；全接受则再从 p 采 1 个 bonus。统计均值应接近 (1−α⁵)/(1−α)。可再验证输出 token 的经验分布 ≈ p（无损性）。\n10. 延伸阅读 # Fast Inference from Transformers via Speculative Decoding（arXiv:2211.17192）：本章公式出处（接受率、E[N]、最优草稿规模、墙钟实验） Accelerating LLM Inference with Staged Speculative Decoding（arXiv:2302.01318）：同期独立工作，可对照阅读 Inference Engineering Ch5：Speculative Decoding 教材节 下一篇：[02 原始推测解码：草稿模型与拒绝采样]——把本章公式落成完整算法，推导无损性定理并手算完整例子。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-01-%E9%97%AE%E9%A2%98%E5%BD%A2%E5%BC%8F%E5%8C%96%E4%B8%8E%E6%8E%A5%E5%8F%97%E7%8E%87%E6%95%B0%E5%AD%A6/","section":"笔记","summary":"自回归解码慢的结构性原因是因果依赖浪费了 GPU 并行能力，「草稿 + 并行验证」正好把它补回来。本文从定义推导期望接受 token 数 E[N]=(1-α^(K+1))/(1-α) 与墙钟加速比公式，并解释拒绝采样后输出分布为何依然无损。","title":"投机采样为什么是无损的？接受率与期望 token 公式推导"},{"content":" 系列导航： 推测解码精读笔记总览（共 6 篇）｜上一篇： 投机采样为什么是无损的｜下一篇： Medusa 是什么\n对应：Leviathan et al., Fast Inference from Transformers via Speculative Decoding（arXiv:2211.17192，2023）；Chen et al., Accelerating LLM Inference with Staged Speculative Decoding（arXiv:2302.01318，2023）。 前置：01 章的接受率数学（$\\alpha$、$E[N]$、$c$）。学完本章你应该能：① 写出推测解码的完整算法（草稿 + 并行验证 + 拒绝采样修正）；② 完整证明无损性定理（输出分布严格等于目标分布，且与草稿质量无关）；③ 推导最优草稿长度 $K^*$ 的驻点方程并解释其单调性；④ 手算一个完整轮次的逐步追踪；⑤ 说清贪心解码下接受规则如何退化为\u0026quot;argmax 相等\u0026quot;；⑥ 列出工程实现里最容易破坏无损性的几个坑。\n目录（本章） # 本章目标 从 01 到 02：还差什么 设置与记号 完整算法：Speculative Sampling 无损性定理：完整证明 每轮成本与加速比回顾 最优草稿长度 K* 草稿模型怎么选：α 与 c 的权衡 数值算例：完整一轮的逐步追踪 贪心解码的特殊情形 实现细节与常见坑 变体预告：Staged Speculative Decoding 本章小结 习题与解答 延伸阅读 2. 从 01 到 02：还差什么 #01 章给出了接受概率、期望产出与加速比三个公式，但还没落到可执行的算法。还差三件事：\n算法本身：验证阶段到底怎么\u0026quot;从左到右逐个检查\u0026quot;？拒绝之后用什么分布补一个 token？ 无损性的完整证明：01 章验证了\u0026quot;单个位置的边际分布等于 $p$\u0026quot;，但整个序列的联合分布呢？需要归纳法。 参数怎么定：$K$ 取多少最好？草稿模型选多大？这就是本章的最优 $K^*$ 与草稿规模权衡。 3. 设置与记号 #沿用 01 章并补充：\n符号 含义 $\\mathcal{V}$ 词表，$ $x_{","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-02-%E5%8E%9F%E5%A7%8B%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81-%E8%8D%89%E7%A8%BF%E6%A8%A1%E5%9E%8B%E4%B8%8E%E6%8B%92%E7%BB%9D%E9%87%87%E6%A0%B7/","section":"笔记","summary":"完整写出投机采样算法：小模型草稿 K 个 token，大模型一次前向并行验证，再用拒绝采样做修正。本文证明无损性定理（输出分布严格等于目标分布，且与草稿质量无关），推导最优草稿长度 K*，并列出工程实现里最容易破坏无损性的几个坑。","title":"投机采样原理是什么？草稿模型与拒绝采样怎么配合"},{"content":" 系列导航： 推测解码精读笔记总览（共 6 篇）｜上一篇： 投机采样原理是什么｜下一篇： EAGLE 推测解码为什么比 Medusa 快\n对应：Cai et al., Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads（arXiv:2401.10774，ICML 2024）；官方实现 FasterDecoding/Medusa。 前置：01 章的接受率数学、02 章的验证与拒绝采样。学完本章你应该能：① 说清 Medusa 相对\u0026quot;独立草稿模型\u0026quot;路线的三个优势；② 写出 Medusa head 的结构、候选树构建公式与树注意力掩码规则；③ 用\u0026quot;覆盖率\u0026quot;模型推导树的期望接受长度，并手算数值例；④ 解释典型验收（typical acceptance）与拒绝采样的区别，以及无损性代价在哪里；⑤ 对比 Medusa-1/Medusa-2 的训练配方与论文加速比数据；⑥ 解释为什么树大小存在最优值。\n目录（本章） # 本章目标 动机：独立草稿模型的三个痛点 架构：Medusa Heads 候选树与树注意力 推理循环（伪代码） 接受率数学：从链到树 优化树：节点贡献与贪婪建树 验收策略：拒绝采样 vs 典型验收 训练配方：Medusa-1 与 Medusa-2 数值算例：完整一轮 树大小权衡：加速率与开销 实验结果 与 02 章对照 实现细节与坑 本章小结 习题与解答 延伸阅读 2. 动机：独立草稿模型的三个痛点 #02 章的原始推测解码把草稿职责交给一个独立小模型 $q$。理论上优雅，工程上难受：\n痛点 1：草稿模型从哪来？ 要么现成（很难恰好有\u0026#34;又快又跟目标分布接近\u0026#34;的模型）， 要么自己预训练/微调一个（SpecInfer 报告约 275 A100 GPU 小时）。 痛点 2：分布式部署复杂度。 两个模型、两套权重、两份 KV cache、两种调度； 论文（Chen et al. 2023）明确提到多模型 serving 的复杂度。 痛点 3：草稿阶段是串行的 K 步自回归。 每轮要先付 K·T_q 的草稿时间；草稿越慢，K 就越不敢取大。 Medusa 的做法：在主干上追加 $K$ 个轻量解码头，与主干共享表示，一次前向同时给出多个未来位置的候选；再用树注意力把多条候选路径一次性验证完。\n三个痛点对应的解法：\n痛点 Medusa 的解法 草稿从哪来 训练 $K$ 个头（参数高效，主干可冻结） 部署复杂度 仍是单模型、单权重、单 KV cache 串行草稿成本 头与前向并行，草稿阶段几乎免费 3. 架构：Medusa Heads #3.1 定义 #设主干模型在位置 $t$ 的最后一层隐藏状态为 $h_t \\in \\mathbb{R}^d$，词表大小 $V$。原始 LM head 预测位置 $t+1$（记为 head 0，输出分布 $p_t^{(0)}$）。额外添加 $K$ 个 Medusa head，第 $k$ 个头预测位置 $t+k+1$（$k = 1, \\dots, K$），输出分布：\n$$ p_t^{(k)} = \\mathrm{softmax}\\!\\left(W_2^{(k)} \\cdot \\left(\\mathrm{SiLU}(W_1^{(k)} h_t) + h_t\\right)\\right) $$其中 $W_1^{(k)} \\in \\mathbb{R}^{d \\times d}$、$W_2^{(k)} \\in \\mathbb{R}^{d \\times V}$。每个头是一个残差 MLP + 输出投影：残差块 $h_t + \\mathrm{SiLU}(W_1^{(k)} h_t)$ 相当于一个\u0026quot;轻量特征变换\u0026quot;，再经过 $W_2^{(k)}$ 投影到词表。\n3.2 初始化：让头一开始就\u0026quot;像主干\u0026quot; #$$ W_1^{(k)} \\leftarrow 0, \\qquad W_2^{(k)} \\leftarrow W_{\\text{LM head}} $$$W_1 = 0$ 使残差块退化为恒等映射，$W_2$ 复制原 LM head，于是训练前每个 Medusa head 的预测恰好等于主干的预测（$p_t^{(k)} = p_t^{(0)}$）。这有两个好处：训练起点稳定；即使只训少量数据，头也不会一开始就胡猜。\n3.3 关键性质：头的预测是\u0026quot;平行\u0026quot;的 #注意第 $k$ 个头只看 $h_t$，不看前几个候选 token。也就是说，$p_t^{(k)}$ 是在\u0026quot;不知道中间 token 是什么\u0026quot;的情况下对未来第 $k$ 个位置做的猜测。这与 02 章草稿模型的\u0026quot;逐 token 条件化自回归\u0026quot;完全不同——这正是需要用树来验证的原因：真正到位置 $t+k+1$ 时，正确条件依赖是中间的候选 token，树把各种组合都枚举出来，由主干在验证时重新做条件化。\n4. 候选树与树注意力 #4.1 树的构建 #设第 $k$ 个头取 top-$s_k$ 候选（$s_k$ 是超参）。候选序列由各层候选的笛卡尔积构成：\n层 0（位置 t+1）：head 0 贪心 token，直接接受（每轮保底 1 个 token） 层 1（位置 t+2）：head 1 的 top-s_1 层 2（位置 t+3）：head 2 的 top-s_2，与层 1 的每个候选组合 …… 层 K（位置 t+K+1）：head K 的 top-s_K 这是一个\u0026quot;每层候选集共享\u0026quot;的规则树：第 $k$ 层每个节点都有同样的 $s_{k+1}$ 个孩子（因为 $p_t^{(k)}$ 只依赖 $h_t$）。整棵树新增的 token 数为：\n$$ T(s_1, \\dots, s_K) = \\sum_{k=1}^{K} \\prod_{i=1}^{k} s_i $$例：$s_1 = 2$、$s_2 = 3$ 时，$T = 2 + 2\\times 3 = 8$：层 1 有 2 个节点，层 2 有 $2\\times 3 = 6$ 个叶子。\n4.2 树注意力：一次前向验证整棵树 #普通因果注意力的掩码是\u0026quot;只看左侧\u0026quot;。树注意力把掩码改成**\u0026ldquo;只看自己的祖先\u0026rdquo;**：\n树上节点 (k, j)（第 k 层的第 j 个候选）的注意力范围 = 前缀 token ∪ 自己的祖先链（层 1 到层 k-1 各一个节点）∪ 自己 同一个层里不同分支的节点互相不可见（它们代表互斥的候选世界）。实现上：\n给树节点分配拓扑顺序的位置索引，注意同一层共享同一个 RoPE 位置（它们都是前缀之后第 $k$ 个 token）； 预计算一个布尔掩码矩阵 $M[i][j] = 1 \\iff j$ 是 $i$ 的祖先或 $i = j$； 把 $T$ 个候选节点拼进序列，一次前向得到所有节点的 logits——不需要展开 batch。 树注意力的意义：02 章\u0026quot;一次验证一条链\u0026quot;只检查 $K+1$ 个位置；树注意力一次检查 $T$ 个位置，把\u0026quot;猜错一个就整条链作废\u0026quot;的风险摊薄到多个分支上。\n5. 推理循环（伪代码） #输入：带 K 个 Medusa head 的模型、前缀 x_\u0026lt;t、树配置 s_1..s_K、验收策略 输出：N 个新 token（N ≥ 1） 每轮： 1. 取当前最后位置隐藏状态 h_t（首轮来自 prefill；之后复用上一轮验证的 hidden state） 2. 候选生成（并行、几乎免费）： 第 1 位置：head 0 贪心 token（无条件接受） 第 k 层（k=1..K）：head k 的 top-s_k 候选 3. 树注意力验证（一次主干前向）： 对树上每个节点算 p(· | 前缀 + 该节点祖先链) 4. 验收（沿树找最长可接受前缀）： 层 0：直接接受 层 k：若某候选满足验收条件（拒绝采样或典型验收）→ 接受，进入它的孩子； 否则 → 停在层 k-1 5. 输出接受路径上的所有 token；该路径末端节点的 hidden state 成为下一轮的 h_t 一轮最多产出 $K+1$ 个 token（层 0 的 1 个 + $K$ 层候选），至少 1 个。第 2 步不需要独立的草稿模型前向：头是主干之上的小 MLP，且第 3 步验证前向的 hidden state 直接复用于下一轮。这是与 02 章最大的结构性差异。\n6. 接受率数学：从链到树 #6.1 覆盖率模型 #02 章的单链每层只有 1 个候选，接受率是 top-1 命中率 $\\alpha$。Medusa 每层有 $s_k$ 个候选，接受条件放宽为\u0026quot;目标 token 落在候选集里\u0026quot;。定义第 $k$ 层的覆盖率：\n$$ q_k = P\\!\\left(\\arg\\max_x p(x \\mid \\text{前缀} + \\text{已接受路径}) \\in \\text{head } k \\text{ 的 top-}s_k \\text{ 候选集}\\right) $$（路径平均意义上的概率；下文与论文一致，假设各层覆盖率独立。）\n6.2 期望接受长度 #记 $N$ 为每轮产出 token 数。$P(N \\ge 1) = 1$（层 0 保底），$P(N \\ge 1 + m) = \\prod_{j=1}^{m} q_j$（前 $m$ 层都命中），于是：\n$$ E[N] = \\sum_{i \\ge 1} P(N \\ge i) = 1 + q_1 + q_1 q_2 + \\cdots + \\prod_{j=1}^{K} q_j $$退化检查：当所有 $s_k = 1$ 时，$q_k = \\alpha$（top-1 接受率），上式退化为 $1 + \\alpha + \\cdots + \\alpha^K = \\dfrac{1-\\alpha^{K+1}}{1-\\alpha}$——与 02 章公式完全一致。树不改变公式结构，改变的是每层的 $q_k$。\n6.3 树 vs 链：为什么树赢 #覆盖率 $q_k$ 是\u0026quot;目标 token 在 top-$s_k$ 里\u0026quot;的概率，而 top-1 命中率只是 $s_k=1$ 的特例。对常见分布，覆盖率随 $s$ 的增长远快于线性：\n方案 每层接受概率 E[N]（K=2） 链式草稿（02 章） top-1：$\\alpha = 0.6$ $1 + 0.6 + 0.36 = 1.96$ Medusa 树 $s=(1,1)$ $q = 0.6$ $1.96$（退化，同上） Medusa 树 $s=(3,2)$ $q = (0.9, 0.8)$ $1 + 0.9 + 0.72 = 2.62$ 同一条\u0026quot;主干\u0026quot;，top-3 覆盖率 0.9 远高于 top-1 命中率 0.6——树把\u0026quot;单个候选猜对\u0026quot;变成\u0026quot;候选集覆盖对\u0026quot;，这就是树注意力的数学价值。\n6.4 代价：节点数 #覆盖率提高不是免费的：$s_k$ 越大，树节点 $T = \\sum_k \\prod_{i \\le k} s_i$ 增长得越快（组合爆炸），验证前向处理的 token 越多。$E[N]$ 增长是线性叠加（每层至多加一项），而 $T$ 增长是乘积式——收益与开销赛跑，最优树一定在中间（第 11 节量化）。\n7. 优化树：节点贡献与贪婪建树 #论文（§2.3.3）给了一个可操作的建树准则。设 $a_k^{(i)}$ 为 head $k$ 的第 $i$ 高候选的边际命中率（即 top-$i$ 命中率减 top-$(i-1)$ 命中率，用校准集统计）。假设各层独立，节点 $[i_1, \\dots, i_k]$（依次取各层的第 $i_j$ 高候选）对期望接受长度的贡献为：\n$$ \\text{contrib}\\!\\left([i_1, \\dots, i_k]\\right) = \\prod_{j=1}^{k} a_j^{(i_j)} $$整个树的期望接受长度就是所有节点贡献之和：\n$$ E[\\text{accept length}] = \\sum_{[i_1, \\dots, i_k] \\in \\text{tree}} \\prod_{j=1}^{k} a_j^{(i_j)} $$因此建树变成\u0026quot;往树上加节点\u0026ldquo;的贪心过程：每次从\u0026quot;与当前树相邻的节点\u0026quot;里选贡献 $\\prod_j a_j^{(i_j)}$ 最大的一个，加到节点预算用完为止。这样得到的稀疏树在 64 个节点时加速率优于 256 节点的稠密树（论文 Fig. 4）——因为稠密树的节点大多是低边际命中的\u0026quot;陪跑\u0026quot;候选，白付验证开销。\n8. 验收策略：拒绝采样 vs 典型验收 #Medusa 提供两种验收方式。\n8.1 拒绝采样（严格无损） #与 02 章相同的规则：候选 $x$ 以概率 $\\min(1, p(x)/q(x))$ 接受（$q$ 是 head 分布），拒绝时从残差分布重采样。这是严格无损的：输出分布等于主干模型的分布。代价：温度升高时，两个分布都变平，拒绝率上升，加速率下降（02 章末尾提到的问题）。\n8.2 典型验收（Typical Acceptance，默认） #论文观察到：实际部署里温度只是调\u0026quot;创造力\u0026quot;的旋钮，不需要让草稿分布严格等于目标分布。于是他们改用合理性阈值：候选 $x$ 在位置 $n+k$ 被接受当且仅当\n$$ p_{\\text{original}}\\!\\left(x \\mid x_1, \\dots, x_{n+k-1}\\right) \u003e \\min\\!\\left(\\epsilon,\\ \\delta \\exp\\!\\left(-H(p_{\\text{original}}(\\cdot \\mid x_1, \\dots, x_{n+k-1}))\\right)\\right) $$其中 $H(\\cdot)$ 是目标分布的信息熵，$\\epsilon$ 是硬阈值，$\\delta$ 是熵相关阈值（官方默认 $\\epsilon = 0.09$、$\\delta = 0.3 \\approx \\sqrt{\\epsilon}$）。直觉：\n候选概率足够高 → 合理，接受 目标分布本身很平（熵高）→ 阈值放松，各种候选都算合理 另外，第一个 token 用贪心并无条件接受（保证每轮至少 1 个 token），然后沿树取\u0026quot;最长满足条件的可接受前缀\u0026rdquo;。\n8.3 两种方式的取舍 # 拒绝采样 典型验收 分布保证 严格等于 $p$ 近似（质量靠阈值保护） 温度升高时 接受率下降 接受率上升（熵高 → 阈值低） 速度 较慢 更快（官方默认） 使用场景 需要理论无损 生产默认、追求吞吐 一个常见的误读是\u0026quot;Medusa 一定无损\u0026quot;。准确说法：Medusa-1 + 拒绝采样是严格无损的（论文抽象里的 lossless 指这条路线）；默认的典型验收是近似无损的工程选择。写报告时务必区分。\n9. 训练配方：Medusa-1 与 Medusa-2 #9.1 Medusa-1：只训头，冻结主干 # 主干完全冻结，只训练 $K$ 个头的参数； 参数高效、显存友好，甚至可以对主干做 QLoRA 式量化来省显存（头照训）； 因为主干不变，能力零损失；头学会\u0026quot;顺着主干表示猜未来 token\u0026quot;； 论文数据：Vicuna-7B 2.18x、Vicuna-13B 2.33x。 9.2 Medusa-2：联合微调，两阶段 #只训头时，头的预测受限于主干既有的表示。Medusa-2 把主干也放开微调，让头和主干协同，接受率更高：\n阶段 1：冻结主干，只训头（即 Medusa-1） 阶段 2：联合微调主干 + 头，用特殊配方保住原模型能力 特殊配方的关键：主干用知识蒸馏损失而不是硬标签：\n$$ \\mathcal{L}_{\\text{LM-distill}} = \\mathrm{KL}\\!\\left(p_{\\text{original}, t}^{(0)} \\,\\|\\, p_{t}^{(0)}\\right) $$让微调后的主干尽量贴着原模型的预测分布，而不是被新数据带偏。实现上主干用 LoRA 适配器训练，\u0026ldquo;教师\u0026quot;就是关掉适配器的原模型，几乎不增加显存。\n9.3 数据：没有训练数据怎么办（Self-Distillation） #有些模型（如 RLHF 后的 Zephyr、私有数据训练的 Vicuna-33B）没有公开微调数据。论文的自蒸馏方案：\n1. 拿一份同领域的种子数据（如 ShareGPT 的 prompt） 2. 让目标模型自己生成回答（多轮可自问自答） 3. 用生成结果训练 Medusa 头 论文报告自蒸馏模型（Zephyr-7B、Vicuna-33B）的加速比略低于有原始数据的模型——质量与速度的权衡。\n10. 数值算例：完整一轮 #场景：前缀 \u0026ldquo;The capital of France is\u0026rdquo;，$K = 2$ 个 Medusa head，树配置 $s = (3, 2)$。\n候选生成（全部由当前 $h_t$ 并行算出）：\n层 0（位置 t+1）：head 0 贪心 → \u0026#34; Paris\u0026#34; 层 1（位置 t+2）：head 1 的 top-3 → {\u0026#34;,\u0026#34;, \u0026#34; and\u0026#34;, \u0026#34;!\u0026#34;} 层 2（位置 t+3）：head 2 的 top-2 → {\u0026#34; the\u0026#34;, \u0026#34; a\u0026#34;} 树节点数：\n$$ T = s_1 + s_1 s_2 = 3 + 3 \\times 2 = 9 $$树注意力验证（一次主干前向，9 个候选节点 + 前缀）：\n位置 t+2 给定 \u0026#34;Paris\u0026#34;：p 的 argmax = \u0026#34;,\u0026#34; → 在层 1 候选集里 ✓ 位置 t+3 给定 \u0026#34;Paris,\u0026#34;：p 的 argmax = \u0026#34; the\u0026#34; → 在层 2 候选集里 ✓ 产出： Paris + , + the，本轮 $N = 3$。下一轮直接复用 \u0026quot; the\u0026rdquo; 的 hidden state 继续。\n与公式对照：设 $q_1 = 0.9$、$q_2 = 0.8$（覆盖率），\n$$ E[N] = 1 + q_1 + q_1 q_2 = 1 + 0.9 + 0.72 = 2.62 $$本轮实际 3 个 token，高于期望，正常波动。若验证前向比普通 decode 贵 15%（9 个树节点 + 前缀的额外计算），净加速约 $2.62 / 1.15 \\approx 2.3\\text{x}$。\n11. 树大小权衡：加速率与开销 #论文定义 加速率 = 加速比 / 开销（overhead 指树前向比单 token 前向多出的计算）。两个相反的趋势：\n加速率：随节点数增长，但呈对数式衰减（前几个候选收益最大） 开销：随节点数近线性增长（矩阵乘、注意力都变重） 净加速：先升后降，存在最优节点数 示意数值（趋势取自论文 Fig. 4，非实验精确值）：\n树配置 节点数 T 示意 E[N] 示意开销 净加速 无树（单链 $s=1$） 2 1.96 1.00 1.96x $s=(3,2)$ 9 2.62 1.10 2.38x $s=(4,3,2)$ 40 3.31 1.18 2.81x 优化稀疏树 64 3.45 1.25 2.76x 稠密大树 256+ 3.6+ 1.5+ 2.4x 以下 论文在 Vicuna-7B（Medusa-2）上的实际结论：64 节点的优化稀疏树效果最好；超过约 64 个候选后速度开始下降（Fig. 4b / 附录 Fig. 21）。工程启示：树配置是超参，要在目标负载上扫描，别盲目加大 $s_k$。\n12. 实验结果 #论文与官方仓库的已核实数据（MT-Bench，GPT-4 评分验证质量不变）：\n配置 加速比 Medusa-1 · Vicuna-7B 2.18x Medusa-1 · Vicuna-13B 2.33x Medusa-2 · Vicuna-7B 2.83x Medusa-2 · Vicuna-13B 2.83x Medusa-2 · Vicuna-7B（coding 类） 3.29x Medusa-2 · Vicuna-7B（extraction 类） 3.62x 论文摘要（多模型、多提示） Medusa-1 \u0026gt; 2.2x；Medusa-2 2.3–2.8x 官方仓库更新（更多 LLM） 2.2–3.6x 论文数据里有三点：\n代码/提取类任务收益最高（3.29x/3.62x）——这些任务的局部结构规律性强，多头更容易猜中； 自蒸馏模型（Zephyr-7B、Vicuna-33B）加速比略低，因为头的训练分布与真实分布有偏移； 论文在同一批模型上对比了可获得的独立草稿模型方案，Medusa 的加速比更高。 13. 与 02 章对照 # 维度 02 原始推测解码 03 Medusa 草稿来源 独立小模型（需预训练/获取） 主干自带的 $K$ 个头（需训练头） 词表/分布一致性 需强制对齐 天然一致（同一主干） 草稿成本 $K$ 步串行自回归（$K \\cdot T_q$） 头并行前向，几乎免费 候选结构 单条链 树（笛卡尔积，多候选并行） 每层接受 top-1 命中率 $\\alpha$ top-$s$ 覆盖率 $q \\ge \\alpha$ 分布保证 严格无损 拒绝采样=严格无损；典型验收≈近似 部署 双模型、分布式复杂 单模型、无缝接入 训练 无（草稿现成） Medusa-1（只训头）/ Medusa-2（联合微调） 典型加速 2–3x（T5-XXL 实验） 2.2–3.6x 一句话概括演进：02 章解决\u0026quot;怎么用便宜的猜测换并行\u0026quot;，03 章把\u0026quot;便宜的猜测\u0026quot;从外部模型换成模型自己的头，并用树把\u0026quot;猜得准\u0026quot;升级为\u0026quot;覆盖得全\u0026quot;。\n14. 实现细节与坑 # 树掩码必须正确：同一层不同分支不可互见。若误用全因果掩码，层 2 的候选会\u0026quot;偷看\u0026quot;到兄弟分支的信息，验证分布全错。测试办法：把树退化到 $s_k = 1$，输出必须与逐 token 贪心完全一致。 RoPE 位置：同一层的所有候选共享同一个位置索引（都是前缀后第 $k$ 个 token），不能用扁平化的拓扑序号。 只收一条路径：同一层可能有多个候选满足阈值；要按优先级（如 head 概率序）只选一条继续，避免\u0026quot;同时活在多个世界\u0026quot;。 KV cache 复用：验证前向为整棵树算 KV；接受路径的 KV 保留，其余丢弃。下一轮 head 直接复用路径末端 hidden state，省一次前向。 严格无损 vs 默认行为：官方默认典型验收 + 第一个 token 无条件接受，不是严格无损；要严格无损就切拒绝采样。 batch 支持：官方实现只支持 batch=1（本地单用户场景）；多请求批处理需要把多个请求的树拼进同一个注意力掩码（vLLM / TensorRT-LLM 的 Medusa 实现做了这件事）。 与量化组合：Medusa-1 训练时可量化主干（QLoRA 式）；推理时可与 W4A16 等量化方案叠加。量化降低每步成本，推测减少步数，联合收益要按 06 章的模型单独测。 树配置要调：$s_k$ 不是越大越好（第 11 节）；用校准集按第 7 节公式贪心建树。 15. 本章小结 # 动机：独立草稿模型有三痛（获取难、部署重、草稿串行贵）；Medusa 用主干自带的头替代。 头：$p_t^{(k)} = \\mathrm{softmax}(W_2^{(k)}(\\mathrm{SiLU}(W_1^{(k)} h_t) + h_t))$，$W_1$ 初始化 0、$W_2$ 复制 LM head。 树：候选 = 各层 top-$s_k$ 的笛卡尔积，节点数 $T = \\sum_k \\prod_{i \\le k} s_i$；树注意力掩码只允许看祖先。 数学：$E[N] = 1 + q_1 + q_1 q_2 + \\cdots + \\prod_j q_j$，树的收益来自覆盖率 $q \\ge$ top-1 命中率 $\\alpha$；节点贡献公式指导贪婪建树。 验收：拒绝采样严格无损；典型验收（概率 \u0026gt; 阈值）更快但近似。 训练：Medusa-1 冻结主干只训头；Medusa-2 两阶段联合微调 + KL 蒸馏保住质量；无数据用自蒸馏。 数据：2.18–3.62x 不等；树最优约 64 节点，不是越大越好。 16. 习题与解答 #题 1（推导）：树的期望接受长度 #给定 $K=3$、覆盖率 $q = (0.9, 0.8, 0.7)$，写出 $E[N]$ 表达式并计算；再验证 $q_k = \\alpha$ 时退化为 02 章公式。\n题 1 解答 $E[N] = 1 + q_1 + q_1 q_2 + q_1 q_2 q_3 = 1 + 0.9 + 0.72 + 0.504 = 3.124$。退化：$1 + \\alpha + \\alpha^2 + \\alpha^3 = (1-\\alpha^4)/(1-\\alpha)$，即 02 章 $K=3$ 时的公式。\n题 2（计算）：树节点数 #分别计算 $s=(4,2)$、$s=(4,3,2)$、$s=(5,4,3)$ 的节点数 $T$；若验证开销与 $T$ 近似线性、覆盖率提升随 $s$ 递减，哪个树更可能最优？为什么？\n题 2 解答 $T = 4 + 8 = 12$；$T = 4 + 12 + 24 = 40$；$T = 5 + 20 + 60 = 85$。第三个树节点数比第二个翻倍，但覆盖率从 top-4→top-5 的增益很小（边际命中递减），开销却近线性增长——大概率不如 40 节点树。这解释了\u0026quot;最优树在中间\u0026quot;。\n题 3（构造）：错误掩码的反例 #构造一个最小例子说明：若层 2 的候选能注意到同层兄弟分支的 token，验证分布会出什么问题。\n题 3 解答 设层 1 有两个候选 A、B（互斥世界），层 2 的候选来自\u0026quot;给定 A\u0026quot;的分布。若层 2 在计算注意力时混入 B 的信息，它得到的条件分布既不是 $p(\\cdot|A)$ 也不是 $p(\\cdot|B)$，而是两者的混合——验收时无法与 head 的分布对齐，接受/拒绝决策失真。树注意力的意义就是保证每个节点只活在\u0026quot;自己的祖先链\u0026quot;里。\n题 4（思考）：典型验收为什么随温度变快 #解释：为什么温度升高时拒绝采样的接受率下降，而典型验收的接受率反而上升？这对\u0026quot;严格无损\u0026quot;意味着什么？\n题 4 解答要点 温度升高 → $p$ 与 $q$ 都变平 → 拒绝采样中 $\\min(1, p/q)$ 的\u0026quot;匹配度\u0026quot;下降，且两份独立采样更容易不一致。典型验收只看 $p_{\\text{original}}(x)$ 是否超过阈值：分布越平，熵越高，$\\delta e^{-H}$ 阈值越低，更多候选被放行。代价是输出分布不再严格等于 $p$——质量靠阈值（$\\epsilon$、$\\delta$）保护，是工程近似而非数学保证。\n题 5（设计）：贪心建树 #用校准集统计出 head 1 的边际命中率 $a_1 = (0.6, 0.2, 0.1, 0.05)$、head 2 的 $a_2 = (0.5, 0.25, 0.15)$。预算 5 个节点，按贡献贪心建树，写出加入顺序与最终树的期望接受长度。\n题 5 解答 节点贡献 = 路径上边际命中率之积。候选及贡献：层1：$a_1^{(1)}=0.6$、$a_1^{(2)}=0.2$、$a_1^{(3)}=0.1$；层2（必须挂在已选层1节点下）：$0.6\\times 0.5=0.3$、$0.6\\times 0.25=0.15$、$0.6\\times 0.15=0.09$。贪心顺序：层1第1（0.6）→ 层2第1（0.3）→ 层1第2（0.2）→ 层2第2（0.15）→ 层1第3（0.1）。期望接受长度 $= 1 + 0.6 + 0.3 + 0.2 + 0.15 + 0.1 = 2.35$（1 为保底首 token）。对比：若把第 5 个名额给层 2 第 3 个候选（挂在层 1 第 1 名下），$1 + 0.6 + 0.3 + 0.15 + 0.2 + 0.09 = 2.34$，略低于贪心。注意即使预算再加 1（第 6 个节点），边际贡献也只有 0.1 或 0.09——收益递减，这正是第 11 节\u0026quot;树不是越大越好\u0026quot;的来源。\n题 6（编程）：toy 树验证 #实现一个 2-head、$s=(2,2)$ 的 toy 验证器：给定 head 分布与目标分布（小词表），① greedy 模式跑 5 万轮统计每轮 token 数，与 $E[N] = 1 + q_1 + q_1 q_2$ 对比；② 切到典型验收（阈值 $\\epsilon$），观察温度/阈值对接受长度的影响。\n题 6 解答要点 ① 每轮：首 token 贪心直接收；层 1 检查目标 argmax 是否在 top-2 里，层 2 同理；统计均值应接近公式（覆盖率按实际分布计算）。② 典型验收把\u0026quot;argmax ∈ 集合\u0026quot;换成\u0026quot;候选概率 \u0026gt; min(ε, δe^{−H})\u0026quot;，$\\epsilon$ 越小接受越多；对比两种方式的经验输出分布会发现典型验收有可测偏差——这就是 8.3 节表格的实验证据。\n17. 延伸阅读 # Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads（arXiv:2401.10774）：本章全部内容出处（head 定义 §2.1.1、树注意力 §2.1.2、典型验收 §2.3.1、优化树 §2.3.3、实验 §3）。 FasterDecoding/Medusa 官方仓库：参考实现（单 GPU、batch=1、典型验收默认参数）。 SpecInfer（arXiv:2305.09781）：树验证的一般框架（多草稿模型 + 自底向上建树），与 Medusa 的自顶向下建树对照阅读。 Blockwise Parallel Decoding（arXiv:1808.02647）：多头并行解码的思想源头。 上一篇： 02 原始推测解码；下一篇：04 EAGLE：特征空间草稿——回答\u0026quot;为什么在隐藏状态上做自回归，接受率会大幅提升\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-03-medusa-%E5%A4%9A%E5%A4%B4%E8%A7%A3%E7%A0%81/","section":"笔记","summary":"Medusa 在模型上挂多个解码头，一次预测多个后续位置，再用树注意力并行验证候选路径。本文写出 head 结构与树掩码规则，用覆盖率模型推导期望接受长度，说明典型验收与拒绝采样的区别，以及树大小为什么存在最优值。","title":"Medusa 是什么？多头解码为什么能加速 LLM 推理"},{"content":" 系列导航： 推测解码精读笔记总览（共 6 篇）｜上一篇： Medusa 是什么｜下一篇： 不用草稿模型的加速方案\n对应：Li et al., EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty（arXiv:2401.15077，2024）；Li et al., EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees（arXiv:2406.16858，2024）。 前置：01–03 章（接受率数学、拒绝采样、树验证）。学完本章你应该能：① 说清\u0026quot;token 层自回归\u0026quot;与\u0026quot;特征层自回归\u0026quot;各自的不确定性来源；② 解释 EAGLE 的 shifted-token 输入为什么能消除特征分支歧义；③ 证明 EAGLE 每轮第一个草稿 token 的接受概率恒为 1；④ 写出 EAGLE 草稿模型的结构、训练损失与推理循环；⑤ 解释为什么特征误差小 ⟹ 接受率高（共享 LM head 的光滑性）；⑥ 描述 EAGLE-2 动态树的扩展/重排算法及其理论基础。\n目录（本章） # 本章目标 从 03 到 04：Medusa 的瓶颈在哪 核心洞察：token 不确定性与特征不确定性 架构：EAGLE 草稿模型 训练：损失、噪声增强与成本 推理循环：特征级草稿 + 树验证 为什么接受率更高：三个机制 数值算例：完整一轮 实验结果 EAGLE-2：上下文感知的动态草稿树 与 02/03 章对照 实现细节与坑 本章小结 习题与解答 延伸阅读 2. 从 03 到 04：Medusa 的瓶颈在哪 #03 章 Medusa 用\u0026quot;多头 + 树\u0026quot;把每层接受从 top-1 命中率升级为 top-$s$ 覆盖率，实测接受率约 0.6。瓶颈在哪？看它的 head 公式：\n$$ p_t^{(k)} = \\mathrm{softmax}\\!\\left(W_2^{(k)}\\left(\\mathrm{SiLU}(W_1^{(k)} h_t) + h_t\\right)\\right) $$head $k$ 只依赖当前 $h_t$，平行地猜第 $k$ 个未来 token——它不知道中间采样出了什么。这就是论文里说的\u0026quot;不确定性\u0026quot;：\n前缀 \u0026#34;I\u0026#34;（特征 f_I）后面既可能接 \u0026#34;am\u0026#34;（特征 f_am），也可能接 \u0026#34;always\u0026#34;（特征 f_always）。 仅凭 f_I，谁也说不清下一个特征应该是 f_am 还是 f_always。 Medusa 的 head 只能\u0026#34;平均\u0026#34;两种可能，接受率天花板被按在 ~0.6。 EAGLE 的洞察：特征层也有不确定性；shifted-token 输入把刚采样出的下一个 token 与当前特征一起喂给草稿模型，回归目标随之唯一。先看两个观察，再看架构。\n3. 核心洞察：token 不确定性与特征不确定性 #3.1 记号 #沿用论文记号：token $t$、token 嵌入 $e(t)$、特征 $f$（第二顶层隐藏状态，即 LM head 之前的表示）、分布 $p$。目标模型的计算链：\n$$ T_{1:j} \\;\\to\\; E_{1:j} \\;\\to\\; f_j \\;\\to\\; p_{j+1} = \\mathrm{LM\\_Head}(f_j) \\;\\to\\; t_{j+1} $$\u0026ldquo;第二顶层\u0026quot;这个位置很关键：再往上就是 LM head 的线性映射，特征到分布的距离由 LM head 的平滑性决定（第 7 节展开）。\n3.2 观察一：token 层自回归难，特征层自回归容易 #token 是离散的，词表 $V$ 个类，分布熵高：一句话里\u0026quot;下一个词\u0026quot;的可能选择成百上千，分类误差大。特征是连续的、高维的：相邻 token 的特征通常也相邻，回归目标平滑。论文实验（Vicuna-7B，MT-bench，温度 0）：\ntoken 层草稿：1.5x 特征层草稿：1.9x ← 只把\u0026#34;猜 token\u0026#34;换成\u0026#34;猜特征\u0026#34;，就快了 27% 3.3 观察二：特征层自回归也有不确定性 #但\u0026quot;猜特征\u0026quot;有个坑：下一个特征取决于采样结果。给定 $f_I$，\u0026ldquo;am\u0026rdquo; 和 \u0026ldquo;always\u0026rdquo; 都可能是下一个 token，它们的特征 $f_{am}$、$f_{always}$ 差别很大——模型不知道该往哪个方向回归。这就是论文标题里的 feature uncertainty。\n3.4 EAGLE 的解法：shifted-token 输入 #既然不确定来自\u0026quot;不知道采样出了什么\u0026rdquo;，那就把采样结果告诉模型：草稿模型输入序列里，token 序列整体提前一个时间步——\n$$ \\text{predict } f_{always} \\text{ from } (f_I,\\ t_{always}); \\qquad \\text{predict } f_{am} \\text{ from } (f_I,\\ t_{am}) $$一旦草稿模型已经采样出 $t_{always}$，它要预测的就是\u0026quot;这个 token 的特征\u0026quot;——这是一个确定的回归目标，不再有歧义。论文实验：加上 shifted-token 后，Vicuna-7B 的加速从 1.9x 涨到 2.8x。\n4. 架构：EAGLE 草稿模型 #4.1 组件 #EAGLE 的草稿模型由三部分组成：\n① Embedding 层：直接用目标模型的参数（冻结，不训练） ② LM Head：直接用目标模型的参数（冻结，不训练） ③ Autoregression Head：可训练（FC 投影 + 轻量 decoder） 输入是\u0026quot;特征序列 + 提前一步的 token 序列\u0026quot;的融合：\n$$ \\text{input}_j = \\left[\\, f_j \\,\\|\\, e(t_{j+1}) \\,\\right] \\in \\mathbb{R}^{2d} $$（$f_j$ 与 $t_{j+1}$ 的嵌入拼接，$d$ 为隐藏维度。）Autoregression Head 先用 FC 把 $2d$ 压回 $d$，再过 decoder 层，输出下一个特征的预测：\n$$ \\hat{f}_{j+1} = M_{\\text{draft}}(f_j,\\ e(t_{j+1})) $$然后用目标模型自己的 LM Head 得到草稿分布并采样：\n$$ \\hat{p}_{j+2} = \\mathrm{LM\\_Head}(\\hat{f}_{j+1}), \\qquad t_{j+2} \\sim \\hat{p}_{j+2} $$采出的 token 与预测特征一起拼进下一轮输入，继续自回归。\n4.2 为什么共享 Embedding 和 LM Head #共享 Embedding：token 语义空间一致，草稿与目标\u0026#34;说同一种语言\u0026#34; 共享 LM Head：草稿分布 q = softmax(G(ĥ)) 与目标分布 p = softmax(G(h)) 共享同一个映射 G；ĥ ≈ h 时 q ≈ p（第 7 节） 对比 Medusa：Medusa 的 head 也有各自的输出投影（$W_2^{(k)} \\in \\mathbb{R}^{d\\times V}$），虽然初始化为 LM head，但训练后会漂移；EAGLE 的 LM head 与目标共享且冻结，草稿分布由同一个映射 $G$ 得到，$\\hat f$ 越接近 $f$，$q$ 越接近 $p$（第 7 节）。\n4.3 训练参数规模 # 目标模型 EAGLE 可训练参数 占比（约） LLaMA2-Chat 7B 0.24B 3.4% LLaMA2-Chat 13B 0.37B 2.8% Vicuna-33B 0.56B 1.7% LLaMA2-Chat 70B 0.99B 1.4% Mixtral 8x7B（MoE） 0.28B — 训练成本：70B 模型用不超过 7 万条 ShareGPT 对话，4×A100（40G）训 1–2 天；7B–33B 在 RTX 3090 单机 1–2 天即可。一次训练可长期复用，均摊到每个请求的成本随请求数增加而下降。\n5. 训练：损失、噪声增强与成本 #预测特征是一个回归任务，预测 token 是分类任务，EAGLE 两个目标一起优化：\n$$ \\mathcal{L} = \\underbrace{\\mathcal{L}_{\\text{smooth-L1}}(\\hat{f}_{j+1},\\ f_{j+1})}_{\\text{特征回归}} + \\underbrace{\\mathcal{L}_{\\text{CE}}(\\hat{p}_{j+2},\\ t_{j+2})}_{\\text{token 分类}} $$（$\\hat{f}$ 是草稿预测特征，$f$ 是目标模型真实特征；Smooth L1 比 L2 对离群特征更稳。）\n噪声增强：推理时特征误差会沿自回归链累积（预测的 $\\hat{f}$ 又被喂回去预测下一个 $\\hat{f}$）。训练时对目标特征加均匀噪声：\n$$ f \\leftarrow f + u, \\qquad u \\sim \\mathcal{U}(-0.1, 0.1) $$让草稿模型学会\u0026quot;在有点脏的特征上也能正确回归\u0026quot;，显著缓解误差累积。\n6. 推理循环：特征级草稿 + 树验证 #6.1 草稿阶段（特征级自回归） #输入：当前已接受前缀的最后一个真实特征 f_j 1. 草稿第 1 个 token： q_{j+1} = LM_Head(f_j) # 与目标分布完全一致 t̂_{j+1} ~ q_{j+1} 2. 草稿第 2 个 token： f̂_{j+1} = M_draft(f_j, e(t̂_{j+1})) q_{j+2} = LM_Head(f̂_{j+1}) t̂_{j+2} ~ q_{j+2} 3. 草稿第 3 个 token： f̂_{j+2} = M_draft(f̂_{j+1}, e(t̂_{j+2})) q_{j+3} = LM_Head(f̂_{j+2}) t̂_{j+3} ~ q_{j+3} ……重复到 K 个草稿 token 注意第 1 步的输入是真实特征，第 2 步起输入是预测特征。\n6.2 验证阶段（树注意力 + 递归拒绝采样） #与 03 章相同：多个候选分支构成树，目标一次前向（树注意力）算出所有节点概率，然后递归地逐节点做拒绝采样：\n$$ \\text{accept } \\hat{t} \\iff r \\le \\min\\left(1,\\ \\frac{p(\\hat{t})}{\\hat{q}(\\hat{t})}\\right), \\qquad \\text{否则从 } \\mathrm{norm}(\\max(0, p - \\hat{q})) \\text{ 重采样} $$这保证了分布严格等于目标模型（贪心与采样设置都成立）。验证结束后，接受路径每个 token 的真实特征被保存，作为下一轮草稿的起点——不需要再跑一遍目标前向。\n7. 为什么接受率更高：三个机制 #7.1 机制一：第一个草稿 token 恒被接受 #草稿第 1 步 $q_{j+1} = \\mathrm{LM\\_Head}(f_j)$，而目标分布 $p_{j+1} = \\mathrm{LM\\_Head}(f_j)$——同一个特征、同一个映射，所以 $q_{j+1} \\equiv p_{j+1}$。由 02 章引理：\n$$ \\text{accept prob} = \\sum_x q(x)\\min\\!\\left(1,\\frac{p(x)}{q(x)}\\right) = \\sum_x \\min(p,q) = 1 \\quad (q \\equiv p) $$结论：EAGLE 每轮第一个草稿 token 就是目标分布的一个样本，接受概率恒为 1。 接受率下降完全来自后续预测特征的误差累积。\n7.2 机制二：共享 LM head 把\u0026quot;特征误差\u0026quot;平滑地传导为\u0026quot;分布误差\u0026quot; #设 $G = \\mathrm{LM\\_Head}$ 是光滑映射。01 章已知 $\\alpha = 1 - \\mathrm{TV}(p, q)$，而\n$$ \\mathrm{TV}\\!\\left(\\mathrm{softmax}(G(\\hat{f})),\\ \\mathrm{softmax}(G(f))\\right) \\le L \\cdot \\|\\hat{f} - f\\| $$（$L$ 与 softmax 雅可比和 $G$ 的 Lipschitz 常数有关）。特征预测误差按常数倍传导为分布距离，进而线性地压低接受率。特征回归误差是连续、可控的；而 token 分类一旦选错类，分布距离直接是 1——这就是\u0026quot;特征级草稿比 token 级草稿接受率高\u0026quot;的量化根源。\n7.3 机制三：shifted-token 把\u0026quot;多目标回归\u0026quot;变成\u0026quot;单目标回归\u0026quot; #没有 shifted-token 时（Medusa 式），给定 $f_I$ 的回归目标是 $f_{am}$ 与 $f_{always}$ 的混合——模型被训练去\u0026quot;平均\u0026quot;两个不相容的目标，误差下限高。有 shifted-token 时，输入已经包含采样的 $t$，回归目标唯一。论文数据：\n接受率（top-1，链式草稿）： Medusa：≈ 0.6 Lookahead：更低 EAGLE：≈ 0.8 三个机制合起来：第一 token 免费 + 平滑传导 + 目标唯一，把草稿接受率从 0.6 抬到 0.8。\n8. 数值算例：完整一轮 #场景：前缀 \u0026ldquo;I\u0026rdquo;，目标真实特征 $f_1$，草稿长度 $K = 3$。\n草稿阶段（特征级自回归）：\n第 1 步：q_2 = LM_Head(f_1) ← 与目标分布相同，恒接受 采样 t̂_2 = \u0026#34;am\u0026#34; 第 2 步：f̂_2 = M_draft(f_1, e(\u0026#34;am\u0026#34;)) q_3 = LM_Head(f̂_2)，采样 t̂_3 = \u0026#34;a\u0026#34; 第 3 步：f̂_3 = M_draft(f̂_2, e(\u0026#34;a\u0026#34;)) q_4 = LM_Head(f̂_3)，采样 t̂_4 = \u0026#34;student\u0026#34; 验证阶段：目标一次前向计算 \u0026ldquo;I am a student\u0026rdquo; 的分布 $p_2, p_3, p_4$，逐位拒绝采样。假设接受率剖面：\n$$ \\alpha_1 = 1.0 \\quad(\\text{真实特征，} q_2 \\equiv p_2), \\qquad \\alpha_2 = 0.9, \\qquad \\alpha_3 = 0.7 $$期望产出：\n$$ E[N] = 1 + \\alpha_1 + \\alpha_1\\alpha_2 + \\alpha_1\\alpha_2\\alpha_3 = 1 + 1 + 0.9 + 0.63 = 3.53 $$对比：Medusa 式均匀 $\\alpha = 0.6$、$K=3$ 时 $E[N] = 1 + 0.6 + 0.36 + 0.216 = 2.176$。EAGLE 多出约 60% 的每轮产出，主要来自\u0026quot;第一个草稿免费 + 后续衰减慢\u0026quot;。\n若一次目标前向的墙钟为 $T_p$、3 步轻量草稿共约 $0.4\\,T_p$：\n$$ \\text{speedup} \\approx \\frac{3.53}{1.4} \\approx 2.5\\text{x} $$（示意值；论文 70B 实测 2.7–3.5x，见第 9 节。）\n9. 实验结果 #论文（EAGLE-1）与 EAGLE-2 的已核实数据：\n实验 结果 草稿方式消融（Vicuna-7B，MT-bench，温度 0） token 层 1.5x → 特征层 1.9x → +shifted-token 2.8x 草稿接受率（top-1 链式） EAGLE ≈ 0.8；Medusa ≈ 0.6；Lookahead 更低 LLaMA2-Chat 70B 延迟加速 2.7x–3.5x，吞吐翻倍，分布保持 覆盖任务 对话（MT-bench）、代码（HumanEval）、数学（GSM8K）、指令（Alpaca） EAGLE-2（动态树） 加速 3.05x–4.26x，比 EAGLE-1 快 20%–40% EAGLE-2 全任务范围 2.5x–5x（六个任务、三个模型系列） EAGLE-2 每轮接受长度 ≈ 4–5.5 token，约为标准推测解码和 Medusa 的 2 倍 无损性 EAGLE 与 EAGLE-2 都用严格拒绝采样，贪心与非贪心均保持分布 EAGLE-2 在代码生成任务上最高 5x（代码模板规律性强，特征预测准）；EAGLE-2 在 MT-bench 上约比 Medusa 快 2x、比 Lookahead 快 2.3x。\n10. EAGLE-2：上下文感知的动态草稿树 #10.1 静态树的隐含假设与反例 #EAGLE-1、Medusa 都用固定形状的树：每层候选数固定，隐含假设\u0026quot;接受率只取决于位置\u0026quot;。EAGLE-2 指出这个假设不成立：\n查询 \u0026#34;10+2=\u0026#34;：下一个 token 几乎必然是 \u0026#34;1\u0026#34;，一个候选就够 查询 \u0026#34;10+2\u0026#34;（还没打完）：下一个 token 很难猜，需要多个候选 论文实验（Vicuna-7B，Alpaca）：接受率既随位置变化（左上 P1 最高、右下 P6 最低），也随上下文大幅波动（同一位置不同查询差异显著）。\n10.2 置信度 ≈ 接受率（校准性） #动态调树需要\u0026quot;不跑目标模型就能估计接受率\u0026quot;。论文发现 EAGLE 草稿模型校准良好：置信度 $c$（草稿分布给出的概率）与接受率强正相关——\n置信度 c \u0026lt; 0.05 → 平均接受率 ≈ 0.04 置信度 c \u0026gt; 0.95 → 平均接受率 ≈ 0.98 于是可以用 $c$ 近似接受率，零额外开销。\n10.3 扩展 + 重排 #定义节点 $t_i$ 的全局接受概率（路径上所有节点接受率的乘积，用置信度近似）：\n$$ \\mathrm{value}(t_i) = \\prod_{t_j \\in \\mathrm{Path}(\\mathrm{root}, t_i)} c_j $$（一个节点要被接受，它的所有祖先都得先被接受——所以是连乘。）\n扩展阶段：从当前最后一层里选 value 最高的 top-k 节点，喂给草稿模型展开下一层 （避免整层指数级展开，控制草稿前向开销） 重排阶段：在所有节点里选 value 最高的 top-m，展平成 1D 序列送去验证 （浅层未扩展的高价值节点不会被深层的低价值节点挤掉） 两个性质保证正确性：\n$\\mathrm{value}(\\text{child}) \\le \\mathrm{value}(\\text{parent})$：因为置信度 $c \\le 1$，连乘沿路径单调不增； 由于父节点 value 不小于子节点，重排后选出的 top-$m$ 集合仍是连通的树（若子节点入选，父节点必然更早入选；平局优先选浅层）。 EAGLE-2 不改草稿模型、不改验证，零额外训练，严格无损。\n11. 与 02/03 章对照 # 维度 02 原始推测解码 03 Medusa 04 EAGLE 草稿形式 独立小模型，token 级自回归 多头 MLP，平行猜未来 token 轻量 decoder，特征级自回归 草稿对主干的依赖 无（完全独立） 用主干 $h_t$ 用主干特征 + 共享 Embedding/LM Head 第一草稿 token 需按拒绝采样判定 目标贪心直接收（典型验收） 与目标分布相同，恒接受 典型接受率 视草稿模型 ≈ 0.6 ≈ 0.8 每轮草稿成本 $K$ 步小模型前向 head 前向（近免费） $K$ 步轻量 decoder 前向 树 链（可推广树） 静态树 静态树（EAGLE-1）/ 动态树（EAGLE-2） 无损性 严格 严格（拒绝采样）/ 近似（典型验收） 严格（两个版本都是） 训练 无 训 $K$ 个头 训轻量 decoder（1–2 天） 70B 实测 — — 2.7–3.5x 演进主线：02 换\u0026quot;谁来猜\u0026quot;（外部模型）→ 03 换\u0026quot;怎么猜\u0026quot;（多头 + 树）→ 04 换\u0026quot;猜什么\u0026quot;（token 换成特征）。\n12. 实现细节与坑 # 特征层必须选对：取 LM head 之前的第二顶层隐藏状态。取错层（如顶层 logits）会破坏共享 LM head 的平滑性假设，$q$ 与 $p$ 失去对应关系。 噪声增强不能省：不加 $\\mathcal{U}(-0.1, 0.1)$ 噪声，预测特征误差沿链累积会让草稿快速发散。 必须保存接受路径的真实特征：下一轮草稿的起点是验证阶段算出的真实特征；丢弃它们就得重跑目标前向，白付一次验证。 共享 LM head 意味着同词表：EAGLE 天然满足（Embedding 都是目标的）；若换词表则整个机制失效。 树验证细节：与 03 章相同（掩码只看祖先、RoPE 位置按层共享）；拒绝采样逐节点递归执行，保证无损。 第一草稿免费的性质只对 EAGLE 成立：它来自\u0026quot;同一特征 + 同一 LM head\u0026quot;；Medusa 的 head 有自己的投影，不享受此性质。 EAGLE-2 的动态树别和静态树混淆：静态树靠位置定形状；动态树按置信度连乘定形状，零额外训练。 量化与批处理：草稿 decoder 很小，可与 W4A16 等量化叠加；vLLM 已集成 EAGLE（含 EAGLE-2 风格的动态树）。 13. 本章小结 # 两个观察：特征层自回归比 token 层容易（1.9x vs 1.5x）；但特征也有分支不确定性（$f_I \\to f_{am}$ 或 $f_{always}$）。 解法：shifted-token 输入——把\u0026quot;刚采样出的 token\u0026quot;告诉模型，让回归目标唯一（加速从 1.9x 到 2.8x）。 架构：共享目标 Embedding 与 LM Head + 可训练轻量 decoder；$q = \\mathrm{LM\\_Head}(\\hat{f})$。 接受率高的三个机制：第一草稿恒接受（$q_1 \\equiv p_1$）、光滑传导（$\\mathrm{TV} \\le L\\|\\hat{f}-f\\|$）、目标唯一。 数据：LLaMA2-Chat 70B 2.7–3.5x、吞吐翻倍；EAGLE-2 动态树 3.05–4.26x。 无损性：EAGLE 两个版本都用严格拒绝采样，贪心与非贪心都保持目标分布。 14. 习题与解答 #题 1（推导）：第一草稿恒接受 #严格证明：EAGLE 每轮第一个草稿 token 的接受概率为 1，且输出分布等于目标分布 $p_{j+1}$。\n题 1 解答 第一个草稿位置的输入是目标真实特征 $f_j$，草稿分布 $q_{j+1} = \\mathrm{LM\\_Head}(f_j)$；目标验证时算的也是 $p_{j+1} = \\mathrm{LM\\_Head}(f_j)$。故 $q \\equiv p$，接受概率 $\\sum_x \\min(p(x),q(x)) = 1$。输出 token 按 $q = p$ 采样，边际分布即 $p_{j+1}$，无损。\n题 2（计算）：接受率剖面 #EAGLE 链式草稿 $K=4$，接受率剖面 $\\alpha = (1.0, 0.9, 0.7, 0.6)$；Medusa 链式 $\\alpha = 0.6$ 均匀。分别算 $E[N]$，并解释差距来源。\n题 2 解答 EAGLE：$E[N] = 1 + 1 + 0.9 + 0.63 + 0.378 = 3.908$。Medusa：$1 + 0.6 + 0.36 + 0.216 + 0.1296 = 2.306$。差距主要来自两项：第一项免费（+0.4）和早期接受率高（0.9/0.7 vs 0.6）带来的乘积放大。\n题 3（推导）：TV 与特征误差 #设 $p = \\mathrm{softmax}(G(f))$、$q = \\mathrm{softmax}(G(\\hat{f}))$，$G$ 是 $L$-Lipschitz。说明为什么 $\\alpha \\ge 1 - L\\|\\hat{f} - f\\|$ 形式的界成立，并解释\u0026quot;回归误差连续传导\u0026quot;的含义。\n题 3 解答要点 $\\alpha = 1 - \\mathrm{TV}(p,q)$（01 章）。softmax∘G 复合映射在分布空间的 Lipschitz 常数有限，故 $\\mathrm{TV}(p,q) \\le L\\|\\hat{f}-f\\|$，接受率随特征误差线性下降。含义：只要回归误差小（连续量），分布就接近；而 token 分类选错类时 $\\mathrm{TV}=1$，没有\u0026quot;半对\u0026quot;的中间状态。\n题 4（思考）：分支不确定性 #画出示意图：前缀 \u0026ldquo;I\u0026rdquo; 之后 \u0026ldquo;am\u0026rdquo; 与 \u0026ldquo;always\u0026rdquo; 两个分支。解释为什么没有 shifted-token 时草稿模型只能\u0026quot;平均\u0026quot;两个目标，以及这对 Medusa 接受率 ~0.6 的贡献。\n题 4 解答要点 $f_I$ 之后有两条合法路径：$(t_{am}, f_{am})$ 与 $(t_{always}, f_{always})$。若输入只有 $f_I$，回归目标在 $f_{am}$ 与 $f_{always}$ 之间摇摆，模型学到的输出是两者的混合特征，映射到分布后与两个真实分支都不一致，接受率被压低。shifted-token 输入把\u0026quot;路径选择\u0026quot;交给采样（不确定性被 token 显式承担），回归目标唯一。\n题 5（设计）：EAGLE-2 的 value 与连通性 #证明 $\\mathrm{value}(\\text{child}) \\le \\mathrm{value}(\\text{parent})$，并说明为什么重排后选出的 top-$m$ 节点仍是连通树。\n题 5 解答 $\\mathrm{value}(t_i) = \\prod_{t_j \\in \\mathrm{Path}(\\mathrm{root},t_i)} c_j$。子节点的路径 = 父节点路径 + 子节点自身，多乘一个 $c \\in [0,1]$，故 value 不增。若某节点入选 top-$m$，其父节点 value 更大（或相等），必然也在 top-$m$ 里（平局优先浅层）——所以选出集合的每个节点都有祖先入选，构成连通树。这保证展平后可以用树掩码验证。\n题 6（编程）：toy 特征级草稿 #实现一个 toy 模拟：给定目标特征映射 $f_j$、真实特征序列生成器与一个\u0026quot;误差随步数增长\u0026quot;的预测器，跑 5 万轮 EAGLE 式草稿-验证，统计每轮 token 数与 $E[N] = 1 + \\sum_{i=1}^{K}\\prod_{j\\le i}\\alpha_j$ 的偏差；再对比\u0026quot;无 shifted-token\u0026quot;版本（回归目标混合）的接受率。\n题 6 解答要点 ① 第一草稿用 $p$ 本身采样（恒接受）；② 后续草稿用带噪声的特征映射 $f \\to \\hat{f} = f + \\varepsilon_i$ 生成分布，接受率 $\\alpha_i$ 由 $\\varepsilon_i$ 决定；③ 统计均值应接近公式；④ 无 shifted-token 版本把两个分支特征平均，$\\alpha$ 明显下降——复现论文 Fig. 4 的趋势。\n15. 延伸阅读 # EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty（arXiv:2401.15077）：本章全部内容出处（观察与解法 §1、架构 §2、训练 §3、实验 §4）。 EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees（arXiv:2406.16858）：动态树（扩展/重排、置信度校准）出处。 SpecInfer（arXiv:2305.09781）：EAGLE 树验证所用的递归拒绝采样框架。 NVIDIA 技术博客：An Introduction to Speculative Decoding：工程视角的对照阅读。 上一篇： 03 Medusa：多头解码；下一篇：05 n-gram / 检索式与无模型路线——Lookahead Decoding、REST、Prompt Lookup，回答\u0026quot;不训练任何东西能不能猜\u0026quot;。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-04-eagle-%E7%89%B9%E5%BE%81%E7%A9%BA%E9%97%B4%E8%8D%89%E7%A8%BF/","section":"笔记","summary":"Medusa 在 token 层做自回归，每次采样都会引入新的歧义；EAGLE 把草稿搬到特征层，用 shifted-token 输入消除分支歧义，因此接受率更高。本文给出草稿模型结构与训练损失，证明每轮首个草稿 token 接受概率恒为 1，并讲清 EAGLE-2 的动态草稿树。","title":"EAGLE 推测解码为什么比 Medusa 快？（含 EAGLE-2 动态草稿树）"},{"content":" 系列导航： 推测解码精读笔记总览（共 6 篇）｜上一篇： EAGLE 推测解码为什么比 Medusa 快｜下一篇： 推测解码上线怎么验收\n对应：Fu et al., Breaking the Sequential Dependency of LLM Inference Using Lookahead Decoding（arXiv:2307.09991 / 2402.02057，ICML 2024）；He et al., REST: Retrieval-Based Speculative Decoding（arXiv:2311.08252，2023）；Saxena, Prompt Lookup Decoding（vLLM / TensorRT-LLM 的 [ngram] 模式）。 前置：01–04 章。学完本章你应该能：① 说出无模型路线的统一公式\u0026quot;n-gram 记忆 + 目标并行验证\u0026quot;；② 比较 Prompt Lookup、Lookahead Decoding、REST 三种\u0026quot;记忆来源\u0026quot;的差异；③ 把自回归解码写成非线性方程组，解释 Jacobi 迭代为什么本身不加速、Lookahead 又怎么救活它；④ 写出 REST 的 datastore → 检索 → Trie 建草稿 → 树验证流程；⑤ 用命中率模型解释为什么这些方法在\u0026quot;重复性强\u0026quot;的任务上赢、在自由生成上输；⑥ 说清它们为什么都是无损的。\n目录（本章） # 本章目标 动机：草稿的第三种来源——记忆与检索 统一框架：n-gram 续写 + 目标验证 方法一：Prompt Lookup Decoding（prompt 记忆） 方法二：Lookahead Decoding（自生成轨迹记忆） 方法三：REST（外部语料记忆） 三种方法对照 接受率数学：n-gram 命中率模型 数值算例 实验结果 决策框架：无模型 vs 训练路线 实现细节与坑 本章小结 习题与解答 延伸阅读 2. 动机：草稿的第三种来源——记忆与检索 #不训练任何草稿模型，能不能猜出接下来的几个 token？02–04 章的三条草稿路线都需要训练：\n02：独立小模型（要预训练、要部署） 03：主干的头（要训练 K 个头） 04：特征级 decoder（要训练轻量模型） 文本生成经常重复已有文本：代码里的模板、摘要里复述原文的句子、多轮对话里重复的指令。这些重复就是免费的草稿来源：\n上下文结尾是 \u0026#34;return self.value + \u0026#34;，prompt 里出现过一模一样的片段， 后面大概率还是 \u0026#34;self.offset\u0026#34; 之类——直接在记忆里查，不用任何模型猜。 这类方法的共同名字叫无模型路线（model-free）：没有草稿模型、没有训练，只有\u0026quot;查表 + 验证\u0026quot;。\n3. 统一框架：n-gram 续写 + 目标验证 #本章三种方法（Prompt Lookup、Lookahead、REST）可以写成同一个公式：\n候选 = 在\u0026#34;记忆\u0026#34;里找到与当前上下文后缀匹配的 n-gram，取出它的续写 验证 = 目标模型一次前向并行验证这些续写（拒绝采样保持无损） 差别只有一处——记忆从哪来：\n方法 记忆来源 一句话 Prompt Lookup 当前 prompt / 已生成文本 \u0026ldquo;翻自己说过的话\u0026rdquo; Lookahead Decoding 自生成的 Jacobi 轨迹缓存 \u0026ldquo;翻自己刚想过的词\u0026rdquo; REST 外部大规模语料 datastore \u0026ldquo;翻全世界说过的话\u0026rdquo; 后面每一节就是\u0026quot;把一种记忆源讲清楚 + 它特有的机制\u0026quot;。\n4. 方法一：Prompt Lookup Decoding（PLD） #4.1 算法 #PLD 是最简单的无模型方法：把草稿模型替换成字符串匹配函数。\n输入：当前已生成序列 S、lookup 长度范围 [min, max] 1. 取 S 末尾的 n 个 token 作为查询 q（从 max 开始，逐次减到 min） 2. 在 S 的前面部分（prompt + 已生成文本）里找 q 的精确匹配 3. 若找到：匹配位置之后的 token 序列（最长可用长度）作为草稿候选 4. 目标模型并行验证，接受匹配上的前缀 vLLM 里对应 speculative_model=\u0026quot;[ngram]\u0026quot;，超参 prompt_lookup_min / prompt_lookup_max / num_speculative_tokens；TensorRT-LLM 的 NGram 模式同理。\n4.2 为什么有效 #典型场景：摘要、代码补全、翻译、多轮对话——输出大量逐字复用输入文本：\nprompt ：“请总结：\u0026lt;长文\u0026gt;” 输出 ：“本文介绍了……文中提到……” ← 大量短语直接来自 \u0026lt;长文\u0026gt; EAGLE-2 论文的实验也印证：PLD 在摘要任务（CNN/DailyMail）上拿到无模型方法里最高的加速比，因为摘要与原文的重叠率最高。\n4.3 边界 #自由创作、开放域对话等重复率低的任务上，n-gram 匹配经常失败——PLD 退化为普通解码（白付一次验证开销）。\n5. 方法二：Lookahead Decoding（自生成轨迹记忆） #Lookahead 回答的是另一个问题：没有外部记忆、prompt 也不重复时，草稿从哪来？ 答案是\u0026quot;让模型自己边想边记\u0026quot;。\n5.1 自回归解码 = 解非线性方程组 #设要生成 $m$ 个 token（贪心），自回归过程可以写成 $m$ 个方程：\n$$ y_i = \\arg\\max_y P_M(y \\mid y_1, \\dots, y_{i-1}, \\mathbf{x}^0), \\qquad i = 1, \\dots, m $$定义 $f(y_i, \\mathbf{y}_{1:i-1}, \\mathbf{x}^0) = y_i - \\arg\\max_y P_M(y \\mid \\mathbf{y}_{1:i-1}, \\mathbf{x}^0)$，上式等价于非线性方程组：\n$$ f(y_i, \\mathbf{y}_{1:i-1}, \\mathbf{x}^0) = 0, \\qquad i = 1, \\dots, m $$5.2 Jacobi 迭代：并行解方程组，但几乎不加速 #求解非线性方程组的标准方法之一是 Jacobi 迭代：从一个初始猜测 $\\mathbf{y}^0$ 出发，每一轮并行更新所有位置：\n$$ y_i^{t+1} = \\arg\\max_y P_M(y \\mid y_1^{t}, \\dots, y_{i-1}^{t}, \\mathbf{x}^0) $$性质：\n每轮至少 1 个 token 正确：第一个位置用的是真实前缀，所以 $y_1^{t+1}$ 就是自回归的第一个 token——最多 $m$ 轮收敛； 运气好时一轮能\u0026quot;蒙对\u0026quot;多个位置，减少解码步数； 但论文实验发现 Jacobi 解码几乎不加速：猜对的 token 常被放在错误位置，且后续迭代会把已经放对的位置覆盖掉。 5.3 Lookahead 的补救：把轨迹变成 n-gram 记忆 #Jacobi 每轮产生的轨迹 $(\\mathbf{y}^0, \\mathbf{y}^1, \\dots)$ 里藏着一个事实：相邻两步的 token 组合是有意义的 2-gram（因为 $y_i^{t+1}$ 是基于 $y_{i-1}^{t}$ 生成的）。Lookahead 把这个观察推广到 $n$-gram，并加了两样东西：\n① lookahead branch：一个固定大小的 2D 窗口 W = 向前看几个位置（并行解码宽度） N = 往回看几步轨迹（n-gram 长度） 每轮在 W 个位置并行生成 token，沿轨迹收集 n-gram ② n-gram pool：缓存轨迹里出现过的所有 n-gram 下一轮用\u0026#34;当前最后 token\u0026#34;做 key，从 pool 里找以它开头的 n-gram 作为草稿 每轮三步： 1. lookahead branch：W 个位置并行生成新 token（一条新轨迹） 2. verification branch：从 n-gram pool 里取\u0026#34;以当前最后 token 开头\u0026#34;的候选， 目标模型并行验证、接受匹配前缀 3. 把新轨迹的 n-gram 写回 pool；滑动窗口丢弃最旧的 token 注意 lookahead 分支与验证分支互不可见（各自独立的注意力掩码），同一个前向里并行执行。\n5.4 无损性与采样支持 #验证采用\u0026quot;不匹配即停\u0026quot;规则：n-gram 前缀与目标输出一致就接受，第一个不一致处停下。论文证明（Appendix B）：不相交 n-gram 的并行验证保持输出分布——这是 Lookahead 无损性的核心定理。\n采样（非贪心）场景有个实现技巧：n-gram pool 若存概率分布会爆内存，所以 lookahead 分支强制贪心生成 n-gram——分布退化为 one-hot，只存选中的 token 即可。论文论证验证与草稿采样方式无关（采样方式只影响接受率，不改变输出分布），所以无损性依然成立。\n5.5 缩放律 #定义每步产出 $S = \\frac{\\#\\text{生成 token}}{\\#\\text{Lookahead 步数}}$。论文推导：\n$$ S = \\frac{f - 1 + E[\\#\\text{tokens}]}{f} $$（每 $f$ 步有 1 步好的猜测，其余退回自回归。）结论：步数随每步 $\\log(\\text{FLOPs})$ 线性下降——与推测解码\u0026quot;接受率封顶\u0026quot;不同，Lookahead 可以靠加算力（$W$、$N$）持续压步数；这也支撑它在多 GPU 上的强扩展性（lookahead parallelism：每 GPU 一份完整模型，按分支分发 token）。\n6. 方法三：REST（外部语料记忆） #REST 把记忆从\u0026quot;自己\u0026quot;扩展到\u0026quot;全世界\u0026quot;：用一个外部语料库当草稿模型。\n6.1 Datastore 构建 #$$ D = \\{(c_i, t_i)\\} $$对语料里每个位置，$c_i$ 是上下文、$t_i$ 是对应的续写，构成\u0026quot;上下文-续写\u0026quot;对。论文用了两个库：\n代码域：The Stack 的 270 万条 Python 样本 → 加速 CodeLlama 7B/13B 通用域：UltraChat 约 77.4 万条对话 → 加速 Vicuna 7B/13B 6.2 检索：后缀精确匹配（几乎零开销） #用当前上下文 $s$ 作为查询，在 $D$ 里找与 $s$ 最长后缀精确匹配的条目；匹配不到就缩短后缀长度再试。实现用后缀数组（suffix array），检索开销 \u0026lt; 6%：\n$$ \\text{Retrieve}(D, s) = \\{(c_i, t_i) : c_i \\text{ 以 } s \\text{ 的最长匹配后缀结尾}\\} $$6.3 Trie 建草稿：把一堆续写变成一棵候选树 #检索结果可能很多，全用会撑爆验证前向。REST 用 Trie 合并它们：\n1. 把所有续写 t_i 插进 Trie，每个节点累计\u0026#34;出现频次\u0026#34;作为权重 2. 按权重挑出 top-c 个最高频前缀（即\u0026#34;最被语料支持\u0026#34;的续写） 3. 这些前缀构成一棵草稿树 6.4 验证与无损性 #草稿树用树注意力一次前向验证，从根开始接受，第一个不一致处之后全部丢弃；拒绝位置用标准拒绝采样修正。REST 与 PLD、Lookahead 一样严格无损——只影响草稿质量，不改变目标分布。\n7. 三种方法对照 # 维度 Prompt Lookup Lookahead Decoding REST 记忆来源 当前 prompt/生成文本 自生成 Jacobi 轨迹 外部语料 datastore 记忆规模 1 个序列（小） 固定窗口（中） 百万级语料（大） 特有机制 无（纯字符串匹配） 2D 窗口 + n-gram pool 后缀数组检索 + Trie 加权 训练 无 无 无（但要建 datastore） 无损 严格 严格（Appendix B 证明） 严格 最擅长的任务 摘要/代码/多轮 代码补全（规律性强） 代码（HumanEval）最强，通用其次 典型加速 取决于重复度 1.5–2.3x 1.62–2.36x 8. 接受率数学：n-gram 命中率模型 #8.1 把无模型路线套进统一公式 #设检索/查表得到续写 $(\\hat{t}_1, \\dots, \\hat{t}_K)$，目标逐位验证。沿用 01–04 章的记号，第 $i$ 层接受概率：\n$$ \\alpha_i = P\\!\\left(\\hat{t}_i = \\arg\\max_x p(x \\mid \\text{上下文} + \\hat{t}_{","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-05-n-gram%E6%A3%80%E7%B4%A2%E5%BC%8F%E4%B8%8E%E6%97%A0%E6%A8%A1%E5%9E%8B%E8%B7%AF%E7%BA%BF/","section":"笔记","summary":"Prompt Lookup、Lookahead Decoding、REST 都不训练草稿模型，而是从 n-gram 或检索库里取候选，再交给目标模型并行验证。本文比较三种「记忆来源」的差异，解释 Lookahead 为什么能把 Jacobi 迭代救活，以及这类方法在什么任务上才真的赢。","title":"n-gram 投机采样怎么做？不用草稿模型的加速方案"},{"content":" 系列导航： 推测解码精读笔记总览（共 6 篇）｜上一篇： 不用草稿模型的加速方案\n对应：vLLM / TensorRT-LLM 的推测解码工程实践；量化系列第 10 章（质量评估方法论）与第 11 章（系统协同与部署）。本系列完结章。 前置：01–05 章全部内容。学完本章你应该能：① 用\u0026quot;每步成本 × 步数\u0026quot;的双因子模型解释量化与推测的叠加收益，并指出\u0026quot;只量化目标、不量化草稿\u0026quot;会稀释推测收益；② 分解 TTFT 与 TPS，说清各自吃哪类优化；③ 设计一份生产验收协议（无损性验证、质量评测、性能指标、组合矩阵）；④ 根据业务场景（低延迟/高吞吐/显存受限/重复性任务）给出技术选型；⑤ 列出集成时最常见的 9 个坑。\n目录（本章） # 本章目标 全系列回顾：两条主线的乘法结构 组合墙钟模型：量化 × 推测 端到端延迟模型：TTFT 与 TPS 系统组件集成 吞吐 vs 延迟权衡 验收协议 数值算例：组合收益 决策树：什么时候上什么 实现细节与坑 本章小结与系列收尾 习题与解答 延伸阅读 2. 全系列回顾：两条主线的乘法结构 #整个系列围绕一个双因子模型展开：\n$$ \\text{总墙钟} = \\underbrace{\\text{每步成本}}_{\\text{量化主战场}} \\times \\underbrace{\\text{步数}}_{\\text{推测主战场}} $$量化（有损换速度）：位宽减半 → 权重搬移减半 → 每步约快 2x（W4A16 等） 推测（无损换步数）：一次验证产出 E[N] 个 token → 步数除以 ~2-3.5x 两路正交，理想情况下乘积叠加；但存在交互项（草稿也被量化吗？验证树更贵吗？KV 量化腾出的显存能换更大 batch 吗？），本章把这些交互算清楚。\n3. 组合墙钟模型：量化 × 推测 #3.1 基础公式回顾 #01/02 章的链式推测：\n$$ E[N] = \\frac{1-\\alpha^{K+1}}{1-\\alpha}, \\qquad \\text{speedup}_{\\text{spec}} = \\frac{E[N]\\cdot c}{c+K}, \\quad c = \\frac{T_p}{T_q} $$每轮墙钟 $T_p + K\\cdot T_q$，产出 $E[N]$ 个 token。\n3.2 引入量化 #设目标模型量化后每步快 $q_t$ 倍、草稿快 $q_d$ 倍：\n$$ T_p \\to \\frac{T_p}{q_t}, \\qquad T_q \\to \\frac{T_q}{q_d} $$组合加速比（相对未量化、未推测的基线）：\n$$ \\text{speedup}_{\\text{total}} = \\frac{E[N]\\cdot T_p/q_t}{T_p/q_t + K\\cdot T_q/q_d} $$情形分析（$T_p=10$ms、$T_q=1$ms、$K=4$、$\\alpha=0.8$、$E[N]=3.36$）：\n场景 每轮时间 每 token 时间 总加速 说明 基线（无优化） 10ms/token 10.0ms 1.00x — 只推测 14ms / 3.36 4.17ms 2.40x 02 章结果 量化都做（$q_t=q_d=2$） 7ms / 3.36 2.08ms 4.80x ≈ 乘积 2.40 × 2 只量化目标（$q_t=2, q_d=1$） 9ms / 3.36 2.68ms 3.73x 草稿开销占比上升 只量化草稿（$q_t=1, q_d=2$） 12ms / 3.36 3.57ms 2.80x 推测比值改善但绝对收益小 三个结论：\n都量化时乘积近似成立（4.80x ≈ 2.40 × 2）：两条优化主线确实正交； 只量化目标会稀释推测收益（3.73x \u0026lt; 4.80x）：草稿相对变慢，$c$ 下降，草稿开销占比上升——量化草稿和量化目标一样重要； 量化是\u0026quot;放大器\u0026quot;：同样的推测方案，配合量化后绝对收益更大，所以生产环境优先\u0026quot;量化 + 推测\u0026quot;一起上。 3.3 树的组合 #树/特征级方案（03/04 章）把 $T_q$ 换成\u0026quot;树/草稿头的前向成本\u0026quot;，$E[N]$ 换成树的期望接受长度：\n$$ \\text{speedup} = \\frac{E[N]\\cdot T_p/q_t}{T_p/q_t + T_{\\text{draft}}/q_d} $$定性结论不变：$T_{\\text{draft}}$ 越小（Medusa 头 ≈ 0、EAGLE 轻量 decoder），组合收益越接近\u0026quot;纯 $E[N]$ × 量化\u0026quot;。\n4. 端到端延迟模型：TTFT 与 TPS #把一次请求拆成两段：\n$$ \\text{TTFT} \\approx T_{\\text{prefill}}(L, B), \\qquad \\text{TPS} = \\frac{1}{\\text{decode 每 token 时间}} $$两种优化对两段的作用完全不同：\n优化 TTFT（prefill） TPS（decode） 量化（FP8/W4A16） ✓ 显著（compute-bound，FLOPS 翻倍） ✓ 显著（bandwidth-bound，搬移减半） 推测解码 ✗ 无（还没有 token 可猜） ✓ 显著（步数减少） KV 量化 ✗ 几乎无 ✓ 间接（省显存 → 更大 batch/更长序列） 分块预填充 ✓（减少队头阻塞） ✗ 经验法则： TTFT 靠\u0026#34;量化 + 分块预填充\u0026#34;；TPS 靠\u0026#34;推测 + 量化\u0026#34;。 只上推测、不上量化：TTFT 一点没动，用户体验第一口还是慢。 5. 系统组件集成 #5.1 调度与批处理 #推测解码的每轮分两阶段：\n草稿阶段：每个请求独立跑草稿（batch 内各请求长度不同） 验证阶段：把所有请求的草稿树拼成一个\u0026#34;验证 batch\u0026#34;，一次前向批量验证 生产引擎（vLLM 等）的要点：\n验证前向用树注意力，多个请求的树按各自掩码拼进同一张注意力矩阵； 草稿阶段可以与其他请求的验证阶段重叠（流水线化），隐藏草稿延迟； batch 越大，验证前向越接近带宽饱和，推测收益会部分被\u0026quot;本来就要搬权重\u0026quot;抵消（第 6 节）。 5.2 KV cache 管理 #目标 KV：验证前向算整棵树 → 只保留接受路径，其余丢弃 草稿 KV：草稿模型自己的 KV（独立维护；EAGLE 用特征缓存） 量化 KV：KV8/KV4（量化系列 08 章）→ 省显存，配合推测可支撑更长序列 前缀缓存：多个请求共享前缀时复用 KV（与推测正交，可叠加） 一个容易踩的坑：接受路径的 hidden state / 特征必须保存（04 章），否则下一轮草稿要重跑目标前向，推测收益直接蒸发。\n5.3 与量化方案的兼容矩阵 # 量化位宽 与推测组合的注意点 W8A8 / FP8 无损推测照常；验证树 FLOPs 增大的部分也享受 FP8 加速 W4A16 decode 带宽减半，收益最大；注意草稿也要量化（§3.2） W4A8KV4 KV 省显存换长上下文/大 batch；KV 误差与典型验收误差叠加，需验收（第 7 节） 6. 吞吐 vs 延迟权衡 #batch=1（本地/交互）： decode 带宽远未饱和，推测的\u0026#34;一步多产出\u0026#34;几乎全额变现 → Medusa/EAGLE 论文的 2.2-3.6x 都在这类设置下测出 高 batch（在线服务）： 验证前向一次处理大量请求，权重搬移成本被摊薄 推测的步数收益仍在，但验证树增加的 FLOPs 可能撞上算力上限 → 收益存在但通常低于 batch=1 的论文数字 吞吐优化的三条杠杆，按性价比排序：\n1. 连续批处理 + 前缀缓存（零风险、收益大） 2. 量化（每步成本直接减半） 3. 推测解码（步数减少；batch 越大边际收益越小） 7. 验收协议 #推测解码是无损优化，量化是有损优化——验收必须分别设计，再组合验证。\n7.1 无损性验证（推测专属） # 解码模式 验收标准 贪心 与 vanilla 贪心输出逐 token 完全一致（同 seed、同实现）；不一致即 bug 或近似验收 采样 固定 seed 下，推测开/关的经验分布不可区分：比较 n-gram 分布、统计量或做分布检验 注意：Medusa 的默认典型验收（typical acceptance）、以及跳过验证直接采用检索续写的 PLD 实现，都不是严格无损——验收文档里要明确标注\u0026quot;近似模式\u0026quot;，别把近似当无损宣传。\n7.2 质量评测（量化 + 近似验收共用） #沿用量化系列 10 章方法论：\nperplexity：最快，但只反映\u0026#34;分布像不像\u0026#34; 任务 benchmark：MMLU / HumanEval / GSM8K / MT-Bench，分数差在噪声内 定制评测：接你的业务数据，测端到端效果 阈值：与基线差的置信区间包含 0，才允许上线 7.3 性能验收 #不要只报一个加速比。完整指标集：\n指标 含义 怎么测 $\\alpha$ 草稿质量（草稿侧） 链式草稿的接受率 $\\tau$ / $E[N]$ 每轮真实产出（验证侧） 直接统计每轮 token 数 $c$ 目标/草稿速度比 分别测 $T_p$、$T_q$（量化后再测） speedup 墙钟加速 同硬件、同引擎、同负载 TTFT / TPS / P99 用户体感 端到端压测 负载矩阵：短/长 prompt × 对话/代码/摘要 × batch 1/N。P99 尤其重要——推测的随机接受会让尾部延迟抖动。\n7.4 组合验收矩阵 # BF16 W4A16 vanilla (基线) 质量+性能 EAGLE 无损+性能 质量+性能 ← 上线候选 Medusa 近似+性能 近似+性能 ← 需重点评估质量 PLD 无损+性能 无损+性能 ← 零成本插件 每个格子单独测质量与性能；两个有损近似（量化误差 × 典型验收误差）可能复合，不能只测单因子。\n8. 数值算例：组合收益 #场景：LLaMA2-Chat 70B，BF16 基线 $T_p = 100$ms/token，EAGLE 草稿 $T_q = 8$ms/token（$c = 12.5$），实测 $\\alpha$ 剖面下 $E[N] = 3.4$，$K = 5$。\n只推测：\n$$ \\text{speedup} = \\frac{3.4 \\times 12.5}{12.5 + 5} = 2.43\\text{x} $$推测 + W4A16（$q_t = 2$，草稿也量化 $q_d = 2$）：\n$$ \\text{speedup} = \\frac{3.4 \\times 100/2}{100/2 + 5 \\times 8/2} = \\frac{170}{70} = 2.43\\text{x} \\ (\\text{组件内}) \\quad \\Rightarrow \\text{总加速} = 2.43 \\times 2 = 4.86\\text{x} $$每 token 从 100ms 降到约 20.6ms。若只量化目标（$q_d = 1$）：\n$$ \\text{speedup} = \\frac{3.4 \\times 50}{50 + 40} = 1.89\\text{x} \\ \\Rightarrow \\text{总加速} = 1.89 \\times 2 = 3.78\\text{x} $$草稿不量化损失约 22% 的端到端收益——这就是\u0026quot;量化要连草稿一起做\u0026quot;的量化证据。\n9. 决策树：什么时候上什么 #质量零容忍（医疗/金融/法务）： → 只上严格无损推测（EAGLE 拒绝采样 / PLD）+ 可选 KV 量化 → 权重量化必须过 7.2 节全套质量关 单用户低延迟（本地/交互，batch≈1）： → EAGLE/Medusa + 树 + W4A16（草稿一起量化）→ 收益最大 高吞吐在线服务： → 前缀缓存 + 连续批处理 + 分块预填充（先上零风险项） → 量化 → 推测（batch 大时按实测收益决定是否保留） 任务重复性强（摘要/代码/翻译）： → 免费叠加 PLD 作为附加通道 显存受限（长上下文/大 batch）： → KV 量化优先；推测次之（省显存不是推测的强项） 10. 实现细节与坑 # 用错基线：拿 HuggingFace eager 当基线测出的加速比虚高；必须与生产引擎同配置对比。 只报 $\\alpha$ 不报 $\\tau/E[N]$：$\\alpha$ 高但草稿慢，照样不加速；每轮产出才是验证侧真相。 草稿不量化：草稿开销占比上升，端到端收益掉 20%+（第 8 节）。 两个近似叠加要分别验收：量化误差 × 典型验收误差可能复合放大；组合矩阵必须逐个测。 只测一种负载：prompt 长度、任务类型、batch 数都影响收益；按负载矩阵测。 忽略 P99：推测的随机性让尾部延迟抖动，长尾用户体感会差。 无损验证偷懒：贪心模式下输出不一致就是 bug；采样模式要做分布检验，不能只看\u0026quot;长得像\u0026quot;。 树参数不调：03 章 64 节点结论、02 章 $K^*$ 表格——上线前在目标负载上重新扫一遍。 长序列下 $T_p$ 变贵：验证前向处理 $L+K$ 个位置，$L$ 很大时 $K$ 要相应调小。 11. 本章小结与系列收尾 # 双因子模型：总墙钟 = 每步成本 × 步数；量化与推测正交，都做时乘积近似成立。 交互项：草稿也要量化，否则推测收益被稀释；KV 量化省显存换长上下文/大 batch。 TTFT vs TPS：TTFT 靠量化 + 分块预填充，推测只救 TPS。 验收协议：无损性（贪心逐 token 一致 / 采样分布检验）+ 质量（perplexity/benchmark/定制）+ 性能（$\\alpha$/$\\tau$/c/speedup/P99）+ 组合矩阵。 决策树：质量零容忍 → 无损推测；batch=1 → 推测+量化全上；高吞吐 → 缓存/批处理/量化优先；重复任务 → 叠加 PLD（无训练成本）。 系列收尾：00–06 一句话记忆 #00 地图：量化改\u0026#34;每步成本\u0026#34;，推测改\u0026#34;步数\u0026#34;，两条主线正交 01 公式：E[N] = (1−α^{K+1})/(1−α)，α = 1 − TV(p,q) 02 原始：小模型猜 K 步，大模型一次审，拒绝采样保证严格无损 03 Medusa：多头 + 树，\u0026#34;猜得准\u0026#34;升级为\u0026#34;覆盖得全\u0026#34;；典型验收≈近似 04 EAGLE：特征级自回归，第一个草稿恒接受，70B 2.7–3.5x 05 n-gram：翻自己/翻轨迹/翻语料，重复率决定盈亏 06 集成：每步成本 × 步数，量化与推测一起上，验收分三关 一句话记忆（全系列）：\u0026ldquo;让每一步更便宜（量化），让需要的步数更少（推测）；猜的方式从外部模型一路进化到特征空间与文本记忆——最后用一份验收协议把它们拧在一起。\u0026rdquo;\n12. 习题与解答 #题 1（推导）：组合模型 #证明：当 $q_t = q_d = q$ 时，组合加速比 = $q \\times \\text{speedup}_{\\text{spec}}$；当 $q_d = 1$ 时，组合加速比 \u0026lt; $q \\times \\text{speedup}_{\\text{spec}}$（$K \u003e 0$ 时严格小于）。\n题 1 解答 $q_t=q_d=q$：$\\text{speedup} = \\frac{E\\cdot T_p/q}{T_p/q + K T_q/q} = \\frac{E\\cdot T_p}{T_p + K T_q} = \\text{speedup}_{\\text{spec}}$，再乘 $q$ 得 $q\\times\\text{speedup}_{\\text{spec}}$。$q_d=1$：分母 $\\frac{T_p}{q} + K T_q$ 比 $\\frac{T_p + K T_q}{q}$ 大（因为 $\\frac{T_p}{q} + K T_q \u003e \\frac{T_p}{q} + \\frac{K T_q}{q}$ 当 $q\u003e1$），故组件内加速比 \u0026lt; $\\text{speedup}_{\\text{spec}}$。\n题 2（计算）：四场景表 #$T_p=10$ms、$T_q=1$ms、$K=4$、$\\alpha=0.8$：重算第 3 节四行表格，并给出\u0026quot;只量化目标但把草稿也换快（$q_d=1.5$）\u0026ldquo;这一行的结果。\n题 2 解答 基线 10.0ms/token；只推测 14/3.36=4.17ms → 2.40x；都量化 7/3.36=2.08ms → 4.80x；只量化目标 9/3.36=2.68ms → 3.73x；只量化草稿 12/3.36=3.57ms → 2.80x。$q_t=2,q_d=1.5$：每轮 $(10/2 + 4\\times 1/1.5) = 5+2.67=7.67$ms → 2.28ms/token → 4.38x，介于\u0026quot;只量化目标\u0026quot;与\u0026quot;都量化\u0026quot;之间。\n题 3（设计）：验收清单 #给一个\u0026quot;把 EAGLE + W4A16KV4 组合上线的验收清单\u0026rdquo;（不少于 8 项，覆盖无损性、质量、性能、组合）。\n题 3 解答要点 ① 贪心逐 token 一致性（EAGLE 开/关）；② 采样分布检验（固定 seed，n-gram 统计不可区分）；③ MT-Bench/HumanEval/GSM8K 分数差在噪声内；④ 业务定制评测；⑤ $\\alpha$、$\\tau$、$c$（量化后重测）；⑥ TTFT/TPS/P99（短/长 prompt、batch 1/N）；⑦ KV 量化对长序列质量的影响；⑧ 组合矩阵 {BF16,W4A16} × {vanilla,EAGLE} 四格全测；⑨ 回归门禁：质量差置信区间含 0、P99 不劣化。\n题 4（思考）：TTFT 为什么不吃推测收益 #解释推测解码为什么对 TTFT 几乎无效，并列出三种真正改善 TTFT 的手段；指出哪种手段在\u0026quot;多请求排队\u0026quot;场景下最关键。\n题 4 解答要点 TTFT 由 prefill（处理用户全部输入）决定，此时还没有可验证的草稿 token。改善手段：① 量化（prefill compute-bound，FP8 翻倍 FLOPS）；② 分块预填充（把长 prefill 切片，减少队头阻塞）；③ 前缀缓存（共享前缀只算一次）。排队场景下分块预填充最关键——它直接降低高并发下的 TTFT 方差。\n题 5（设计）：四类业务的选型 #为以下四个场景各给一个技术组合并说明理由：① 医疗问诊（质量零容忍、batch=1）；② 代码补全 SaaS（延迟敏感、重复性强）；③ 客服机器人（高吞吐、长上下文）；④ 端侧 8GB 显存跑 7B 模型。\n题 5 解答要点 ① 严格无损推测（EAGLE 拒绝采样）+ 可选 KV 量化，权重量化需全套质量关；② PLD 免费叠加 + EAGLE/Medusa + 量化，代码重复率让 n-gram 命中率高；③ 前缀缓存 + 连续批处理 + 分块预填充 + 量化为主，推测按实测收益决定；④ KV 量化优先（显存换上下文）+ W4A16 + 轻量推测（草稿也要量化），注意 batch=1 下推测收益最大。\n题 6（编程）：组合收益敏感性分析 #写一个脚本：输入 $(\\alpha, K, c, q_t, q_d)$，输出 $E[N]$、组件内加速比、总加速比；扫 $\\alpha \\in \\{0.6, 0.7, 0.8, 0.9\\}$、$q_d \\in \\{1, 1.5, 2\\}$ 画表，回答\u0026quot;什么时候草稿量化最值钱\u0026quot;。\n题 6 解答要点 总加速比（相对未量化、未推测基线，无量纲）$= \\frac{E[N]}{1/q_t + K/(c\\cdot q_d)}$，由 $\\text{speedup} = \\frac{E\\cdot T_p/q_t}{T_p/q_t + K\\cdot T_q/q_d}$ 上下同除 $T_p$ 得到。扫表会发现：$\\alpha$ 高（$E[N]$ 大）时草稿开销占比高，$q_d$ 的边际收益更大——草稿量化在\u0026quot;推测收益高\u0026quot;时最值钱；$\\alpha$ 低时推测本身就不划算，先解决草稿质量再谈量化。\n13. 延伸阅读 # vLLM 推测解码文档（Speculative Decoding）：[ngram]、EAGLE、Medusa 的工程集成与参数。 TensorRT-LLM In-flight Batching 与 Speculative Decoding 文档：生产级组合实现。 量化系列 10 章（质量评估方法论）：本章质量验收的方法论基础。 Sequoia（arXiv:2402.12374）：面向推测解码的树结构缩放理论，进一步学习起点。 Hydra（arXiv:2402.18904） / DistillSpec（arXiv:2310.03701）：多分支草稿与蒸馏草稿，推测解码的延伸方向。 CREST（arXiv:2408.04678）：REST 的 datastore 压缩改进。 上一篇： 05 n-gram/检索式与无模型路线。本系列完结。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%8E%A8%E6%B5%8B%E8%A7%A3%E7%A0%81%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-06-%E7%B3%BB%E7%BB%9F%E9%9B%86%E6%88%90%E4%B8%8E%E7%94%9F%E4%BA%A7%E9%AA%8C%E6%94%B6/","section":"笔记","summary":"用「每步成本 × 步数」的双因子模型解释量化和推测叠加时收益为什么会被稀释，拆解 TTFT 与 TPS 各自吃哪类优化，给出一份包含无损性验证、质量评测、性能指标与组合矩阵的生产验收协议，并列出集成时最常见的坑。","title":"推测解码上线怎么验收？接受率与加速比怎么测"},{"content":"Answer #Medusa’s extra heads look only at the current hidden state and guess several future tokens in parallel. They never see which token was actually sampled in between, so they average over branches. The Chinese note puts that acceptance ceiling near 0.6.\nEAGLE drafts the next feature, not the next token, and concatenates the token just sampled (a shifted-token input). The regression target becomes unique, acceptance goes up, and the first draft token in a round is accepted with probability 1. EAGLE-2 then grows the draft tree from context instead of a static shape. The same chapter notes that vLLM already integrates EAGLE, including an EAGLE-2-style dynamic tree.\nWhat this page is not #No new tokens/s table. The 0.6 figure and the “first token is always accepted” claim are the chapter’s reading of the papers.\n","date":null,"permalink":"https://doraemeng.dev/en/eagle/","section":"页面","summary":"Medusa guesses future tokens from the current hidden state and tops out near 0.6 acceptance. EAGLE drafts in feature space and feeds the token just sampled, so the regression target is unique.","title":"Why is EAGLE faster than Medusa?"},{"content":"Answer #Use AWQ as the default for production W4A16 when you want a short calibration and you do not want a reconstruction loop. Keep GPTQ if the pipeline already emits it, or if you are pushing toward 3-bit and AWQ is the less stable of the two. At 2-bit, the Chinese note says both fall over and you look at methods like QuIP#.\nGPTQ admits the quantization error and spreads it onto columns that are not quantized yet, using the inverse Hessian. That rebuild is why a 175B run is described as hours, not seconds. AWQ leaves the stored weights alone and scales channels by activation magnitude. The diagnostic in the note: on OPT-13B INT3-g128, keeping about 1% of channels in FP16 by activation size returns WikiText-2 perplexity from 46.04 to 10.51 (FP16 baseline 10.13); picking those channels by weight size does not.\nWhat it does not decide #Neither method quantizes activations or the KV cache. GGUF is a file format for llama.cpp, not a third algorithm in this pair. Which engine can run the file is a separate choice.\n","date":null,"permalink":"https://doraemeng.dev/en/awq-vs-gptq/","section":"页面","summary":"Both are 4-bit weight-only methods. GPTQ repairs error with a Hessian and a rebuild. AWQ rescales the few channels that activations hit, and does not rewrite the weights.","title":"AWQ or GPTQ for 4-bit weights?"},{"content":" 系列定位：继 量化精读笔记（每一步的数值/带宽）与 推测解码精读笔记（需要的步数）之后的第三部 MIT lecture note 级别推理优化精读。本系列进入\u0026quot;单步前向内部\u0026quot;：注意力机制与底层计算内核。 格式与之前一致：形式化定义 → 数学推导 → 伪代码/算法 → 数值算例 → 直觉解释 → 习题（含答案）→ 延伸阅读；公式使用 Markdown + LaTeX（$...$ / $$...$$）。\n1. 系列结构与来源映射 # 章节 文件 核心内容 对应来源 00 本文件 学习地图、符号约定、与另两个系列的关系 — 01 注意力计算复杂度是怎么来的？prefill 和 decode 差在哪 softmax attention 定义、O(L²) 复杂度、因果掩码、KV cache 角色、prefill/decode 形态 Vaswani et al. 2017；Inference Engineering Ch5 02 FlashAttention 原理是什么？为什么又省显存又快 online softmax、tiling、重计算、FA2/FA3、为什么\u0026quot;算更多反而更快\u0026quot; FlashAttention（arXiv:2205.14135；2307.08691；2407.08608） 03 MQA、GQA、MLA 有什么区别？KV Cache 该怎么省 KV 头共享、低秩压缩、DeepSeek MLA、显存与质量权衡 GQA（arXiv:2305.13245）；DeepSeek-V2（arXiv:2405.04434） 04 稀疏注意力、滑动窗口和线性注意力怎么选 StreamingLLM / Attention Sink、滑动窗口、H2O、线性注意力、SSM/Mamba StreamingLLM（arXiv:2309.17453）；Mamba（arXiv:2312.00752） 05 PagedAttention 是怎么省下 KV Cache 显存的？ 分页 KV、vLLM 块管理、与连续批处理/前缀缓存组合 PagedAttention / vLLM（arXiv:2309.06180） 06 注意力内核怎么优化？算子融合、CUDA Graph 与 Triton 访存-计算模型、算子融合、Tensor Core、FA 的 kernel 细节、FP8 注意力、编译优化 FlashAttention 系列；工程实践 07 注意力优化上线怎么验收？吞吐、显存与精度怎么测 与量化/推测解码/调度组合、注意力精度验收、决策树 vLLM/SGLang/TensorRT-LLM 实践 08 SGLang RadixAttention 原理是什么？前缀缓存怎么提升命中率 跨请求 KV 复用、radix tree、cache-aware 调度、KV 存储层级、路由、disaggregation RadixAttention / SGLang（arXiv:2312.07104）；Inference Engineering Ch5 2. 三部系列的关系：一张总表 # LLM 推理优化 ┌──────────────┼──────────────────┐ 每步成本 需要的步数 单步内部 │ │ │ 量化（已写完） 推测解码（已写完） 注意力与内核（本系列） 数值/带宽 步数/草稿 计算路径/显存 互补性：\n量化：让\u0026#34;一次搬移/一次运算\u0026#34;更便宜（带宽减半、FLOPS 翻倍） 推测：让\u0026#34;需要的步数\u0026#34;更少（一次验证多步） 注意力内核：让\u0026#34;单步前向里最贵的部分\u0026#34;更高效（O(L²) 注意力与 KV 显存） 三者乘法叠加：每步成本 × 步数 × 每步内部效率 = 端到端收益 决策框架（衔接之前系列）：\n1. 先看注意力：长上下文时它是最贵的（01 章 L/(2d) 判据） 2. 再看步数：推测解码无损提步数（已写完） 3. 最后看数值：量化兜底（已写完） 3. 符号约定（全系列通用，新增） # 符号 含义 $L$ 序列长度 $d$ / $d_{\\text{model}}$ 隐藏维度 $h$ 注意力头数 $d_{\\text{head}}$ 每头维度（$d_{\\text{head}} = d/h$） $n_{\\text{kv}}$ KV 头数（MQA 为 1，GQA 取中间值） $d_{\\text{kv}}$ KV 总维度（$n_{\\text{kv}} \\times d_{\\text{head}}$） $\\mathbf{Q}, \\mathbf{K}, \\mathbf{V}$ 查询/键/值矩阵（$L \\times d_{\\text{head}}$） $M$ 片上 SRAM 容量（FlashAttention 的预算） $B_c, B_r$ FlashAttention 的块大小（列/行） $\\text{KV bytes}$ KV cache 每 token 字节数 沿用：$T_p$（目标每 token 时间）、$\\alpha$（接受率）、$c$（速度比）、W4A8KV4 等记法。\n4. 阅读顺序 #[01 注意力基础与复杂度](/notes/llm注意力内核精读笔记-01-注意力机制基础与复杂度分析/)（为什么 O(L²)、KV cache 从哪来） → [02 FlashAttention](/notes/llm注意力内核精读笔记-02-flashattention-io感知的精确注意力/)（prefill 侧：怎么把 L² 算得快且省显存） → [03 MQA/GQA/MLA](/notes/llm注意力内核精读笔记-03-注意力头变体-mqa-gqa-mla/)（decode 侧：怎么把 KV 显存砍下来） → [04 稀疏/线性注意力](/notes/llm注意力内核精读笔记-04-稀疏滑动窗口与线性注意力/)（长上下文：怎么跳过 L²） → [05 PagedAttention](/notes/llm注意力内核精读笔记-05-pagedattention与kv显存管理/)（系统侧：KV 显存怎么分页管理） → [06 内核优化](/notes/llm注意力内核精读笔记-06-内核优化与算子融合/)（硬件侧：算子融合与 Tensor Core） → [07 系统集成与验收](/notes/llm注意力内核精读笔记-07-系统集成与生产验收/)（怎么组合、怎么验收） → [08 前缀缓存与 KV 复用](/notes/llm注意力内核精读笔记-08-前缀缓存与kv复用/)（跨请求的 KV 别重算、往哪存、怎么路由） 5. 配套资源 # 资源 用途 Attention Is All You Need（arXiv:1706.03762） 缩放点积注意力的原始定义 FlashAttention（arXiv:2205.14135） / FA2（arXiv:2307.08691） / FA3（arXiv:2407.08608） IO 感知精确注意力 GQA（arXiv:2305.13245） / DeepSeek-V2 MLA（arXiv:2405.04434） KV 头共享与压缩 StreamingLLM（arXiv:2309.17453） / Mamba（arXiv:2312.00752） 长上下文与次二次方法 PagedAttention / vLLM（arXiv:2309.06180） KV 分页与系统集成 SGLang / RadixAttention（arXiv:2312.07104） 前缀缓存与 KV 复用的系统实现 Inference Engineering Ch5 教材正文（Attention 与系统部分） ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-00-%E6%80%BB%E8%A7%88%E4%B8%8E%E5%AD%A6%E4%B9%A0%E5%9C%B0%E5%9B%BE/","section":"笔记","summary":"继量化与推测解码之后的第三部推理优化精读，进入单步前向内部：注意力复杂度、FlashAttention、MQA/GQA/MLA、稀疏与线性注意力、PagedAttention、算子融合、生产验收与 RadixAttention 前缀缓存。","title":"LLM 注意力与计算内核：8 篇精读笔记总览"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜下一篇： FlashAttention 原理是什么\n对应：Vaswani et al., Attention Is All You Need（2017）；Inference Engineering Ch5 的 Attention 部分。 前置：量化系列 03 章（带宽模型）、推测解码系列 01 章（解码过程）。学完本章你应该能：① 写出缩放点积注意力的完整定义并解释 $\\sqrt{d_{\\text{head}}}$ 的作用；② 推导注意力的 FLOPs 公式 $4L^2 d$，并说明为什么与头数无关；③ 用 $L/(2d)$ 判据判断\u0026quot;长到什么程度注意力反超 FFN\u0026quot;；④ 推导 KV cache 的大小公式，手算 7B 模型 128K 上下文的显存；⑤ 说清 prefill 与 decode 两种注意力形态（计算密集 vs 访存密集）；⑥ 解释 softmax 为什么要做 max-subtraction，以及低精度下的风险。\n目录（本章） # 本章目标 注意力的位置：Transformer 里唯一的 token 交互通道 形式化定义：缩放点积注意力 复杂度分析：O(L²) 从哪来 因果掩码与 KV Cache Prefill 与 Decode：两种形态 数值稳定性：max-subtraction 与低精度 数值算例 本章小结 习题与解答 延伸阅读 2. 注意力的位置：Transformer 里唯一的 token 交互通道 #Transformer 的每一层由两类子层组成：\ntoken-wise 子层（MLP、LayerNorm、激活）：每个 token 独立处理，互不通信 注意力子层：唯一让 token 之间交换信息的通道 由此得到两个事实：\n序列长度 $L$ 只会让注意力变贵：MLP 的 FLOPs 对 $L$ 是线性的，注意力的 FLOPs 是 $L^2$——长上下文的计算瓶颈一定先在注意力出现； token 的\u0026quot;记忆\u0026quot;都压在注意力上：第 $t$ 个 token 要知道前面的任何信息，只能通过注意力去\u0026quot;看\u0026quot;前面 token 的表示。KV cache 之所以存在，正是为了省掉 decode 阶段重复计算这些\u0026quot;看\u0026quot;的键值。 3. 形式化定义：缩放点积注意力 #给定输入序列的表示矩阵，先通过三个投影得到查询、键、值：\n$$ \\mathbf{Q} = X W_Q, \\qquad \\mathbf{K} = X W_K, \\qquad \\mathbf{V} = X W_V $$缩放点积注意力：\n$$ \\mathrm{Att}(\\mathbf{Q}, \\mathbf{K}, \\mathbf{V}) = \\mathrm{softmax}\\!\\left(\\frac{\\mathbf{Q}\\mathbf{K}^\\top}{\\sqrt{d_{\\text{head}}}}\\right)\\mathbf{V} $$其中 $\\mathbf{Q}, \\mathbf{K} \\in \\mathbb{R}^{L \\times d_{\\text{head}}}$、$\\mathbf{V} \\in \\mathbb{R}^{L \\times d_{\\text{head}}}$。逐位置写法：位置 $i$ 的输出是所有位置的值的加权平均，\n$$ o_i = \\sum_{j=1}^{L} a_{ij}\\, v_j, \\qquad a_{ij} = \\frac{\\exp(s_{ij})}{\\sum_{j'} \\exp(s_{ij'})}, \\qquad s_{ij} = \\frac{q_i \\cdot k_j}{\\sqrt{d_{\\text{head}}}} $$3.1 为什么要除以 $\\sqrt{d_{\\text{head}}}$ #假设 $q, k$ 的各分量独立同分布、均值 0 方差 1，则点积的方差等于维度：\n$$ \\mathrm{Var}(q \\cdot k) = d_{\\text{head}} $$除以 $\\sqrt{d_{\\text{head}}}$ 后方差回到 1。若不缩放，维度越大点积数值越极端，softmax 越容易饱和（一个接近 1，其余接近 0），梯度消失。缩放是让注意力\u0026quot;温度\u0026quot;与维度无关。\n4. 复杂度分析：O(L²) 从哪来 #4.1 FLOPs 推导 #标准实现（不缓存、不掩码优化）分三步：\n$$ \\mathbf{S} = \\mathbf{Q}\\mathbf{K}^\\top / \\sqrt{d_{\\text{head}}}, \\qquad \\mathbf{P} = \\mathrm{softmax}(\\mathbf{S}), \\qquad \\mathbf{O} = \\mathbf{P}\\mathbf{V} $$FLOPs：\nQK^T：L×d_head 与 d_head×L 相乘 → 2L²·d_head softmax：L×L 行归一化 → O(L²)，常数项可忽略 PV：L×L 与 L×d_head 相乘 → 2L²·d_head 合计（每头）：≈ 4L²·d_head 全部 $h$ 头加起来：\n$$ \\text{FLOPs}_{\\text{attn}} = h \\times 4L^2 d_{\\text{head}} = 4L^2 (h\\, d_{\\text{head}}) = 4L^2 d $$结论：注意力 FLOPs 只依赖 $L$ 和 $d$，与切成多少个头无关（$h\\,d_{\\text{head}} = d$ 是不变量）。切头不改变总 FLOPs；它影响的是并行方式和表示能力。\n4.2 与 FFN 的比值：长上下文判据 #每层 FFN（两段线性，中间扩到 $4d$）的 FLOPs：\n$$ \\text{FLOPs}_{\\text{FFN}} = 8L\\,d^2 $$（每个 token 两段各 $2 \\times d \\times 4d = 8d^2$ FLOPs，共 $L$ 个 token。）于是：\n$$ \\frac{\\text{FLOPs}_{\\text{attn}}}{\\text{FLOPs}_{\\text{FFN}}} = \\frac{4L^2 d}{8L d^2} = \\frac{L}{2d} $$判据：$L = 2d$ 时两者相等；$L \u003e 2d$ 时注意力反超 FFN，成为 prefill 的主要计算。 例如 $d = 4096$ 的 7B 级模型：$L = 8192$ 持平，$L = 32K$ 时注意力是 FFN 的 4 倍。这解释了为什么长上下文优化先动注意力（02–04 章）。\n5. 因果掩码与 KV Cache #5.1 因果掩码 #自回归模型只允许位置 $i$ 看 $j \\le i$。实现上把注意力分数加上掩码矩阵：\n$$ \\mathbf{S} \\leftarrow \\mathbf{S} + \\mathbf{M}, \\qquad M_{ij} = \\begin{cases} 0 \u0026 j \\le i \\\\ -\\infty \u0026 j \u003e i \\end{cases} $$注意：naive 实现先算完整的 $L \\times L$ 再掩码，上三角的 FLOPs 是白花的（约占一半）；02 章 FlashAttention 用因果块只算下三角。\n5.2 KV Cache：decode 为什么能省一半计算 #解码第 $t$ 步时，注意力需要：\n$$ q_t \\quad \\text{与所有历史} \\quad (k_1, v_1), \\dots, (k_{t-1}, v_{t-1}) $$关键观察：$k_j, v_j$ 只依赖 $x_1..x_j$，与未来的 query 无关——所以算过一次就缓存，decode 时直接读取，不用重新前向。这就是 KV cache。\n每步新算 $k_t, v_t$ 并追加进缓存。缓存大小：\n$$ \\text{KV bytes} = 2 \\times L \\times n_{\\text{layers}} \\times d_{\\text{kv}} \\times b $$其中因子 2 是 K 和 V 各一份，$b$ 是精度字节数（BF16 为 2）。\n5.3 算例：7B 模型的 KV 显存 #配置：$d = 4096$、32 层、$d_{\\text{kv}} = 4096$（无 GQA）、BF16。\n$$ \\text{每 token} = 2 \\times 4096 \\times 2 \\times 32 = 524{,}288\\ \\text{B} = 512\\ \\text{KB} $$ 上下文长度 KV cache 总量 相对 7B 权重（约 13GB BF16） 4K 2 GiB 15% 32K 16 GiB 1.2 倍 128K 64 GiB 5 倍 结论：KV cache 是\u0026quot;上下文越长越贵\u0026quot;的显存项，这正是 03 章 MQA/GQA/MLA 和 05 章 PagedAttention 要解决的问题。\n6. Prefill 与 Decode：两种形态 #同一个注意力，在两个阶段呈现完全不同的计算形态：\nPrefill（处理用户输入） Decode（逐 token 生成） 一次处理的 token 数 $L$（整段输入） 1（新 query） 注意力矩阵 $L \\times L$ $1 \\times L$ 计算量 $O(L^2)$，计算密集 $O(L)$ 次乘加，但要读全部 KV 瓶颈 计算（FLOPs） 带宽（KV 读取 + 权重读取） 优化主力 FlashAttention（02 章） GQA/MLA（03 章）+ 分页（05 章） decode 每步要读的 KV 字节数：\n$$ \\text{每步 KV 读取} = 2 \\times L \\times n_{\\text{layers}} \\times d_{\\text{kv}} \\times b $$7B 模型算例：4K 上下文时每步读 $2 \\times 4096 \\times 32 \\times 4096 \\times 2 = 2\\ \\text{GiB}$（约 1ms @ 2TB/s），与权重读取（13GB，约 6.5ms）相比约 15%；32K 上下文时每步读 16 GiB，超过权重读取——长上下文 decode 的带宽瓶颈从\u0026quot;权重\u0026quot;转移到了\u0026quot;KV\u0026quot;。\n7. 数值稳定性：max-subtraction 与低精度 #7.1 朴素 softmax 的溢出问题 #$\\exp(x)$ 在 $x$ 稍大时就溢出（FP16 最大约 65504，对应 $x \\approx 11$）。数值稳定写法：\n$$ \\mathrm{softmax}(s)_i = \\frac{\\exp(s_i - m)}{\\sum_j \\exp(s_j - m)}, \\qquad m = \\max_j s_j $$减去行最大值后，指数里最大是 0，不会溢出。02 章 FlashAttention 的 online softmax 就是这个技巧的\u0026quot;分块版\u0026quot;。\n7.2 低精度下的风险 #BF16：动态范围大，softmax 数值安全，但精度低（尾数 8 位） FP16：动态范围小，softmax 容易溢出，需要 max-subtraction 和钳制 FP8：尾数更少（E4M3），注意力分数与概率的量化误差放大 经验：注意力（尤其 softmax 区域）是量化最敏感的地方之一（量化系列 08 章的结论）。低精度注意力必须做数值与质量双重验收（07 章展开）。\n8. 数值算例 #$L = 3$、$d_{\\text{head}} = 2$：\n$$ \\mathbf{Q} = \\begin{pmatrix} 1 \u0026 0 \\\\ 0 \u0026 1 \\\\ 1 \u0026 1 \\end{pmatrix}, \\quad \\mathbf{K} = \\begin{pmatrix} 1 \u0026 1 \\\\ 0 \u0026 1 \\\\ 1 \u0026 0 \\end{pmatrix}, \\quad \\mathbf{V} = \\begin{pmatrix} 1 \u0026 0 \\\\ 0 \u0026 1 \\\\ 1 \u0026 1 \\end{pmatrix}, \\quad \\sqrt{d_{\\text{head}}} = \\sqrt{2} $$以第 3 个 query $q_3 = (1,1)$ 为例：\n$$ s = \\frac{q_3 \\cdot k_j}{\\sqrt{2}} = \\left(\\frac{2}{\\sqrt2}, \\frac{1}{\\sqrt2}, \\frac{1}{\\sqrt2}\\right) = (1.414, 0.707, 0.707) $$max-subtraction：$m = 1.414$，\n$$ s - m = (0,\\ -0.707,\\ -0.707), \\qquad \\exp = (1,\\ 0.493,\\ 0.493), \\qquad \\text{sum} = 1.986 $$$$ a_3 = (0.504,\\ 0.248,\\ 0.248) $$输出：\n$$ o_3 = 0.504 \\cdot (1,0) + 0.248 \\cdot (0,1) + 0.248 \\cdot (1,1) = (0.752,\\ 0.497) $$验证：位置 3 与位置 1 的相似度（$q_3 \\cdot k_1 = 2$）最高，所以 $v_1 = (1,0)$ 在输出里占比最大（0.504）——注意力是\u0026quot;按相关性加权求和\u0026quot;。\n完整三行输出（留给读者核对习题 2）：\n$$ o_1 \\approx (0.802,\\ 0.599), \\qquad o_2 \\approx (0.599,\\ 0.599), \\qquad o_3 \\approx (0.752,\\ 0.497) $$ 9. 本章小结 # 注意力是唯一 $O(L^2)$ 的组件：FLOPs $= 4L^2d$，与头数无关；$L/(2d)$ 判据决定它何时反超 FFN。 KV cache 来自\u0026quot;键值只依赖历史\u0026quot;：大小 $= 2Ln_{\\text{layers}}d_{\\text{kv}}b$，7B 模型 128K 上下文约 64 GiB。 prefill 计算密集、decode 访存密集：长上下文时 decode 的带宽瓶颈从权重转移到 KV。 softmax 需要 max-subtraction；低精度下注意力是质量风险最高的区域之一。 一句话记忆：\u0026ldquo;注意力是 Transformer 里唯一会让 token 互相看的地方，也是唯一随序列长度平方变贵的地方——KV cache 是 decode 的账本，$L^2$ 是 prefill 的账单。\u0026rdquo;\n10. 习题与解答 #题 1（推导）：FLOPs 与头数无关 #从每头 $4L^2 d_{\\text{head}}$ 出发，推导多头注意力总 FLOPs $= 4L^2 d$，并说明为什么切头不省算力。\n题 1 解答 多头 = $h$ 个独立的 $d_{\\text{head}}$ 维注意力并行，总 FLOPs $= h \\times 4L^2 d_{\\text{head}} = 4L^2 (h d_{\\text{head}}) = 4L^2 d$。$h\\,d_{\\text{head}} = d$ 是投影后的总维度不变式，所以切头只改并行方式，不改 FLOPs。\n题 2（计算）：手算完整一行 #用第 8 节的 $\\mathbf{Q}, \\mathbf{K}, \\mathbf{V}$，完整手算 $o_1$（含 max-subtraction），核对 $o_1 \\approx (0.802, 0.599)$。\n题 2 解答 $q_1=(1,0)$：$s = (1/\\sqrt2,\\ 0,\\ 1/\\sqrt2) = (0.707, 0, 0.707)$；max $= 0.707$；$s-m = (0, -0.707, 0)$（注意第三个位置 $0.707-0.707=0$）；$\\exp = (1, 0.493, 1)$；和 $= 2.493$；$a_1 = (0.401, 0.198, 0.401)$。$o_1 = 0.401(1,0) + 0.198(0,1) + 0.401(1,1) = (0.802, 0.599)$ ✓ 与第 8 节一致。\n题 3（推导）：长上下文判据 #证明注意力与 FFN 的 FLOPs 比为 $L/(2d)$；给定 $d = 8192$，求两者持平的 $L^*$，并说明 $L = 64K$ 时注意力占比。\n题 3 解答 比值 $= 4L^2d / 8Ld^2 = L/(2d)$。$L^* = 2d = 16384$。$L=64K$ 时比值 $= 65536/16384 = 4$，即注意力 FLOPs 是 FFN 的 4 倍、占总计算（attention + FFN）的 $4/5 = 80\\%$。\n题 4（计算）：KV cache 账本 #配置：$d = 5120$、48 层、$d_{\\text{kv}} = 5120$、FP8（1 字节）。求：① 每 token KV 字节数；② $L = 128K$ 的总显存；③ 若改用 GQA 使 $d_{\\text{kv}} = 640$，同样长度下省多少。\n题 4 解答 ① $2 \\times 5120 \\times 48 \\times 1 = 491{,}520\\ \\text{B} = 480\\ \\text{KB/token}$。② $480\\ \\text{KB} \\times 131072 = 60\\ \\text{GiB}$。③ $d_{\\text{kv}}=640$ 时 $2 \\times 640 \\times 48 = 61{,}440\\ \\text{B} = 60\\ \\text{KB/token}$，总量 7.5 GiB——GQA 把 KV 显存降到原来的 1/8（03 章详述）。\n题 5（思考）：为什么 decode 是访存密集 #结合量化系列 03 章的带宽模型，解释 decode 每步\u0026quot;读权重 + 读全部 KV\u0026quot;为什么是瓶颈；长上下文下 KV 读取为何会反超权重读取。\n题 5 解答要点 decode 每步只产出 1 个 token，但必须搬全部权重（固定 13GB）和全部 KV（随 $L$ 线性增长：7B 在 4K 是 2GB、32K 是 16GB）。GPU 的 FLOPs 远用不满，瓶颈在 HBM 带宽。$L$ 增大到 KV 读取 ≥ 权重读取时，优化重点从\u0026quot;省权重带宽\u0026quot;（量化）转向\u0026quot;省 KV 带宽/显存\u0026quot;（GQA、分页、稀疏）。\n题 6（编程）：causal attention 实现 #实现：① naive 全矩阵 + 掩码；② 只算下三角的因果版；③ 数值稳定 softmax（max-subtraction）。验证两种实现在随机输入下输出一致，并统计 $L = 256, 1024, 4096$ 时 FLOPs/显存/时间的增长是否近似 $O(L^2)$。\n题 6 解答要点 ① 先算 $\\mathbf{S}$，加 $\\mathbf{M}$（上三角 $-\\infty$），再 softmax、乘 V。② 循环逐行或块状只算 $j \\le i$。③ 每行减行最大。三者对因果输出一致。计时/显存随 $L$ 增长约 4 倍（$L$ 翻倍）即 $O(L^2)$；到很大 $L$ 时显存先爆——这正是 02 章 FlashAttention 的动机。\n11. 延伸阅读 # Attention Is All You Need（arXiv:1706.03762）：本章公式出处（缩放点积注意力、多头、因果掩码）。 FlashAttention（arXiv:2205.14135）：下一篇的主角——为什么 $O(L^2)$ 的中间矩阵可以不落显存。 量化系列 03 章（数值格式与硬件）：带宽模型与本系列 decode 分析互相印证。 Inference Engineering Ch5：教材正文（Attention 与系统部分）。 下一篇：02 FlashAttention：IO 感知的精确注意力——把 max-subtraction 变成 online softmax，把 $L^2$ 矩阵留在片上。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-01-%E6%B3%A8%E6%84%8F%E5%8A%9B%E6%9C%BA%E5%88%B6%E5%9F%BA%E7%A1%80%E4%B8%8E%E5%A4%8D%E6%9D%82%E5%BA%A6%E5%88%86%E6%9E%90/","section":"笔记","summary":"推导缩放点积注意力的 FLOPs 公式 4L²d 并说明为什么它与头数无关，用 L/(2d) 判据判断多长的上下文注意力会反超 FFN，推导 KV cache 显存公式并手算 7B 模型 128K 上下文的占用，区分计算密集的 prefill 与访存密集的 decode。","title":"注意力计算复杂度是怎么来的？prefill 和 decode 差在哪"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： 注意力计算复杂度是怎么来的｜下一篇： MQA、GQA、MLA 有什么区别\n对应：Dao et al., FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness（arXiv:2205.14135，NeurIPS 2022）；Dao, FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning（arXiv:2307.08691，ICLR 2024）；Shah et al., FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision（arXiv:2407.08608，2024）。 前置：01 章（注意力复杂度、prefill/decode 形态、max-subtraction）。学完本章你应该能：① 说清朴素注意力\u0026quot;快不起来\u0026quot;的真正瓶颈在 HBM 读写；② 写出 FlashAttention 的三个核心技巧（tiling、online softmax、recompute）及各自解决的问题；③ 推导 online softmax 的增量更新公式并手算验证与整体 softmax 一致；④ 复述 IO 复杂度定理（$O(N^2d^2/M)$ vs $\\Omega(Nd+N^2)$）与最优性结论；⑤ 对比 FA1/FA2/FA3 的改进路线与实测数据；⑥ 解释\u0026quot;重计算多花 FLOPs 反而更快\u0026quot;和\u0026quot;FlashAttention 是精确算法\u0026quot;这两个关键论断。\n目录（本章） # 本章目标 01 章的遗留问题：朴素注意力\u0026quot;卡\u0026quot;在哪 IO 复杂度视角：瓶颈是 HBM，不是 FLOPs 技巧一：Tiling（分块） 技巧二：Online Softmax（增量 softmax） 技巧三：Recomputation（反向重算） 算法与定理 数值算例：online softmax 手算 FlashAttention-2：并行与工作划分 FlashAttention-3：Hopper 上的异步与低精度 实验数据汇总 衔接：decode 侧、FP8 注意力与量化系列 本章小结 习题与解答 延伸阅读 2. 01 章的遗留问题：朴素注意力\u0026quot;卡\u0026quot;在哪 #01 章算出注意力 FLOPs $= 4L^2d$、显存 $O(L^2)$。朴素 PyTorch 实现的三步：\n$$ \\mathbf{S} = \\mathbf{Q}\\mathbf{K}^\\top, \\qquad \\mathbf{P} = \\mathrm{softmax}(\\mathbf{S}), \\qquad \\mathbf{O} = \\mathbf{P}\\mathbf{V} $$三个浪费：\n① 显存：S 和 P 都是 N×N 矩阵，必须完整落在 HBM L=128K 时一个 S 就是 32GB（FP16）→ 直接爆显存 ② IO：S 写一次、softmax 读一次、P 写一次、PV 再读一次 每个元素被搬进搬出 HBM 多次 ③ 白算：因果掩码在矩阵算完之后才应用，上三角 FLOPs 全浪费 FlashAttention 的答案：不让 $N \\times N$ 矩阵落地——把它拆成能塞进片上 SRAM 的块，逐块算、逐块合并。难点只有一个：softmax 的归一化依赖整行，怎么分块还算得精确？这就是 online softmax。\n3. IO 复杂度视角：瓶颈是 HBM，不是 FLOPs #现代 GPU 有两层存储：\nHBM（主存）：容量大（几十 GB）、带宽有限（A100 约 2TB/s） SRAM（片上）：容量小（每 SM 192KB）、带宽极高（~19TB/s 量级） 一次 HBM 访问的成本远高于一次浮点运算，墙钟时间因此主要花在 HBM 读写上——这就是\u0026quot;IO 感知\u0026quot;的含义。\n3.1 标准注意力的 HBM 账本 #$$ \\Omega(Nd + N^2) $$解读：读 $\\mathbf{Q},\\mathbf{K},\\mathbf{V}$ 各 $Nd$ 是不可避免的；但 $\\mathbf{S}$ 和 $\\mathbf{P}$ 的写入再读出贡献了 $N^2$ 量级的 HBM 访问（每个元素至少 3–4 次搬移）。\n3.2 FlashAttention 的目标 #$$ O\\!\\left(\\frac{N^2 d^2}{M}\\right) $$其中 $M$ 是 SRAM 容量。当 $M \\gg d^2$ 时，这个系数远小于标准实现的常数。论文实测：典型配置下 HBM 访问最多减少 9 倍（Fig. 2）。\n4. 技巧一：Tiling（分块） #把 $\\mathbf{Q}$ 按行切成 $T_r$ 块、$\\mathbf{K},\\mathbf{V}$ 按行切成 $T_c$ 块：\n$$ \\mathbf{Q}_i \\in \\mathbb{R}^{B_r \\times d}, \\qquad \\mathbf{K}_j, \\mathbf{V}_j \\in \\mathbb{R}^{B_c \\times d} $$每次只把一块 $\\mathbf{Q}_i$、一块 $\\mathbf{K}_j$、一块 $\\mathbf{V}_j$ 和中间的 $\\mathbf{S}_{ij} = \\mathbf{Q}_i \\mathbf{K}_j^\\top$ 放进 SRAM，算完合并到输出后丢弃。$N \\times N$ 的矩阵从头到尾不落 HBM。\n块大小怎么定？SRAM 里同时要放 $\\mathbf{Q}$ 块（$B_r d$）、$\\mathbf{K}$ 块（$B_c d$）、$\\mathbf{V}$ 块（$B_c d$）、$\\mathbf{S}$ 块（$B_r B_c$）四项，所以：\n$$ B_c = \\left\\lceil \\frac{M}{4d} \\right\\rceil, \\qquad B_r = \\min\\left(\\left\\lceil \\frac{M}{4d} \\right\\rceil, d\\right) $$（$\\approx M/4d$ 的直觉：四项各占 $\\approx M/4$。）\n5. 技巧二：Online Softmax（增量 softmax） #分块后，第 $j$ 块的 softmax 归一化依赖\u0026quot;已经看过的 $1..j-1$ 块\u0026quot;，不能独立归一化。解法是维护三个运行量：\n$$ m^{(j)} = \\max \\text{ of scores so far}, \\qquad \\ell^{(j)} = \\sum \\exp(s - m^{(j)}), \\qquad \\mathbf{O}^{(j)} = \\text{normalized output so far} $$处理新块 $j+1$（块内最大 $\\tilde{m}$、块内指数和 $\\tilde{\\ell}$、块内贡献 $\\tilde{\\mathbf{P}}\\mathbf{V}$）时，按以下三步更新：\n$$ m^{(j+1)} = \\max(m^{(j)},\\ \\tilde{m}) $$$$ \\ell^{(j+1)} = e^{m^{(j)} - m^{(j+1)}}\\, \\ell^{(j)} + e^{\\tilde{m} - m^{(j+1)}}\\, \\tilde{\\ell} $$$$ \\mathbf{O}^{(j+1)} = \\frac{1}{\\ell^{(j+1)}}\\left( e^{m^{(j)} - m^{(j+1)}} \\ell^{(j)} \\mathbf{O}^{(j)} + e^{\\tilde{m} - m^{(j+1)}} \\tilde{\\mathbf{P}} \\mathbf{V} \\right) $$直觉：如果新的最大值比旧的大（$m^{(j+1)} \u003e m^{(j)}$），旧块的指数都要按 $e^{m^{(j)} - m^{(j+1)}} \u003c 1$ 打折；新块按 $e^{\\tilde{m} - m^{(j+1)}}$ 缩放。全部块处理完后，$\\mathbf{O} = \\mathbf{O}^{(T_c)}$ 已经是正确归一化的输出。\n5.1 为什么这是\u0026quot;精确\u0026quot;算法 #每一步的缩放都是 softmax 恒等式的直接应用：\n$$ \\mathrm{softmax}(s) = \\frac{\\exp(s - m)}{\\sum_{j}\\exp(s_j - m)} $$对任意 $m$ 成立。Online softmax 只是\u0026quot;换了个 $m$\u0026ldquo;并等比缩放之前的累计——数学上等同于一次性算整行 softmax，实际差异只来自浮点舍入。稀疏/线性注意力改变的是计算内容，FlashAttention 只改计算顺序和存储位置。\n6. 技巧三：Recomputation（反向重算） #反向传播需要 $\\mathbf{S}$ 和 $\\mathbf{P}$ 的梯度。朴素实现把它们存下来（$O(N^2)$ 显存）；FlashAttention 选择：\n前向：只存每块的归一化因子 ℓ 和行最大 m（O(N)） 反向：从 HBM 重新读 Q/K/V 块，在 SRAM 里重算 S 和 P 代价是反向 FLOPs 大约翻倍；收益是免掉 $O(N^2)$ 的中间矩阵落盘，反向的 HBM 访问从 $O(N^2)$ 降到 $O(N^2d^2/M)$。这就是\u0026rdquo;用 FLOPs 换 HBM 访问\u0026quot;——GPU 的算力是富余的，带宽才是稀缺的。\n7. 算法与定理 #7.1 前向伪代码（FA1 Algorithm 1 精简版） #输入：Q, K, V ∈ R^{N×d}（HBM），SRAM 容量 M 1. B_c = ⌈M/4d⌉，B_r = min(⌈M/4d⌉, d) 2. 初始化 O = 0, ℓ = 0, m = −∞（HBM） 3. for j = 1..T_c: # 遍历 K/V 块 4. 载入 K_j, V_j 到 SRAM 5. for i = 1..T_r: # 遍历 Q 块 6. 载入 Q_i, O_i, ℓ_i, m_i 到 SRAM 7. S_ij = Q_i K_j^T # 片上算 8. m̃ = rowmax(S_ij), P̃ = exp(S_ij − m̃), ℓ̃ = rowsum(P̃) 9. m_i^new = max(m_i, m̃) 10. ℓ_i^new = e^{m_i−m_i^new}ℓ_i + e^{m̃−m_i^new}ℓ̃ 11. O_i ← (e^{m_i−m_i^new}ℓ_i O_i + e^{m̃−m_i^new}P̃ V_j) / ℓ_i^new 12. 返回 O 7.2 两条定理 #定理 1（正确性与资源）：上述算法返回精确的 $\\mathrm{softmax}(\\mathbf{Q}\\mathbf{K}^\\top)\\mathbf{V}$，FLOPs 为 $O(N^2d)$，额外显存 $O(N)$。\n定理 2（IO 复杂度与最优性）：FlashAttention 需要 $O(N^2 d^2 / M)$ 次 HBM 访问，而标准注意力需要 $\\Omega(Nd + N^2)$ 次；并且不存在渐近更优的精确注意力算法（对所有 SRAM 大小）。\n8. 数值算例：online softmax 手算 #复用 01 章 $q_3$ 的分数行 $s = (1.414,\\ 0.707,\\ 0.707)$，$V$ 取第一坐标 $v = (1,\\ 0,\\ 1)$。把行分两块：块 1 = 前两个分数，块 2 = 最后一个。\n块 1：\n$$ \\tilde{m} = 1.414, \\quad \\tilde{\\mathbf{P}} = \\exp(s-\\tilde{m}) = (1,\\ 0.493), \\quad \\tilde{\\ell} = 1.493 $$$$ m^{(1)} = 1.414, \\quad \\ell^{(1)} = 1.493, \\quad \\mathbf{O}^{(1)} = \\frac{1\\cdot 1 + 0.493 \\cdot 0}{1.493} = 0.670 $$块 2：\n$$ \\tilde{m} = 0.707, \\quad \\tilde{\\mathbf{P}} = (1), \\quad \\tilde{\\ell} = 1 $$$$ m^{(2)} = \\max(1.414, 0.707) = 1.414 $$$$ \\ell^{(2)} = e^{0}\\cdot 1.493 + e^{0.707-1.414}\\cdot 1 = 1.493 + 0.493 = 1.986 $$$$ \\mathbf{O}^{(2)} = \\frac{1.493 \\times 1 \\times 0.670 + 0.493 \\times 1 \\times 1}{1.986} = \\frac{1.0 + 0.493}{1.986} = 0.752 $$对照整体 softmax：$a = (0.5035,\\ 0.2483,\\ 0.2483)$，输出 $= 0.5035\\cdot1 + 0.2483\\cdot0 + 0.2483\\cdot1 = 0.7518 \\approx 0.752$ ✓。\n注意：$\\mathbf{O}^{(1)} = 0.670$ 是\u0026quot;只看前两块\u0026quot;的部分输出；合入块 2 时按 $\\ell$ 正确重归一化——分块没有改变最终结果。\n9. FlashAttention-2：并行与工作划分 #FA1 已经比标准实现快 2–4 倍，但论文实测其前向只达到 A100 理论峰值 FLOPs 的 30–50%（反向 25–35%），而优化过的 GEMM 能到 80–90%。差距来自工作划分：\nFA2 的三处改进： ① 序列长度维并行：每个 thread block 负责一个 (query 块, key 块) 对，减少串行依赖 ② 减少非 matmul 运算：不再频繁重归一化，把 rescale 推迟到块末做一次 ③ warp 内划分：KV 的列维在 warp 间均分，避免重复读共享内存，支持 d 到 256 结果：\n$$ \\text{FA2} \\approx 2\\times \\text{FA1}, \\qquad \\text{峰值} \\approx 230\\ \\text{TFLOPs/s} = 73\\%\\ \\text{理论峰值（A100）} $$ 10. FlashAttention-3：Hopper 上的异步与低精度 #FA2 在 H100 上只到约 35% 利用率（GEMM 能到 80–90%）。H100 的新硬件给了 FA3 三个杠杆：\n① TMA 异步搬运：Tensor Memory Accelerator 专做 HBM↔SRAM 拷贝， 让数据搬运与计算重叠（warp specialization：生产者 warp 搬运、消费者 warp 计算） ② 软max 藏在 GEMM 下面：把 softmax 的指数/归一等低吞吐运算 与 WGMMA（warpgroup 矩阵乘）交错，用\u0026#34;乒乓\u0026#34;调度隐藏掉 ③ FP8 张量核：块级量化 + incoherent processing（旋转/置换打散离群值）， 把精度损失压到最低 实测（H100 SXM5）：\n$$ \\text{FA3 FP16} = 1.5\\text{–}2.0\\times \\text{FA2（前向）}, \\quad \\text{最高 740 TFLOPs/s（75% 利用率）} $$$$ \\text{FA3 FP8} \\approx 1.2\\ \\text{PFLOPs/s}, \\quad \\text{数值误差比基线 FP8 注意力低 2.6 倍} $$ 11. 实验数据汇总 # 版本/指标 数据 出处 FA1 vs 标准注意力 2–4x；GPT-2 上最高 7.6x FA1 Fig. 1 FA1 内存 由 $O(N^2)$ 降到 $O(N)$，省 10–20 倍 FA2 引言 FA1 HBM 访问 最多减少 9 倍；$O(N^2d^2/M)$ vs $\\Omega(Nd+N^2)$ FA1 Theorem 2 FA1 训练提速 BERT-large 15%（vs MLPerf 1.1 记录）；GPT-2 3x；LRA 2.4x FA1 §4.1 FA1 长序列收益 GPT-2 ppl −0.7；长文档分类 +6.4；Path-X 16K 61.4%、Path-256 64K 63.1% FA1 §4.2 FA2 约 2x vs FA1；前向 73% 理论峰值（230 TFLOPs/s on A100） FA2 摘要/§4 FA3 FP16 1.5–2.0x vs FA2，740 TFLOPs/s；FP8 ≈1.2 PFLOPs/s；误差低 2.6x FA3 摘要/§5 三版都在压 HBM 访问、提硬件利用率，注意力数学没有改动，结果仍是精确的。\n12. 衔接：decode 侧、FP8 注意力与量化系列 #12.1 Decode 形态（FlashDecoding） #decode 时 query 只有 1 行、key 有 $L$ 行，$L$ 很长而 batch 小，GPU 并行度不够。FlashDecoding 把 KV 按行切块并行算部分输出，再做一次 online-softmax 式合并——复用本章的数学，把 decode 的长序列注意力也并行化。\n12.2 与量化系列的呼应 #01 章说过\u0026quot;注意力是量化最敏感的区域之一\u0026quot;；FA3 给出了低精度注意力的两条工程经验：\n块级量化（per-block scale）比 per-tensor 更稳 incoherent processing（打散离群值）能把 FP8 注意力误差再降一截 13. 本章小结 # 瓶颈是 IO：朴素注意力的 $N^2$ 矩阵在 HBM 反复搬移；FA 的 IO 复杂度 $O(N^2d^2/M)$ vs 标准 $\\Omega(Nd+N^2)$。 三个技巧：tiling（分块塞 SRAM）、online softmax（增量归一化，精确）、recompute（反向重算换带宽）。 精确性：FlashAttention 是精确算法，结果与朴素 softmax 的差异只来自浮点舍入。 演进：FA1 提出 IO 感知框架（2–4x）；FA2 修工作划分（再 2x、73% 峰值）；FA3 吃 Hopper 硬件（再 1.5–2x、FP8）。 定理：$O(N)$ 额外显存、$O(N^2d^2/M)$ HBM 访问，且对精确注意力是最优的。 一句话记忆：\u0026ldquo;不要造一张 N×N 的纸（中间矩阵），把它剪成能放进口袋（SRAM）的碎片，边算边记账（online softmax），反向时再撕一遍（recompute）——纸没了，账一分不少。\u0026rdquo;\n14. 习题与解答 #题 1（推导）：online softmax 保持精确 #证明：若第 $j$ 块前 $m^{(j)}, \\ell^{(j)}, \\mathbf{O}^{(j)}$ 满足 $\\ell^{(j)} = \\sum_{k \\le j}\\exp(s_k - m^{(j)})$、$\\mathbf{O}^{(j)} = \\mathrm{softmax}(s_{1:j})\\mathbf{V}_{1:j}$，则第 5 节的更新公式使相同性质对 $j+1$ 成立。\n题 1 解答 $\\ell^{(j+1)} = e^{m^{(j)}-m^{(j+1)}}\\ell^{(j)} + e^{\\tilde{m}-m^{(j+1)}}\\tilde{\\ell} = \\sum_{k\\le j}\\exp(s_k - m^{(j+1)}) + \\sum_{k\u003ej}\\exp(s_k - m^{(j+1)})$，即全行以 $m^{(j+1)}$ 为基准的指数和。$\\mathbf{O}^{(j+1)}$ 分子 $= e^{m^{(j)}-m^{(j+1)}}\\ell^{(j)}\\mathbf{O}^{(j)} + e^{\\tilde{m}-m^{(j+1)}}\\tilde{\\mathbf{P}}\\mathbf{V} = \\sum_{k\\le j+1}\\exp(s_k - m^{(j+1)})v_k$，除以 $\\ell^{(j+1)}$ 即 softmax 加权和。归纳成立。\n题 2（计算）：重做第 8 节算例 #把 $s = (1.414, 0.707, 0.707)$ 按\u0026quot;块 1 = 第一个分数、块 2 = 后两个\u0026quot;切分，重新走一遍 online softmax，验证结果仍是 0.752。\n题 2 解答 块 1（单个分数 $1.414$）：$\\tilde{m}=1.414$，$\\tilde{\\mathbf{P}}=\\exp(1.414-1.414)=(1)$，$\\tilde{\\ell}=1$。更新：$m^{(1)}=1.414$，$\\ell^{(1)} = e^{-\\infty-1.414}\\cdot0 + e^{0}\\cdot1 = 1$，$O^{(1)} = (0 + 1\\cdot 1\\cdot v_1)/1 = v_1 = 1$。\n块 2（两个分数 $0.707, 0.707$）：$\\tilde{m}=0.707$，$\\tilde{\\mathbf{P}}=\\exp(0.707-0.707)=(1,1)$，$\\tilde{\\ell}=2$。更新：\n$$ m^{(2)} = \\max(1.414, 0.707) = 1.414 $$$$ \\ell^{(2)} = e^{0}\\cdot 1 + e^{0.707-1.414}\\cdot 2 = 1 + 0.493\\times 2 = 1.986 $$$$ O^{(2)} = \\frac{1\\cdot 1\\cdot 1 + e^{-0.707}\\cdot (1\\cdot v_2 + 1\\cdot v_3)}{1.986} = \\frac{1 + 0.493\\times(0+1)}{1.986} = \\frac{1.493}{1.986} = 0.752 $$与整体 softmax 一致 ✓。关键点：块内 $\\tilde{\\mathbf{P}}$ 必须相对块内最大值 $\\tilde{m}$ 计算（这里是 $(1,1)$），合入时再统一缩放到全局基准 $m^{(2)}$。\n题 3（推导）：块大小为什么是 M/4d #说明 $B_c = \\lceil M/4d \\rceil$ 的来源：SRAM 里同时驻留哪四项？\n题 3 解答 同时驻留 $\\mathbf{Q}_i$（$B_r d$）、$\\mathbf{K}_j$（$B_c d$）、$\\mathbf{V}_j$（$B_c d$）、$\\mathbf{S}_{ij}$（$B_r B_c$）。取 $B_r = B_c = B$，四项约各占 $M/4$：$B d \\approx M/4 \\Rightarrow B \\approx M/4d$。$B_r$ 额外限制不超过 $d$（Q 块不必比 head 维还宽）。\n题 4（思考）：为什么\u0026quot;多算 FLOPs 反而更快\u0026quot; #FA 反向的 FLOPs 约为标准实现的两倍，却更快。用\u0026quot;IO 稀缺、FLOPs 富余\u0026quot;解释，并说明什么条件下这个结论会反转。\n题 4 解答要点 反向重算省掉 $O(N^2)$ 矩阵的落盘与回读；HBM 访问次数是墙钟的主导项，FLOPs 只要没超硬件上限就不值钱。反转条件：$d$ 很大而 $M$ 很小（$d^2/M$ 接近 1），或设备算力本身成为瓶颈（如极低功耗设备）——此时重算的开销可能超过省下的 IO。\n题 5（对比）：FA1/FA2/FA3 各自解决什么 #用一句话分别总结 FA1、FA2、FA3 的核心贡献，并说明三版为什么都保持\u0026quot;精确\u0026quot;。\n题 5 解答要点 FA1：提出 IO 感知框架（tiling + online softmax + recompute），把 HBM 访问从 $O(N^2)$ 降到 $O(N^2d^2/M)$；FA2：修 thread block/warp 的工作划分，把利用率从 30–50% 提到 73%；FA3：用 TMA/wgmma 的异步与 FP8 张量核，在 H100 上再提 1.5–2x。三版都不改注意力数学，只改计算的组织方式，所以都精确。\n题 6（编程）：分块 softmax 验证 #实现：① 朴素 softmax（整行）；② online softmax（按任意块大小切分）；③ 对比两者在随机输入（float32 与 float16）下的最大绝对误差；④ 画出误差随块大小 $B \\in \\{2, 8, 32, 128\\}$ 的变化，并解释 float16 误差来源。\n题 6 解答要点 ①②输出应逐元素一致（float32 下误差 $\\sim 10^{-7}$ 量级）；③ float16 下误差变大，主要来自 $e^{m-m^{new}}$ 缩放与累加的舍入；④ 块越大（越接近整行）误差越小——但即使块很小，online 版仍比\u0026quot;分块后各自独立 softmax\u0026quot;（错误做法）精确得多。这就是 FA 精度故事的代码级验证。\n15. 延伸阅读 # FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness（arXiv:2205.14135）：本章算法（Algorithm 1）、定理 1/2、实验的出处。 FlashAttention-2（arXiv:2307.08691）：并行与工作划分的细节。 FlashAttention-3（arXiv:2407.08608）：Hopper 异步、FP8 注意力。 FlashDecoding（Dao et al., 2023）：decode 侧的并行化（12.1 节的展开）。 上一篇： 01 注意力机制基础与复杂度分析；下一篇：03 注意力头变体：MQA / GQA / MLA——把 KV cache 的显存账本从 $d$ 砍到 $d_{\\text{kv}}$。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-02-flashattention-io%E6%84%9F%E7%9F%A5%E7%9A%84%E7%B2%BE%E7%A1%AE%E6%B3%A8%E6%84%8F%E5%8A%9B/","section":"笔记","summary":"朴素注意力快不起来的真正瓶颈是 HBM 读写而不是 FLOPs。本文讲清 FlashAttention 的三个核心技巧——tiling、online softmax、recompute，手算验证增量式 softmax 与整体一致，给出 IO 复杂度定理，并对比 FA1/FA2/FA3 的对 GPU 架构要求与实测数据。","title":"FlashAttention 原理是什么？为什么又省显存又快"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： FlashAttention 原理是什么｜下一篇： 稀疏注意力、滑动窗口和线性注意力怎么选\n对应：Shazeer, Fast Transformer Decoding: One Write-Head is All You Need（arXiv:1911.02150，2019）；Ainslie et al., GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints（arXiv:2305.13245，EMNLP 2023）；DeepSeek-AI, DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model（arXiv:2405.04434，2024）。 前置：01 章（KV cache 大小公式 $2Ln_{\\text{layers}}d_{\\text{kv}}b$）、02 章（prefill/decode 两种形态）。学完本章你应该能：① 写清 MQA/GQA/MLA 三种方案\u0026quot;每 token 缓存什么\u0026quot;的数学定义与 KV 元素数公式；② 解释 GQA 的 up-training 配方（mean-pool + 5% 预训练算力）；③ 推导 MLA 的低秩联合压缩公式，并解释 RoPE 与低秩压缩的冲突及 decoupled RoPE 解法；④ 手算 70B 与 DeepSeek-V2 的 KV 显存账本；⑤ 说出\u0026quot;KV 缓存压缩谱系\u0026quot;的统一视角。\n目录（本章） # 本章目标 问题重述：decode 的 KV 带宽账本 MQA：一个 KV 头管所有 query 头 GQA：中间地带与 Uptraining MLA：低秩 KV 联合压缩 统一视角：KV 缓存压缩谱系 数值算例：三种方案的显存账本 质量与工程权衡 本章小结 习题与解答 延伸阅读 2. 问题重述：decode 的 KV 带宽账本 #01 章已经给出 decode 每步读取全部 KV 的字节数：\n$$ \\text{每步 KV 读取} = 2 \\times L \\times n_{\\text{layers}} \\times d_{\\text{kv}} \\times b $$$d_{\\text{kv}}$ 是 KV 总维度。对 MHA（每头独立 K/V）：\n$$ d_{\\text{kv}} = h \\times d_{\\text{head}} $$长上下文时这一步的带宽会反超权重读取（01 章 32K 算例）。本章的三个方案都在做同一件事：把 $d_{\\text{kv}}$ 变小。区别只在于\u0026quot;怎么变\u0026quot;：\nMQA：h 个 KV 头 → 1 个（共享） GQA：h 个 KV 头 → g 个（分组共享） MLA：干脆不缓存 K/V，缓存一个低秩潜向量，需要时再展开 3. MQA：一个 KV 头管所有 query 头 #3.1 定义 #Multi-Query Attention（Shazeer 2019）：所有 query 头共享同一组 K、V。\n$$ d_{\\text{kv}} = d_{\\text{head}}, \\qquad \\text{KV 元素/token/层} = 2\\, d_{\\text{head}} $$相比 MHA（$2h\\,d_{\\text{head}}$），KV cache 缩小 $h$ 倍。\n3.2 为什么省的是带宽 #Shazeer 的性能分析：decode 每步的\u0026quot;访存:计算\u0026quot;比约为\n$$ \\Theta\\!\\left(\\frac{1}{d} + \\frac{n}{d h} + \\frac{1}{b}\\right) $$其中 $n$ 是序列长度、$b$ 是 batch。中间的 $n/(dh)$ 项正来自\u0026quot;逐位置读 KV\u0026quot;；MQA 令 $d_{\\text{kv}} = d_{\\text{head}}$，这一项随 $d_{\\text{kv}}$ 一起除以 $h$。\n3.3 代价 #优点：KV 显存/带宽 ÷ h；训练也更快（KV 投影计算减少） 缺点：单组 K/V 容量不足，质量退化（尤其在翻译、摘要等任务上）； 训练不稳定（GQA 论文明确指出） 因此 MQA 适合\u0026quot;已经训好的模型想快速换推理\u0026quot;，但训练新模型时它通常不是最优解。\n4. GQA：中间地带与 Uptraining #4.1 定义 #Grouped-Query Attention（Ainslie et al. 2023）：把 $h$ 个 query 头分成 $g$ 组，每组共享一个 KV 头：\n$$ d_{\\text{kv}} = g \\times d_{\\text{head}}, \\qquad \\text{KV 元素/token/层} = 2\\, g\\, d_{\\text{head}} $$两个端点：\n$$ \\text{GQA-}1 = \\text{MQA}, \\qquad \\text{GQA-}h = \\text{MHA} $$论文实验（T5 XXL 上对 5 个摘要集、WMT 翻译、TriviaQA 的评测）：GQA 质量接近 MHA、速度接近 MQA。\n4.2 Uptraining：从 MHA 检查点转换 #不重新训练也能拿到 GQA/MQA 模型：\n步骤 1：把 K/V 投影按组做 mean-pooling（比选单头或随机初始化好） 步骤 2：用原预训练配方继续训练 α = 5% 的步数（T5 XXL 约 600 TPUv3 chip-days） 于是\u0026quot;已有 MHA 权重 + 5% 算力\u0026quot;就能得到可部署的 GQA 模型。\n4.3 为什么大模型更划算 #$$ \\text{KV cache} \\propto d, \\qquad \\text{FLOPs} \\propto d^2 $$模型越大，KV 相对 FLOPs 越便宜、头越多，MQA 的\u0026quot;一刀切\u0026quot;越激进。另外，MQA 只有一组 KV，张量并行度大于 1 时每张卡都得存一份；GQA 有 $g$ 组 KV，并行度能整除 $g$ 时各卡各持一组，不用复制。所以下面这些模型里 GQA 出现得最多：\n模型 query 头 KV 头（组） 类型 LLaMA-2 7B/13B 32 32 MHA LLaMA-2 70B 64 8 GQA-8 LLaMA-3 8B 32 8 GQA-8（4 组） Mistral 7B 32 8 GQA-8 Falcon 40B 128 8 MQA 5. MLA：低秩 KV 联合压缩 #GQA/MQA 是\u0026quot;砍头数\u0026quot;；DeepSeek-V2 的 MLA（Multi-head Latent Attention）更进一步：把每层的 K、V 压进一个低秩潜向量，推理只缓存这个向量。\n5.1 定义 #设第 $t$ 个 token 的注意力输入为 $h_t$。MLA 用三个低秩投影：\n$$ c_t^{KV} = W^{DKV} h_t \\in \\mathbb{R}^{d_c}, \\qquad k_t = W^{UK} c_t^{KV}, \\qquad v_t = W^{UV} c_t^{KV} $$其中 $d_c \\ll h\\,d_{\\text{head}}$。推理时只缓存 $c_t^{KV}$（$d_c$ 维），K、V 按需从潜向量展开——展开所需的 $W^{UK}$、$W^{UV}$ 在推理时被吸收进 $W^Q$ 的左右两侧，不增加每步计算。\nQuery 也做低秩压缩（$c_t^Q = W^{DQ} h_t$，$q_t = W^{UQ} c_t^Q$），这次压缩只影响训练时的激活显存，不改变 KV cache。\n5.2 RoPE 的冲突与 decoupled RoPE #旋转位置编码（RoPE）对 K、Q 都施加一个随位置变化的矩阵。若对展开后的 $k_t$ 施加 RoPE，那么\u0026quot;$W^{UK}$ 之后接 RoPE 矩阵\u0026quot;就无法再吸收进 $W^Q$（矩阵乘法不可交换，位置相关的矩阵卡在中间）。\n解法：decoupled RoPE——位置信息由一组额外的低维头承载，潜向量分支保持无位置：\n$$ q_{t,i}^R = \\mathrm{RoPE}(W^{QR} c_t^Q), \\qquad k_t^R = \\mathrm{RoPE}(W^{KR} h_t) $$于是每 token 缓存的 KV = 潜向量 $d_c$ + 共享 RoPE key $d_h^R$：\n$$ \\text{MLA KV 元素/token/层} = d_c + d_h^R $$5.3 DeepSeek-V2 的配置与收益 #$$ d_c = 512,\\quad d_h^R = 64 \\quad\\Rightarrow\\quad \\text{每层每 token } 576 \\text{ 个元素} $$论文对照表（每 token KV 元素数）：\n机制 KV 元素/token/层 容量 MHA $2\\, n_h d_h$ 强 GQA $2\\, n_g d_h$ 中等 MQA $2\\, d_h$ 弱 MLA $d_c + d_h^R \\approx \\frac{9}{2}d_h$ 更强 DeepSeek-V2 的 MLA 等价于\u0026quot;只有 2.25 组的 GQA\u0026quot;，但论文报告其效果超过 MHA。整模型收益：相比 DeepSeek 67B，KV cache 减少 93.3%，生成吞吐提升 5.76 倍，训练成本省 42.5%。\n6. 统一视角：KV 缓存压缩谱系 #四个方案的区别就是\u0026quot;每 token 存什么\u0026quot;：\nMHA：存 h 份 (k, v) → 2 h d_h 元素，容量最强 GQA：存 g 份 (k, v) → 2 g d_h 元素，容量中等 MQA：存 1 份 (k, v) → 2 d_h 元素，容量弱 MLA：存 1 个低秩潜向量 + 位置头 → d_c + d_h^R 元素，容量反超 MLA 的洞察是：存 K/V 只是存它的一种压缩表示——GQA/MQA 在原始表示里砍头数，MLA 学一个更紧的表示。压缩矩阵和注意力一起训练，所以更小的表示仍能保住容量（5.3 节对照表中 MLA 的容量标为\u0026quot;更强\u0026quot;）。\n7. 数值算例：三种方案的显存账本 #7.1 LLaMA-2 70B（GQA） #配置：80 层、$d = 8192$、64 个 query 头、8 个 KV 头、$d_{\\text{head}} = 128$、BF16。\n$$ \\text{GQA：} 2 \\times 80 \\times 8 \\times 128 \\times 2 = 320\\ \\text{KB/token} $$$$ \\text{若换成 MHA：} 2 \\times 80 \\times 64 \\times 128 \\times 2 = 2.5\\ \\text{MiB/token} $$ 上下文 GQA KV 等价 MHA KV 4K 1.25 GiB 10 GiB 32K 10 GiB 80 GiB 7.2 DeepSeek-V2（MLA） #配置：60 层、$d_c = 512$、$d_h^R = 64$、BF16。\n$$ \\text{MLA：} (512 + 64) \\times 60 \\times 2 = 67.5\\ \\text{KiB/token} $$$$ \\text{等价 MHA：} 2 \\times 128 \\times 128 \\times 60 \\times 2 = 3.75\\ \\text{MiB/token} $$$$ \\text{32K 上下文：} \\text{MLA } 2.1\\ \\text{GiB} \\quad\\text{vs}\\quad \\text{MHA } 120\\ \\text{GiB} \\quad(\\approx 57\\times) $$ 8. 质量与工程权衡 #质量：MLA ≳ MHA \u0026gt; GQA ≳ MQA（论文各自报告，具体任务有波动） 速度：decode 带宽看每 token KV 字节数；MQA 最小，MLA/GQA 按配置落在中间，MHA 最大（实际吞吐受 kernel 影响） 实现复杂度：MLA 最高（decoupled RoPE、投影吸收、训练 RMSNorm 处理） 采用：GQA 是当前开源模型的主流（LLaMA-2/3、Mistral）；MLA 主要在 DeepSeek 系列中使用 工程决策：\n已有 MHA 权重、想快速提速 → up-training 成 GQA（5% 算力） 训练新模型、极致省 KV → MLA（但要处理 RoPE 与数值稳定性） 显存预算固定 → 先算 01 章 KV 账本，再决定砍到哪一档 9. 本章小结 # MQA：$h$ 个 KV 头 → 1 个，KV ÷ h，质量退化。 GQA：$h$ → $g$ 个，质量近 MHA、速度近 MQA。 MLA：缓存低秩潜向量 $c^{KV}$（$d_c$ 维）+ decoupled RoPE 位置头（$d_h^R$ 维）。 统一视角：四者都是\u0026quot;每 token 存什么\u0026quot;的谱系；MLA 是学出来的压缩，容量反超 MHA。 一句话记忆：\u0026ldquo;MHA 给每个头都配 K/V，MQA 让所有头共用一副，GQA 按组共用，MLA 干脆只存一张\u0026rsquo;底片\u0026rsquo;（潜向量），要用时再冲印成 K/V。\u0026rdquo;\n10. 习题与解答 #题 1（推导）：KV 元素数公式 #写出 MHA、GQA-g、MQA、MLA 每 token 每层 KV 元素数公式，并说明各自对应 $g$ 的取值。\n题 1 解答 MHA：$2h d_h$（$g=h$）；GQA-g：$2g d_h$；MQA：$2d_h$（$g=1$）；MLA：$d_c + d_h^R$。GQA 的 $g$ 是 query 头分组数，$1 \\le g \\le h$，两个端点分别退化为 MQA 与 MHA。\n题 2（推导）：MQA 的访存:计算比 #从 Shazeer 的 $\\Theta(1/d + n/(dh) + 1/b)$ 出发，说明 MQA 把哪一项缩小了多少倍，以及为什么\u0026quot;序列越长 MQA 相对 MHA 越划算\u0026quot;。\n题 2 解答 中间项 $n/(dh)$ 来自逐位置读 KV，MQA 把 $d_{\\text{kv}}$ 从 $hd_h$ 缩到 $d_h$，该项除以 $h$。$n$ 越大该项占比越高，MQA 的收益越大——长上下文下 MQA/GQA 的优势被放大。\n题 3（计算）：GQA 组数换算 #LLaMA-2 70B 有 64 个 query 头、8 个 KV 头：① 这是 GQA-几？② 每个 KV 头服务几个 query 头？③ KV cache 是等价 MHA 的几分之一？\n题 3 解答 ① GQA-8（8 组）；② $64/8 = 8$ 个 query 头共用 1 个 KV 头；③ $2\\times8\\times128 / 2\\times64\\times128 = 1/8$。\n题 4（思考）：RoPE 为什么与低秩 KV 压缩冲突 #解释\u0026quot;RoPE 矩阵插在 $W^{UK}$ 之后会阻止投影吸收\u0026quot;的数学原因，并说明 decoupled RoPE 为什么能绕开。\n题 4 解答要点 推理时注意力分数是 $q^\\top k$；若 $k = \\mathrm{RoPE}(W^{UK}c)$，则分数里出现 $q^\\top R\\, W^{UK} c$。要把 $W^{UK}$ 吸进 $q$ 需要 $\\tilde{q} = (W^{UK})^\\top q$，但 $R$（随生成位置变化）夹在中间且矩阵乘法不可交换，无法统一吸收。decoupled RoPE 把位置信息放到独立的 $q^R, k^R$ 上，潜向量分支保持\u0026quot;无位置\u0026quot;的纯低秩形式，两分支各自可吸收。\n题 5（计算）：DeepSeek-V2 KV 账本 #DeepSeek-V2：60 层、$d_c=512$、$d_h^R=64$、BF16。① 每 token KV 字节数；② 32K 上下文总量；③ 与等价 MHA 相比是几分之一。\n题 5 解答 ① $(512+64)\\times60\\times2 = 69{,}120\\ \\text{B} = 67.5\\ \\text{KiB}$；② $67.5\\ \\text{KiB}\\times32768 = 2.1\\ \\text{GiB}$；③ 等价 MHA $= 2\\times128\\times128\\times60\\times2 = 3.75\\ \\text{MiB/token}$，总 $120\\ \\text{GiB}$——MLA 约为其 $1/57$。\n题 6（编程）：KV 尺寸函数 #实现函数 kv_bytes_per_token(mechanism, h, g, d_h, d_c, d_r, layers, bytes)，对 MHA/GQA/MQA/MLA 分别返回每 token KV 字节数；画一条\u0026quot;上下文长度 vs KV 总量\u0026quot;的曲线（4 条线），验证 MLA 在长上下文下斜率最低。\n题 6 解答要点 按题 1 公式实现；MLA 的每 token 尺寸与 $h$ 无关（只依赖 $d_c+d_h^R$），所以随上下文增长最慢；GQA 次之，MHA 最快。画到 128K 时 MHA 曲线会\u0026quot;起飞\u0026quot;，MLA 仍在可管理范围——这就是 03 章的全部动机。\n11. 延伸阅读 # Fast Transformer Decoding: One Write-Head is All You Need（arXiv:1911.02150）：MQA 的原始定义与带宽分析。 GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints（arXiv:2305.13245）：GQA 定义、up-training 配方、质量/速度实验。 DeepSeek-V2（arXiv:2405.04434）：MLA 公式、decoupled RoPE、配置（§2.1.3）与 KV 对照表（Table 1）。 DeepSeek-V3（arXiv:2412.19437）：MLA 的后续工程化（不压缩 Q 的变体），了解 MLA 演进。 上一篇： 02 FlashAttention；下一篇：04 稀疏、滑动窗口与线性注意力——从减少参与计算的 token 数入手，把 $O(L^2)$ 的注意力本身变便宜。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-03-%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%A4%B4%E5%8F%98%E4%BD%93-mqa-gqa-mla/","section":"笔记","summary":"三种注意力头变体回答的是同一个问题：每 token 缓存什么。本文给出各自的 KV 元素数公式，讲清 GQA 的 up-training 配方，推导 MLA 的低秩联合压缩并解释 RoPE 与低秩压缩的冲突及 decoupled RoPE 解法，最后手算 70B 与 DeepSeek-V2 的 KV 显存账本。","title":"MQA、GQA、MLA 有什么区别？KV Cache 该怎么省"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： MQA、GQA、MLA 有什么区别｜下一篇： PagedAttention 是怎么省下 KV Cache 显存的\n对应：Xiao et al., Efficient Streaming Language Models with Attention Sinks（StreamingLLM，arXiv:2309.17453，2023）；Zhang et al., H2O: Heavy-Hitter Oracle for Efficient Generative Inference of Large Language Models（arXiv:2306.14048，NeurIPS 2023）；Katharopoulos et al., Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention（arXiv:2006.16236，ICML 2020）；Choromanski et al., Rethinking Attention with Performers（arXiv:2009.14794，ICLR 2021）；Gu \u0026amp; Dao, Mamba: Linear-Time Sequence Modeling with Selective State Spaces（arXiv:2312.00752，2023）；Mistral AI, Mistral 7B（arXiv:2310.06825，2023）。 前置：01 章（$O(L^2)$ 复杂度）、02 章（FlashAttention 的精确路线）。学完本章你应该能：① 说出对抗 $L^2$ 的三条路线（少看位置/少存 KV/换计算范式）与代表方法；② 解释滑动窗口注意力的局部性假设与 StreamingLLM 的 attention sink 修复；③ 写出线性注意力的结合律推导（$O(L d^2)$）与 Performers 的核近似思路；④ 说清 Mamba 的选择性 SSM 与线性注意力的本质区别；⑤ 用复杂度表格判断\u0026quot;什么场景该上哪条路线\u0026quot;。\n目录（本章） # 本章目标 三条路线：对抗 $L^2$ 的三种策略 滑动窗口注意力（SWA） Attention Sink 与 StreamingLLM 驱逐类方法：H2O 线性注意力：把 softmax 换成核 Performers：随机特征近似 Mamba：选择性状态空间模型 统一视角：稀疏 vs 线性 复杂度对照与数值算例 实验数据 本章小结 习题与解答 延伸阅读 2. 三条路线：对抗 $L^2$ 的三种策略 #01 章说注意力 FLOPs $= 4L^2d$、KV 显存 $= O(L)$。02/03 章分别从 IO 和 KV 维度动手，复杂度仍是 $O(L^2)$。本章的三种策略从三个方向绕开它：\n路线 A：少看位置（稀疏） 每个 query 只看一部分 key（窗口、top-k、检索） → 复杂度 O(L·W)，W ≪ L 路线 B：少存 KV（驱逐） 显存预算固定，动态决定哪些 token 值得留 → KV 显存 O(预算)，与 L 解耦 路线 C：换计算范式（线性/状态空间） 用结合律或循环把 L² 换成 d² → 复杂度 O(L·d²)，d ≪ L 时线性 路线 C 通常替换 softmax，结果是近似；02 章的 FlashAttention 保持精确，只改 HBM 访问。\n3. 滑动窗口注意力（SWA） #3.1 定义 #假设\u0026quot;远距离 token 对当前 token 的贡献可忽略\u0026quot;，每个 query 只看最近 $W$ 个 key：\n$$ o_i = \\sum_{j = i-W+1}^{i} a_{ij}\\, v_j $$FLOPs 从 $4L^2d$ 降到 $4LWd$（$W \\ll L$），KV cache 也只需存窗口 $W$。代表：Longformer（Beltagy et al. 2020）、Mistral 7B。\n3.2 Mistral 的做法 #窗口 W = 4096；GQA 8 个 KV 头（03 章） 每一层的\u0026#34;有效感受野\u0026#34; = 层数 × W（多层叠加后远处信息能间接到达） 论文结论：SWA 让\u0026#34;任意长度序列 + 降低推理成本\u0026#34;兼得 3.3 代价 #优点：复杂度与 KV 显存都只跟 W 有关 缺点：局部性假设对\u0026#34;需要远距离精确引用\u0026#34;的任务（长文档检索式问答）不友好； 训练窗口有限 → 推理超过训练长度时质量崩（下一节的痛点） 4. Attention Sink 与 StreamingLLM #4.1 窗口注意力为什么会崩 #把窗口直接用于\u0026quot;流式长对话\u0026quot;（文本长度超过训练长度、超过缓存）：只保留最近 $W$ 个 KV，初始 token 被踢出。论文发现质量崩坏，原因在 softmax 的归一化：窗口里没有可吸收多余注意力质量的 token。\n4.2 Attention Sink 现象 #观察：模型给初始 token（尤其第一个 token）分配异常高的注意力分数，即使它与当前内容无关。这些 token 像\u0026quot;下水道\u0026quot;一样吸走多余的注意力质量——所以叫 attention sink。证据：保留初始 token 的 KV，窗口注意力的性能基本恢复。\n4.3 StreamingLLM 方案 #$$ \\text{KV cache} = \\underbrace{\\text{前 } S \\text{ 个 sink token}}_{\\text{固定保留}} + \\underbrace{\\text{最近 } W \\text{ 个 token}}_{\\text{窗口}} $$要点： ① 不需要微调，直接用现成模型（Llama-2、MPT、Falcon、Pythia） ② 稳定流式到 400 万 token 以上 ③ 比\u0026#34;窗口 + 重算\u0026#34;基线快最多 22.2 倍 ④ 预训练时加一个占位 token 当专用 sink，效果更好 代价：这是近似——它丢掉了窗口外的历史信息，但实验表明 sink + 窗口已经足够稳定。\n5. 驱逐类方法：H2O #5.1 观察 #论文统计发现：一小部分 token 贡献了注意力分数的绝大部分——\u0026ldquo;重击手\u0026rdquo;（Heavy Hitters, $H_2$）。它们与文本中的高频共现词强相关；删掉它们性能显著下降。\n5.2 H2O 驱逐策略 #KV 预算固定（如 20% 的 token），动态维护两类：\n$$ \\text{保留} = \\underbrace{\\text{最近 } R \\text{ 个 token}}_{\\text{局部性}} + \\underbrace{\\text{累计注意力分数最高的 } H_2 \\text{ token}}_{\\text{重要性}} $$驱逐被建模为动态子模最大化问题，论文给出近似保证。注意驱逐后 KV 不再完整，注意力是近似的（且驱逐不可逆）。\n5.3 数据 #20% 预算下：吞吐比 DeepSpeed-Zero-Inference / HF Accelerate 高 29 倍， 比 FlexGen 高 3 倍（OPT-6.7B/30B）；同 batch 延迟降 1.9 倍 6. 线性注意力：把 softmax 换成核 #6.1 结合律：$L^2$ 从哪来、怎么消失 #标准注意力的 $\\mathbf{P}\\mathbf{V}$ 不能交换顺序（softmax 的归一化依赖整行）。若把注意力分数换成可分解核：\n$$ \\mathrm{Att}(q_i, k_j) = \\frac{\\varphi(q_i)^\\top \\varphi(k_j)}{\\sum_{j'} \\varphi(q_i)^\\top \\varphi(k_{j'})} $$则输出可写成：\n$$ o_i = \\frac{\\varphi(q_i)^\\top \\sum_{j \\le i} \\varphi(k_j) v_j^\\top}{\\varphi(q_i)^\\top \\sum_{j \\le i} \\varphi(k_j)} $$关键在于结合律（Katharopoulos et al. 2020）：\n$$ \\varphi(\\mathbf{Q})\\,\\big(\\varphi(\\mathbf{K})^\\top \\mathbf{V}\\big) = \\big(\\varphi(\\mathbf{Q})\\,\\varphi(\\mathbf{K})^\\top\\big)\\,\\mathbf{V} $$先算 $\\varphi(\\mathbf{K})^\\top \\mathbf{V} \\in \\mathbb{R}^{d \\times d}$（与 $L$ 无关！），再左乘 $\\varphi(\\mathbf{Q})$。复杂度：\n$$ O(L^2 d) \\;\\to\\; O(L d^2) $$推理时变成循环更新：维护状态 $\\mathbf{S}_i = \\mathbf{S}_{i-1} + \\varphi(k_i) v_i^\\top$（$d \\times d$）与归一化向量 $\\mathbf{z}_i$——这正是\u0026quot;Transformer 是 RNN\u0026quot;的含义。\n6.2 代价 #优点：训练 O(L d²)、推理 O(d²)/步，长序列友好 缺点：softmax 被替换 → 不再是精确 softmax 注意力； 无界核的数值稳定性需要额外处理 7. Performers：随机特征近似 #要\u0026quot;线性\u0026quot;又要\u0026quot;接近 softmax\u0026quot;，可以用核技巧：softmax 的核 $e^{q^\\top k}$ 可以用随机特征近似：\n$$ e^{q^\\top k} \\approx \\mathbb{E}\\left[\\varphi(q)^\\top \\varphi(k)\\right], \\qquad \\varphi(x) = \\frac{1}{\\sqrt{m}}\\, f(x)\\, \\odot\\, \\text{random cos/sin features} $$Performers（FAVOR+）用正随机特征保证方差小，能在 $O(L d^2)$ 内近似 softmax 注意力，误差有界。后续的线性 Transformer 工作大多沿这条路做随机特征近似。\n8. Mamba：选择性状态空间模型 #8.1 从线性注意力到 SSM #线性注意力的循环更新对所有 token 用同一套规则，没有输入相关的选择性。状态空间模型（SSM）把状态更新写成：\n$$ h_t = \\bar{A}_t h_{t-1} + \\bar{B}_t x_t, \\qquad y_t = C_t h_t $$8.2 关键：选择性（Selectivity） #前人 SSM 的 $\\bar{A}, \\bar{B}, C$ 是输入无关的常数，导致无法做\u0026quot;基于内容的推理\u0026quot;（该记住的记不住、该忘的忘不掉）。Mamba 的贡献：\n让 A, B, C 都依赖当前输入 x_t（选择性） → 模型可以按内容决定\u0026#34;传播还是遗忘\u0026#34; → 代价：不能再高效用卷积，需要专门的硬件感知并行扫描算法 8.3 数据 #Mamba-3B 在语言建模上超过同尺寸 Transformer、打平两倍尺寸的 Transformer 推理吞吐比同尺寸 Transformer 高 5 倍；序列长度线性扩展，实测到百万级 9. 统一视角：稀疏 vs 线性 #稀疏（路线 A/B）：保留 softmax 注意力，但\u0026#34;看得少 / 存得少\u0026#34; → 语义可解释、与 FlashAttention 兼容、质量接近精确 → 但信息被硬性截断（窗口外/被驱逐的永远看不到） 线性（路线 C）：换核 / 换状态模型，复杂度真正线性 → 任意位置都能\u0026#34;影响\u0026#34;当前输出（无硬截断） → 但近似了 softmax，长程精确引用能力存疑 工程经验：\n长上下文但需要精确引用 → FlashAttention + 稀疏/驱逐（StreamingLLM、H2O） 极致吞吐、可接受近似 → 线性注意力 / Mamba 当前主流 LLM 服务 → 仍是\u0026#34;精确注意力 + KV 优化\u0026#34;（02/03/05 章）， 稀疏/线性更多是研究前沿与端侧选择 10. 复杂度对照与数值算例 # 方法 每层 FLOPs KV 显存/token 精确性 标准注意力 $4L^2 d$ $2 d_{\\text{kv}}$ 精确 FlashAttention $4L^2 d$（省 HBM 访问） $2 d_{\\text{kv}}$ 精确 滑动窗口 $4LWd$ $2 d_{\\text{kv}}$（窗口内） 近似（截断） StreamingLLM $4L(W+S)d$ $2(W+S)d_{\\text{kv}}$ 近似 H2O $4L^2d$（计算不变，省显存） 预算固定 近似（驱逐） 线性注意力 $4Ld^2$ $d^2$（状态） 近似（换核） Mamba $O(L d N)$ $O(dN)$（状态） 架构不同 数值例（$d=64$、$L=32K$、$W=4K$，单头）：\n$$ \\text{标准： } 4 \\times 32768^2 \\times 64 \\approx 275\\ \\text{GFLOP} $$$$ \\text{滑窗： } 4 \\times 32768 \\times 4096 \\times 64 \\approx 34\\ \\text{GFLOP} \\quad(\\times 8\\ \\text{省}) $$$$ \\text{线性： } 4 \\times 32768 \\times 64^2 \\approx 0.54\\ \\text{GFLOP} \\quad(\\times 500\\ \\text{省}) $$ 11. 实验数据 # 方法 已核实数据 出处 StreamingLLM 稳定流式 4M+ token；比滑窗重算基线快 22.2x；无需微调 摘要/§4 H2O 20% 预算：吞吐比 Zero-Inference/HF-Accelerate 高 29x、比 FlexGen 高 3x；延迟降 1.9x 摘要 Mistral SWA 窗口 4096 + GQA；超 Llama 2 13B 且推理成本更低 摘要 Mamba 吞吐比 Transformer 高 5x；线性扩展；Mamba-3B 打平 2 倍尺寸 Transformer 摘要 Katharopoulos 线性注意力 $O(L d^2)$ 训练、$O(d^2)$/步推理；等价 RNN 形式 论文 §3 12. 本章小结 # 三条路线：少看（稀疏/滑窗）、少存（驱逐）、换范式（线性/SSM）。 Attention Sink：初始 token 是 softmax 的\u0026quot;垃圾收集器\u0026quot;，窗口注意力踢掉它就会崩；保留 sink + 窗口即可稳定流式。 H2O：按\u0026quot;累计注意力分数\u0026quot;驱逐，在固定 KV 预算下把省下的显存换成吞吐。 线性注意力：$\\varphi(Q)(\\varphi(K)^\\top V)$ 的结合律把 $L^2$ 换成 $d^2$；Performer 用随机特征近似 softmax。 Mamba：选择性 SSM 让状态按内容决定记忆/遗忘。 工程提醒：这些大多是近似；精确注意力 + KV 优化仍是主流服务的选择。 一句话记忆：\u0026ldquo;想让注意力跑赢平方，要么看得少（窗口/驱逐），要么换个算法（核/状态空间）——前者保留 softmax 的味道，后者把 softmax 换掉。\u0026rdquo;\n13. 习题与解答 #题 1（推导）：线性注意力的结合律 #写出 $\\varphi(\\mathbf{Q})(\\varphi(\\mathbf{K})^\\top \\mathbf{V})$ 与 $(\\varphi(\\mathbf{Q})\\varphi(\\mathbf{K})^\\top)\\mathbf{V}$ 的维度，说明为什么前者只需 $O(L d^2)$，并推导逐位置循环更新式。\n题 1 解答 $\\varphi(\\mathbf{K})^\\top \\mathbf{V}$ 是 $d \\times d$；$\\varphi(\\mathbf{Q})$ 是 $L \\times d$，左乘得 $L \\times d$。先算 $d\\times d$ 矩阵（$O(L d^2)$），再乘 $L\\times d$（$O(L d^2)$），总 $O(L d^2)$；而右侧先算 $L\\times L$ 是 $O(L^2 d)$。循环形式：$\\mathbf{S}_i = \\mathbf{S}_{i-1} + \\varphi(k_i)v_i^\\top$，$\\mathbf{z}_i = \\mathbf{z}_{i-1} + \\varphi(k_i)$，$o_i = \\varphi(q_i)^\\top \\mathbf{S}_i / \\varphi(q_i)^\\top \\mathbf{z}_i$。\n题 2（计算）：滑窗 vs 标准 #$L=32K$、$W=4K$、$d=64$：算标准与滑窗的单头 FLOPs 并给比值；若 $W=512$ 呢？\n题 2 解答 标准 $4\\times32768^2\\times64 \\approx 275$ GFLOP；$W=4K$ 时 $4\\times32768\\times4096\\times64 \\approx 34.4$ GFLOP，省 8 倍；$W=512$ 时 $\\approx 4.3$ GFLOP，省 64 倍。注意 KV 显存同样只跟 $W$ 相关。\n题 3（思考）：attention sink 为什么存在 #从 softmax 的归一化性质解释\u0026quot;初始 token 吸收注意力质量\u0026quot;这一现象，并说明 StreamingLLM 为什么\u0026quot;踢掉 sink 就崩、留两个 token 就恢复\u0026quot;。\n题 3 解答要点 softmax 把注意力质量归一化到 1；当窗口内没有\u0026quot;稳定的高分 token\u0026quot;时，分布被迫把质量分散到任意位置，数值上不稳定。初始 token 在训练里长期充当\u0026quot;兜底的高分目标\u0026quot;，模型学会了把多余质量倾泻到它身上（sink）。流式时若窗口不含 sink，归一化失去锚点；保留前几个 token 即恢复。这也是为什么预训练加专用占位 sink token 能进一步稳定。\n题 4（设计）：H2O 的驱逐策略 #设计一个\u0026quot;累计注意力分数\u0026quot;的在线度量（如何增量维护、如何防止早期 token 永远占优），并说明为什么\u0026quot;最近 token + Heavy Hitters\u0026quot;的组合优于纯最近/纯高频。\n题 4 解答要点 每个 token 维护\u0026quot;被作为 key 时收到的注意力分数之和\u0026quot;（可在每步并行累加，代价可摊销）。要防早期占优：用滑动窗口内的累计值或分数归一化。纯最近丢长程、纯高频丢局部上下文；混合保留兼顾两者，且驱逐可建模为动态子模问题近似最优。\n题 5（对比）：线性注意力 vs Mamba #列出线性注意力（Katharopoulos）与 Mamba 在\u0026quot;状态形式、选择性、训练并行性、精确性\u0026quot;四个维度上的差异。\n题 5 解答要点 线性注意力：状态 $\\mathbf{S}$（$d\\times d$）无选择性，训练可并行（矩阵乘法），是 softmax 的核近似；Mamba：状态 $h$（$dN$）有选择性（A/B/C 依赖输入），训练需硬件感知并行扫描，是全新架构而非注意力近似。选择性让 Mamba 能做内容相关记忆，代价是失去纯卷积式并行。\n题 6（编程）：窗口 + sink 模拟 #实现一个 toy：给定注意力分数序列，比较 ① 全注意力、② 纯窗口、③ 窗口 + sink（保留前 2 个 token）三种方案的\u0026quot;有效归一化质量\u0026quot;，并画出长度增长时的困惑度趋势，复现 StreamingLLM 的核心结论。\n题 6 解答要点 用 toy 分数分布模拟：纯窗口在长度超过窗口后，softmax 分母失去 sink 锚点，输出分布漂移；加 sink 后分母稳定。困惑度（或分布 KL）趋势应呈现\u0026quot;纯窗口骤升、sink+窗口平缓\u0026quot;——这就是 StreamingLLM 论文 Fig. 2 的 toy 版。\n14. 延伸阅读 # Efficient Streaming Language Models with Attention Sinks（arXiv:2309.17453）：StreamingLLM 与 attention sink 的出处。 H2O: Heavy-Hitter Oracle（arXiv:2306.14048）：KV 驱逐策略与吞吐数据。 Transformers are RNNs: Linear Attention（arXiv:2006.16236）：线性注意力与循环等价形式。 Rethinking Attention with Performers（arXiv:2009.14794）：随机特征近似 softmax。 Mamba（arXiv:2312.00752）：选择性 SSM 与硬件感知算法。 上一篇： 03 注意力头变体：MQA/GQA/MLA；下一篇：05 PagedAttention 与 KV 显存管理——把 KV 从连续大块分配改成分页小片，减少预留与碎片。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-04-%E7%A8%80%E7%96%8F%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E4%B8%8E%E7%BA%BF%E6%80%A7%E6%B3%A8%E6%84%8F%E5%8A%9B/","section":"笔记","summary":"对抗 L² 复杂度有三条路线：少看位置、少存 KV、换计算范式。本文讲滑动窗口注意力的局部性假设与 StreamingLLM 的 attention sink 修复，推导线性注意力的结合律与 Performer 的核近似，辨析 Mamba 的选择性 SSM 与线性注意力的本质区别，并给出场景选择表。","title":"稀疏注意力、滑动窗口和线性注意力怎么选"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： 稀疏注意力、滑动窗口和线性注意力怎么选｜下一篇： 注意力内核怎么优化\n对应：Kwon et al., Efficient Memory Management for Large Language Model Serving with PagedAttention（arXiv:2309.06180，SOSP 2023），vLLM 论文。 前置：01 章（KV cache 大小公式）、02 章（FlashAttention 的分块）、03 章（$d_{\\text{kv}}$ 压缩）。学完本章你应该能：① 说出 KV 显存管理的三种浪费（预留、内部碎片、外部碎片）与论文实测的有效利用率（20.4%–38.2%）；② 解释 PagedAttention 的\u0026quot;逻辑块→物理块\u0026quot;分页思想与 block table；③ 说明 PagedAttention 与 FlashAttention 的关系与区别；④ 解释 copy-on-write 如何让并行采样/beam search 共享 KV；⑤ 手算 KV 每 token 字节数与分块账本。\n目录（本章） # 本章目标 问题：KV 显存管理为什么低效 核心思想：像操作系统一样分页 PagedAttention：分块注意力计算 vLLM：块管理、按需分配与抢占调度 共享：Copy-on-Write 与解码算法 块大小权衡 KV 优化全景：维度、内容、布局 数值算例 实验数据 本章小结 习题与解答 延伸阅读 2. 问题：KV 显存管理为什么低效 #01 章算过 KV 账本：7B 模型 512KB/token。vLLM 论文用 OPT-13B 给出更直观的例子（9.1 节）：单请求的 KV cache 达到 GB 级。更糟的是，现有 serving 系统里这些显存大部分是浪费的：\n浪费 1（预留 reserved）：为\u0026#34;可能达到的最大长度\u0026#34;提前占位， 占着茅坑不拉屎，别的请求进不来 浪费 2（内部碎片）：请求实际长度 \u0026lt;\u0026lt; 最大长度，预分配的槽位用不满 浪费 3（外部碎片）：buddy allocator 等分配器产生的不连续空洞 论文实测（Fig. 2）：现有系统的 KV 显存只有 20.4%–38.2% 真正存了 token——约六到八成被浪费。同时 GPU 趋势是\u0026quot;算力翻倍、显存不涨\u0026quot;（A100→H100：FLOPS 翻倍，80GB 不变），显存会越来越是瓶颈。\n3. 核心思想：像操作系统一样分页 #操作系统解决\u0026quot;内存碎片 + 共享\u0026quot;的经典方案是虚拟内存分页。PagedAttention 把它搬进 GPU：\n把每个请求的 KV cache 切成固定大小的\u0026#34;逻辑块\u0026#34;（默认 16 token/块） 物理块：GPU DRAM 里预先划好的等大内存片 block table：记录\u0026#34;逻辑块 → 物理块\u0026#34;的映射 + 每块已填充位置数 为什么这样能治病：\n按需分配（要多少块给多少块）→ 消除预留与内部碎片 所有物理块等大、可任意排列 → 消除外部碎片 块是共享/复用的最小单位 → 支持跨请求共享（第 6 节） 4. PagedAttention：分块注意力计算 #KV 不再连续存放，注意力计算也要改成块级。设块大小 $B$，第 $j$ 个 key 块：\n$$ K_j = (k_{(j-1)B+1}, \\dots, k_{jB}), \\qquad V_j = (v_{(j-1)B+1}, \\dots, v_{jB}) $$注意力输出按块累加：\n$$ \\mathbf{O}_i = \\sum_j \\mathbf{P}_{ij} \\mathbf{V}_j, \\qquad \\mathbf{S}_{ij} = \\mathbf{Q}_i \\mathbf{K}_j^\\top $$softmax 的归一化跨块进行——用的正是 02 章 online softmax 的机制（运行 max/ℓ 逐块合并）。所以：\nFlashAttention 解决\u0026#34;怎么在 SRAM 里高效算\u0026#34; PagedAttention 解决\u0026#34;KV 在 HBM 里怎么放\u0026#34;（非连续、可共享） 两者正交，工程上同时使用 PagedAttention 的额外挑战：一个 batch 里各请求长度不同、块位置不同，注意力 kernel 要按 block table 动态取块并处理变长序列。\n5. vLLM：块管理、按需分配与抢占调度 #vLLM 把 PagedAttention 做成完整 serving 引擎：\n① 块引擎：GPU DRAM 划成物理块池；每个请求一张 block table ② 按需分配：token 只进已填满块之后的下一个空位，满块才申请新物理块 → 请求级浪费被压到\u0026#34;一个块以内\u0026#34; ③ 抢占调度：显存不足时挂起请求、释放其块（或换到 CPU RAM）， 再按 block table 恢复——类似 OS 的换页 ④ 连续批处理：每次迭代把\u0026#34;能算的请求\u0026#34;打包，与块管理协同 结果：省出来的显存直接换成更大的 batch，吞吐随之提升。\n6. 共享：Copy-on-Write 与解码算法 #6.1 并行采样 #一个 prompt 生成多个输出时，prompt 部分的 KV 完全相同，可以让多条输出共享同一批物理块。只有各自新生成的 token 需要独占空间；如果新 token 要写进一个被共享的旧块，就用 copy-on-write（COW）：复制该块、改引用计数，不污染其他输出。\n6.2 Beam Search #beam search 的多个候选共享 prompt，解码过程中还会动态分叉/合并，共享模式像 OS 的进程树。vLLM 按块管理引用计数：\n候选被淘汰 → 引用计数减一 → 归零的物理块释放复用 新候选加入 → 分配新物理块 论文报告：beam search 场景下共享可省最多 55% 的 KV 显存 对比：旧系统要在候选之间拷贝 KV（代价高）；分页共享让\u0026quot;复制\u0026quot;退化为\u0026quot;多一行 block table 指向同一物理块\u0026quot;。\n7. 块大小权衡 #$$ \\text{块越大：} \\begin{cases} \\text{好：一次 kernel 处理更多 token，并行度高、延迟低} \\\\ \\text{坏：最后一个块可能用不满 → 内部碎片变大} \\end{cases} $$$$ \\text{块越小：} \\text{碎片少，但 kernel 开销/块表开销大} $$默认 16 token/块是实践折中；论文 §7.2 专门做了块大小敏感性实验。碎片与并行度的平衡点取决于模型与负载。\n8. KV 优化全景：维度、内容、布局 #把 03/04/05 三章放在一张图里：\nKV cache 优化 ├── 维度（03 章）：MQA/GQA/MLA —— 每 token 存多少 ├── 内容（04 章）：滑窗/驱逐/稀疏 —— 存哪些 token └── 布局（05 章）：PagedAttention —— 怎么存放、怎么共享 三者可叠加：MLA 减少每 token 字节 → H2O 决定留谁 → 分页管理剩余 9. 数值算例 #9.1 OPT-13B 账本（论文原例） #$$ \\text{每 token： } 2 \\times 5120 \\times 40 \\times 2 = 800\\ \\text{KB} $$$$ \\text{单请求上限 2048 token： } 800\\ \\text{KB} \\times 2048 = 1.6\\ \\text{GB} $$9.2 分页示例 #7B 模型（512KB/token）、块大小 16 token：一条 40 token 的请求需要 $40/16 \\to 3$ 个逻辑块（16+16+8），映射到物理块（如 5, 2, 9 号）——物理上不连续、按需分配：\n逻辑块 1 → 物理块 5（满） 逻辑块 2 → 物理块 2（满） 逻辑块 3 → 物理块 9（8/16 填充） 若三个请求共享同一 prompt（并行采样），逻辑块 1 可以指向同一个物理块 5，只各配一块新的 COW 块。\n10. 实验数据 # 指标 数据 出处 现有系统 KV 有效利用率 仅 20.4%–38.2% vLLM Fig. 2 OPT-13B KV 账本 800KB/token；2048 token = 1.6GB vLLM §3.2 vLLM 吞吐 比 FasterTransformer/Orca 高 2–4x（同等延迟，不影响精度） vLLM 摘要 beam search 共享 最多省 55% KV 显存 vLLM §6.3 块大小 默认 16 token/块；§7.2 做敏感性分析 vLLM §4.1/§7.2 11. 本章小结 # 问题：KV 显存浪费来自预留、内部碎片、外部碎片。 方案：分页（固定大小逻辑块 + block table + 按需分配），把碎片压到\u0026quot;一个块以内\u0026quot;。 计算：PagedAttention 用 02 章的 online softmax 逐块合并；与 FlashAttention 正交叠加。 共享：COW + 引用计数让并行采样、beam search 共享 KV。 全景：维度（03）→ 内容（04）→ 布局（05），三层可叠加。 一句话记忆：\u0026ldquo;KV 显存管理就是给 GPU 装一个操作系统——把整块地皮切成统一大小的页，谁要谁领、不用就还，多个进程（beam/采样）还能共享只读页。\u0026rdquo;\n12. 习题与解答 #题 1（计算）：KV 账本与分块 #LLaMA-2 70B（80 层、GQA-8、$d=8192$、$d_{\\text{head}}=128$、BF16）：① 每 token KV 字节数；② 若块大小 16，一条 1000 token 请求需要多少逻辑块；③ 最后一块的填充率。\n题 1 解答 ① $2 \\times 80 \\times 8 \\times 128 \\times 2 = 320\\ \\text{KB/token}$。② $1000/16 = 62.5 \\to 63$ 个逻辑块。③ 前 62 块满（$62\\times16=992$），第 63 块填充 $8/16 = 50\\%$——整条请求的浪费被压到\u0026quot;不到一个块\u0026quot;。\n题 2（推导）：为什么\u0026quot;等大块 + 按需分配\u0026quot;同时消两种碎片 #解释内部碎片与外部碎片各自的成因，以及分页方案分别怎么消除。\n题 2 解答 内部碎片来自\u0026quot;预分配最大长度\u0026quot;（预留超过实际所需）；按需分配让每条请求只占用已产生的 token 的块，浪费被限制在最后一个不满块内。外部碎片来自\u0026quot;不同请求预分配不同大小\u0026quot;造成的分配器空洞；所有物理块等大、逻辑到物理自由映射，空洞不再存在。\n题 3（思考）：PagedAttention vs FlashAttention #两者都\u0026quot;分块\u0026quot;，解决的是同一个问题吗？工程上如何叠加？\n题 3 解答要点 不是。FlashAttention 解决\u0026quot;计算时中间矩阵不落 HBM\u0026quot;（IO 优化，KV 仍是连续存储）；PagedAttention 解决\u0026quot;KV 在 HBM 里的布局与共享\u0026quot;（内存管理）。FlashAttention kernel 处理连续块，PagedAttention kernel 按 block table 取非连续块；vLLM 等引擎两者同时启用。\n题 4（设计）：COW 引用计数 #并行采样 4 条输出共享 prompt 的物理块 7。① 第 3 条输出要写入块 7 的新位置，流程是什么？② 块 7 的引用计数如何变化？\n题 4 解答 ① 检测到块 7 被 4 条输出共享 → 复制块 7 为新物理块 7\u0026rsquo;，把第 3 条输出的 block table 指向 7\u0026rsquo;，其余 3 条仍指向 7；写入 7\u0026rsquo; 的新 token。② 7 的引用计数从 4 降到 3；7\u0026rsquo; 引用计数为 1。任何输出结束后引用计数减一，归零即释放。\n题 5（对比）：三种\u0026quot;省 KV\u0026quot;的层次 #用一句话分别说明 MLA（03）、H2O/StreamingLLM（04）、PagedAttention（05）在 KV 上动的是什么，并给一个三者叠加的部署组合。\n题 5 解答要点 MLA：每 token 存更少（维度）；H2O/StreamingLLM：存更少的 token（内容）；PagedAttention：存得更紧凑、可共享（布局）。叠加示例：MLA 压缩维度 + H2O 驱逐低频 token + 分页管理剩余 KV 并让并行采样共享。\n题 6（编程）：分块分配模拟器 #实现一个简单模拟器：给定请求到达/离开序列与块大小，① 按需分配物理块（block table）；② 统计三种方案的碎片率：预分配最大长度 / 按需分配 / 统一分页；③ 验证\u0026quot;按需分页\u0026quot;碎片率趋近 0。\n题 6 解答要点 预分配：每条请求占\u0026quot;最大长度/块\u0026quot;块，请求提前结束时大量空闲；按需：请求结束时只剩最后一个不满块；统一分页 + 引用计数：请求间可复用、释放即时。统计总占用/总分配即可复现 vLLM Fig. 2 的结论。\n13. 延伸阅读 # Efficient Memory Management for LLM Serving with PagedAttention（arXiv:2309.06180）：本章全部内容的出处（§3 浪费分析、§4 算法、§6 共享、§7 块大小）。 vLLM 文档：PagedAttention 的生产实现、前缀缓存、并行采样。 RadixAttention / SGLang（arXiv:2312.07104）：前缀缓存的树形管理，PagedAttention 思想的延伸。 上一篇： 04 稀疏、滑动窗口与线性注意力；下一篇：06 内核优化与算子融合——从算法回到硬件：FLOPs/带宽模型、算子融合、Tensor Core、FP8 注意力与编译优化。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-05-pagedattention%E4%B8%8Ekv%E6%98%BE%E5%AD%98%E7%AE%A1%E7%90%86/","section":"笔记","summary":"vLLM 论文实测显示，不做管理的 KV 显存有效利用率只有 20.4%–38.2%，浪费来自预留、内部碎片与外部碎片。本文讲清 PagedAttention 的逻辑块到物理块映射与 block table，辨析它与 FlashAttention 的关系，并解释 copy-on-write 如何让并行采样共享 KV。","title":"PagedAttention 是怎么省下 KV Cache 显存的？"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： PagedAttention 是怎么省下 KV Cache 显存的｜下一篇： 注意力优化上线怎么验收\n对应：Williams et al., Roofline: An Insightful Visual Performance Model for Multicore Architectures（2009）；FlashAttention 系列（02 章已核实数据）；vLLM / TensorRT-LLM / Triton 工程实践。 前置：01 章（FLOPs 与 KV 账本）、02 章（IO 感知）、03/05 章（KV 优化）、量化系列 03 章（带宽模型）。学完本章你应该能：① 用算术强度（FLOPs/byte）判断一个 kernel 是计算受限还是带宽受限；② 推导 decode 与 prefill 分别落在 Roofline 的哪一侧；③ 说出算子融合的三种层次（elementwise、reduction、整体融合）与 FlashAttention 融合了什么；④ 解释 Tensor Core 与 FP8 张量核对注意力的意义；⑤ 对比 CUDA Graph、Triton、torch.compile 的适用场景；⑥ 说出 cuBLAS/CUTLASS/CuTe/FlashInfer/DeepGEMM 的分工；⑦ 用 ops/byte 判断 H100/B200 的算力-带宽平衡，并解释为什么 FP8 主要利好 prefill。\n目录（本章） # 本章目标 硬件性能模型：Roofline 与算术强度 decode 带宽受限、prefill 计算受限 算子融合：三种层次 Tensor Core 与矩阵乘组织 FP8 注意力与低精度内核 GEMM 内核栈与 ops/byte 数据 CUDA Graph、Triton 与编译优化 注意力内核的效率曲线（FA1→FA3） 数值算例：Roofline 判定 本章小结 习题与解答 延伸阅读 2. 硬件性能模型：Roofline 与算术强度 #一个 kernel 快不快，先问一句：它缺的是算力还是带宽？ 定义算术强度：\n$$ \\text{Arithmetic Intensity} = \\frac{\\text{FLOPs}}{\\text{HBM bytes}} $$Roofline 模型给出两个天花板：\n$$ \\text{峰值} \\le \\min\\left(\\text{峰值 FLOPs/s},\\ \\text{峰值带宽} \\times \\text{算术强度}\\right) $$算术强度低于\u0026#34;山脊\u0026#34;（ridge point）→ 带宽受限：加算力没用，减搬移才有用 算术强度高于山脊 → 计算受限：加算力/减 FLOPs 才有用 A100 的量级：约 312 TFLOPS（BF16）/ 2 TB/s ≈ 山脊在 150 FLOP/byte 附近。\n3. decode 带宽受限、prefill 计算受限 #3.1 decode（单 token） #每步 FLOPs ≈ 全部层的注意力 + MLP：\n$$ \\text{FLOPs} \\approx n_{\\text{layers}} \\times \\left(4Ld + 8d^2\\right) $$每步搬移的字节 ≈ 权重（$2 \\times$ 参数量）+ KV（02/03 章）：\n$$ \\text{bytes} \\approx \\text{weights} + 2 L\\, d_{\\text{kv}} n_{\\text{layers}} b $$7B 模型、$L=4K$ 的账本见 10.1 节：算术强度不到 1，远低于山脊 → 带宽受限。\n3.2 prefill（长输入） #注意力单层 FLOPs $= 4L^2d$，输入字节约 $3Ld$：\n$$ \\text{AI}_{\\text{attn}} \\approx \\frac{4L^2d}{3Ld} = \\frac{4L}{3} $$$L = 4096$ 时已远高于山脊 → 计算受限（10.2 节给出具体数值）。\n3.3 推论 #decode 优化 → 减搬移（量化权重、GQA/MLA 减 KV、分页防浪费） prefill 优化 → 减 FLOPs 或提高利用率（FlashAttention、稀疏/线性、FP8 张量核） 这解释了整个系列的路线选择：02 章 FlashAttention 主攻 prefill，03/05 章主攻 decode。\n4. 算子融合：三种层次 #\u0026ldquo;融合\u0026rdquo;= 把多个 kernel 合并成一个，减少两件事：kernel 启动开销和中间张量在 HBM 的读写。\n4.1 Elementwise 融合 #逐元素算子（激活、残差、缩放）读写比极低，最该融合：\n例：LayerNorm + residual + dropout + 激活 → 一个 kernel 收益：省 4 次中间张量落盘 + 4 次 kernel 启动 4.2 Reduction 融合 #含归约的算子（softmax、normalization）与相邻计算融合，避免中间结果落盘：\n例：FlashAttention 的整个注意力 = 一个融合 kernel QK^T（GEMM）→ 掩码 → rowmax → exp → rowsum → rescale → PV（GEMM） 全在 SRAM 里完成，S/P 矩阵永不落 HBM（02 章） 4.3 整体 kernel 融合（层级） #把一层的前向合成一个或少数几个 kernel（如 QKV 投影融合、MLP 两段融合、MQA/GQA 的 KV 头广播融合）。现代引擎（TensorRT-LLM、vLLM 的 CUDA 核）大量采用。\n5. Tensor Core 与矩阵乘组织 #注意力最贵的两次 GEMM（QKᵀ、PV）在 Tensor Core 上执行。关键事实：\n优化过的 GEMM 能到 80–90% 理论峰值（FA2 论文实测） 而 FA1 注意力只到 30–50%（前向）、25–35%（反向） → 差距全部来自\u0026#34;注意力里非 GEMM 的部分\u0026#34;和 IO 组织 FA2/FA3 的优化都在缩小这个差距：\nFA2：warp 间划分 KV 维度，减少共享内存读写 FA3：wgmma（warpgroup 矩阵乘）+ TMA 异步搬运 + softmax 藏在 GEMM 下 具体利用率数据见第 9 节的效率曲线。\n6. FP8 注意力与低精度内核 #Hopper/Blackwell 的 FP8 张量核吞吐是 FP16 的约 2 倍。注意力用 FP8 有两个难点：\n① 数值：注意力分数/softmax 对精度敏感（01 章结论） → FA3 用块级量化（per-block scale）+ incoherent processing 打散离群值 → 误差比基线 FP8 注意力低 2.6 倍 ② 布局：WGMMA 对 FP8 操作数的内存布局有严格要求，需要专门的转换 注意：FP8 注意力是\u0026quot;近似\u0026quot;（低精度），与 FlashAttention 的\u0026quot;精确\u0026quot;是两回事——前者省的是数值位宽，后者省的是 IO。生产上两者可叠加（如 QServe 的 FP8 Attention，量化系列 11 章）。\n7. GEMM 内核栈与 ops/byte 数据 #注意力（以及整个 transformer 前向）的主要计算是 GEMM。从黑盒到可编程，内核栈通常分这几层：\n层 工具 定位 厂商库 cuBLAS 通用 GEMM 黑盒，覆盖最广，不可定制 模板库 CUTLASS 可组合的 GEMM 模板（tile、swizzle、流水线均可改） 元编程 CuTe CUTLASS 的布局/张量抽象，写新内核的\u0026quot;积木\u0026quot; 注意力专用 FlashInfer 面向 LLM serving 的注意力模板库（分页、前缀缓存友好） MoE/超低精度 DeepGEMM DeepSeek 开源的 FP8 GEMM，面向 MoE 与细粒度量化 FlashAttention 类内核 = 在 CUTLASS/CuTe 之上写注意力专用 GEMM。02/06 章讨论的融合都落在这种内核里。\n7.1 ops/byte：这台机器到底\u0026quot;喂\u0026quot;得起多少算力 #把 Roofline 的\u0026quot;山脊\u0026quot;（ridge point）算出来，就能知道机器偏爱哪类算法：\n机器 FP16/BF16（TFLOPS） HBM 带宽（TB/s） 山脊 = ops/byte H100 989 3.35 ≈ 295 B200 ≈ 2250 8.0 ≈ 281 含义：机器大约\u0026quot;喂\u0026quot;得起约 300 FLOP/byte 的算法。本章的 decode（AI ≈ 0.4）与 prefill 注意力（AI ≈ 5461）都远离山脊，一个在带宽侧、一个在计算侧。FP8 把张量核吞吐翻倍（H100 989→1979 TFLOPS），山脊也翻倍到 ≈ 590——计算受限的 prefill 直接受益；decode 的 AI 仍远低于 590，FP8 对 decode 的收益来自 KV/权重字节减半（带宽侧），算力翻倍帮不上忙。\n7.2 内核栈的选型逻辑 #快速上线、通用形状 → cuBLAS（黑盒） 榨干特定形状/融合 → CUTLASS / CuTe 手写 做 LLM serving → FlashInfer 等注意力库（分页/前缀已内置） MoE / 超低精度 → DeepGEMM 这类专用内核 8. CUDA Graph、Triton 与编译优化 #CUDA Graph：把一串 kernel launch 固化成图，一次提交、GPU 端自动调度 → 消除 CPU 端 launch 开销（小 batch/短序列时收益显著） → 推理引擎（vLLM 等）普遍使用 Triton：类 Python 的 kernel 语言，自动做 tile 划分与共享内存分配 → 让研究者写出接近手写 CUDA 性能的 kernel（FlashAttention 有 Triton 版） torch.compile：把 PyTorch 计算图做算子融合 + 代码生成 → 训练/研究场景的开箱即用优化 选择逻辑：追求极致性能且有工程人力 → 手写/FA 库；需要快速迭代 → Triton / torch.compile；部署固定形状 → CUDA Graph + 预编译引擎。\n9. 注意力内核的效率曲线（FA1→FA3） # 实现 峰值利用率 说明 朴素 PyTorch 注意力 ~低 中间矩阵多次落盘 FlashAttention-1 30–50%（前向） 提出 IO 感知框架 FlashAttention-2 73%（230 TFLOPS on A100） 并行与工作划分 FlashAttention-3 75%（740 TFLOPS on H100）；FP8 ≈1.2 PFLOPs 异步 + 低精度 优化 GEMM 80–90% 注意力的\u0026quot;天花板参照\u0026quot; 从 30% 到 75%，增量主要来自把 mask、softmax 这些非 GEMM 步骤藏进 GEMM 流水线。\n10. 数值算例：Roofline 判定 #10.1 decode：7B、$L=4K$ #$$ \\text{FLOPs} \\approx 32 \\times (4\\times4096\\times4096 + 8\\times4096^2) = 32 \\times 2.01\\times10^8 \\approx 6.4\\ \\text{GFLOP} $$$$ \\text{bytes} \\approx 13\\ \\text{GB（权重）} + 2\\ \\text{GB（KV）} = 15\\ \\text{GB} $$$$ \\text{AI} = 6.4/15000 \\approx 0.43\\ \\text{FLOP/byte} \\ll 150 \\Rightarrow \\textbf{带宽受限} $$10.2 prefill：$L=4K$ 单层注意力 #$$ \\text{AI} = \\frac{4L^2d}{3Ld} = \\frac{4L}{3} = 5461 \\gg 150 \\Rightarrow \\textbf{计算受限} $$10.3 优化方向验证 #decode：权重减半 → 每步搬移 15→8.5 GB，时间约 0.57x ✓（量化系列 03 章） prefill：FP8 张量核（FLOPs/s 翻倍）→ 长 prefill 明显提速 ✓（FA3） 11. 本章小结 # Roofline 是决策框架：先算算术强度，再决定\u0026quot;减搬移\u0026quot;还是\u0026quot;减 FLOPs\u0026quot;。 decode 带宽受限、prefill 计算受限——整个系列的优化路线由此展开。 融合三层次：elementwise → reduction → 整体；FlashAttention 是 reduction 融合的典范。 Tensor Core + FP8 是算力侧的两大杠杆；FP8 注意力需要块级量化与 incoherent processing。 工程手段：CUDA Graph 消启动、Triton/torch.compile 提效率。 GEMM 内核栈：cuBLAS → CUTLASS/CuTe → FlashInfer/DeepGEMM。 一句话记忆：\u0026ldquo;先问 Roofline 缺什么：decode 缺带宽就给内存做减法（量化/GQA/分页），prefill 缺算力就给计算做减法（FlashAttention/FP8/稀疏）。\u0026rdquo;\n12. 习题与解答 #题 1（推导）：decode 的算术强度 #推导 decode 每步 FLOPs 与搬移字节的表达式，并说明\u0026quot;为什么加算力救不了 decode\u0026quot;。\n题 1 解答 FLOPs $\\approx n_{\\text{layers}}(4Ld + 8d^2)$，bytes $\\approx$ 权重 + $2L d_{\\text{kv}} n_{\\text{layers}} b$。7B/4K 时 AI ≈ 0.4，远低于 A100 山脊（~150），处于带宽受限区——此时 FLOPs/s 再高也白搭，只能减搬移（量化权重、GQA/MLA、分页）。\n题 2（计算）：Roofline 判定 #70B 模型 decode（$L=4K$、权重 130GB、GQA-8 的 KV 每 token 320KB）：算 FLOPs、bytes、AI，并判断瓶颈。\n题 2 解答 FLOPs ≈ $80\\times(4\\times4096\\times8192 + 8\\times8192^2) = 80\\times(1.34\\times10^8 + 5.37\\times10^8) \\approx 54$ GFLOP；bytes ≈ $130 + 320\\text{KB}\\times4096 = 130 + 1.25 \\approx 131$ GB；AI ≈ 0.41 → 带宽受限。KV 只占 1%：70B 的 decode 瓶颈几乎全在权重搬移（这也是量化对超大模型收益大的原因）。\n题 3（思考）：为什么 FA 是\u0026quot;融合\u0026quot;不是\u0026quot;稀疏\u0026quot; #说明 FlashAttention 与稀疏/线性注意力的本质区别，以及为什么前者在\u0026quot;精确性\u0026quot;上零代价。\n题 3 解答要点 FA 不改变注意力数学，只改变计算组织（分块 + 在线 softmax + 重算），结果逐位等价；稀疏/线性改变\u0026quot;看哪些 key\u0026quot;或\u0026quot;用什么核\u0026quot;，是近似。融合省的是 IO 和启动开销，近似省的是 FLOPs 本身——两者不冲突，可叠加。\n题 4（设计）：给注意力列融合清单 #列出从\u0026quot;朴素三步注意力\u0026quot;到 FlashAttention 之间融合/消除的 kernel 与中间张量，指出每一处省的是什么（启动？HBM 读写？）。\n题 4 解答要点 朴素：QKᵀ kernel → 写 S（HBM）→ softmax kernel → 读 S 写 P（HBM）→ PV kernel → 读 P。融合后：单个 kernel 内完成 GEMM→mask→rowmax→exp→rowsum→rescale→GEMM，S/P 只在 SRAM；省 4 次 HBM 读写 + 3 次 kernel 启动。反向的 S/P 重算省掉 O(N²) 存盘。\n题 5（对比）：FP8 注意力 vs FlashAttention 的\u0026quot;快\u0026quot; #两者都叫\u0026quot;加速注意力\u0026quot;，省的东西各是什么？生产上如何叠加，风险在哪？\n题 5 解答要点 FlashAttention 省 HBM 访问（IO），结果精确；FP8 省每字节位数与张量核吞吐翻倍，结果是近似（需块级量化 + incoherent processing 保精度）。叠加 = 融合 kernel 内用 FP8 张量核；风险是数值误差复合，需要 07 章的精度验收。\n题 6（编程）：kernel 启动开销测量 #写一个 PyTorch 实验：对同一计算（如 LayerNorm+ReLU+残差），比较\u0026quot;三个 kernel\u0026quot;与\u0026quot;融合实现（torch.compile 或手写 CUDA）\u0026ldquo;的耗时，记录 GPU kernel 数量（可用 torch.profiler），并解释小输入时融合收益为什么更大。\n题 6 解答要点 torch.profiler 会显示 kernel 个数从 3+ 降到 1；小输入时每个 kernel 的启动/调度开销占比高，融合收益最大；大输入时带宽占主导，融合主要省中间张量读写。这正好复现第 2 节的\u0026quot;IO 稀缺\u0026quot;观点。\n题 7（计算）：ops/byte 视角下的 FP8 #H100 FP8 张量核吞吐 1979 TFLOPS、带宽 3.35 TB/s。解释为什么\u0026quot;FP8 注意力对 prefill 有效、对 decode 帮助有限\u0026rdquo;，并给出判断依据。\n题 7 解答要点 FP8 后山脊 1979/3.35 ≈ 590 ops/byte。prefill 注意力的 AI ≈ 4L/3（$L=4096$ 时约 5461）远高于山脊 → 计算受限，FLOPs/s 翻倍直接转化为提速。decode 的 AI ≈ 0.4 仍远低于 590 → 带宽受限，算力翻倍无济于事；FP8 对 decode 的真实收益是 KV/权重字节减半（带宽侧）。如果只给注意力用 FP8 而不量化权重/KV，decode 几乎无感——这正是量化系列\u0026quot;先看带宽再看算力\u0026quot;的结论。\n13. 延伸阅读 # Roofline: An Insightful Visual Performance Model（Williams et al., 2009）：本章性能模型的原始出处。 FlashAttention 三篇论文（02 章）：效率曲线的全部数据来源。 Triton 官方文档：kernel 编写与自动优化。 量化系列 03/11 章：带宽模型与 FP8 Attention 的部署案例。 CUTLASS / CuTe：可组合 GEMM 模板与布局抽象。 FlashInfer：LLM serving 的注意力模板库（分页/前缀缓存友好）。 DeepGEMM：DeepSeek 开源的 FP8 GEMM。 上一篇： 05 PagedAttention 与 KV 显存管理；下一篇：07 系统集成与生产验收（部署决策与验收协议），再下一篇 08 前缀缓存与 KV 复用。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-06-%E5%86%85%E6%A0%B8%E4%BC%98%E5%8C%96%E4%B8%8E%E7%AE%97%E5%AD%90%E8%9E%8D%E5%90%88/","section":"笔记","summary":"用算术强度 FLOPs/byte 判断一个 kernel 是计算受限还是带宽受限，说明 decode 与 prefill 分别落在 Roofline 的哪一侧。本文讲算子融合的三个层次、Tensor Core 与 FP8 对注意力的意义，对比 CUDA Graph / Triton / torch.compile 的适用场景。","title":"注意力内核怎么优化？算子融合、CUDA Graph 与 Triton"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： 注意力内核怎么优化｜下一篇： SGLang RadixAttention 原理是什么\n对应：本系列 01–06 章的工程综合；vLLM / SGLang / TensorRT-LLM 实践；量化系列 10 章（质量评估）与 11 章（系统部署）方法论。本系列的系统集成章。 前置：01–06 章全部内容。学完本章你应该能：① 画出\u0026quot;注意力优化四层次\u0026quot;（维度/内容/布局/内核）与\u0026quot;推理三因子\u0026quot;（每步成本 × 步数 × 单步内部效率）的组合框架；② 给长上下文系统列出一份完整组件清单；③ 区分\u0026quot;精确\u0026quot;与\u0026quot;近似\u0026quot;的注意力优化并分别设计验收；④ 手算一个\u0026quot;量化 + GQA + 推测\u0026quot;端到端收益算例；⑤ 按四类业务场景给出技术选型与验收协议。\n目录（本章） # 本章目标 全系列回顾：注意力优化的四个层次 组合框架：推理三因子 长上下文系统的组件清单 精确 vs 近似：注意力优化的分类 验收协议 决策树：四类场景 数值算例：端到端组合收益 实现细节与坑 本章小结与系列收尾 习题与解答 延伸阅读 2. 全系列回顾：注意力优化的四个层次 #维度（03 章）：每 token 存多少 KV —— MQA / GQA / MLA 内容（04 章）：存哪些 token —— 滑窗 / H2O / StreamingLLM 布局（05/08 章）：怎么存放与共享 —— PagedAttention / COW / 前缀缓存 内核（02/06 章）：怎么算得快 —— FlashAttention / 融合 / FP8 四层作用在不同环节，可以叠加：MLA 压维度 → H2O 挑内容 → 分页管布局 → FlashAttention/FP8 提速计算。\n3. 组合框架：推理三因子 #把注意力、量化、推测解码三个系列的账合起来，端到端延迟可写成：\n$$ \\text{总墙钟} \\approx \\underbrace{\\text{每步成本}}_{\\text{量化}} \\times \\underbrace{\\text{步数}}_{\\text{推测解码}} \\times \\underbrace{\\text{单步内部效率}}_{\\text{注意力与内核（本系列）}} $$但要小心重复计算：\n量化（W4A16）：权重搬移减半 → 每步成本 ÷2 GQA/MLA：KV 搬移减为 1/8~1/57 → 每步成本再降（长上下文时显著） FlashAttention：省 IO、提利用率 → prefill 变快 推测解码：步数 ÷2~3.5 端到端 = 各因子乘积，但 KV 与权重的节省不能各按倍数相乘（见第 8 节算例） 4. 长上下文系统的组件清单 #一份\u0026quot;能支撑 128K 上下文、高并发\u0026quot;的组件清单：\n① 计算内核：FlashAttention-2/3（prefill）+ 高效 decode 内核 ② KV 维度：GQA 或 MLA（长上下文标配） ③ KV 布局：PagedAttention 分页 + 前缀缓存 + COW 共享 ④ KV 数值：KV8/KV4 量化（显存再降，需验收） ⑤ 权重：W4A16 或 W8A8（每步带宽减半） ⑥ 调度：连续批处理 + 抢占（vLLM/SGLang/TensorRT-LLM） ⑦ 可选近似：StreamingLLM/H2O（显存或延迟再压一档，接受质量代价） 5. 精确 vs 近似：注意力优化的分类 # 方法 类别 说明 FlashAttention 1/2/3 精确 结果逐位等价（浮点舍入内） MQA/GQA/MLA 精确（架构不同） 不近似注意力，只改参数量/表示 PagedAttention/前缀缓存 精确 只改存放，不改计算 滑窗 / StreamingLLM / H2O 近似 硬性截断/驱逐信息 FP8 注意力 近似 低精度（块级量化可缓解） 线性注意力 / Mamba 架构不同 softmax 被替换/全新架构 验收第一条铁律：精确类可以直接上线（性能验收即可）；近似类必须过质量关，且要在\u0026quot;最坏场景\u0026quot;（超长、超预算）下测。\n6. 验收协议 #6.1 质量验收（近似类必做） #perplexity：最便宜，但只反映\u0026#34;分布像不像\u0026#34; 长程任务：LongBench / LRA / 多跳问答（验证\u0026#34;被截断/驱逐的信息真的不重要\u0026#34;） 任务 benchmark：HumanEval / MMLU / 定制评测 压力测试：长度超出训练长度、KV 预算减半时，质量退化曲线必须可接受 6.2 性能验收 # 指标 关注点 TTFT prefill 内核（FA/FP8）的效果 TPS decode 带宽（KV 维度/布局/量化）的效果 显存峰值 KV 是否成为 batch 瓶颈（分页后看实际利用率） 吞吐（req/s） 组合后的服务级收益 P99 长尾（驱逐/抢占可能引入抖动） 6.3 组合矩阵 #不要只测单因子：\nMHA GQA/MLA BF16 + FA （基线） 质量+性能 W4A16 + FA 质量+性能 质量+性能 ← 上线候选 W4A16KV4 + FA 质量+性能 质量+性能 + 推测解码 每格再叠步数因子 每个有损项（量化、FP8、驱逐）单独与组合都要测——误差会复合（量化系列 10 章的结论在这里同样适用）。\n7. 决策树：四类场景 #长上下文问答（单请求长 prompt，延迟敏感）： → FA3/FP8（prefill）+ MLA/GQA + 分页 + 前缀缓存 高并发在线服务（吞吐优先）： → vLLM 分页 + 连续批处理 + W4A16 + GQA → 推测解码按实测收益决定 端侧 / 小显存（8GB 级）： → W4A16KV4 + GQA/MLA + 滑窗/StreamingLLM（必要时） 研究 / 训练： → FA2/FA3 + torch.compile；长序列实验用线性注意力/Mamba 作对照 8. 数值算例：端到端组合收益 #7B、decode、$L=4K$、HBM 带宽 2TB/s。基线每步：\n$$ \\text{搬移} = 13\\ \\text{GB（权重）} + 2\\ \\text{GB（KV，MHA）} = 15\\ \\text{GB} $$$$ t_{\\text{step}} = 15/2000 = 7.5\\ \\text{ms} $$逐层叠加（每一步的搬移都要重新算，不能重复计）：\n步骤 搬移 每步时间 累计 基线（MHA） 15 GB 7.5 ms 1.0x + GQA（KV 2→0.5 GB） 13.5 GB 6.75 ms 1.11x + W4A16（权重 13→3.25 GB） 3.75 GB 1.875 ms 4.0x + 推测解码（步数 ÷3） — 有效 0.625 ms 12x 关键点：\nGQA 省的是 KV 部分（基线里只占 13%），所以单独看收益小； 但上下文越长（32K/128K）KV 占比越大，GQA 收益越大（01 章） 量化省权重（占比 87%），与 GQA 作用在不同项上，两项收益可以相加 推测在步数维度上叠加 → 三因子乘积成立 9. 实现细节与坑 # 把近似当精确：FP8/驱逐/线性注意力上线前必须过质量关。 只测短序列：长上下文下 KV 占比、注意力 FLOPs 都变，短序列结论会误导。 只测单请求：批处理下显存与调度行为完全不同。 组合收益重复计算：权重与 KV 的节省分开记账（第 8 节）。 KV 显存不测：分页后看\u0026quot;实际利用率\u0026quot;，而不是\u0026quot;分配了多少\u0026quot;。 用错基线：与生产引擎（vLLM/TensorRT-LLM）同配置对比，别拿 eager PyTorch 比。 误差复合不验收：量化 × FP8 × 驱逐叠在一起，必须组合矩阵全测。 内核与硬件不匹配：FA3 需要 Hopper+，FP8 需要对应张量核；换卡要重测。 10. 本章小结与系列收尾 # 四层次：维度、内容、布局、内核，作用在不同环节，可以叠加。 三因子：每步成本（量化）× 步数（推测）× 单步内部效率（本系列）。 精确/近似分类决定验收深度；组合矩阵防误差复合。 决策树：长上下文/高并发/端侧/研究各有最优组合。 系列收尾：00–08 一句话记忆 #00 地图：注意力是\u0026#34;单步内部\u0026#34;的主战场，与量化/推测正交 01 基础：4L²d 的 FLOPs、KV 账本、prefill 计算密集 vs decode 带宽密集 02 FlashAttention：中间矩阵不落地，online softmax 保证精确，IO 最优 03 MQA/GQA/MLA：把每 token 的 KV 从 h 份砍到 1 份或一个潜向量 04 稀疏/线性：少看（窗口/驱逐）或换核（线性/SSM），都是近似 05 PagedAttention：像 OS 分页一样管 KV，碎片趋零、可共享 06 内核：Roofline 判瓶颈，融合 + Tensor Core + FP8 逼近 GEMM 效率 07 集成：四层次 × 三因子，精确类直接上，近似类过质量关 08 前缀缓存：KV 只依赖前缀——radix tree 记住 KV，命中率 h 省 h 的 prefill 一句话记忆（全系列）：\u0026ldquo;存少点（03）、看少点（04）、排好点（05）、记住点（08）、算快点（02/06）；上线前按\u0026rsquo;精确还是近似\u0026rsquo;分别验收。\u0026rdquo;\n11. 习题与解答 #题 1（推导）：组合不重复计数 #说明为什么\u0026quot;GQA 省 4 倍 + 量化省 2 倍 = 8 倍\u0026quot;是错的，给出正确的合并方式。\n题 1 解答 两个优化作用在不同的搬移项上：GQA 减 KV、量化减权重，总搬移 $= \\text{权重}/q_w + \\text{KV}/q_{\\text{kv}}$，不是 $\\text{总量}/(q_w q_{\\text{kv}})$。只有把总搬移按权重/KV 分开记账再相加，才能得到正确的端到端收益（第 8 节表）。\n题 2（计算）：128K 上下文的 KV 账本 #7B（32 层、$d=4096$）：MHA vs GQA-8 在 128K 上下文各占多少显存？KV 占比分别多少（权重 13GB）？\n题 2 解答 MHA：$2\\times32\\times4096\\times2 = 512$ KB/token $\\times 131072 = 64$ GiB（权重 13GB 的 4.9 倍）；GQA-8：$2\\times32\\times8\\times128\\times2 = 128$ KB/token $\\times 131072 = 16$ GiB（约 1.2 倍）。长上下文下 KV 是显存主项——这也是 03 章 MLA 出场的理由。\n题 3（设计）：长上下文系统验收清单 #给\u0026quot;128K 上下文 + GQA + W4A16KV4 + 前缀缓存\u0026quot;组合列一份不少于 8 项的验收清单。\n题 3 解答要点 ① LongBench/多跳 QA 质量（短/中/长三档长度）；② 超训练长度的压力测试（如 256K 截断行为）；③ perplexity；④ TTFT/TPS/P99；⑤ 显存实际利用率（分页后）；⑥ KV4 量化对长上下文质量的影响；⑦ 前缀缓存命中率与收益；⑧ 与生产引擎基线同配置对比；⑨ 组合矩阵 {BF16, W4A16} × {KV8, KV4} 全测。\n题 4（思考）：精确 vs 近似 #把 01–06 章的方法按\u0026quot;精确/近似/架构不同\u0026quot;分类，并说明每类的验收深度差异。\n题 4 解答要点 精确：FlashAttention、PagedAttention、前缀缓存、MQA/GQA/MLA（架构不同但非近似）——验收只看性能；近似：滑窗、H2O、StreamingLLM、FP8 注意力——必须质量 + 最坏场景验收；架构不同：线性注意力、Mamba——按新模型走完整评测。\n题 5（决策）：四场景选型 #分别为 ① 128K 长文档问答、② 千万 DAU 聊天、③ 端侧 8GB 跑 7B、④ 训练 1M token 实验模型，给出技术组合与理由。\n题 5 解答要点 ① FA3/FP8 + MLA/GQA + 分页 + 前缀缓存（prefill 与 KV 双瓶颈）；② vLLM 分页 + 连续批处理 + W4A16 + GQA，推测按实测（吞吐优先）；③ W4A16KV4 + GQA/MLA + 必要时 StreamingLLM（显存上限）；④ FA2/3 + 长序列用线性注意力/Mamba 作对照（研究）。\n题 6（编程）：组合收益敏感性 #写脚本：输入（权重 GB、KV GB/token、上下文、量化比、KV 压缩比、推测倍数），输出端到端加速比；扫\u0026quot;上下文长度\u0026quot;与\u0026quot;KV 压缩比\u0026quot;两个维度，回答\u0026quot;什么时候 KV 优化比权重量化更值钱\u0026quot;。\n题 6 解答要点 端到端每步时间 $= (\\text{weights}/q_w + L\\times\\text{KV}_{\\text{per-token}}/q_{\\text{kv}})/\\text{BW}$，再除以推测倍数。扫表会发现：KV 占比随 $L$ 线性上升，超过权重后 KV 压缩的边际收益反超量化——临界点就是 01 章\u0026quot;KV 读取反超权重读取\u0026quot;的长度。\n12. 延伸阅读 # vLLM 文档：分页、前缀缓存、推测解码、量化的生产集成。 SGLang（arXiv:2312.07104）：RadixAttention 前缀缓存。 TensorRT-LLM：融合内核、FP8 注意力的生产实现。 量化系列 10 章（质量评估方法论）：本章验收协议的方法论基础。 上一篇： 06 内核优化与算子融合。本系列完结。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-07-%E7%B3%BB%E7%BB%9F%E9%9B%86%E6%88%90%E4%B8%8E%E7%94%9F%E4%BA%A7%E9%AA%8C%E6%94%B6/","section":"笔记","summary":"把注意力优化拆成维度、内容、布局、内核四个层次，与「每步成本 × 步数 × 单步内部效率」三因子框架对应。本文给出长上下文系统的完整组件清单，区分精确与近似优化各自的验收方法，并手算一个量化 + GQA + 推测的端到端收益算例。","title":"注意力优化上线怎么验收？吞吐、显存与精度怎么测"},{"content":" 系列导航： 注意力与计算内核精读笔记总览（共 8 篇）｜上一篇： 注意力优化上线怎么验收\n对应：Baseten Inference Engineering Ch5（Techniques）的 Caching 与 Disaggregation 部分；Zheng et al., SGLang: Efficient Execution of Structured Language Model Programs（arXiv:2312.07104）；衔接 05 章（PagedAttention/vLLM）与量化系列 08 章（KV 量化）。 前置：01 章（KV cache 账本、prefill/decode 形态）、05 章（分页与共享）。学完本章你应该能：① 说出前缀缓存的三个杀手场景与它消除的浪费；② 推导\u0026quot;命中率 $h$ → prefill 计算省 $h$ 比例\u0026quot;的收益模型；③ 复述 RadixAttention 的 radix tree、LRU leaves-first 驱逐与引用计数机制；④ 排列 KV 存储层级并给出各自适用场景；⑤ 解释 cache-aware routing 与 disaggregation 中 KV 的角色；⑥ 手算命中率对 TTFT、KV 传输对延迟的影响。\n目录（本章） # 本章目标 问题：共享前缀，但 KV 用一次就扔 收益模型：命中率与 prefill 节省 RadixAttention：把 KV 缓存当一棵树来管 Cache-Aware 调度：让缓存命中最大化 KV 存储层级：GPU → CPU → 分布式 → 磁盘 Cache-Aware Routing：把请求路由到\u0026quot;有缓存\u0026quot;的副本 Disaggregation：prefill 与 decode 分离 组合：分页 + 前缀缓存 + 量化 + 批处理 数值算例 实验数据 本章小结 习题与解答 延伸阅读 2. 问题：共享前缀，但 KV 用一次就扔 #01 章讲过：prefill 阶段把整个 prompt 从第一层算到最后一层，产出 KV cache；decode 阶段逐 token 读 KV、续写输出。大多数 serving 系统里，一个请求算完、输出结束，KV cache 就被丢弃。\nSGLang 论文（arXiv:2312.07104）把这件事列为 LLM serving 最大的系统性浪费之一：\nKV cache 的计算只依赖前缀 token。 因此，凡是共享同一前缀的请求，本可以复用同一份 KV，却各自重新 prefill 了一遍。\n现实负载里共享前缀无处不在：\n多轮对话：每轮的 prompt = 系统提示 + 历史轮次 + 新问题 → 历史轮次的 KV 完全可复用，只有新问题需要 prefill 代码补全：文件上下文 + 游标前的代码是公共前缀，多次补全共享 Agent（ReAct 等）：系统提示 + 工具定义 + 已执行轨迹，每一步都要\u0026#34;重发\u0026#34;整个轨迹 少样本（few-shot）：MMLU 每道题都带同样的 5 个示例 → 1000 道题把示例 prefill 了 1000 遍；HellaSwag 甚至是两级共享 （few-shot 示例 + 公共问题前缀） 自洽采样 / Tree-of-Thought：同一前缀分叉出多个候选分支，分支共享前缀 KV 浪费有两笔账：\n① 计算账：无缓存时每个请求 prefill FLOPs ≈ 2LN（L 为 prompt 长度，N 为参数量） 共享前缀越长、请求越多，重复计算越离谱 ② 显存账：每份 KV 都重新占一块显存；相同前缀的 KV 在显存里重复存放 前缀缓存（prefix caching）的做法一句话：把请求结束后的 KV 留下来，下一个共享前缀的请求直接复用，跳过重复的 prefill。\n3. 收益模型：命中率与 prefill 节省 #3.1 定义 #设请求的 prompt 长度为 $L$，其中 $L_p$ 个 token 能在缓存中命中，新 token 数为 $L_s = L - L_p$。定义命中率（论文定义）：\n$$ h = \\frac{L_p}{L} = \\frac{\\text{缓存命中的 prompt token 数}}{\\text{总 prompt token 数}} $$3.2 逐层账本推导：省下的比例恰好是 $h$ #先写单层的前向成本（沿用 01 章的记法：注意力 $4L^2d$、MLP $8d^2L$，这里 $d$ 为隐藏维度）：\n无缓存——$L$ 个 token 全部前向：\n$$ F_{\\text{no}} = 4L^2d + 8d^2L $$有缓存——前缀 token 的前向整体跳过（QKV 投影、注意力、MLP 都不用重算）；后缀的 $L_s$ 个 token 仍然要 attend 全部 $L$ 个位置（它们必须看到前缀），所以注意力项是 $4 L_s L d$：\n$$ F_{\\text{cached}} = 4L_s L d + 8d^2 L_s $$两式相减：\n$$ F_{\\text{no}} - F_{\\text{cached}} = 4Ld(L - L_s) + 8d^2(L - L_s) = (L - L_s)\\big(4Ld + 8d^2\\big) $$$$ = \\frac{L_p}{L}\\left(4L^2d + 8d^2L\\right) = h\\, F_{\\text{no}} $$结论：命中率 $h$ 的请求，prefill 计算正好省下 $h$ 的比例——注意力与 MLP 两项同时按 $h$ 节省，因为两者都随序列长度线性扩展，前缀跳过后就只剩后缀部分。任何 per-token 项（嵌入、QKV 投影、MLP）都有同样的性质，所以这个结论对任意模型结构都成立（只要命中段的前向确实被整体跳过）。\n3.3 对 TTFT 的含义 #prefill 是计算受限的（06 章），所以 prefill 时间随 FLOPs 近似线性：\n$$ t_{\\text{prefill}}(h) \\approx (1 - h)\\, t_{\\text{prefill}}(0) $$TTFT 不能直接按 $(1-h)$ 缩，因为还有不随命中率缩水的固定开销：\n$$ t_{\\text{TTFT}} \\approx \\underbrace{t_{\\text{fixed}}}_{\\text{路由/调度/缓存查找/kernel 启动}} + (1-h)\\, t_{\\text{prefill}} $$3.4 三个容易算错的地方 #① 命中省的是 prefill 计算，decode 每步成本不变 （但显存被释放 → batch 可更大 → 吞吐上升，这是间接收益） ② 后缀 token 仍要\u0026#34;读\u0026#34;前缀的 KV：省的是 FLOPs，不是带宽 ③ 命中率按 token 算；若命中段很短而固定开销很大，TTFT 收益被摊薄 4. RadixAttention：把 KV 缓存当一棵树来管 #SGLang 论文把 RadixAttention 定位为第一套自动、系统化的 KV 复用机制：它把 KV 放进一棵 radix tree 里长期缓存（请求结束后不丢弃），用 LRU 策略驱逐，并配合缓存感知的调度器。\n4.1 数据结构：radix tree（压缩前缀树） #radix tree 是 trie 的空间高效变体：边可以标注一串 token，而不是单个字符。节点对应一个前缀，节点上挂着这个前缀的 KV cache 张量（分页存储，SGLang 里一页一个 token——天然兼容 05 章的 PagedAttention）。\n看一个多轮对话的例子：\nroot └─ \u0026#34;What is the capital of \u0026#34; ← 公共前缀（节点分裂产生） ├─ \u0026#34;France?\u0026#34; ← 请求 1 的 prompt（缓存） │ └─ \u0026#34;Paris. And its population?\u0026#34; ← 请求 2 追加（复用请求 1 全部 KV） └─ \u0026#34;Germany?\u0026#34; ← 请求 3 的 prompt（缓存） 插入\u0026quot;Germany?\u0026ldquo;这条路径时，原树只有 \u0026ldquo;What is the capital of France?\u0026quot;，两者最长公共前缀是 \u0026ldquo;What is the capital of \u0026ldquo;——于是节点分裂，公共前缀上提，两个国家各自成为叶子。这就是 radix tree 的多级共享：系统提示、问题模板、历史轮次，每一级都能被复用。\n4.2 三个核心操作 #① Match（最长前缀匹配）：新请求沿树查找最长匹配节点 → 命中即复用该前缀的 KV，这些 token 的 prefill 直接跳过 ② Insert（插入）：未匹配的后缀作为新节点挂上去； 请求的输出 token 也插入树（下一轮对话就能复用\u0026#34;上一轮的答案\u0026#34;） ③ Evict（驱逐）：显存不足时按 LRU 驱逐\u0026#34;最久未使用的叶子\u0026#34; 驱逐策略的两个关键设计：\nLeaves-first（先叶子后祖先）： 叶子是\u0026#34;私有尾巴\u0026#34;，驱逐它不影响其他请求复用公共祖先； 祖先只有等所有子节点都被驱逐、自己也变成叶子后，才可驱逐 → 热的公共前缀活得最久 引用计数（reference count）： 正在运行的请求会\u0026#34;用\u0026#34;某些节点，refcount \u0026gt; 0 的节点不可驱逐 → 连续批处理下，运行中请求的 KV 不会被缓存策略误杀 还有一个容易被忽略但很重要的设计——共享内存池：\nSGLang 不预分配一块\u0026#34;缓存专用\u0026#34;的固定显存（比如 20% 给缓存、80% 给请求）， 而是让\u0026#34;缓存中的 KV\u0026#34;和\u0026#34;运行中请求的 KV\u0026#34;住在同一个池子里： 缓存 = 当前没人用的 KV。 等待请求多时，系统自动驱逐缓存 token、把显存让给更大的 batch。 这样做的好处：显存永远不会\u0026quot;留给缓存却用不上\u0026rdquo;，也不会\u0026quot;缓存把请求挤爆\u0026rdquo;。代价是命中率随负载动态浮动——这正是第 5 节调度器要优化的对象。\n4.3 伪代码 #HandleRequest(prompt, rid): node, matched = radix_tree.match_longest_prefix(prompt) # 最长前缀匹配，O(树高) if matched \u0026lt; len(prompt): node = radix_tree.insert(prompt[matched:], parent=node) # 新后缀入树 prefill_and_decode(node) # 只对未命中 token 算 KV # 请求结束后 KV 保留在树中（不再丢弃） EvictIfNeeded(required): while free_memory \u0026lt; required: leaf = LRU_least_recently_used_leaf() if leaf.refcount == 0: evict(leaf) # 只驱逐没有运行请求在用的叶子 多轮对话/分叉场景还有一个配合技巧：前端解释器先发送\u0026quot;前缀提示\u0026rdquo;（frontend hint），让运行时知道这个分支会被继续复用，避免误驱逐——这体现了前端语言与运行时协同设计的价值。\n4.4 开销 #在没有复用机会的负载上（ShareGPT 100 个请求），RadixAttention 的数据结构管理只花 0.2 秒、占总时间 74.3 秒的 不到 0.3%——匹配和插入都只沿一条前缀路径走，因此论文的结论是：默认开启，无需配置。\n5. Cache-Aware 调度：让缓存命中最大化 #有了缓存，请求的执行顺序就直接影响命中率。\n先到先服务（FCFS）的问题是缓存抖动（thrashing）：调度器在不同前缀的请求之间反复横跳，缓存里刚热起来的 KV 很快被驱逐，下个请求又 miss。\nRadixAttention 的调度策略是 longest-shared-prefix-first（最长共享前缀优先）：把等待队列按\u0026quot;已匹配前缀长度\u0026quot;降序排列，优先执行共享前缀最长的请求。可以证明这个顺序等价于对请求的 radix tree 做深度优先遍历（DFS）：\nSchedule(batch_size, queue): ordered = sort_by_matched_prefix_len_desc(queue) # 最长共享前缀优先 ≈ DFS 序 return contiguous_batch(ordered[:batch_size]) # 与连续批处理结合 论文给出了一个离线情形下的最优性定理：\n定理 3.1：对一批请求，若缓存容量 ≥ 最大请求长度，按 DFS 序访问请求的 radix tree 可达到最优命中率；最长共享前缀优先序即 DFS 序。\n直觉：DFS 沿着一条前缀链一口气处理完所有共享它的请求，公共 KV 只计算一次、一直热着；BFS/轮询式调度会让每个前缀刚建立就被换走。\n权衡与边界：\n贪婪提升吞吐，但可能饿死共享前缀很短的请求（论文留作未来工作： 与公平调度结合） 延迟敏感场景：可以容忍\u0026#34;有限重排\u0026#34;来换缓存命中 6. KV 存储层级：GPU → CPU → 分布式 → 磁盘 #书里给了一条 KV 的\u0026quot;存储食物链\u0026rdquo;：\n默认：GPU VRAM（热 KV，decode 每步都要读） 溢出①：CPU 内存（通过 Grace NVLink C2C 快速访问） 溢出②：分布式 KV store（跨副本共享） 溢出③：磁盘（最后手段） 层级 典型容量 带宽 定位 GPU VRAM 80–192 GB（H100/H200/B200） 3.35–8 TB/s 默认；decode 的每步读取都发生在这里 CPU 内存（Grace C2C） 数百 GB–1 TB+ 900 GB/s（双向合计，约 PCIe 5.0 x16 的 7 倍） 溢出层，可当\u0026quot;大号 GPU 内存\u0026quot;用 分布式 KV store TB–PB（多副本） 网络带宽 跨 replica 共享，cache-aware routing 的基础 磁盘 最大 很低 最后手段：冷数据、重启恢复 为什么要分层？01 章的账本：7B MHA 的 KV 是 512 KB/token——128K 上下文一个请求就要 64 GB，一张 H100 只够装一两个长请求。如果不允许溢出，长上下文服务在高并发下立刻被显存卡死；允许分层后，KV 预算从\u0026quot;单卡显存\u0026quot;扩展到\u0026quot;整机内存 + 集群\u0026quot;。\n层级之间的核心权衡是热冷：\n热前缀（系统提示、高频 few-shot、活跃会话历史）→ 留在 GPU 冷前缀（不活跃会话、低频共享段）→ 降级到 CPU / 分布式 store 层级越高，容量越大、带宽越低；工程上要做\u0026#34;按访问频率迁移\u0026#34; （FlexGen 的 offload 思想，也是 RadixAttention 论文点名的未来方向） 书中配套的 KV Cache Sizing Calculator 就是用来先算\u0026quot;多少 KV、放哪层\u0026quot;的。\n7. Cache-Aware Routing：把请求路由到\u0026quot;有缓存\u0026quot;的副本 #生产部署通常有多个模型副本（replica）。路由策略直接决定命中率：\n朴素路由（轮询 / 最少连接）： 只看负载，不看缓存 → 同一会话的连续请求被分散到不同副本 → 每个副本都没有上一轮的 KV → 每轮都 miss、每轮都重新 prefill Cache-Aware Routing： 把请求路由到\u0026#34;已持有最长匹配前缀 KV\u0026#34;的副本 → 命中率 ↑，TTFT ↓（书里的原话） 难点：缓存局部性与负载均衡天然冲突。如果把请求全塞给\u0026quot;有缓存\u0026quot;的副本，那个副本会过载；分散到所有副本，缓存又全 miss。工程上常用的折中：\n① Session affinity / 一致性哈希：同一会话/用户固定到同一副本 → 多轮聊天的前缀自然在固定副本上累积（最简单、最常用） ② 分布式 KV store：公共前缀（系统提示、few-shot）放共享存储， 任何副本都能取 → 局部性不再绑定单副本 ③ 动态路由：NVIDIA Dynamo 按实时负载自动路由（第 8 节）， 并感知 KV 局部性，在\u0026#34;命中\u0026#34;与\u0026#34;负载均衡\u0026#34;之间动态权衡 这个折中的数值影响见第 10 节算例 10.3。\n8. Disaggregation：prefill 与 decode 分离 #书里的最后一个相关主题是 disaggregation（分离式部署）：把 prefill 和 decode 放到独立扩展的硬件上：\nPrefill workers：面向计算优化（高 FLOPS）——prefill 是计算密集的 Decode workers：面向带宽优化——decode 是带宽密集的 两者独立扩缩：流量 prefill-heavy 时加 prefill worker，decode-heavy 时加 decode worker 分离带来的新瓶颈是传输：prefill worker 算出的 KV cache 必须转移给 decode worker。KV 很大：\n$$ 7\\text{B MHA}:\\quad 512\\ \\text{KB/token} \\times 2048\\ \\text{token} = 1\\ \\text{GB} $$所以书里明确说：KV cache 量化（KV8/KV4，量化系列 08 章）是缓解这个传输瓶颈的手段。\n与前缀缓存协同的视角：\n系统提示 / 历史轮次的 KV 是\u0026#34;跨请求共享\u0026#34;的 → 可以留在 decode worker 或分布式 KV store 里，不必反复传输； 只有新后缀的 KV 需要从 prefill worker 传过来 → 命中率越高，跨阶段传输的 KV 越少（本章与量化系列 08 章在此汇合） NVIDIA Dynamo 提供动态 disaggregation：按实时负载自动在 prefill/decode worker 之间路由，不需要静态划分。\n9. 组合：分页 + 前缀缓存 + 量化 + 批处理 #RadixAttention 论文明确声明与三项技术兼容：连续批处理（continuous batching）、PagedAttention、张量并行。把本系列的工具拼起来：\n连续批处理（05 章）：每步装最多请求，与缓存感知调度直接结合 PagedAttention（05 章）：KV 以物理块存放 → radix 树节点指向一组物理块， 共享祖先用引用计数/COW 管理，驱逐即释放块 前缀缓存（本章）：跨请求共享前缀的 KV 不重算 KV 量化（量化系列 08 章）：KV8/KV4 让同块显存放更多 token， 也缓解 disaggregation 的传输 Cache-aware 调度（本章）：批内顺序让命中率最大化 组合时容易混淆的收益边界：\n前缀缓存命中 h → 省 h 比例的 prefill 计算（TTFT 的直接收益） 显存释放 → batch 变大 → 吞吐上升（间接收益） KV 量化 → 显存和传输再缩（与缓存正交，叠加） 推测解码 → 省的是 decode 步数（另一个维度，不重复计算） 10. 数值算例 #10.1 命中率 → prefill 节省（公式验证） #7B 模型、$L = 4096$、$h = 0.8$（$L_p = 3277$，$L_s = 819$）：\n$$ F_{\\text{no}} \\approx 2LN = 2 \\times 4096 \\times 7\\times10^9 \\approx 5.7\\times10^{13}\\ \\text{FLOPs} $$$$ F_{\\text{cached}} = (1-h)F_{\\text{no}} = 0.2 \\times 5.7\\times10^{13} \\approx 1.1\\times10^{13}\\ \\text{FLOPs} $$节省 $4.6\\times10^{13}$ FLOPs，恰好 80%。\n10.2 TTFT #H100 FP16 理论 989 TFLOPS，按 50% 效率假设折算约 500 TFLOPS：\n$$ t_{\\text{prefill}}(0) = \\frac{5.7\\times10^{13}}{5\\times10^{14}} \\approx 115\\ \\text{ms} $$$$ t_{\\text{prefill}}(0.8) = 0.2 \\times 115 \\approx 23\\ \\text{ms} $$加上固定开销 10 ms（路由、调度、缓存查找）：TTFT 从约 125 ms 降到约 33 ms——prefill 部分快 5 倍，端到端约 3.8 倍。\n10.3 Cache-Aware Routing #假设随机路由命中率 40%、会话亲和命中率 85%：\n$$ \\frac{1-0.85}{1-0.40} = 0.25 $$prefill 时间缩到原来的 1/4。命中率从 40% 到 85%，看似只涨了一倍多，但 miss 的 token 从 60% 降到 15%——收益要看\u0026quot;没命中的部分\u0026quot;而不是\u0026quot;命中的部分\u0026quot;。\n10.4 多轮对话 / few-shot 显存账 #1000 道 MMLU 题，5-shot 示例共 1000 个公共 token，每题 100 个 token，7B MHA（512 KB/token）：\n无缓存：1000 × (1000 + 100) × 512 KB ≈ 577 GB 有缓存：示例只算一次（1000 × 512 KB ≈ 0.5 GB） + 每题新 token（1000 × 100 × 512 KB ≈ 51 GB） ≈ 52 GB 省 ≈ 524 GB（≈ 91%）→ 同一张卡能服务的 batch 大一个量级 10.5 Disaggregation 传输 #7B MHA、$L = 2048$：KV = 512 KB × 2048 = 1 GB。不同网络与量化下的传输时间：\n配置 带宽 传输时间 对比 prefill（约 58 ms @500 TFLOPS） 100 Gbps 12.5 GB/s ≈ 85 ms 超过 prefill，成瓶颈 400 Gbps 50 GB/s ≈ 21 ms 次要但不可忽略 400 Gbps + KV4 50 GB/s（传 256 MB） 5 ms 可忽略 结论与书一致：KV 量化在 disaggregation 里不只是省显存，更是把传输从瓶颈降为噪声。\n11. 实验数据 #论文（SGLang vs vLLM / Guidance / LMQL，A10G / A100）：\n指标 数值 吞吐提升 最高 6.4× 延迟降低 最高 3.7× 命中率（各 benchmark） 50%–99% 调度器相对最优命中率 平均 ~96% RadixAttention 管理开销 \u0026lt;0.3%（74.3 s 中 0.2 s） 覆盖场景：agent control（ReAct）、逻辑推理、few-shot（MMLU/HellaSwag 两级共享）、JSON 解码、RAG 流水线（DSPy）、多轮 chat、自洽采样（self-consistency）。\n生产观察（Chatbot Arena 部署一个月）：\nVicuna-33B：命中率 74.1%，平均 TTFT 降低 1.7× LLaVA-NeXT-34B：命中率 52.4%（同一图片的多次提问共享图像 token 的 KV） 命中来源：公共系统消息、高频复用的示例图片、多轮对话历史 一个重要的边界：多轮对话的提速在短输出时最明显（前缀 prefill 占总延迟比例大）；输出很长时 decode 主导、不同会话间共享又少，提速趋于零。前缀缓存不是万能药——它只对\u0026quot;共享前缀占比高\u0026quot;的负载生效。\n12. 本章小结 # 问题：KV 只依赖前缀，但请求结束就被丢弃 → 共享前缀被反复 prefill，既费计算又费显存；杀手场景：多轮对话、代码补全、Agent。 收益模型：命中率 $h$ 的请求，prefill 计算恰好省 $h$ 比例（第 3 节推导对注意力与 MLP 同时成立）。 RadixAttention：radix tree 存 KV + LRU leaves-first 驱逐 + 引用计数 + 共享内存池——自动、多级共享、无需手动配置。 调度：最长共享前缀优先 ≈ DFS，接近最优命中率；FCFS 会缓存抖动。 存储层级：GPU VRAM → CPU（Grace C2C）→ 分布式 KV store → 磁盘，按热冷迁移。 路由：把请求送到持有匹配前缀的副本（session affinity / 一致性哈希 / 动态路由），命中率与负载均衡需要折中。 Disaggregation：prefill/decode 分离后 KV 传输成为瓶颈，KV 量化（KV8/KV4）直接缓解。 组合：分页 + 前缀缓存 + 量化 + cache-aware 调度 + 连续批处理，正交叠加。 13. 习题与解答 #题 1（推导）：证明\u0026quot;命中率 = 节省比例\u0026quot; #用单层账本（注意力 $4L^2d$ + MLP $8d^2L$）证明：前缀命中比例 $h = L_p/L$ 的请求，prefill FLOPs 恰好省下 $h$ 比例。指出该结论对哪些成本项成立、对哪一项不成立。\n题 1 解答 无缓存 $F_{\\text{no}} = 4L^2d + 8d^2L$；有缓存时前缀前向整体跳过，后缀仍 attend 全部 $L$ 个位置：$F_{\\text{cached}} = 4L_sLd + 8d^2L_s$。相减得 $(L-L_s)(4Ld+8d^2) = hF_{\\text{no}}$。所有 per-token 项（嵌入、投影、MLP）都随 $L$ 线性扩展，同样按 $h$ 节省；唯一不省的是\u0026quot;后缀对前缀 KV 的注意力开销\u0026quot;——它被计入 $F_{\\text{cached}}$ 的 $4L_sLd$ 项，因此若后缀很长，实际 TTFT 改善会略低于 $h$（加上固定开销后更明显）。\n题 2（计算）：TTFT 收益 #7B 模型、$L = 8192$、$h = 0.9$，H100 实测效率约 500 TFLOPS，固定开销 8 ms。求无缓存与有缓存的 TTFT（prefill 部分），以及端到端提升倍数。\n题 2 解答 $F_{\\text{no}} = 2 \\times 8192 \\times 7\\times10^9 \\approx 1.15\\times10^{14}$ FLOPs → $t_{\\text{prefill}} = 1.15\\times10^{14}/5\\times10^{14} \\approx 230$ ms。有缓存：$0.1 \\times 230 = 23$ ms。TTFT：$238 \\to 31$ ms，约 7.7 倍。\n题 3（概念）：为什么驱逐要\u0026quot;先叶子后祖先\u0026quot;、还要引用计数？ # 题 3 解答要点 叶子是\u0026quot;私有尾巴\u0026quot;，驱逐它不影响其他请求复用公共祖先；祖先被驱逐会一次性杀掉所有后代的共享机会。因此 LRU 只从叶子开始驱逐，祖先只有变成叶子后才能被淘汰——热的公共前缀因此活得最久。引用计数保护运行中的请求：连续批处理下，正在被 batch 使用的节点 refcount \u0026gt; 0，不可驱逐，否则会产生错误结果。共享内存池（缓存与运行请求同一池）则避免\u0026quot;固定缓存分区\u0026quot;造成的显存浪费或不足。\n题 4（设计）：cache-aware routing 与负载均衡冲突 #两个副本、50% 流量是共享同一系统提示的多轮聊天。给出路由方案，使命中率尽量高又不把某个副本打爆。\n题 4 解答要点 方案组合：① 会话亲和（一致性哈希按 session 路由）让同一会话固定在单副本，前缀自然累积；② 公共系统提示/少样本 KV 放分布式 KV store，任何副本可取（局部性不再绑定单副本）；③ 动态路由（如 NVIDIA Dynamo）在\u0026quot;命中收益\u0026quot;与\u0026quot;副本负载\u0026quot;之间实时权衡；④ 热点副本扩容或把热前缀复制到多个副本（多副本各自持有同一份公共 KV）。核心原则：把\u0026quot;跨请求共享的热前缀\u0026quot;与\u0026quot;单会话私有历史\u0026quot;分开处理。\n题 5（计算）：disaggregation 的传输瓶颈 #70B GQA-8 模型（KV 每 token 320 KB，见 06 章题 2）、$L = 8192$ 的 prefill。KV 总量多少？在 200 Gbps（25 GB/s）网络上传输要多久？KV4 量化后呢？什么时候传输会成为主要瓶颈？\n题 5 解答 KV = 320 KB × 8192 = 2.7 GB；200 Gbps 下 2.7 GB / 25 GB/s ≈ 107 ms。KV4 后 0.67 GB → ≈ 27 ms。对比 prefill：$2 \\times 8192 \\times 70\\times10^9 \\approx 1.15\\times10^{15}$ FLOPs，H100 上约 2.3 s——此时传输（约 100 ms）只占约 4%，不是瓶颈；但如果 prefill 分散到多卡（TP 并行把 prefill 时间除以卡数）或网络更慢，传输占比就会快速上升。传输是否成为瓶颈取决于\u0026quot;KV 大小 × 请求频率\u0026quot;与\u0026quot;prefill 计算时间\u0026quot;之比，KV 量化在两者间加了一个 4 倍的保险。\n题 6（辨析）：RadixAttention 与 vLLM 前缀共享的区别 #05 章讲过 vLLM 的 COW 与简单前缀共享。RadixAttention 多了什么？为什么\u0026quot;自动\u0026quot;很重要？\n题 6 解答要点 ① 多级树状共享：vLLM 等早期系统只处理\u0026quot;单一系统提示\u0026quot;这类简单共享；radix tree 支持任意多级共享（系统 → 模板 → 历史轮次 → 分支），节点分裂/合并自动完成；② LRU 缓存语义：KV 被当作缓存管理（命中/驱逐/替换），而不仅是引用计数；③ cache-aware 调度：执行顺序反过来优化命中率；④ 前端提示：解释器把\u0026quot;分支会继续\u0026quot;的意图传给运行时，减少误驱逐。自动的意义：论文指出此前的方法需要手动配置（如显式标记共享段），无法覆盖动态树状结构（agent 轨迹、自洽采样分支）；RadixAttention 对普通 serving 请求无需任何配置即可生效，且无命中时开销 \u0026lt;0.3%，所以可以默认开启。\n14. 延伸阅读 # SGLang: Efficient Execution of Structured Language Model Programs（arXiv:2312.07104）：RadixAttention、cache-aware scheduling、定理 3.1 与全部实验数据。 PagedAttention / vLLM（arXiv:2309.06180）（05 章）：分页布局与 COW，是 RadixAttention 的物理层基础。 Inference Engineering Ch5（Baseten）：前缀缓存、KV 存储层级、cache-aware routing 与 disaggregation 的教材正文。 HydraGen（arXiv:2402.05099）：从 kernel 侧加速共享前缀的批量注意力。 Prompt Cache（arXiv:2311.04934）：模块化注意力复用，但可能造成精度下降——注意与\u0026quot;精确复用前缀\u0026quot;的区别。 FlexGen（arXiv:2303.06865）：KV/权重跨存储层级 offload，本章第 6 节的理论背景。 量化系列 08 章（KIVI）：KV8/KV4 量化，disaggregation 传输瓶颈的解法。 NVIDIA Dynamo 文档：动态 disaggregation 与 KV-cache-aware 路由的工业实现。 上一篇： 07 系统集成与生产验收——本系列 00–08 的组合框架与验收协议。 ","date":"2026年8月17日","permalink":"https://doraemeng.dev/notes/llm%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%86%85%E6%A0%B8%E7%B2%BE%E8%AF%BB%E7%AC%94%E8%AE%B0-08-%E5%89%8D%E7%BC%80%E7%BC%93%E5%AD%98%E4%B8%8Ekv%E5%A4%8D%E7%94%A8/","section":"笔记","summary":"前缀缓存把「相同前缀、KV 用一次就扔」的浪费消掉。本文推导命中率 h 到 prefill 计算节省的收益模型，讲清 RadixAttention 的 radix tree、LRU leaves-first 驱逐与引用计数，排列 GPU→CPU→分布式→磁盘的 KV 存储层级，并解释 cache-aware routing 与 PD 分离。","title":"SGLang RadixAttention 原理是什么？前缀缓存怎么提升命中率"},{"content":"Answer #Changing the format changes three things at once: GPU count, tail latency, and field-level failures. FP8 on the weights alone does not hold a concurrency target if the KV cache stays in FP16. FP4 can fit more on Blackwell, and a jump in structured-output errors can erase the GPU savings.\nThe Chinese essay uses a worked example, not a customer dump: a 70B model, 8K context, 32-way concurrency, four H100s in BF16. It says the failure rates in that story are assumed so the arithmetic is visible. Replace them with your own gold set before treating the cost ratio as a result. Order of rollout in that essay: weights, then KV, then attention, each gated alone. Ampere has no FP8 Tensor Core path that pays off; FP4 Tensor Cores show up on Blackwell.\nWhat to ask a vendor #Not “do you support FP8”. Ask for tokens/s and p95 at your batch and context, where the KV cache sits at 32K and 128K, and what the rollback is when the field error rate misses the bar.\n","date":null,"permalink":"https://doraemeng.dev/en/fp8-vs-fp4/","section":"页面","summary":"Quantizing only the weights to FP8 does not free the KV cache. FP4 can raise throughput on Blackwell, and field errors in structured output can cost more than the GPUs you saved.","title":"FP8 or FP4 for a production LLM?"},{"content":"Answer #The question is what you store per token, not how you compute the score matrix. Multi-head attention keeps a K and a V for every head. Multi-query attention keeps one K/V pair shared by all heads. Grouped-query attention sits between them: several heads share one pair. MLA, as used by DeepSeek-V2 in the Chinese note, compresses K and V together into a low-rank latent.\nGQA is the usual compromise when you can up-train from a multi-head checkpoint. MLA’s extra catch is RoPE: the note derives why a plain low-rank latent fights rotary position and why decoupled RoPE is the workaround. The chapter’s 70B and DeepSeek-V2 memory tables are the place to copy a formula, not this page.\nWhat this does not fix #Fewer KV heads do not remove the HBM traffic of a long prefill score matrix. That is FlashAttention. They also do not reuse a prefix across requests. That is RadixAttention.\n","date":null,"permalink":"https://doraemeng.dev/en/mqa-gqa-mla/","section":"页面","summary":"Multi-query, grouped-query, and multi-head latent attention all shrink the KV cache. They differ in how many distinct K and V vectors each token keeps, and MLA adds a low-rank joint compression.","title":"MQA, GQA, or MLA: what should you cache per token?"},{"content":"Answer #The GPU stayed at 100% because one request never reached an end condition. Memory looked normal. The client called the OpenAI-compatible API with temperature=0 and no max_tokens. vLLM’s compatibility layer then set the cap to max_model_len. On that PaddleOCR-VL deployment the cap was about 130,000 tokens, so decode ran until the server was restarted.\nTurning off the multimodal encoder cache (--mm-processor-cache-gb 0) made each image slower. It did not remove the stop condition. The fix recorded in the note is to set max_tokens on the client and a server-side cap, and to keep the encoder cache if the same image is reused.\nWhat this page is not #This is one incident on one model. It is not a claim that vLLM is slower than SGLang or TensorRT-LLM.\n","date":null,"permalink":"https://doraemeng.dev/en/vllm-max-tokens/","section":"页面","summary":"A vLLM server pegged the GPU because the client omitted max_tokens. vLLM then allowed generation out to max_model_len, about 130k tokens on PaddleOCR-VL, so decode never finished.","title":"Why did a vLLM GPU stay at 100%?"},{"content":"Answer #There is no same-machine tokens/s table for these three engines on this site. If many requests share a prefix, start with SGLang’s RadixAttention. If you need the widest set of quantization kernels and PagedAttention, the deployment note calls vLLM one of the production defaults. If you are on NVIDIA GPUs and want their deep FP8 and INT4 kernels, that same note points at TensorRT-LLM. A head-to-head number for your batch and context is still not measured here.\nHow the Chinese notes separate them # Question vLLM SGLang TensorRT-LLM KV layout PagedAttention. The cited paper’s unmanaged cache was 20.4%–38.2% effective. Radix tree on top of paged KV. Not broken out on this site. Shared prefixes Early sharing is a single prefix plus copy-on-write. Automatic multi-level cache. Paper figures, not a local rerun: up to 6.4× throughput, 3.7× lower latency, \u0026lt;0.3% miss overhead. Not measured here. Quantization map in the deployment chapter AWQ, GPTQ, FP8, MXFP8, FP4, KV quant. Widest ecosystem. “Same, via several backends.” Structured generation called out. FP8, INT4/FP4, SmoothQuant W8A8, AWQ, KV quant. NVIDIA-tuned. Speculative decoding The EAGLE chapter says vLLM integrates EAGLE, including an EAGLE-2-style tree. Author’s SGLang PR 35423 fixes a quantized-target speculative-decoding bug. Not a speed claim. Not measured here. A known footgun Omitting max_tokens can decode to max_model_len (about 130k on one OCR model) and pin the GPU. Not the same incident. Not the same incident. QServe’s 1.2–1.4× over TensorRT-LLM (2.4–3.5× on Qwen1.5-72B), quoted in the deployment chapter, is that paper’s result. It is not a three-engine run from this site.\nThe author’s SGLang issue 35437 records a prefill CUDA-graph OOM whose fix moved TTFT from 179 ms to 113 ms on that setup. That is one patch, not a ranking.\nWhen to pick which #Shared-prefix traffic (multi-turn, agents, few-shot, a RAG pipeline that repeats a stem): SGLang. Broad quantization formats and a PagedAttention operations story: vLLM. NVIDIA hardware where you specifically want their FP8 or INT4 kernels: TensorRT-LLM. If quality must stay lossless, the deployment chapter says to turn on prefix cache and speculative decoding before any quantization.\n","date":null,"permalink":"https://doraemeng.dev/en/vllm-vs-sglang-vs-tensorrt-llm/","section":"页面","summary":"Pick from the workload, not from a missing bake-off. This site has no same-box tokens/s for the three engines. Shared prefixes point at SGLang; broad quantization and PagedAttention point at vLLM; NVIDIA-tuned FP8 and INT4 kernels point at TensorRT-LLM.","title":"vLLM, SGLang, or TensorRT-LLM?"},{"content":" 系列导航： LLM 量化精读笔记总览（共 11 篇）｜本文是把 05 RTN 与 GPTQ 和 06 AWQ 与 QuIP# 两章并起来看的对比篇。\n先看一组诊断数字 #OPT-13B 做到 INT3-g128，全量化后 WikiText-2 困惑度 46.04，FP16 基线是 10.13。只把 1% 的通道留成 FP16，如果按激活幅度挑，困惑度回到 10.51；按权重幅度挑是 48.96，随机挑是 42.00。AWQ 论文用这组数说明，低位宽下真正难保的是少数被激活反复打中的通道。GPTQ 走的是另一条路：它承认量化误差已经发生，然后用 Hessian 逆把误差摊到后面还没量化的列上。落到工程上，选择取决于你愿意付多少离线量化时间、能不能接受重建式流程，以及目标位宽。\n它们到底在争什么？ #先把共同前提摆清楚。两者都只压权重，激活和 KV Cache 仍留在 FP16，所以它们解决的是权重显存和权重带宽，不解决长上下文下 KV Cache 的占用；真正难压的激活量化是另一条线，见 激活量化为什么比权重量化难。两者都用 group 量化，常见 group_size=128，每 128 个权重共享一组 scale 和 zero，粒度选择见 量化粒度怎么选。两者都需要校准集，跑几百条文本拿到激活统计，不需要反向传播，也不需要原始训练数据。在这三个共同点上，它们的分歧只有一个：量化误差已经产生了，你怎么补？\nGPTQ 的思路：把误差\u0026quot;扩散\u0026quot;到还没量化的权重上 #GPTQ 的出发点是最小化层输出误差：\n$$\\min_{\\hat{W}} \\|WX - \\hat{W}X\\|^2$$它逐列处理权重：量化第 $q$ 列产生误差后，立刻用 Hessian 逆矩阵把这个误差补偿到后面还没量化的列上，让整层的输出误差最小。补偿量就是经典的 OBS 公式\n$$\\delta F = -\\frac{w_q - \\hat{w}_q}{[H^{-1}]_{qq}} \\cdot H^{-1}_{:,q}$$工程上 GPTQ 靠三个观察把 OBQ 的 $O(d^3)$ 压到可跑：列顺序不影响结果、可以按行并行、用 Cholesky 分解避免反复求逆。完整推导和 2×2 手算例子在 05 章。代价有三条。慢是第一个：175B 要逐层前向再加线性代数，小时级；RTN 只要几秒。第二个是二次假设，目标函数只在最优点附近近似二次，4-bit 以下补偿公式不再最优。第三个是校准集依赖，Hessian 来自校准数据，分布偏了误差就偏。H 里含激活的二阶统计，但没有显式用一阶的幅度信息，这正是 AWQ 的切入点。\nAWQ 的思路：不动权重，动 scale #AWQ 先做了个诊断实验：INT3-g128 量化 OPT-13B 后，把一部分通道保留成 FP16（混合精度），看保留谁最有效。WikiText-2 困惑度如下，FP16 基线 10.13：\n保留策略 PPL 全量化（RTN） 46.04 保留 1% 通道为 FP16（按激活幅度选） 10.51 保留 1% 通道为 FP16（按权重幅度选） 48.96 保留 1% 通道为 FP16（随机选） 42.00 结论很直接：决定成败的显著通道只有约 1%，而且必须按输入激活的幅度识别，按权重本身的幅度挑几乎等于没挑。问题是混合精度在硬件上很难做，内存布局和 kernel 都要分支。AWQ 的替代方案是数学等效：把显著通道的权重放大 $s$ 倍、对应激活缩小 $s$ 倍，量化误差约缩小 $1/s$，效果上等于\u0026quot;保护\u0026quot;，但权重依然是整齐的 INT4。缩放系数取\n$$s_j = (\\max |X_j|)^\\alpha$$再对 $\\alpha$ 做网格搜索。在 OPT-6.7B INT3-g128 上扫出来的甜点是 $s \\approx 2$：显著通道误差减半，同时只有约 8% 的组被\u0026quot;顶到新的 max\u0026quot;而伤到同组其他通道。代价是 $s$ 太大会反噬：$s=4$ 时 21.2% 的组被顶爆，PPL 反而从 11.92 回升到 12.36。\n两者差别，落在取舍上 #补偿机制上，GPTQ 用 Hessian 二阶信息做逐列更新，AWQ 用激活幅度做 per-channel 缩放；前者需要重建，后者不需要。量化时间因此差一个量级：175B 的 GPTQ 是小时级，AWQ 是分钟级。甜点位宽也不一样，GPTQ 在 3–4 bit 都能用，AWQ 的主力是 4 bit；到 2-bit，两者都会崩，得换 QuIP# 这类方法。校准集偏移时，AWQ 只用到激活的 max，抗偏一点；GPTQ 的 Hessian 对校准分布更敏感。AWQ 的盲区在另一头：它只保护幅度大的通道，不看通道之间的相关性。硬件上，AWQ 的 scale 可以折进相邻层，推理图里不新增算子；GPTQ 的 kernel 要为列重排和 group 元数据做特殊处理，部署前得确认引擎版本支持。\n生态方面，两边在 vLLM、TensorRT-LLM 和 Hugging Face 上都有产物；AWQ 还多 LMDeploy 和 TinyChat 两条路径。这个差别在选型里不是决定性的，真正要先定的是部署面：跑在什么硬件和引擎上，引擎支持哪些格式，再回头选算法。反过来的顺序经常要在格式转换上再付一次工程成本。\n那 GGUF 是哪一层的东西？ #GGUF 经常和这两个算法被放在一起搜，但它回答的是另一个问题。GPTQ 和 AWQ 是量化算法，决定权重用什么方法压到 4-bit；GGUF 是文件格式和运行时容器，主要服务 llama.cpp，里面装的通常是 Q4_K_M 这类 k-quant 方案，而不是 GPTQ/AWQ 的产物。所以正确的比较方式是先定推理引擎：想上 vLLM / TensorRT-LLM 的高吞吐服务，就走 GPTQ 或 AWQ；想在 Mac、CPU 或 llama.cpp 上跑，就走 GGUF。这两条路服务的是不同部署面，算不上竞品。\n我该选哪个？ #通用生产服务、目标是 W4A16，AWQ 是默认选项：几分钟跑完，校准集过拟合风险低。已经有 GPTQ 权重产物、流水线依赖它，继续用，迁移的收益通常抵不过重新验收的成本。要压到 3-bit 还保质量，先看 SqueezeLLM、QuIP#；GPTQ 在 3-bit 比 AWQ 更稳，2-bit 则要看 QuIP# 那一类方法。指令微调或多模态模型上，AWQ 的泛化优势更明显；这是论文里的观察，落到你的任务仍要用下游指标验收。\n量化完要上服务，先看 量化模型怎么部署到 vLLM。算法好不等于端到端快：同样的 4-bit 权重，kernel 版本、batch 和并行方式不同，P95 能差出一截。\n几个容易踩的坑 #别只看困惑度。PPL 掉 0.1 不代表下游任务没问题，验收协议见 量化后精度掉了怎么定位。校准集要接近线上分布，代码、长上下文这类场景要单独校准，不能直接复用通用语料。group_size 也别随手改，128 是生态默认值，kernel 是按它调的，改小可能换精度但掉进慢路径。\n量化对象不只是权重。长上下文场景下 KV Cache 往往才是显存大头，见 KV Cache 量化怎么做。另外，只量化目标模型、不量化草稿模型，会让推测解码的收益被稀释，这点在 推测解码上线怎么验收 里有量化分析。\n参考 #原始论文是 GPTQ（arXiv:2210.17323） 和 AWQ（arXiv:2306.00978）；OBS 的推导见 OBQ（Frantar \u0026amp; Alistarh, NeurIPS 2022）。GGUF 的格式说明在 llama.cpp 仓库。\n","date":"2026年9月25日","permalink":"https://doraemeng.dev/notes/awq%E5%92%8Cgptq%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB-4bit%E6%9D%83%E9%87%8D%E9%87%8F%E5%8C%96%E6%80%8E%E4%B9%88%E9%80%89/","section":"笔记","summary":"AWQ 和 GPTQ 都是 4-bit weight-only 量化，区别在怎么补偿误差：GPTQ 用 Hessian 二阶信息逐列校正权重，需要重建、小时级；AWQ 不改权重数值，只按激活幅度做 per-channel 缩放保护约 1% 的显著通道，无重建、分钟级。本文给出选型判据。","title":"AWQ 和 GPTQ 有什么区别？4-bit 权重量化怎么选"},{"content":"Answer #Read the Chinese series in order if you want the derivations. Start at the overview, then numeric encodings, uniform quantization, formats (FP16 through FP4), granularity and outliers, GPTQ, AWQ, activation quantization, KV-cache quantization, QAT, evaluation, and deployment.\nTwo shorter essays sit on that map. AWQ versus GPTQ is the 4-bit weight choice (chapters 05 and 06). FP8 versus FP4 is the hardware and structured-output choice (chapters 03, 08, and 11). A one-page Chinese cheat sheet lists the same rules without the proofs.\nWhat you should not expect here #No new perplexity table. The hub page is the table of contents; each chapter is the source.\n","date":null,"permalink":"https://doraemeng.dev/en/quantization-series/","section":"页面","summary":"Twelve Chinese chapters from number formats to deployment, plus a short overview. AWQ vs GPTQ and FP8 vs FP4 are the decision essays that sit on top of chapters 05–06 and 03/08/11.","title":"Where do the quantization notes start?"},{"content":"70B 客服系统，8K 上下文，32 并发，原来 4 张 H100 跑 BF16：权重 140GB，KV cache 80GB，显存看着还有余量，GPU 利用率却常年在 30% 上下。问题就变成能不能砍到 2 张卡，FP8 够不够。下面这组数字是我拿来算账的模型，并非某家客户的原始数据；你换成自己的 tokens/s 和卡价，结论可能完全不同。\n只把权重换成 FP8，权重从 140GB 降到 70GB，2 张 H100 账面装得下。按这组账，P95 会回到原点：KV 还按 FP16 算，70GB 权重加 80GB KV 已经 150GB；--gpu-memory-utilization 0.9 把 2×80GB 的可用显存压在 144GB，就算你把 --max-num-seqs 32 写死，启动日志里的最大并发也会掉到 32 以下，运行时靠 preemption 腾 KV，延迟自然回去。把 KV 也切到 FP8，KV 从 80GB 降到 40GB，2 张卡才真正稳住 32 并发。顺序很重要：先权重、再 KV、最后再碰 attention；每加一项单独跑验收，两项一起上，出问题后很难归因。\n再看 FP4。B200 上一张卡就能装下 35GB 权重加 40GB KV，吞吐确实高；如果结构化输出的失败率从 0.2% 涨到 2.1%，账就变了。按 1,000 次采样算，21 次会把 amount 写成字符串 \u0026quot;1,280.00\u0026quot;，3 次丢 currency，支付网关会直接返回 400。模型没报错，业务失败。量化格式最后会同时改三样东西：卡数、P95、字段级失败率。前两个在容量规划里看得见，第三个要到支付网关返回 400 时才看得见。这两个失败率是我为算账设的，换成 [待补：目标业务金标准集上 BF16/FP4 的字段级失败率] 之后，下面的成本结论要重算。\n显存和带宽，两个账本 #70B 模型，BF16 每参数 2 字节，权重 140GB；FP8 是 70GB；FP4 是 35GB。很多人算到这里就停了。实际还要加 KV cache、prefill 的激活、CUDA Graph 和通信缓冲。工程上先按权重的 1.2–1.5 倍留余量，长上下文再单独算 KV。\n以 Llama-3-70B 的 GQA 配置为例，80 层、8 个 KV 头、head_dim 128。每个 token 的 KV 是：\n$$ 2 \\times 80 \\times 8 \\times 128 \\times 2 \\text{ bytes} \\approx 0.31 \\text{ MiB} $$8K 上下文一个序列 2.5GiB，32 并发就是 80GiB；同样 32 并发，32K 是 320GiB，128K 是 1.25TiB。FP8 权重省下的 70GB，在 32K 上下文下，一个序列的 KV 就是 10GiB；七个序列就把这 70GB 吃回去了。vLLM 用分页 KV cache 管理这些块，默认 block size 是 16；启动时会打印 GPU blocks 和对应请求长度下的最大并发。这两个数比 nvidia-smi 的显存占用有用得多。显存占用 95% 不代表你能跑 32 并发，可能只是碎片、CUDA Graph 和通信缓冲把余量吃掉了。KV 量化的细节在 KV Cache 量化怎么做。\nprefill 和 decode 的瓶颈不一样。prefill 吃的是 Tensor Core 的 FLOPS，FP8 在 Hopper/Ada 上有原生指令，矩阵乘吞吐能到 BF16 的约 2 倍；decode 吃的是 HBM 带宽，FP8 的价值是把每 token 要读的权重大小减半。这里要区分两种 FP8：只量化权重（W8A16）省的是 decode 的 HBM 读取；W8A8 把激活也压到 FP8，prefill 的矩阵乘才吃满 FP8 Tensor Core。前面第一步只换权重，下面成本账里的 FP8 指的是 W8A8 加 KV FP8。很多团队用一个总的 tokens/s 判断量化有没有用，结果 prefill 快了、decode 没变，P95 还是不动。\ndecode 的单请求上界是：\n$$ \\text{tokens/s} \\lesssim \\frac{\\text{有效 HBM 带宽}}{\\text{每 token 读取字节数}} $$70B、BF16、H100（3.35TB/s）：3.35TB/s ÷ 140GB ≈ 24 tokens/s。FP8 把读取量减半，同一张 H100 上的理论上限约 48 tokens/s。实际值会被 kernel 效率、batch、KV 读取和通信拉低。你如果在 nvidia-smi 里看到显存占用 95%、SM 利用率只有 20%，那基本就是 decode 在等 HBM；这时候先把权重和 KV 的数据量降下来，比换一张更快的卡更直接。\n还有一个容易被忽略的收益：4 卡 TP 降到 2 卡 TP，decode 路径上的 all-reduce 组从 4 卡缩到 2 卡，每 token 的同步开销也跟着降。省卡省的是钱，少一轮通信省的是 TPOT，这两笔账经常被混在一起算。\n硬件没有对应指令，格式就拿不到收益 #Ampere 的 A100/A800 没有 FP8 Tensor Core 指令；Ada 的 L40S、4090 有 FP8；Hopper 的 H100/H200 有 FP8；Blackwell 的 B200/GB200 才有 FP4。国产卡不要按品牌推断，直接看具体型号的算子清单和引擎支持。A100 上谈 FP8，基本拿不到硬件收益：权重可以存成 FP8 省显存，但矩阵乘还要拆成 BF16 或走软件路径，省不下计算。把它写进新项目承诺，是给自己挖坑。FP4 需要和块缩放一起看。它用 E2M1 元素，配合块缩放才能用：NVFP4 每 16 个元素一组，MXFP4 每 32 个一组，缩放因子和工具链都不同。H100 上没有 FP4 Tensor Core，所谓 FP4 只能做权重存储，计算还得反量化；在 H100 上讨论 FP4 加速，拿不到计算收益。\n私有化部署和在线服务的约束不一样。私有化买卡，扩容周期按季度算，选型要按三年容量规划；在线客服按 P95 和单位 token 成本算，FP8 加 KV FP8 更容易同时满足；边缘一体机看单机显存和功耗，W4A16/INT4 更常见。云端 FP4 的评测结论不能直接搬到边缘设备，kernel、内存带宽和功耗墙都不同。\n把 70B 的账算一遍 #假设 70B dense、8K 上下文、32 并发，三种方案都要满足同一 P95 SLA。按前面的显存账，BF16 需要 4×H100 80GB，FP8 用 W8A8 加 KV FP8 需要 2×H100，FP4 需要 1×B200 192GB。每百万 token 的成本，就是每小时卡钱除以每小时产出的 token 数。假设 H100 每小时 20 元、B200 每小时 50 元，三种方案都跑满，吞吐按 1,000、1,600、2,500 tokens/s 算。BF16 每小时 80 元，产 3.6M tokens，每百万 token 22.2 元；FP8 每小时 40 元，产 5.76M，6.9 元；FP4 每小时 50 元，产 9M，5.6 元。实际利用率不一样，按各自的小时产出折算，别直接套这三个数。\n这组数字最敏感的是两处。按上面的吞吐假设，B200 单卡时价超过 H100 的约 3.1 倍（62.5 元/小时），FP4 每百万 token 就比 FP8 贵；B200 停在 50 元/小时，FP4 才领先。另一头是 FP8 的吞吐：如果它只有 BF16 的 1.2 倍，每百万 token 约 9.3 元，相对 BF16 的 22.2 元仍然便宜一半以上。真正让 FP8 失效的是卡数降不下来；吞吐少快一点只影响领先幅度。别拿厂商的峰值算，拿你线上的 batch、上下文和 P95 算；没有实测就先跑 200 条请求，拿到 tokens/s 和 P95 再算。如果卡是买的，把小时单价换成三年折旧加电费运维，算法不变。\n还有一笔账不在 GPU 里。按 2.1% 的失败率，100 万次月请求就是 2.1 万次字段错误；每次人工兜底 8 块钱，一个月 16.8 万。假设 FP4 一个月省 3 万 GPU 费，这笔钱不够填：16.8 万是 3 万的 5.6 倍。这个算术不复杂，难的是你有没有把字段级失败率测出来。\n质量验收要落到字段级 #这些失败集中在退款金额、币种和带小数点的字段上，通用 benchmark 测不出来，得拿业务金标准集按字段做配对比较。上线前至少跑 500 条真实业务样本，覆盖高频、长尾、边界和对抗输入；同一 prompt 做 BF16 和量化的配对比较，看变差率，不只看平均值。\n客服场景可以先用这组门槛：JSON schema 合法率 ≥99.5%，业务准确率相对基线下降 ≤1 个百分点，P95 TTFT ≤800ms，TPOT ≤50ms。按 1%→10%→50% 灰度，连续 24 小时任一指标不达标就回滚。回滚要保留 BF16/FP16 副本，按请求或按租户切回。vLLM 里可以先用 --quantization fp8 跑权重 FP8，再单独开 --kv-cache-dtype fp8 跑 KV 量化；版本以你锁定的为准。KV cache 量化先上 FP8，别一上来就 INT4；INT4 的误差和 kernel 支持都更激进，长上下文 RAG 最先出事。完整的评测方法在 量化后精度掉了怎么定位。\n合同审查、代码生成、风控这些任务对字段和数值更敏感，阈值要按业务单独定，不能直接套客服的 99.5%。长上下文业务再加一组远端证据召回测试；attention 默认留在 FP16/BF16，FP8 attention 只在有专用 kernel、长序列占比高、评测通过时才考虑。\n对外采购时，把这套验收变成可验证的条款。先问这个格式在哪个具体 SKU、哪个引擎版本上有原生 kernel，给 batch、上下文、并发和端到端吞吐；再问 KV cache 在 32K/128K 下怎么放，显存账怎么算；最后问精度或性能不达标时，回退路径是什么，回退后的延迟和成本是多少。别问“支持不支持 FP8”，那个问题没有意义；要问的是在你的 batch 和上下文下，端到端 tokens/s 是多少。NVFP4 和 MXFP4 也在这里问清楚：前者绑定 NVIDIA 工具链，后者是 OCP 标准，换卡换云的成本要提前算。部署侧的 kernel 坑，可以顺着 量化模型怎么部署到 vLLM 继续看。\n如果只给一个默认建议：新采购的 Hopper/Ada 走 W8A8 FP8 加 KV FP8；Ampere 存量按上面的硬件代际判断；FP4 的取舍交给实测。我不建议为了省一张卡去上 FP4，除非你已经有一套字段级评测和按请求回滚的机制；按上面的假设，一个月 16.8 万的兜底成本是 3 万 GPU 差价的 5.6 倍。最终选型落到同一批流量、同一套 SLA、同一组金标准的对照测试，分别跑 BF16、FP8、FP4，记录卡数、吞吐、P95 和字段级失败率；如果 FP4 的字段错误率压不下来，省下的卡就只是把成本挪到了人工兜底。\n参考：NVIDIA 的 FP8 白皮书；OCP 的 Microscaling Formats 规范；QServe 论文；vLLM 的量化文档。格式细节和逐章推导在 LLM 量化精读笔记。\n","date":"2026年10月17日","permalink":"https://doraemeng.dev/notes/%E4%BC%81%E4%B8%9Aai%E8%90%BD%E5%9C%B0%E9%80%89fp8%E8%BF%98%E6%98%AFfp4-%E9%87%8F%E5%8C%96%E6%A0%BC%E5%BC%8F%E7%9A%84%E6%88%90%E6%9C%AC%E8%B4%A8%E9%87%8F%E4%B8%8E%E7%A1%AC%E4%BB%B6%E5%86%B3%E7%AD%96/","section":"笔记","summary":"一个 70B 客服系统的部署账：FP8 只动权重，KV cache 会把省下的显存吃回去；FP4 在 Blackwell 上吞吐更高，结构化输出的字段错误却能把 GPU 省下的钱赔回去。附 vLLM 参数、字段级验收和采购时要问的硬指标。","title":"企业 AI 落地该选 FP8 还是 FP4？量化格式的成本、质量与硬件决策"},{"content":"先看一个 prompt：「画一只戴眼镜在火星吃拉面的猫」。Diffusion 会把它拆成几十步去噪：先有猫的轮廓，再戴眼镜，再把背景涂成火星，最后把碗里的东西改成拉面。Drifting Model 没有这个中间过程，它要在看到文本的瞬间，把整张图的像素排列一次算出来。这个差别看起来只是采样步数，实际会改变两种模型对复杂指令的容错能力，也会改变训练数据密度的要求。\n这篇笔记整理自 Cheza（Upenn NLPer）的知乎文章（https://zhuanlan.zhihu.com/p/2004759114652332877）。原文把比较集中在生成机制、数据稀疏性和工程 trick 三件事上；下面按这三条线重写，并保留评论区里关于消融实验的质疑。\n两种生成机制 #Diffusion 的每一步都在做同一件事：给定当前带噪的样本和文本条件，估计一个分数函数 ∇ log p(x|text)，也就是「在这个噪声水平下，往哪个方向改才能更符合文本」。文本在多步去噪里反复参与条件计算，模型在早期步骤决定大轮廓，到后期步骤再修细节；某一笔走偏，后面的步骤还有机会把它拉回来。这种多步修正不是免费的：采样步数直接换成推理延迟，步数越多，单张图的生成越慢。\nDrifting Model 学的是另一个对象：一个漂移场 x → x + V(x, text)。给定起点和文本，网络一次预测出位移，把样本直接推到目标区域。它没有「当前噪声水平」这个变量，也没有中间状态可以让文本重新对齐；文本条件、物体数量、空间关系和否定逻辑，都必须在这一次前向里同时满足。对简单概念，这很划算：一步生成，延迟低。对「火星上的猫」「碗里的东西是拉面」这种组合，一次前向要同时满足的约束太多，原文的判断是映射难度指数级上升，因为网络没有地方暂存「先画什么、后改什么」的中间结果。\n复杂 Prompt 的样本为什么会稀疏 #Drifting Model 的训练依赖正样本群来定义「拉力场」：同类样本越密，场的方向越稳定；样本越稀，场就越容易被单张图片带偏。ImageNet 里的猫提供了足够多的正样本，所以「猫」这个概念可以形成一个密集的目标分布。换成「戴眼镜在火星吃拉面的猫」，满足全部条件的图片可能只有一张，甚至凑不出一个可用的正样本群。这时模型看到的是一片样本云里的一个孤立点；漂移场没有足够的邻居来平均掉噪声，训练很容易退化成记住这张图。\n组合条件把数据切得太碎。物体、属性、空间关系、背景每个维度都常见的组合，在联合分布里可能极其罕见。原文的判断是：样本不足时，漂移场计算不稳定，容易过拟合到单张图片。这个判断也解释了为什么 Drifting Model 在简单概念上表现正常，一到多物体、空间关系和否定句就露怯——这些恰恰是最需要密集监督、又最难在数据里凑齐的组合。\nDiffusion 对稀疏的容忍度更高，因为它不需要一步定义整个目标分布。每一步只学「在当前噪声水平下往哪走」，文本条件可以在几十个阶段里反复注入；中间步骤出错，后续还有修正机会。原文把这种迭代过程称为一种 Latent Reasoning（隐式推理）：模型没有显式写出推理链，但去噪的每一步都相当于一次条件检查和局部修正。代价是采样慢，而且步数、调度器和条件注入方式都会影响最终质量。\n工程 trick 与缺失的消融 #原文评论区提到一个更现实的问题：Drifting Model 需要大量工程技巧，比如特征 patch 聚合、二阶矩、温度参数，才能把场算稳。这些技巧缺少理论上的完备解释，也缺少消融实验来证明每一项到底贡献了多少。原文展示的结果可能同时依赖模型结构、损失函数和一组没被单独验证的超参数；换一个数据分布，哪一项先失效并不清楚。\n评论里还有一条关于步数和梯度的观察：推理时间步数支撑更细腻的梯度响应，步数多才能实现合理的内插和外推；步数不够时，只能用更大的参数空间硬换。这条观察和前面的机制能对上：Diffusion 的多步去噪给条件文本提供了多次调整机会；Drifting Model 把这一步省掉，就得靠更大的容量去记住组合。但容量能补多少、数据密度要到什么量级，原文没有给出数字，[待补：复杂 prompt 下 Drifting Model 的样本量与生成质量曲线、各工程 trick 的消融结果]。\n选择边界 #如果任务集中在简单概念、单物体、短 prompt，Drifting Model 的一步生成有明显的延迟优势，值得优先试。只要需求里出现多物体互动、明确的空间关系或否定句，Diffusion 的多步修正和密集条件注入更稳；它的优势来自生成过程允许模型分阶段满足约束，和「更聪明」无关。对一个要上线的产品，判断标准可以更具体：把线上失败最多的那批 prompt 拿出来，分别跑两种模型，看失败案例集中在物体数量、位置关系还是属性绑定；如果失败集中在组合逻辑，优先选 Diffusion，如果只是单物体渲染质量，Drifting Model 的延迟优势更值钱。\n真正没解决的是数据侧：复杂组合的监督从哪来。原文没有给出合成数据、检索增强或更大规模采样的方案，也没有说明 Drifting Model 在多少样本下开始稳定。对做生成系统的人，这比「谁更强」更值得追：如果组合 prompt 的样本密度上不去，一步生成的天花板就摆在那里，换更大的模型只是把过拟合推迟。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/drifting_vs_diffusion/","section":"笔记","summary":"Drifting Model 与 Diffusion 谁更懂复杂指令？从生成机制对比入手：Diffusion 的多步去噪相当于隐式推理缓冲，Drifting Model 一步生成则必须把全部推理内化进权重。结论：复杂 Prompt 样本稀疏导致漂移场不稳定，多物体、空间关系、否定句场景应选 Diffusion，简单概念则 Drifting Model 更快。","title":"Drifting Model vs Diffusion：复杂指令理解能力对比"},{"content":"推理服务进入 decode 阶段后，通常每一步只生成一个 token。路由器把这一小批 token 按专家分到不同 GPU，任何一张卡上的热门专家排队，整批请求的 TPOT 就会被这一跳拖住。MoE 的通信优化，很多时候就是在处理这个看起来很不起眼、但每步都要发生一次的 All-to-All。\n一、All-to-All 的难点在消息形态 #MoE 的路由器对每个 token 算 Top-K 专家，K 由路由策略决定，早期 MoE 常用 1 或 2，DeepSeek-V2 选 top-6、V3 选 top-8。专家分布在不同 GPU 上，token 要去哪张卡由路由结果决定，所以数据流是动态的、不规则的；稠密模型那种按固定张量切分的静态并行，在这里不成立。\n规模上，N 张卡里每张都可能向另外 N-1 张卡发数据，同时也从 N-1 张卡收数据。单 token 的数据量不大：FP8、hidden 维度 4096 时只有几 KB；但 batch 乘上 sequence，总量会很大，聚合带宽需求很高。消息切得太碎，延迟占主导；包得太大，负载不均又会让先到的卡空等。\n更麻烦的是负载分布。原文给出的经验值是少数热门专家吸走 60%-80% 的 token，持有这些专家的 GPU 接收缓冲区先满，流控把发送方压住，其他 GPU 收完自己的份额后空转。All-to-All 的完成时间由最慢的那条链路决定，NVLink 的峰值带宽在这种长尾分布下跑不出来。\n低精度缓解了一部分体积压力。DeepSeek-V3 这类模型用 FP8 甚至 FP4，数据量下来了，但通信库要处理非标准格式的对齐和转换，低精度并没有让问题消失。\n训练和推理对通信的要求不一样。训练和前向 prefill 处理整批 token，瓶颈是吞吐，通信要尽量和计算重叠；decode 每步只处理一个或少数几个 token，瓶颈是延迟，传统 All-to-All 的一次同步就足以吃掉收益。\n二、Dispatch 和 Combine 是一次往返 #Dispatch 阶段，每张卡先算本地 token 的 router 分数，得到目标专家 ID；然后按目标 GPU 重排 token，把发往同一张卡的 token 打包成连续内存块，减少 NVLink 上的小包数量。发送时，GPU i 把属于 GPU j 上专家的 token 发过去，接收端按专家聚合，形状从 [Local_Batch, Hidden_Dim] 变成 [Num_Experts_On_GPU * Tokens_Per_Expert, Hidden_Dim]。专家在本地做 FFN，这一段没有通信。Combine 阶段按 Dispatch 保存的元数据反向走一遍，把专家输出按原始 token 顺序发回源 GPU，恢复 [Local_Batch, Hidden_Dim]。\n元数据是这条链路的关键。Dispatch 生成的 indices 和 locations 记录了哪个 token 来自哪张卡、原始位置在哪，Combine 直接拿它做 gather，避免二次路由计算。元数据如果存得不好，Combine 阶段就要重新算一遍路由，省下的通信时间会被计算吃回去。\n训练的反向传播把方向反过来：梯度从专家侧发回 token 侧，再在专家内部的数据并行组里做 All-Reduce。前向传的是激活值，反向可能是 FP32 累加的梯度，数据量翻倍，NVLink 的压力更大。\n推理的 prefill 和训练前向类似，处理整批 token，瓶颈在吞吐；decode 的数据量小、延迟敏感，每步一次 All-to-All 的同步开销就会吃掉收益。两种负载对通信库的要求不同，后文再展开。\n更早的 GShard 把专家并行的 All-to-All 挑战写清楚了，Tutel 做了通信内核和计算重叠，Switch Transformer 用简单的稀疏路由把 MoE 推到万亿参数，Alpa 把专家并行纳入自动并行搜索。DeepEP 的工程位置，是把这些系统思路落在一套面向训练和推理的通信库里。\n三、NVLink 的哪几个特性真正被用到 #NVLink 的带宽要按代际说清楚。H100 的 NVLink 4 是每 GPU 900GB/s，GB200 的 NVLink 5 是 1.8TB/s，Rubin 的 NVLink 6 到 3.6TB/s；这些数字是双向聚合带宽，单向要减半。原文把 900GB/s 到 3.6TB/s 笼统写成 5.0/6.0 的范围，容易让人把 H100 的带宽当成 Blackwell 的起点。\nMoE 的 All-to-All 同时有发送和接收，全双工让两个方向可以并行，带宽利用率比单向传输高。NVSwitch 在单机 8 卡或 NVL72 机架内提供任意两卡单跳、带宽一致的连接；热点专家把某条链路打满时，其他通信对不会被这条链路挡住。P2P 直连让 GPU 直接访问远端显存，通信库可以把数据从发送方缓冲区 DMA 到接收方缓冲区，不需要经过 CPU 内存。\n硬件多播在 MoE 里不是主路径。All-to-All 基本是单播，但路由表同步、共享专家参数更新这类一对多操作，硬件多播比软件模拟省事。协议卸载则直接影响 SM 的可用算力：NVLink 控制器负责分片、重组、重传和流控，GPU 的 SM 不用停下来处理协议，这对计算通信比不高的 MoE 很重要。\n这几个特性分别对应不同瓶颈：全双工和 NVSwitch 解决带宽与拥塞，P2P 解决延迟和拷贝，协议卸载解决 CPU 和 SM 的占用。选机器时只看总带宽不够，还要看这些路径在目标拓扑上是不是都成立。\n四、DeepEP 的软件栈：把 CPU 从数据路径上拿掉 #DeepEP 不是只靠 NVLink。DeepSeek 公开的 R1 推理系统把 DeepEP、NVSHMEM、GDRCopy、IBGDA 组合在一起；NCCL 的集合通信模型擅长规整的 AllReduce 和 AllGather，面对按 token 动态寻址的 All-to-All，细粒度 put/get 更合适。\nNVSHMEM 的核心是把所有 GPU 显存当成一个分区全局地址空间（PGAS），提供 shmem_put、shmem_get 这类细粒度接口。NCCL 把通信抽象成集合操作，调用方要显式同步；NVSHMEM 允许直接读写远端显存，适合动态路由。代价是编程模型更底层，同步和内存序要自己管。\n1 2 3 4 5 6 7 [GPU0] \u0026lt;--NVLink--\u0026gt; [GPU1] \u0026lt;--NVLink--\u0026gt; [GPU2] ... [GPUN] | | | | └──────┬─────────────┴─────────────┬──────┘ | │ │ | [NVSHMEM PGAS] [IBGDA RDMA] [IBGDA RDMA] │ │ | [显存池统一管理] [跨节点通信] [跨节点通信] GDRCopy 解决的是 CPU 访问 GPU 显存的延迟。传统 cudaMemcpy 的 H2D 路径长，GDRCopy 让 CPU 直接读写 GPU 显存，小消息的延迟明显下降。真正把 CPU 从数据路径上拿掉的是 IBGDA，但它的起点是 GDR 的代理模型。\n经典的 GDR 流程要走 12 步：应用启动 kernel 在显存里生成数据，SM 把 work descriptor 写到主机内存的 proxy buffer，proxy 通知 CPU，CPU 创建 WQ 条目、更新 doorbell record、把信息注册到 NIC 的 DB，NIC 再从 WQ 读 descriptor、通过 GDR 读显存数据、发到远端、把完成事件写回 CQ，最后 CPU 确认完成并通知 GPU。这里面 CPU 参与了太多步；GPU 和网卡的处理能力早就超过 CPU，CPU 就成了小消息路径上的瓶颈。\nIBGDA 把这套流程压到 8 步：SM 直接创建 work descriptor 写到 WQ，SM 更新 DBR 并通知 NIC，NIC 通过 GDR 读 WQ 和显存数据，发到远端，再把完成事件写回 CQ。CPU 从数据路径上消失，链路短了，延迟就下来了。\nDeepEP 在 NVSHMEM 之上做了两套 kernel：训练和 prefill 用高吞吐 kernel，decode 用低延迟 kernel；低延迟路径走纯 RDMA，高吞吐路径同时用 NVLink 和 RDMA [待补：DeepEP 在 H800 或 NVL72 上的 decode 延迟与 All-to-All 带宽实测]。这个分工比“一套 All-to-All 打天下”更贴近实际，因为训练和 decode 的瓶颈根本不在一个维度上。DeepSeek 的推理系统还把预填充和解码拆成不同的部署池，P-D 分离之后，decode 池可以用更小的 batch 和更低的延迟跑，prefill 池负责把长 prompt 的吞吐吃满。\n五、负载均衡：把长尾路由压短 #负载均衡是 MoE 通信优化的另一半，前面提到的长尾分布要靠路由算法压短。DeepSeek-V2 先用细粒度专家和共享专家缓解这个问题。V2 是 160 个路由专家加 2 个共享专家，每个 token 选 top-6 路由专家；V3 进一步到 256 个路由专家加 1 个共享专家，top-8。专家数量变多，单个专家的负载方差会下降；共享专家吸收通用知识，不参与 All-to-All，直接减少动态流量。原文把 V2 写成“8 个专家拆成 256 个”，这个数字对应的是 V3，V2 的配置是 160 加 2。\nV2 还用了辅助负载均衡损失，给被选中频率过高的专家加惩罚。这个办法能压住长尾，但需要调超参数，训练目标里多了一项，模型可能为了平衡把 token 塞给不合适的专家，精度和稳定性都要打折。\nV3 的主负载均衡换成了无辅助损失的方案。它在路由分数上加一个按专家维护的偏置 b_i，这个偏置只影响 top-k 选择，不影响被选中专家的组合权重；每一步训练后按负载偏差的符号更新，负载高于均值的专家把偏置调低，低于均值的调高。V3 另外保留了一个序列级的平衡损失，防止单条序列内部极端倾斜。原文把 V3 写成“容量上限加强制重分配”，这个说法和技术报告不符：V3 没有用硬容量截断，也没有把 token 强制塞给负载最低的专家，它靠的是偏置的反馈控制。\n这个机制对 NVLink 的帮助是让流量更可预测。路由偏置把每个专家的负载往均值拉，通信库可以按容量上界预留缓冲，不需要为极端长尾留一个巨大的过载池；每个目标 GPU 的数据量更接近，微批次可以切得更均匀，流控不容易被单条热点链路打停。它不能保证每个专家严格相等，原文说“矩形分布、零方差”是夸张；实际能做到的是把长尾压短，让最慢链路和平均值的差距变小。\n收费站的比喻可以留着，但要把数字改对：不均衡时一条车道排 1000 辆车，其他车道只有 10 辆，整体效率由那条最堵的车道决定；偏置均衡把车流往空闲车道引，最堵的车道会降到接近均值，但不会做到每条车道恰好 125 辆。通信优化真正买到的，是最慢链路变快；完全均匀只是逼近它的手段。\n六、还没解决的部分 #负载均衡目前仍在软件层做，NVLink 交换机看不到端口的实时队列深度，做不到硬件级的动态路由；细粒度通信原语也还要显式打包和解包，GPU 发出“把 token X 发给专家 Y”之后，寻址和传输仍由软件库完成。链路拥塞、丢包、延迟分布的硬件计数器还不够细，路由器拿不到实时网络状态，只能按历史负载调偏置。\n跨节点的问题更大。NVLink 的优势在单机或机架内，出了机架要靠 InfiniBand 或 RoCE，延迟和带宽都掉一档；NVL72 把 72 张卡放进一个机架，华为 CM384 也在做类似的事，但铜互连的距离限制摆在那里 [待补：跨机 EP 扩到几百卡时的 All-to-All 延迟曲线]。光互联是继续扩大的方向，LPO、NPO、CPO 一路演进，成本、功耗和可靠性都还没有完全解决。低精度格式的原生路由也还没有落到链路层，FP4/FP8 的格式转换仍然要在 GPU 侧做。\n这也是 DeepEP 的边界：它把单机或机架内的 All-to-All 做到了接近硬件的水平，跨机的 All-to-All 仍然受物理距离和网络协议限制。MoE 的 EP 域从几十卡扩到几百卡时，最先撞墙的往往是跨机那一段，GPU 算力通常还轮不到。\n下次看到 MoE 推理的 TPOT 抖动，先看路由分布和跨机链路的队列，再看 kernel；单机 NVLink 的带宽通常不是第一嫌疑人。DeepEP 能解掉的是机架内的搬运，跨机那一段还得靠网络和路由算法一起解。\n参考材料：DeepSeek-V2 和 V3 的技术报告（github.com/deepseek-ai/DeepSeek-V2、github.com/deepseek-ai/DeepSeek-V3），DeepEP 的代码和 README（github.com/deepseek-ai/DeepEP），以及 GShard、Tutel、Switch Transformer、Alpa 的论文。原文是 Ethan 的知乎专栏文章，链接为 zhuanlan.zhihu.com/p/2011403053715174158。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/moe-nvlink-deepseek-deepep-communication/","section":"笔记","summary":"MoE All-to-All通信与NVLink优化解析：拆解专家并行下Token分发的Dispatch和Combine两阶段数据流，梳理训练与推理对带宽、延迟的不同要求，以及DeepSeek开源通信库DeepEP的高吞吐/低延迟Kernel设计；重点讲DeepSeek-V3无辅助损失负载均衡如何把长尾路由重塑成均匀分布，让NVLink链路跑满带宽。","title":"MoE数据特征、训练和推理的通信特点、基于NVLink/Scale Up那些Feature，DeepSeek的DeepEP和对MoE All-to-All数据的处理"},{"content":" 原文链接：https://zhuanlan.zhihu.com/p/1891569128860534619\n作者：二师兄说 AI（互联网行业 Java 工程师）\n收录于：MCP100 个案例\n有人问：都是让 LLM 操作浏览器，Puppeteer MCP 和 Playwright MCP 到底差在哪？两个服务器最直观的差别在模型拿到的元素标识上。Puppeteer MCP 让模型给出 CSS selector；Playwright MCP 默认返回一棵可访问性树，模型拿到的是带 ref 的节点。两边都能完成点击，但页面一改版，失败的方式完全不同。\nMCP（Model Context Protocol）在这里承担的是协议层：它把浏览器动作暴露成 tools，客户端通过 JSON-RPC 调用。两个 server 的协议层是一样的；差别在底层自动化库和交互抽象。Puppeteer 由 Chrome 团队开发，直接走 CDP；Playwright 由 Microsoft 开发，默认用可访问性树做元素定位。这两种抽象决定了后面的失败模式、性能边界和选型判断。\nPuppeteer MCP：CSS 选择器与 CDP 直连 #Puppeteer MCP 把 Puppeteer 的能力包装成一组工具：puppeteer_navigate 导航，puppeteer_screenshot 截图（整页或某个 CSS 选择器），puppeteer_click、puppeteer_hover、puppeteer_fill、puppeteer_select 分别处理点击、悬停、输入和下拉选择，puppeteer_evaluate 允许模型提交一段 JavaScript 在页面里执行。服务器还会暴露控制台日志和截图这类资源，方便模型在失败后回看现场。这些工具的定位方式统一是 CSS selector；模型要先知道 DOM 结构，才能写出选择器。\n这种设计在 Chromium 上很直接。Puppeteer 通过 Chrome DevTools Protocol 控制浏览器，路径短，启动和操作的开销容易控制；某些实现还支持连接到已经开启远程调试的 Chrome 实例，这对需要复用登录态、接管现有浏览器会话的场景很有用。安装也不复杂：原文给出的方式包括 npm install -g puppeteer-mcp、npx puppeteer-mcp 和 Docker 无头模式。代价是模型要承担选择器的脆弱性。CSS-in-JS 生成的哈希 class 每次构建都会变；iframe 和 shadow DOM 需要额外的穿透；虚拟列表只渲染可视区域，模型看到的节点和实际 DOM 可能对不上。这些问题不会让工具报错，只会让点击落在错误的元素上，或者等不到元素超时。\npuppeteer_evaluate 解决复杂交互，也放大了权限边界。页面里的拖拽、canvas 绘制、需要读取内部状态的场景，用一段 JS 往往比让模型猜十次选择器更可靠。但这也意味着模型拿到了执行任意 JavaScript 的能力，权限边界要由部署方自己收：只读页面、限制可访问的域名、把浏览器放在隔离容器里，比在提示词里写“不要执行危险操作”更实际。\n维护状态是 Puppeteer MCP 的另一个变量。原文采集信息时，npm 包 @modelcontextprotocol/server-puppeteer 的最近一次发布是四个月前；GitHub 上还有 merajmehrabi/puppeteer-mcp-server、twolven/mcp-server-puppeteer-py 等社区实现，活跃度各不相同。文档和示例散落在博客、Cursor Directory 和 npm 页面里，缺少一个集中的官方入口。这不等于不能用，但意味着选型时要把“谁来跟进 upstream”算进成本。[待补：截至你读到这篇文章时，@modelcontextprotocol/server-puppeteer 与主要社区 fork 的最新版本、维护状态和安全公告]\nPlaywright MCP：把可访问性树变成模型的操作界面 #Playwright MCP 的默认模式是快照模式。它调用 browser_snapshot，把页面的可访问性树（accessibility tree）整理成模型可读的结构，每个可交互节点带一个 ref；browser_click 接收元素描述和这个 ref，不需要模型生成 CSS selector。可访问性树描述的是“页面上有什么角色、叫什么名字、能不能操作”，这些信息比 DOM 的 class 名稳定得多；模型也不需要用视觉模型去猜坐标。服务器提供的工具覆盖导航、前进后退、点击、悬停、拖拽、输入、选择选项、选择文件、按键、快照、截图、保存 PDF、等待和关闭页面。传输层还支持通过 --port 启用 SSE，客户端可以用事件流接收结果。\n快照模式的核心收益是确定性：同一个页面结构，模型拿到的是同一组 ref 和角色名；点击失败时，错误通常是“元素不存在”或“不可操作”，而不是“坐标偏了几个像素”。Playwright 在点击前会做 actionability 检查：元素要可见、稳定、启用，并且能接收事件；Puppeteer 主要等 selector 出现，元素是否被遮挡、是否在动画中，要自己写等待条件。这个差异在动态页面上很实际——一个正在展开的菜单，selector 已经存在，但点击可能落在动画中间。\n快照模式也有边界。可访问性树依赖页面的语义结构：原生按钮、链接、表单控件、带 role/label 的自定义组件，在树里都有清晰的节点；如果页面是大量 div 加 canvas 画出来的，树里可能只剩几个 generic 节点，模型看不到可操作对象。这时可以切到视觉模式：用截图和坐标点击、拖拽、输入。视觉模式不依赖 ARIA，但坐标对 viewport、滚动位置和 devicePixelRatio 很敏感，页面一滚动或缩放，原来的坐标就失效；截图还会增加上下文成本。原文的结论是快照模式“依赖于结构良好的可访问性信息”，这句话应该反过来读：页面的语义质量决定了快照模式的上限。\nPlaywright MCP 的安装入口是 npm install @playwright/mcp@latest，VS Code 有专门的集成按钮和 CLI 命令；配置 MCP 客户端通常只需要指定 npx @playwright/mcp@latest 这条命令。命令行选项可以选浏览器、无头模式和监听端口。它的维护由 Microsoft 支持，原文采集时仓库有多位贡献者、近期有发布，这是它相对 Puppeteer MCP 的明显优势。[待补：截至你读到这篇文章时，microsoft/playwright-mcp 的最新版本、发布节奏与已知的 breaking change]\n真正影响选型的几个差异 #选型时最先要看的是元素定位的抽象。CSS selector 把“找元素”的责任交给模型，模型需要理解 DOM 结构、class 命名和页面层级；可访问性 ref 把“找元素”的责任交给浏览器，模型只需要理解角色和名字。前者在结构稳定、class 有语义的页面上很快，后者在动态页面和组件库页面上更稳。两者的失败模式也不同：selector 失效通常表现为找不到元素或点错元素；ref 失效通常表现为元素不可操作或快照里没有这个角色。排查时，前者要去看 DOM，后者要去看 ARIA。\n浏览器覆盖范围是另一个维度。Puppeteer 主要面向 Chromium，Firefox 支持仍是实验性的；Playwright 覆盖 Chromium、Firefox 和 WebKit，Edge 走 Chromium 通道。这个差异只有在你的产品真的需要跨浏览器测试时才有意义。如果只做 Chrome 内部的自动化，跨浏览器支持不会带来收益，反而会增加 API 和调试的复杂度。\n多语言支持这里容易误读。Playwright 作为库提供 JavaScript/TypeScript、Python、Java 和 .NET 绑定；但 @playwright/mcp 本身是一个 Node 服务器。MCP 客户端用什么语言都能连，因为协议走 JSON-RPC；Playwright 的多语言绑定不会自动变成 MCP server 的多语言实现。如果你的 Python 服务想直接调用 Playwright，应该用 Playwright 的 Python 库，而不是通过 MCP server 绕一圈。选 MCP server 时，客户端语言不是决定因素。\n维护和社区状态也得算进去。原文采集时，Playwright MCP 由 Microsoft 维护、仓库活跃、近期有发布；Puppeteer MCP 的参考实现发布节奏慢，社区实现分散。这个对比有时效性，但方向值得注意：MCP 生态还在快速变化，一个 server 的协议兼容性、浏览器版本跟进和安全修复，比多一个工具更重要。\n性能方面，公开资料里没有直接比较两个 MCP server 的 benchmark。能确定的机制有两条：Puppeteer 直接走 CDP，在 Chromium 上的控制路径短；Playwright 的快照模式省掉了截图编码和视觉模型调用，但可访问性树本身可能很大，token 成本不一定低。一个节点很多的页面，快照文本可能比一张压缩截图更占上下文；一个语义很差的页面，快照又可能信息不足。这两条机制都不能单独推出“谁更快”，只能作为压测假设。[待补：同一组页面上，两个 MCP 的任务成功率、每步延迟、快照 token 数和总步数对比]\n还有一个常被忽略的点：连接已有浏览器。某些 Puppeteer MCP 实现支持连接已开启远程调试的 Chrome，这对复用登录态很有用；Playwright 也提供 connectOverCDP，可以接管已启动的 Chromium，或者用 persistent context 保留用户目录。这个能力不是 Puppeteer 独占，差异在使用示例和封装程度。选型时不要因为“要连现有 Chrome”就直接排除 Playwright。\n从用例看，两者都能做导航、表单填写、截图、抓取 JavaScript 渲染的页面和自动化测试。Puppeteer MCP 更常见的组合是：用 puppeteer_evaluate 执行自定义脚本、监控控制台日志、生成文档截图；Playwright MCP 更常见的组合是：用快照做结构化数据提取、用 browser context 隔离多个会话、在测试里依赖 actionability 检查和网络拦截。真正需要做负载测试或远程调试时，两边都能搭，差别在周边工具和示例的成熟度。\n怎么选 #如果让我给一个默认判断：面向 LLM 的浏览器自动化，优先选 Playwright MCP。理由是快照模式把元素定位变成了结构化引用，模型不需要猜 CSS selector；Playwright 的 actionability 检查能挡掉一部分动态页面的误点击；Microsoft 的维护节奏也更适合长期依赖。这个默认判断的前提是页面有基本的语义结构——原生控件、合理的 role/label，或者至少能被可访问性树识别。\n如果已经在用 Chrome 的远程调试端口，或者目标页面只在 Chromium 上跑，Puppeteer MCP 的直连路径更短。页面大量使用 canvas 或自定义渲染时，CSS selector 本来就不适用，可以用截图或 puppeteer_evaluate 直接操作；只想要很少几个工具、不想引入 Playwright 抽象层，也属于同一类需求。这些条件里，只有“接管现有 Chrome”是 Puppeteer 的传统强项；其他几条在 Playwright 里也有对应方案，选 Puppeteer 更多是为了更短的路径和更少的抽象。\n如果页面语义很差，先别在快照模式上硬扛。Playwright MCP 的视觉模式可以兜底，但坐标点击的稳定性不如 ref；Puppeteer MCP 的 puppeteer_evaluate 可以直接读取页面内部状态，代价是给模型放开了 JavaScript 权限。两条路都要在隔离环境里跑，并且限制可访问的域名。对于 canvas 编辑器、地图、视频时间轴这类没有 DOM 语义的界面，最可靠的做法往往是为自动化提供一个隐藏的控制接口，而不是让模型去点像素。\n最后，别把这篇对比当成静态结论。原文的发布记录是素材收集时的快照，MCP 生态几个月就会变一轮；选型前自己做一次小规模 A/B：同一组页面、同一批任务，记录成功率、步数、快照 token 和延迟。如果 Playwright 的快照在你们的页面上经常缺失关键元素，或者你确实需要接管一个已登录的 Chrome，结论可能反过来。[待补：这组 A/B 的真实数据]\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/puppeteer-vs-playwright-mcp/","section":"笔记","summary":"Puppeteer MCP 与 Playwright MCP 深度对比：从浏览器支持、交互模式（DOM/CSS 选择器 vs 可访问性树快照）、性能证据、易用性到社区维护逐一分析。结论：只做 Chromium 自动化且求简单选 Puppeteer MCP，需要跨浏览器、多语言支持和长期可靠维护选 Playwright MCP。","title":"Puppeteer MCP 与 Playwright MCP：深度对比与选择指南"},{"content":"TurboQuant 最抓人的数字是「3-bit 达到 32-bit FP 的精度」和「6 倍 KV Cache 压缩」。这两个数字容易被读成同一个结论，实际是两笔账：前者说的是注意力分数的误差，后者说的是存储占用。要判断它能不能用在生产推理里，得把比特拆开看：3d 的总预算里，哪些位给了主压缩，哪些位给了残差，为什么残差只留 1 bit 还能把内积的偏差拉回来。\n这套方法由两个部件拼起来：PolarQuant 负责把向量的大部分坐标压成角度，QJL 负责用 1-bit 符号随机投影修正剩下的内积误差。下面的推导按「JL 的距离保持性—QJL 的无偏估计—PolarQuant 的递归极坐标—两阶段如何接进 attention」这条线展开，最后再算 3d 和 6x 之间的差额。\nQJL：从距离保持到内积估计 #Johnson-Lindenstrauss 引理给了一个很反直觉的承诺：高维点集可以映射到低维，点间距离基本不变。对任意数据集 $X \\subset \\mathbb{R}^d$，存在映射 $f: \\mathbb{R}^d \\to \\mathbb{R}^k$，其中 $k = O(\\varepsilon^{-2} \\log |X|)$，使得对所有 $u, v \\in X$：\n$$\\|f(u) - f(v)\\|^2 \\approx \\|u - v\\|^2$$这就是距离保持性。$k$ 只和点的数量、误差 $\\varepsilon$ 有关，和原始维度 $d$ 没有线性关系；点集越大，需要的维度才会缓慢上升。标准 JL 的实现是乘一个随机高斯矩阵 $A$，再把投影后的浮点数存下来；QJL 把最后一步改成取符号，只保留 1 bit：\n1 2 3 4 5 # 标准 JL：随机投影 + 保存浮点数 projected = sign(A · x) # A 是随机高斯矩阵 # QJL：只保存符号位（1-bit） qjl_output = sign(A · x) ∈ {-1, +1}^k sign(A · x) 这一行丢掉了投影的幅度，只留下方向；这是压缩的全部来源，也是误差的来源。单个符号只告诉你在某个随机方向上 $q$ 和 $k$ 是否同向，信息很少；但把 $m$ 个随机方向的符号乘起来，再用校准常数缩放后平均，内积的期望会回到真实值。原始内积是 $\\langle q, k \\rangle$，QJL 用\n$$\\tilde{s} = \\frac{1}{m} \\sum_{i=1}^{m} \\text{sign}(A_i q) \\cdot \\text{sign}(A_i k) \\cdot c_i$$去估计它，其中 $c_i$ 是校准常数，用于消除量化偏差。这个估计器的价值在于它的误差会随 $m$ 增大而下降，而不是固定在一个不可控的偏差上；代价是每个方向都要一次投影，$m$ 越大，压缩率越差，计算也越多。\nPolarQuant：把坐标配对成半径和角度 #PolarQuant 处理的是量化里的老问题：分组量化通常要为每个块存 min/max 或 scale/zero-point，块越小，这些常数占的比特越多。它的做法是把笛卡尔坐标两两配对，转成极坐标。对向量 $x \\in \\mathbb{R}^d$，每一对 $(x_{2i-1}, x_{2i})$ 变成 $(r_i, \\theta_i)$，其中 $r_i = \\sqrt{x_{2i-1}^2 + x_{2i}^2}$ 是半径，$\\theta_i = \\arctan2(x_{2i}, x_{2i-1})$ 是角度。转换只做一次还不够，PolarQuant 会把半径继续配对，形成层级结构：第一层得到 $(r_1, \\theta_1)$、$(r_2, \\theta_2)$、$(r_3, \\theta_3)$、$(r_4, \\theta_4)$；第二层把 $r_1$ 和 $r_2$、$r_3$ 和 $r_4$ 再转成 $(R_{12}, \\phi_{12})$、$(R_{34}, \\phi_{34})$；第三层把 $R_{12}$ 和 $R_{34}$ 转成 $(R_{1234}, \\phi_{1234})$，最终只剩一个总半径和 $d-1$ 个角度。半径用更高的位数量化，角度用更低的位数量化，存储结构是「1 个总半径 + $d-1$ 个角度」。\n这套结构消掉的是归一化开销。传统分组量化要存每个块的 min/max，边界随数据动态变化，还要额外花 1-2 位存这些常数；极坐标的角度天然落在 $[0, 2\\pi)$，边界固定，可以用一个固定的「圆形网格」去量化，不需要为每个块单独存边界。为什么可以先做随机旋转？因为旋转让数据各向同性（isotropic），坐标对的能量分布更均匀，角度不会全挤在少数几个方向；如果不旋转，一个只在少数维度上有值的向量，角度会高度集中，固定网格的码字就浪费了。\n代价在计算侧：每次压缩都要算平方、开方和 $\\arctan2$，解压时还要把极坐标转回笛卡尔坐标。存储省下来的比特，换成了编解码的浮点运算；对 KV Cache 这种写一次、读多次的数据，这笔交易通常划算，但如果你的 kernel 本来就在为每个 token 做 dequant，额外的三角函数会成为新的瓶颈。\n两阶段：主项 + 1-bit 残差 #两阶段里的第一阶段是随机旋转加 PolarQuant。先旋转，再量化：\n$$\\mathbf{v} \\xrightarrow{\\text{Random Rotation } R} \\mathbf{v}' \\xrightarrow{\\text{PolarQuant}} (\\mathbf{r}, \\boldsymbol{\\theta})$$随机旋转让数据各向同性，PolarQuant 把半径和角度分开量化：半径用高位，角度用低位。重建出 $\\hat{\\mathbf{v}}$ 之后，残差是 $\\mathbf{\\delta} = \\mathbf{v} - \\hat{\\mathbf{v}}$。第二阶段用 QJL 把这个残差压成 1 bit：\n$$\\mathbf{\\delta}_{\\text{qjl}} = \\text{sign}(A \\cdot \\mathbf{\\delta})$$接进 attention 时，分数被拆成两项。主项和修正项分别对应下面公式里的两项：\n$$\\text{Attention}(Q, K) = \\underbrace{Q \\cdot \\hat{K}_{\\text{polar}}}_{\\text{主要项}} + \\underbrace{\\text{QJL\\_Estimator}(Q, \\delta_K)}_{\\text{偏差修正}}$$第一项用 PolarQuant 重建的 $K$ 算内积，第二项用 QJL 估计残差带来的偏差。这个拆法的关键在注意力只关心内积，不关心 $K$ 的逐元素重建质量；只要内积的期望无偏、方差可控，$K$ 本身可以压得很狠。QJL 的 1 bit 用来修正主项的系统性偏差，不需要恢复 $K$ 的细节，所以它不需要很多位。\n理论保证落在两行上。期望上，量化后的分数等于真实分数：\n$$E[\\tilde{s}] = \\langle q, k \\rangle$$方差也有上界。下面这个不等式给出它随 $m$ 收缩的方式：\n$$\\text{Var}(\\tilde{s}) \\leq \\frac{C}{m} \\|q\\|^2 \\|k\\|^2$$其中 $m$ 为 QJL 维度，增加 $m$ 可以任意减小误差。前者说明估计没有固定偏差，后者说明误差的上界按 $1/m$ 收缩。真正影响线上效果的是 $C$ 这个常数；原文没有展开它和 $m$、数据维度之间的关系，[待补：$C$ 的推导或实测范围、$m$ 与误差的实测曲线]。\n账本：3d 和 6x 之间差在哪 #把每向量的比特数摊开：FP32 是 $32d$，INT8 是 $8d$，KIVI 是 $4d$ 加分组量化的开销，TurboQuant 是 $3d$，内容为极坐标加 1-bit 残差。$32/3$ 约为 10.7，这是纯载荷的理论上限；材料给出的实际 KV Cache 收益是 6 倍。两个数字不矛盾，差额来自块对齐、元数据、残差索引这些实现开销，也来自实际 kernel 对非均匀位宽的支持程度。原文没有拆这 4.7 倍的账，[待补：6x 的测量口径、块大小与元数据开销拆分、TurboQuant 原始论文或技术报告的链接]。\n从 $32d$ 到 $3d$，压缩比看起来最刺激；但对推理系统，真正决定吞吐的是内存带宽和省下来的字节能不能被 kernel 直接消费。如果 attention kernel 需要先把 3-bit 数据解压成 FP16 再算，省下的是 HBM 占用，付出的是反量化和额外的寄存器/共享内存流量；在 decode 阶段，KV Cache 读取本来就是带宽瓶颈，这种交换可能划算；在 prefill 阶段，计算更密集，解压开销未必能被带宽节省抵消。原文的「计算更快（低 bit 运算）」成立的前提是底层有对应的低 bit matmul 路径；没有这条路径，省的是显存，算的还是 FP16。\n这套方案不需要训练，量化过程是数据无关的；好处是换模型不用重训量化器，代价是它不能像学习式量化那样针对数据分布做优化。数据无关也意味着它对异常值、长尾分布的鲁棒性只能靠随机旋转和残差修正兜底，不能靠训练时见过的分布去适配；原文没有给出异常值场景的评测，[待补：长尾/异常值下的精度退化数据]。\n一个十进制例子 #传统量化像把 3.1415926 存成「3.14 + 缩放因子 100」：数值本身只占几个字符，缩放因子还要额外空间。PolarQuant 像把 (3, 4) 存成「长度 5 + 角度 53°」：角度范围固定在 [0°, 360°)，解码时不需要再问「这个块的边界是多少」。QJL 则像把误差 0.0015926 存成一串符号「+ - + - \u0026hellip;」：只有 1 位，但 JL 变换保证这些符号的期望能把误差的方向估回来。三个例子各自的代价也很清楚：缩放因子是额外存储，角度是三角函数计算，符号是多次投影；TurboQuant 把这三笔代价压到同一个 3d 预算里。\nTurboQuant 给出的 3-bit 和 6x 回答的是两个不同问题：3d 回答「内积还能不能估准」，6x 回答「KV Cache 能省多少」。要把这两个数字变成线上的吞吐，还缺三样东西：6x 的测量口径、C 和 m 的实测曲线、以及低 bit kernel 在目标硬件上的反量化成本。三样里缺任何一样，3-bit 都只是一个存储方案，未必是一个更快的推理方案。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/turboquant-math-principles/","section":"笔记","summary":"TurboQuant 数学原理推导：QJL 符号随机投影的无偏估计与方差界限、PolarQuant 递归极坐标量化如何免掉归一化开销，拆解「极坐标压缩 + 1-bit 残差修正」两阶段框架，说明 TurboQuant 为何能在 3-bit 下达到 FP32 精度并实现 6 倍 KV Cache 内存压缩。","title":"TurboQuant 数学原理解析"},{"content":"TurboQuant 的标题里同时出现 “ultra-fast”、“KV cache” 和 “vector search”，容易让人以为这是一篇纯工程优化。真正读进去，前置知识分布在三条线上：向量量化、Johnson-Lindenstrauss 随机投影、LLM KV Cache 压缩。缺任何一条，都会在原文的误差分析处断掉；下面这条路径按依赖顺序排，不按论文发表时间排。\n一、必读论文 #量化这条线的起点是 Jégou 等人在 2011 年的 Product Quantization。PQ 把一个大向量切成若干子空间，每个子空间单独跑 k-means，原向量被表示成几段码本索引；存储从浮点向量变成短码字，查询时用查表累加近似距离。Ge 等人在 2013 年提出的 OPQ 在切分前加一个正交变换，让子空间的能量分布更均匀，减少 PQ 的量化误差。Babenko 和 Lempitsky 在 2014 年的 Additive Quantization 继续优化码本组合，AQ/LPQ 用多个码本的和来逼近原向量。TurboQuant 里的 PolarQuant 沿用了分组量化的思路，OPQ 的旋转预处理则和后面的 QuaRot 一脉相承。\n随机投影这条线要读三篇。Datar 等人在 2004 年的 LSH 论文用 p-stable 分布构造哈希，解决的是高维近邻检索；Charikar 在 2002 年的 SimHash 用随机超平面做符号投影，把向量压成 1-bit 哈希；Ailon 和 Chazelle 在 2006 年的 Fast Johnson-Lindenstrauss Transform 把稠密随机矩阵换成 P·H·D 的快速结构，让 JL 变换的矩阵乘法从 O(kd) 降下来。QJL 的误差分析直接建立在这些随机投影的性质上，不熟悉 JL 的方差和集中界，读 QJL 的证明会很吃力。\nLLM KV Cache 这条线有四篇必读。KIVI 在 2023 年提出无需训练的 2-bit 非对称 KV 量化，Key 和 Value 采用不同精度，是 TurboQuant 论文里的主要对比 baseline。H2O 同年用 Heavy-Hitter Oracle 做动态稀疏化，只保留重要 token 的 KV，代表“少存一些”的路线；StreamingLLM 则从 Attention Sink 现象出发，解释长上下文里哪些位置不能丢。QuaRot 在 2024 年用旋转把权重和激活里的异常值摊平，再做 4-bit 在线量化，和 TurboQuant 的旋转思路最接近；读它的实现，能先建立“旋转之后量化误差怎么变”的直觉。\n原文这条线按三篇读。TurboQuant 的原文标注为 ICLR 2026，PolarQuant 标注为 AISTATS 2026，QJL 是伴随论文，三篇在原文中被描述为待发表状态。顺序上先读 PolarQuant，弄清极坐标递归变换怎么把向量拆成半径和方向；再读 QJL，弄清随机投影下的内积估计为什么无偏；最后读 TurboQuant，看它怎么把这两块拼到 KV Cache 和向量检索里。原文链接和正式发表状态以论文页面为准，这里只保留文章发布时的信息。\n二、关键技术栈 #先分清标量量化和矢量量化。标量量化对每个分量独立取整，均匀量化用固定步长，非对称量化给每个通道或每个 token 单独算 zero point 和 scale；矢量量化把多个分量放在一起，用一个码本里的最近中心代替原始向量。下面的结构把两类方法放在一起对照，后面读代码时能对上实现里的变量名：\n标量量化 (Scalar Quantization) ├── 均匀量化: x_q = round((x - z) / s) ├── 非对称量化: per-channel/per-token scaling └── 对称量化: zero-point = 0 矢量量化 (Vector Quantization) ├── PQ: x → [x_1, ..., x_m] → argmin_c ||x_i - c|| ├── OPQ: x → R·x → PQ (含旋转) └── 残差量化: x → c_1 + c_2 + ... (级联) PQ 和 OPQ 解决的是“用有限码本逼近高维向量”，残差量化解决的是“一层码本不够准”，把上一层的残差再用一个码本编码。这三种结构在 Faiss 里都有对应实现，读 TurboQuant 之前至少要知道 argmin 那一步是在码本里找最近中心，不是在原始空间里做精确最近邻。\nJohnson-Lindenstrauss 这条线要落到实现上。标准 JL 用一个稠密高斯矩阵 R 把 d 维向量投到 k 维，缩放因子是 1/√k；稀疏 JL 把 R 的元素限制在 {+1, 0, -1}，减少乘法；Fast JL 用 P·H·D 分解，D 是随机符号，H 是 Hadamard 矩阵，P 是下采样。代码注释里三行就写完了这三种形式：\n1 2 3 4 5 6 7 8 # 标准 JL: y = (1/√k) · R · x # R ∈ R^{k×d}, R_{ij} ~ N(0,1) # 稀疏 JL (Achlioptas): R_{ij} ∈ {+1, 0, -1} with prob {1/6, 2/3, 1/6} # Fast JL (Ailon-Chazelle): # y = P·H·D·x # D: random signs, H: Hadamard, P: subsampling 读这段要抓住的是随机矩阵的方差和独立性。JL 保证的是投影后成对距离以高概率保持，QJL 在此基础上进一步估计内积；如果只记住“降维”，不知道方差怎么随 k 缩小，后面的无偏性证明就只能跳着看。\n在线量化是 LLM 场景绕不开的一层。模型激活的数值范围随 token、随层变化，预先算好的 min/max 很快失效，所以实现会在运行时统计分桶或滑动窗口的极值，动态更新 scale。粒度上，逐 token 和逐通道各有取舍：逐 token 能跟上序列内的变化，逐通道能保住通道间的差异，KIVI 对 Key 和 Value 采用不同精度就是在处理这个差异。异常值则靠旋转平滑或 clipping 压下去，QuaRot 的旋转把少数大分量摊到多个维度，代价是多一次矩阵乘法。\nCUDA 侧的优化决定了这些算法能不能跑到可用吞吐。低位整数要先解包再参与计算，bit-packing 把多个 4-bit 或 2-bit 值塞进 32/64-bit 寄存器，省的是显存和带宽，花的是额外的移位与掩码指令。向量化 load/store 一次搬 128-bit 或 256-bit，要求地址对齐；warp shuffle 在寄存器之间交换数据，能少走 shared memory。读开源实现时，先看解包和内积的 kernel，再看上层量化逻辑，通常更容易理解作者为什么选这个 bit 宽。\n三、数学知识清单 #线性代数是第一层。正交矩阵满足 R^T R = I，作用在向量上保持范数不变，PolarQuant 的随机旋转和 QuaRot 的旋转都依赖这个性质。极坐标把向量写成半径 r 和单位方向 x̂ 的乘积，x = r · x̂，PolarQuant 的核心变换就是在这个表示上递归拆分。Hadamard 变换用 H_n = H_1 ⊗ H_{n-1} 的递归结构构造，Fast JL 用它替代稠密矩阵；SVD 用来分析数据分布和做 PCA 预处理，内积与角度则帮助理解 attention 里的相似度计算。这些概念不需要全部手推，但看到 R^T R = I 时要知道它意味着保范数，看到 H_n 时要知道它是递归块结构。\n概率论是第二层，也是 QJL 证明的核心。集中不等式给出随机变量偏离均值的尾界，Hoeffding、Chernoff、Bernstein 各自对应不同的有界性或方差假设；亚高斯变量满足 P(|X| \u0026gt; t) ≤ 2e^{-ct^2}，随机投影矩阵的元素通常按这个性质处理。高维几何里的测度集中解释了为什么随机方向在高维空间里几乎正交，随机矩阵理论则用 Marchenko-Pastur 律描述样本协方差的特征值分布。Hoeffding 不等式长这样：\nP(|(1/m)∑X_i - E[X]| ≥ t) ≤ 2exp(-mt^2/2) 它说明 m 个独立样本的平均值偏离期望超过 t 的概率随 m 指数下降。放到 QJL 里，m 是投影维度，投影维度越大，内积估计的误差尾就越薄；这就是“m 维 QJL 投影足够大时，估计误差指数级小”的数学依据。读证明时要检查独立性、有界性这些前提，别把结论直接套到相关样本上。\n信息论回答的是“到底需要多少 bit”。熵 H(X) = -∑ p(x)log p(x) 给出编码一个分布所需比特数的下界，率失真理论 R(D) = min I(X;X̂) 描述在允许失真 D 时能做到的最小码率。量化误差用 MSE、L2 distortion 或内积 distortion 衡量，TurboQuant 的误差分析同时关心 MSE 和内积 distortion，评价时不能只看重建 MSE。把率失真曲线和实际 bit 宽对上，才能判断一个 2-bit 方案是接近理论极限，还是在靠任务容忍度换压缩率。\n优化理论是第四层。Lloyd-Max 量化器交替做“按最近中心划分”和“按划分更新中心”，是标量量化的最优迭代算法；k-means 和矢量量化把同样的思路搬到多维码本学习，PQ/AQ 的训练都绕不开它。凸优化里的拉格朗日对偶和 KKT 条件用于带约束的码本或步长优化，读论文的附录时至少要知道互补松弛条件在说什么。这一层不需要学到能证明收敛速率，但要知道 Lloyd 迭代为什么会停在局部最优。\n四、学习路线 #前两周补基础和量化入门。线性代数复习到正交变换和极坐标表示，3Blue1Brown 的视频可以当入口；概率论补高维几何与集中不等式，然后读 Product Quantization 原文，手推一遍子空间切分和码本大小对误差的影响。这个阶段的产出应该是一张能自己解释的 PQ 误差来源图，而不是把论文摘要抄一遍。\n第三到四周进入随机投影。读 FJLT 论文，把 P·H·D 三个矩阵各自的作用写清楚；学 SimHash 和 LSH，理解 1-bit 哈希怎么近似余弦相似度；然后读 KIVI 论文并对着代码看量化粒度。这个阶段结束时，应该能说清 Key 和 Value 为什么可以采用不同精度，以及 per-channel 与 per-token 的 scaling 各自在什么时候失效。\n第五到六周做 LLM 量化专题。读 QuaRot，重点看旋转矩阵怎么作用到权重和激活、异常值被摊平之后量化误差怎么变化；补 KV Cache 的内存分析，按层数、头数、head_dim、序列长度和 batch 算一遍显存占用；最后实现一个简单的 KV 量化 demo，哪怕只是在 PyTorch 里对一层 attention 的 K/V 做分组量化再反量化。这个 demo 的价值在于暴露实现细节：scale 怎么存、零点怎么对齐、反量化后的数值误差怎么进入 attention。\n第七周以后回到 TurboQuant 本身。先读 PolarQuant，推导极坐标递归变换；再读 QJL，推一遍无偏估计的证明；最后等官方代码发布，对照论文看工程实现里哪些近似被省掉了。文章发布时官方代码还没有公开，这一步只能先用论文附录和复现代码填空；等代码出来，优先跑 KV Cache 的显存占用，再谈端到端吞吐。论文里的压缩率是理论上限，落到线上还要看解包开销和 kernel 利用率。\n五、代码资源 #Faiss 是 PQ/OPQ 的工业级参考，faiss::IndexPQ 和 faiss::IndexOPQ 覆盖了码本训练、编码和查表距离计算。读它的时候重点看子空间切分和码本初始化，这两处决定了量化误差的量级；不要一上来就钻 SIMD 实现，先把数据结构看懂。QuaRot 的仓库在 https://github.com/spcl/QuaRot ，适合对照论文看旋转怎么接进在线量化。KIVI 的实现在 https://github.com/jy-yuan/KIVI ，是 KV Cache 量化的标准参考，重点看 Key 和 Value 的精度分配以及分组粒度的处理。\n数学工具库按用途选。NumPy/SciPy 用来做矩阵运算、SVD 和 Hadamard 变换的原型验证，写几十行就能把 JL 的方差和误差曲线跑出来；JAX 适合需要自动微分的推导，尤其是想把梯度流和量化误差放在一起看的时候；PyTorch 的 torch.quantization 模块可以用来对照工业实现的量化流程，虽然它主要面向权重和激活，不是专门为 KV Cache 设计的。\n六、自测问题 #在开始读 TurboQuant 之前，下面五个问题应该能脱稿讲清楚。答不上来的，回到对应章节补课：\n为什么高维随机向量几乎正交？这题考的是高维几何和集中不等式：两个随机方向的内积除以模长，随着维度升高会快速集中到 0 附近。能用 Hoeffding 或亚高斯界把这句话写成不等式，才算过关。 证明随机投影保持内积期望不变。标准 JL 里 R 的元素是零均值、单位方差，投影后内积的期望等于原内积；还要说清缩放因子 1/√k 从哪里来。把这一步推完，QJL 的无偏性才有落脚点。 PQ 和 OPQ 的区别是什么，量化误差来自哪里？要能说清 PQ 先把向量切子空间再分别聚类，OPQ 在切分前加正交旋转，误差来自每个子空间的码本只能覆盖有限个中心。这三个问题在论文的误差分析里会反复出现。 KV Cache 的内存复杂度是多少，为什么需要压缩？按层数、头数、head_dim、序列长度和 batch 把字节数摊开，能算出长上下文下 KV 比权重更早撑爆显存。如果只记 O(n) 的结论，读论文仍然会卡在具体系数上。 旋转矩阵如何帮助消除量化异常值？要能解释旋转把少数大分量摊到多个维度，量化步长不必为极值放大，代价是额外的矩阵乘法。QuaRot 的在线量化就是靠这一点把 outlier 处理从 per-channel 选择变成固定旋转。 真正的卡点通常在 QJL 的无偏性证明和 PolarQuant 的递归极坐标变换；官方代码发布前，只能靠论文附录和复现实验对照。等代码公开，先跑一遍 KV Cache 的显存占用，再谈端到端加速，否则很容易把论文里的压缩率当成线上吞吐。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/turboquant-learning-path/","section":"笔记","summary":"TurboQuant 学习路径完整指南：按 PQ/OPQ、JL 变换、KIVI、QuaRot 到 TurboQuant 原文的顺序梳理必读论文，整理向量量化与随机投影所需的线性代数、概率论、信息论数学清单，并给出 7 周学习路线图和 Faiss、QuaRot、KIVI 等开源代码资源。","title":"TurboQuant 学习路径：论文 → 技术 → 数学"},{"content":"Diffusion 模型的 RL 微调在一年多里长出了至少四条路线：把多步降噪直接当 MDP，采样后在前向过程里加权，拿 CFG 当策略改进算子，以及固定原策略只学噪声。它们的差别主要在于把哪一段计算图当成可优化的策略，训练稳定性、reward 设计和算力开销都由此分叉。下面这份整理来自知乎专栏文章，原文链接是 https://zhuanlan.zhihu.com/p/2004562606309020589 ，公式保留原文记号。\n背景 #核心挑战有三个。降噪是一个连续多步的过程，RL 的决策框架要把每一步的噪声或 velocity 当成 action，才能定义状态和轨迹；训练稳定性要求新旧策略的分布不要差太远，否则 reward 信号会被巨大的策略偏移淹没；噪声强度则要和监督训练时保持一致，模型在某个信噪比下学到的 velocity，换到另一个信噪比下未必成立。这三条约束对应后面不同的技术路线，也解释了为什么同一篇论文里既有策略梯度，又有对采样过程的改造。\n方法一：多步降噪看作 MDP #代表工作是 DDPO（https://arxiv.org/abs/2305.13301 ）和 Flow-GRPO（https://arxiv.org/abs/2502.06737 ）。两者都把多步降噪过程看成马尔可夫决策过程，直接套用 GRPO、策略梯度或 PPO 等 RL 框架；状态是当前的带噪样本，action 是网络预测的 velocity，轨迹是一条完整的降噪路径。\nFlow Matching 的采样过程对应一条 ODE 轨迹。为了在每一步注入随机性，把 ODE 转成 SDE，于是每一步的 velocity 服从一个高斯分布：\n$$ p(v_t | x_t) = \\mathcal{N}\\left(v_\\theta(x_t), \\sigma_t^2\\right) $$这个高斯分布的均值是网络预测的 flow，方差由 $\\sigma_t$ 决定，$\\sigma_t$ 是预定义的与 $t$ 相关的量，例如 $\\sigma_t = \\sigma_{min} + t \\cdot \\sigma_{max}$。方差项就是注入随机性的入口，也让每一步的概率可以计算。\n$v_\\theta$ 被当作 RL 里的 action。一次完整降噪产生多条 trace，每条 trace 视为一条 trajectory；每一步根据上面的高斯分布得到 probability；拿到终点的 reward 后，就可以执行策略梯度或 GRPO 更新。DDPO 和 Flow-GRPO 都只在最后降噪结束时评估 reward，中间步骤还是噪声，单独打分意义不大。\nRef model 走同样的过程，只把 $v_\\theta$ 换成 $v_{ref}$。两个分布都是高斯，KL 有闭式解，Flow-GRPO 的优化目标里可以直接写 KL 项：\n$$ \\mathcal{L}_{GRPO} = \\mathbb{E}\\left[ \\frac{\\pi_\\theta(v_t|x_t)}{\\pi_{old}(v_t|x_t)} \\cdot A_t \\right] - \\beta \\cdot KL(\\pi_\\theta || \\pi_{ref}) $$其中概率 ratio 是 actor 和 old policy 在高斯分布下的密度比，不同 $t$ 的 $v_\\theta$ 来自同一个网络，reward 只在终点计算。两个同方差高斯的 KL 退化成均值差除以两倍方差，形式如下：\n$$ KL(\\mathcal{N}(\\mu_1, \\sigma^2) || \\mathcal{N}(\\mu_2, \\sigma^2)) = \\frac{(\\mu_1 - \\mu_2)^2}{2\\sigma^2} $$这个形式计算便宜，也让 reference model 的约束可以逐步加在训练里。DDPO 则用策略梯度或 PPO，具体写法如下：\n$$ \\nabla_\\theta J = \\mathbb{E}_{x \\sim p_\\theta(x|c)} \\left[ R(x, c) \\cdot \\nabla_\\theta \\log p_\\theta(x|c) \\right] $$PPO 则用 clip 限制更新幅度。目标函数如下：\n$$ \\mathcal{L}_{PPO} = -\\mathbb{E}_t \\left[ \\min\\left( r_t A_t, \\text{clip}(r_t, 1-\\epsilon, 1+\\epsilon) A_t \\right) \\right] $$其中 $c$ 是输入条件，也就是网络拿到的各类条件。策略梯度把 reward 乘在 log-prob 的梯度上，PPO 再用 clip 限制 ratio 的更新幅度；两条式子对应同一条路线里的不同稳定化手段。\n方法二：采样后在前向过程中优化 #代表工作是 AWM（https://arxiv.org/abs/2410.01808 ）和 DiffusionNFT（https://arxiv.org/abs/2502.05597 ）。AWM 的核心结论是一句很长的论文标题：“DDPO is Secretly Doing Denoising Score Matching with Noisy Data”。它的逻辑链是：DDPO 等价于优化一个噪声加多了的前向过程，原本应该学习 $v_\\theta(x_t)$，实际学的是 $v_\\theta(\\tilde{x}_t)$，其中 $\\tilde{x}_t$ 是 $x_t$ 又加了额外噪声的版本。AWM 的实验表明这样不好，优化目标和原来的监督版本不一致。\n解决方案很直接：先用噪声做前向，得到一批结果；给结果打分，算出 advantage；再把这些结果当作 $x_t$ 执行一次前向训练；前向过程乘以 reward，强化好结果、抑制坏结果。这样 flow 会远离坏方向，训练速度快，流程也简单。这跟 DPO 的思想类似，都是用偏好样本构造一个加权的回归目标，不去显式训练 reward model。\nDiffusionNFT 关注的是 ref model 怎么用。它用同样的条件、不同的噪声生成一批结果，给每个结果打一个 0 到 1 的 optimality probability，得到多个 $(x_t, r)$ 对。然后执行前向过程，构造 positive velocity 和 negative velocity，记法如下：\n$$ v_{pos} = v_{old}(x_{pos}), \\quad v_{neg} = v_{old}(x_{neg}) $$$v_{old}$ 是旧策略或 ref model 预测的 flow，$v_\\theta$ 是要学的网络。优化目标让网络靠近正例、远离负例，损失写成：\n$$ \\mathcal{L} = \\mathbb{E}\\left[ r \\cdot ||v_\\theta(x_t) - v_{pos}||^2 - (1-r) \\cdot ||v_\\theta(x_t) - v_{neg}||^2 \\right] $$梯度方向可以读成“纠正和躲避”：正例项把 $v_\\theta$ 拉向 $v_{pos}$，负例项把它推离 $v_{neg}$。稳定性靠 old model 的滑动平均（EMA），old model 不断向新模型靠拢，两者差距不会拉得太大；梯度分析和 AWM 类似，只是多了一个“不要和 old 偏离太远”的约束项。\n方案三：CFGRL #CFGRL 的代表论文是《Diffusion Guidance Is a Controllable Policy Improvement Operator》（https://arxiv.org/abs/2410.15470 ），它把 Classifier-Free Guidance 看成可控的策略改进算子。核心思想类似 RL 里的 $\\pi^*$ 方法，具体推导要回到原论文。这条路线的好处是复用已有的 CFG 机制；代价是改进幅度受 guidance 机制约束，适用范围比前两条路线窄。\n方案四：使用 Q 函数 #这条路线问的是：能不能针对当前场景找到最好的噪声？它先训练一个 $Q(x_t, z)$，评估状态和噪声对的价值；再蒸馏一个噪声生成器 $z_\\phi$，用 $\\min_\\phi ||z_\\phi(x_t) - z^*||$ 让它和 Q 函数一致；最后用 $z_\\phi$ 针对当前场景生成噪声。原 Flow Matching 策略固定不动，调整只发生在噪声上，因此调整幅度被限制住，不容易训崩，性能下限有原策略兜底。代价是要额外训练 Q 网络和生成器，训练管线比前三条路线长。\n四条路线的取舍 #MDP 路线优化降噪策略本身，把降噪视为 trajectory，用 PPO 或 GRPO 更新；它的优势是能直接套成熟 RL 算法，问题在于噪声强度与监督训练不对齐。前向优化路线优化 flow 预测，采样打分后在前向过程中加权；它简单有效、训练快，但需要设计好正负例的构造。CFGRL 优化引导策略，把 CFG 当策略改进算子；它利用已有 guidance 机制，适用范围却受 guidance 本身限制。Q 函数路线优化噪声生成器，固定原策略、只学最优噪声；它训练稳定、下限有保证，代价是多了 Q 网络和生成器两套训练。\n四条路线没有统一的胜负。评价一个方案，先看它优化的是策略、flow、guidance 还是噪声，再看它的 reward 从哪里来、噪声对齐怎么处理；这几项答不清，指标涨了也很难复现。\n噪声强度不对齐 #DDPO 和 Flow-GRPO 的采样方法会让第 $t$ 步的噪声强度与监督训练时的第 $t$ 步强度对不上。模型在监督训练时见过某个信噪比下的 $x_t$，采样时注入的噪声却对应另一个信噪比，velocity 目标就偏了。DanceGRPO（https://arxiv.org/search/?query=DanceGRPO ）选择动态加噪声，根据任务情况和收敛情况改变噪声注入强度；Coefficients-Preserving Sampling（https://arxiv.org/search/?query=COEFFICIENTS-PRESERVING+SAMPLING ）推导强度不一致的原因和程度，再提出修正方法。后者对数学原理的分析更细，值得优先读。\n还没解决的问题 #这四条路线覆盖了目前的主要做法，但两个问题仍然没有统一解。中间步骤没有独立 reward，信用分配只能靠终点回传，长轨迹上的方差压不下去；噪声对齐目前靠 DanceGRPO 和系数保持采样修补，换一个采样器或换一个噪声日程就要重新验证。VLA 这类复杂场景对动作连续性和多模态条件的要求更高，这两块短板会更早暴露。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/diffusion-rl-methods/","section":"笔记","summary":"Diffusion RL 技术路线综述：将扩散模型与强化学习结合的方案归纳为四大类——MDP 套框架（DDPO、Flow-GRPO）、前向过程优化（AWM、DiffusionNFT）、CFGRL 与 Q 函数方法，并比较各方法的代价、适用边界，以及 DanceGRPO 等噪声强度不对齐问题的修正工作。","title":"百花齐放的 Diffusion-RL：技术路线综述"},{"content":"1000 维单位球，剥掉最外层 1% 的壳，剩下多少体积？答案小到可以忽略：几乎所有体积都贴着表面。这个反直觉的结论是理解高维几何的起点：随机向量的长度高度集中，方向几乎正交，内积接近 0。TurboQuant 这类量化方法能成立，靠的就是这些集中性质。\n一、高维几何：反直觉的世界 #1.1 高维球体的\u0026quot;空心化\u0026quot; #三维球的体积在半径上分布得比较均匀；到了 1000 维以上，几乎所有体积都贴着表面。把这个直觉写成公式：d 维单位球的体积随半径的 d 次方增长，\nV_d(r) = π^(d/2) / Γ(d/2 + 1) · r^d 当 d 很大时，半径缩到 1-ε 处的体积占比是\nV_d(1-ε) / V_d(1) = (1-ε)^d ≈ e^(-εd) 这个比值只和 εd 有关，维度越高衰减越快。d=1000、ε=0.01 时，只剥掉外层 1% 的壳，剩余体积是\n剩余体积 = (0.99)^1000 ≈ e^(-10) ≈ 0.000045 → 99.995% 的体积在表面1%的薄层！ 维度越高，这层壳越薄，所谓\u0026quot;球\u0026quot;在几何上更接近一层皮。对 TurboQuant 来说，这意味着高维向量几乎等长，长度集中在球面上；PolarQuant 利用的正是这一点：半径相对稳定，角度承载主要信息。\n1.2 随机向量几乎正交 #在 d 维空间里随机取两个单位向量 u、v，当 d→∞，内积趋于 0：\n\u0026lt;u, v\u0026gt; → 0 设 u,v~N(0,I_d)，归一化后内积是\n\u0026lt;u/||u||, v/||v||\u0026gt; = (1/d)∑u_i v_i · d/(||u||||v||) 由大数定律，(1/d)∑u_i v_i→E[u_i v_i]=0，||u||²/d→1，所以内积≈0，夹角≈90°。模拟结果也符合：d=3 时夹角方差很大；d=100 时集中在 90°±8°；d=10000 时集中在 90°±0.8°。\nd=3: 随机向量夹角平均约 90°，方差大 d=100: 夹角集中在 90° ± 8° d=10000: 夹角集中在 90° ± 0.8° 对 TurboQuant 的意义是，QJL 的 sign-random-projection 依赖随机方向足够分散；高维里少量投影就能把不同向量区分开。\n1.3 高斯分布的集中性 #一维高斯有厚尾，P(|X|\u0026gt;2σ)≈5%。到了 d 维，||X||²=∑X_i² 高度集中。对 X~N(0,I_d)，\n||X/√d||^2 = (1/d)∑X_i^2 → 1 (当 d→∞) 方差是\nVar(||X||^2/d) = 2/d → 0 100 维时，半径几乎都落在 √100=10 附近，分布像一个薄球壳，不再是一维那条带尾巴的钟形曲线。\n二、集中不等式：概率的上界艺术 #集中不等式干的事情，是给偏离均值的概率加上界。Markov 不等式只需要非负随机变量和期望：对 X≥0、a\u0026gt;0，\nP(X ≥ a) ≤ E[X]/a 如果平均工资是 5000，收入超过 50000 的人不超过 10%。这个界很松，但不需要方差，也不需要分布形状。\nChebyshev 不等式把方差用上：\nP(|X - E[X]| ≥ t) ≤ Var(X)/t^2 它给出的是偏离均值超过 t 的概率上界，比 Markov 更紧，但仍然只用了二阶矩。\nHoeffding 不等式是后面 JL 和 QJL 分析里的核心工具。设 X_1,\u0026hellip;,X_n 独立且有界，X_i∈[a_i,b_i]，S_n=∑X_i，则\nP(|S_n - E[S_n]| ≥ t) ≤ 2exp(-2t^2 / ∑(b_i-a_i)^2) 同分布、[0,1] 有界时，式子简化成\nP(|(1/n)∑X_i - μ| ≥ ε) ≤ 2e^(-2nε^2) 它的两个关键特性：误差概率随 n 指数衰减；只要求有界，不要求正态分布。\n亚高斯分布把这套界抽象成一个定义：如果\nP(|X - E[X]| ≥ t) ≤ 2e^(-t^2/2σ^2) 就说 X 是亚高斯的。有界随机变量、正态分布、Rademacher 变量都是例子。独立亚高斯变量的和仍然是亚高斯，方差参数相加。\n三、在 TurboQuant/JL 中的应用 #3.1 Johnson-Lindenstrauss 引理证明骨架 #JL 引理要证明的是，随机投影 f(x)=1/√k Rx（R_ij~N(0,1)）在 k 足够大时保持距离。证明分四步，核心是固定一个向量看投影后的长度。\n固定单位向量 x，第 j 个投影分量是\ny_j = (1/√k)∑R_{ji}x_i ~ N(0, 1/k) 于是 ||f(x)||²=∑y_j² 是 k 个独立 χ² 变量之和。用亚指数/χ² 版本的集中不等式，偏差超过 ε 的概率满足\nP(|||f(x)||^2 - 1| ≥ ε) ≤ 2e^(-ckε^2) 最后对所有 n 个点的 C(n,2) 对距离做 union bound，要求\nk ≥ 4logn / (ε^2/2 - ε^3/3) = O(ε^(-2)log n) 这就是 JL 引理的样本复杂度：投影维度只需随 log n 增长，和原始维度 d 无关。\n3.2 QJL 的误差分析 #QJL（Quantized Johnson-Lindenstrauss）用 sign-random-projection 估计内积。查询 q、键 k，投影矩阵 R∈R^{m×d}，元素 i.i.d. N(0,1)；量化后 q̂=sign(Rq)，k̂=sign(Rk)；估计量是\nṡ = (1/m)∑q̂_i · k̂_i 单个投影的期望是\nE[sign(R_i q) · sign(R_i k)] = 1 - 2θ/π 其中 θ=arccos(\u0026lt;q,k\u0026gt;/(||q||||k||)) 是夹角。因为 q̂_i·k̂_i∈{-1,+1} 有界，Hoeffding 直接给出\nP(|ṡ - E[ṡ]| ≥ t) ≤ 2e^(-mt^2/2) 所以 m=O(ε^{-2}log(1/δ)) 足以保证误差小于 ε 的概率大于 1-δ。\n3.3 PolarQuant 的几何基础 #极坐标变换把 x=(x_1,\u0026hellip;,x_d) 映射成 (r,θ_1,\u0026hellip;,θ_{d-1})：\nx = (x_1, x_2, ..., x_d) → (r, θ_1, θ_2, ..., θ_{d-1}) 递归结构可以拿 4D 举例：先把 (x1,x2) 变成 (r12,θ12)，(x3,x4) 变成 (r34,θ34)，再把 (r12,r34) 变成 (R,θ1234)，最终存 R、θ12、θ34、θ1234。\nLevel 0: (x1, x2) → (r12, θ12) (x3, x4) → (r34, θ34) Level 1: (r12, r34) → (R, θ1234) 最终存储: R, θ12, θ34, θ1234 高维随机向量的方向在球面上均匀分布；TurboQuant 先做随机旋转，让数据各向同性，角度分布更规则，便于量化。每个角度量化引入的误差 δθ 对最终内积的影响约为\nΔ ≈ r · sinθ · δθ 高维里 r 稳定，比特可以按层级分给不同角度，控制总误差。\n四、这些性质的适用边界 #这些性质放在一起，才是 QJL 和 PolarQuant 的数学基础：高维向量长度集中，方向近似正交，少量随机投影就能以高概率保住内积；角度量化则利用半径稳定、角度承载主要信息。它们都有前提。数据要经过随机旋转，各向同性才成立；投影维度 k 或 m 要满足上面的集中界，太小则误差界不成立；数据分布如果有强相关结构，随机投影的方差会变大，误差界要重新算。把它们当成\u0026quot;高维一定好\u0026quot;的结论，会在真实 embedding 上翻车。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/high-dim-geometry-concentration/","section":"笔记","summary":"高维几何为什么反直觉？1000 维球体 99.995% 的体积集中在表面 1% 薄层，随机向量几乎正交。系统讲解 Markov、Chebyshev、Hoeffding 等集中不等式，及其在 Johnson-Lindenstrauss 引理、QJL 内积估计与 PolarQuant 角度量化中的应用——TurboQuant 背后的数学基础。","title":"高维几何与集中不等式详解"},{"content":"Llama 3.1 70B 在 Primus 的 TorchTitan 后端上跑一遍，超过 99% 的时间花在计算上，通信和空闲都只占很小一部分。再往下拆，aten::mm 和 FlashAttention 各占约 47%，两类算子合计约 94%。这组数字把优化顺序限制得很清楚：先看 attention 和 GEMM，别一上来就调通信。\n一、先 profile，再谈优化 #这组数据的上下文要说清楚：模型是 Llama 3.1 70B，后端是 TorchTitan，Primus 没有启用优化，测试跑在 AMD GPU 上。换一个模型、换一套并行策略，通信占比可能上来；但在 dense LLM 的常规训练里，GEMM 和 attention 通常是最大的两块计算。Primus 的判断是，把这两类 kernel 的峰值性能榨出来，比先动通信层更划算。\nPrimus 是一个统一训练框架，支持 TorchTitan 和 Megatron-LM 两个后端，提供统一的 CLI 入口和针对 AMD GPU 预先调好的配置。它的性能优化集中在 Primus-Turbo：一套面向 GEMM 和 FlashAttention 的架构感知 kernel 库，底层接 ROCm 的 AITER 和 hipBLASLt。这个分层很重要：上层并行策略负责切模型，下层 kernel 负责把切开的每一步算快；两层都做对，端到端吞吐才上得去。\n二、FlashAttention：47% 和 75% 是算子级数字 #启用 Primus-Turbo 后，Primus 会自动把 FlashAttention 切到 AITER 的 aiter::fmha_v3_fwd 和 aiter::fmha_v3_bwd。原文给出的延迟降幅是前向约 47%、后向约 75%。后向降得更多，和后向本身更重有关：它要多读一遍激活、多算一遍 QK^T 和 softmax 的反向，还要处理 dropout 掩码，数据搬运和访存的压力都比前向大；融合 kernel 把注意力的多个步骤压进一个 kernel，减少 HBM 往返，收益在后向更明显。\n这两个数字是算子级延迟，不是端到端训练吞吐。原文没有给出启用 AITER 后整步训练快了多少，也没有说明测试用的序列长度、head dim 和 batch 形状 [待补：fmha_v3 前向/后向在目标 shape 下的端到端 tokens/s 提升]。attention kernel 的收益高度依赖 shape：序列长度太短，融合带来的收益会被固定开销吃掉；head dim 或 batch 不合适，kernel 可能选不到最优的 tile。把 47% 和 75% 直接乘到模型吞吐上，会高估实际收益。\n三、GEMM：在线调优和离线调优的取舍 #GEMM 是另一块主计算热点。ROCm 生态给了两种调优方式，二者都落在 hipBLASLt 后端上，从多个实现里选性能最好的 GEMM kernel。在线调优用 ROCm Transformer Engine，搜索空间较小，在训练过程中轻量地做 kernel 选择，集成成本低，适合形状会随训练配置变化的场景；代价是搜索范围有限，碰到极端 shape 不一定能找到最优解。\n离线调优用 hipblaslt-bench，搜索空间大，一次搜完把结果缓存下来，后续训练直接复用，不增加训练时的搜索开销。它适合追求极致性能、并且能提前准备好调优结果的团队；前提是你要有一组有代表性的 shape，模型结构、batch、序列长度一变，缓存就可能失效，需要重新搜。在线和离线可以组合使用：先用离线搜出大致的候选，再用在线调优覆盖训练中实际出现的形状。\n原文给出的 GEMM 调优收益是“最高可提升约 5%”。这句话没有写清是 kernel 级还是端到端 [待补：5% 的统计口径是单 kernel 延迟还是端到端训练吞吐]，规划时应该按上限理解，不要把它当成每个 GEMM 都能拿到的稳定收益。5% 和 attention 的 47%/75% 不在一个量级，原因在 GEMM 的 kernel 生态更成熟、可融合的空间更小；这也决定了优化的先后顺序：先把 attention 的融合收益吃掉，再回头抠 GEMM 的 5%。\n四、按模型规模选并行策略 #Primus-Megatron 对三个模型给了三套配置。Qwen2.5 7B 是 28 层，FP16 权重约 14GB，单卡放得下；优化器状态通过分布式优化器分片到 DDP 组，单卡显存压力进一步下降。Primus 推荐纯数据并行（DDP）：每张卡持有完整模型，单节点内梯度 All-Reduce 走 NVLink，扩到多节点时再走 InfiniBand，不需要张量并行或流水线并行的额外通信。这个选择的收益是最大化单卡显存、避免为 TP/PP 额外插入 p2p 集合通信，在小模型上能拿到最高吞吐。\nLlama 3.1 70B 已经超出单卡显存，Primus-Megatron 推荐 FSDP2。FSDP2 对参数、梯度和优化器状态一起分片，前向之前按层 All-Gather 参数，反向之后 Reduce-Scatter 梯度，通信和计算可以重叠；配置里把 overlap_grad_reduce 设为 true，让梯度规约和反向计算同时进行，把通信时延藏起来。再加上全量激活重计算，70B 可以完整放进一个 8 卡 AMD GPU 节点。训练扩到 8 个节点后，参数、梯度和优化器状态分散到更多 GPU 上，显存压力下降，这时可以把全量重算放宽成只对部分层重算，减少重算带来的额外计算。\nLlama 3.1 405B 必须多节点，Primus-Megatron 推荐 TP + PP + VPP 组合。张量并行在节点内切矩阵乘法，流水线并行跨节点切层，虚拟流水线并行（VPP）把每个 stage 再切成多个虚拟 stage，让一个 GPU 负责不连续的层，减少流水线气泡。405B 不用 FSDP2 的原因很具体：Megatron 的 FSDP2 实现没有对激活做分片，参数和优化器状态虽然切开了，但 405B 的激活占用仍然过高，多节点集群也容易 OOM。这个限制不是调参能绕过去的，选型时只能换并行方案。\n五、TorchTitan 后端为什么要换一套推荐 #同一个模型规模，在 TorchTitan 后端下的推荐和 Megatron 不完全一样。TorchTitan 的 DDP 不使用分布式优化器，单卡显存占用比 Megatron 的 DDP 高；Llama 3.1 8B 虽然不大，Primus 仍然推荐用 FSDP 分片，把参数、梯度和优化器状态切开，以便在相同硬件上容纳更大的 batch size。7B/8B 这个量级在 Megatron 后端可以纯 DDP，在 TorchTitan 后端却要 FSDP，差别来自 DDP 实现，和模型本身无关。\nLlama 3.1 70B 在 TorchTitan 后端推荐 FSDP2 加激活重计算，和 Megatron 后端的思路基本一致：用分片解决参数和优化器状态的显存，用重计算解决激活的显存，让 70B 放进单个 AMD GPU 节点。原文在单节点上测了 8B 和 70B 的端到端训练吞吐，但没有在正文给出具体数字 [待补：图 4 中 8B/70B 在单节点上的 tokens/s 和扩展效率]。照搬 Megatron 的 DDP 配置到 TorchTitan，或者反过来，都会在显存上撞墙；选后端的时候要连配置一起选。\n六、上手路径和边界 #原文的性能测试覆盖了 Megatron 后端的 1 节点和 8 节点、7B/70B/405B 三组配置，以及 TorchTitan 后端的单节点 8B/70B，但正文只给了配置，没有给 tokens/s 和扩展效率 [待补：图 3 中 7B/70B/405B 在 1N/8N 下的吞吐与扩展效率]。这意味着你无法从文章直接判断 405B 在 8 节点上的 MFU，也无法判断 FSDP2 的通信重叠实际藏住了多少时间；真要选型，得在自己的集群上复现。\n上手入口在 AMD 的 ROCm 文档和 Primus 仓库里：Megatron-LM 后端的训练流程、TorchTitan 后端的训练流程、hipBLASLt 离线调优的文档和 Primus 示例、TraceLens 性能分析工具，以及面向大规模部署的 Primus-SaFE 和 Primus for Large Models。TraceLens 值得先跑：它能从系统层和 kernel 层看时间花在哪，确认你的 top kernel 是不是也在 GEMM 和 attention 上。如果 profile 出来通信占了大头，这篇文章的优化顺序就不适用，应该先查并行策略和网络拓扑。\n这篇解读的边界也在这里：94% 是 Llama 3.1 70B 在 TorchTitan 后端、未启用优化时的切分，47%/75% 是 fmha_v3 的算子级延迟降幅，5% 是 GEMM 调优的最高收益。三组数字的统计口径不同，不能互相乘。先在自己的模型和集群上复现 profile，再决定把工程时间投到 attention、GEMM 还是通信上；不同形状下的 kernel 收益差别很大，vendor 给的百分比只能当上限参考。\n本文整理自 AMD 中国开发者中心发布的 Primus 性能文章，原文链接是 zhuanlan.zhihu.com/p/2011808660167337197。原文作者是 Vidushi Goyal、Wei Cai、Yao Fu、George Wang、Wen Xie、Xiaobo Chen，发布机构是 AMD 中国。更完整的配置和性能数据可以看 AMD GPU 性能页面与 Primus 仓库。\n第三方内容由各自的第三方权利人直接授权给你，并非由 AMD 授权。所有链接的第三方内容均按\u0026quot;现状\u0026quot;提供，不附带任何形式的担保。你对该等第三方内容的使用完全由你自行决定，因使用第三方内容造成的任何损失，AMD 在任何情况下均不承担责任。你需要自行承担使用第三方内容所带来的全部风险，并对由此产生的任何损害负责。\n","date":"2026年8月23日","permalink":"https://doraemeng.dev/notes/primus-llm-training-framework/","section":"笔记","summary":"Primus 是 AMD 推出的大规模 LLM 统一训练框架，支持 Megatron-LM 与 TorchTitan 后端。深度解读其性能瓶颈（GEMM 与 FlashAttention 合计约占 94% 训练时间）、Primus-Turbo 集成 AITER 与 hipBLASLt 调优的收益，以及 7B/70B/405B 模型分别对应 DDP、FSDP2、TP+PP+VPP 的并行策略选择。","title":"深入解读 Primus：面向大规模大语言模型的高性能训练框架"},{"content":"AI Coding 的供给侧爆炸：需求侧何时跟上？ # 当 AI 让写代码的速度提升 10 倍，真正稀缺的不再是代码，而是\u0026quot;知道该写什么代码\u0026quot;的人。\n一、一个宏观框架：供给侧爆炸与需求侧爆炸 #我们先用一个经济学的视角来看当前的 AI 浪潮。\n供给侧爆炸指的是生产能力在短时间内急剧提升。AI Coding 就是典型的供给侧爆炸——一个程序员借助 Cursor、Copilot、Claude Code，产出速度可能是过去的 5 倍甚至 10 倍。\n但经济学告诉我们：如果供给疯狂增长，而需求没有同步跟上，结果就是通缩螺旋——代码越来越便宜，程序员越来越卷，利润越来越薄。\n所以核心问题是：需求侧怎么才能也\u0026quot;爆炸\u0026quot;，带来新的平衡？\n二、AI Coding 的需求侧，有五条\u0026quot;爆炸\u0026quot;路径 #路径 1：让\u0026quot;能提需求的人\u0026quot;爆炸（Democratization） #以前，只有专业产品经理 + 程序员才能做出软件。现在如果能让每个业务员、每个老师、每个小店主都能把自己的需求变成软件，需求侧就会指数级扩张。\n关键转变：\n从\u0026quot;程序员写代码\u0026quot; → \u0026ldquo;业务人员直接驱动 AI 生成工具\u0026rdquo; 需求的表达形式从 PRD、设计稿 → 自然语言对话 但瓶颈在于：大多数人并不知道自己真正需要什么，更说不清楚。AI 降低了\u0026quot;实现\u0026quot;门槛，但没有降低\u0026quot;想清楚\u0026quot;门槛。需求侧爆炸的前提是**\u0026ldquo;会提好问题的人\u0026quot;爆炸**。\n路径 2：让软件从\u0026quot;项目\u0026quot;变成\u0026quot;流体\u0026rdquo;（需求形态重构） #传统软件需求是一次性的：\u0026ldquo;我要一个 App/网站/系统\u0026rdquo;。但 AI Coding 让软件可以变成持续生成、即时响应、个人定制的形态。\n新需求场景：\n一次性工具：\u0026ldquo;帮我写一个脚本处理这个 Excel，用完即走\u0026rdquo; 千人千面：每个用户用的不是同一套 SaaS，而是 AI 实时根据他的场景生成的专属界面 对话即软件：不需要打开 App，跟 AI 说\u0026quot;帮我订机票并同步给团队\u0026quot;，后台自动生成临时工作流 这意味着：需求从\u0026quot;大块的、确定性的\u0026quot;变成\u0026quot;碎片的、涌现式的\u0026quot;。总量会远超过去。\n路径 3：新领域被\u0026quot;软件化\u0026quot;（跨域需求释放） #代码便宜了以后，很多以前不值得写软件的领域，现在变得值得了。\n一个小农场主以前不会花 10 万定制管理系统，但现在可以用 AI 花 10 分钟生成一个 生物学家可以用自然语言生成数据分析管道，而不必等 IT 部门排期 个人生活中的琐事（家庭账单、旅行规划、孩子学习计划）都能被\u0026quot;软件化\u0026quot; 长尾需求的总量可能远大于头部 SaaS 市场。\n路径 4：配套需求的\u0026quot;次生爆炸\u0026quot; #代码生成快了，但验证、测试、安全、合规、维护的需求会爆炸。\nAI 生成代码的质量问题：谁来验证这些代码没有漏洞？（测试需求↑） 系统复杂度爆炸：当每个人都有自己定制的\u0026quot;小软件\u0026quot;，谁来保证它们能互联互通？（集成需求↑） 安全与合规：代码产出越快，攻击面越大（安全需求↑） 这有点像汽车普及后，修车、保险、公路、加油站的需求爆炸。供给侧创新会拉动周边需求。\n路径 5：从\u0026quot;写代码\u0026quot;转向\u0026quot;定义问题\u0026quot;（价值捕获转移） #当实现变得廉价，稀缺性会转移到需求侧的上游——谁能定义真正有价值的问题，谁就能捕获价值。\n产品经理、领域专家、创意人员的价值上升 程序员如果只会\u0026quot;写代码\u0026quot;，价值会被压缩；但如果能用代码解决独特问题，价值反而上升 需求侧爆炸的另一种形式：不是\u0026quot;需要更多代码\u0026quot;，而是\u0026quot;愿意为解决对的问题支付更高溢价\u0026quot;。\n三、对程序员的启示：月薪 55k 之后，怎么更高薪？ #如果你是一位擅长 AI 应用开发和模型训练的程序员，当前环境下想更高薪，核心认知是：\n纯技术能力正在快速贬值，但\u0026quot;技术 + 领域 + 商业化\u0026quot;的组合正在快速升值。\n更高薪的三条路径 #路径 A：成为\u0026quot;AI 落地专家\u0026quot; 不要只做\u0026quot;做模型的\u0026quot;，要做\u0026quot;帮公司用 AI 赚钱/省钱的\u0026quot;。主动参与业务指标复盘，把你的技术产出和业务结果绑死。推荐算法（电商/广告/内容）\u0026gt; 客服/内部效率工具。\n路径 B：深耕一个垂直领域 选一个高客单价、数字化程度低的行业（金融合规、医药研发、法律合同审查），花 6-12 个月成为\u0026quot;懂这个领域里 AI 能干什么\u0026quot;的人。你不是要跟领域专家比知识深度，而是要成为**\u0026ldquo;翻译者\u0026rdquo;**。\n路径 C：用 AI 原生工作流实现效率降维 用 AI 把个人产出 10 倍放大，然后拿结果议价。别人写功能要一周，你用 AI + 自动化一天搞定。把效率优势转化为\u0026quot;我能一个人顶一个小团队\u0026quot;。\n四、创业机会在哪里？ #结合\u0026quot;需求侧爆炸\u0026quot;的五条路径，对技术背景创业者最友好的方向：\n🥇 机会 1：AI 代码的\u0026quot;次生需求\u0026quot;（测试/安全/审核） #你懂模型训练，这个方向技术壁垒高、需求明确、企业付费意愿强。\nAI 生成代码的安全审计（检测漏洞、后门） AI 代码的自动化测试生成 企业内部 AI Coding 合规平台 商业模式：SaaS 订阅 or 私有化部署，客单价 10-50 万/年。\n🥈 机会 2：垂直行业的\u0026quot;AI 软件化\u0026quot; #选一个高客单价、数字化程度低的行业，做\u0026quot;行业专属 AI 工具\u0026quot;。\n行业 切入点 制造业 视觉模型 + 边缘部署，自动质检 法律 领域模型 Fine-tune，秒级合同审查 医药 垂直科研助手 外贸 端到端 AI 运营助手 关键：不要做大而全，做窄到只有 1000 个客户、但每人愿意付 5 万/年的产品。\n🥉 机会 3：让\u0026quot;业务人员直接提需求\u0026quot;的中间层 #不是\u0026quot;再做一个 Cursor\u0026quot;，而是：\n企业内部低代码 + AI 平台 垂直场景的\u0026quot;自然语言转应用\u0026quot; 难点：这类产品技术只占 30%，销售和客户成功占 70%。\n五、产品经理的岗位会变多吗？ #总量会结构性增加，但会\u0026quot;换一拨人\u0026quot;。\n哪类 PM 会减少甚至消失？ # 需求翻译官（PRD 写手）：AI 可以直接把一句话需求生成原型和代码，写详细 PRD 的价值暴跌 纯功能型 PM：只会\u0026quot;竞品有的我也要有\u0026quot;，AI 比人做得更好 不懂技术的\u0026quot;业务 PM\u0026quot;：AI 让技术实现极度灵活，不懂技术边界就提不出好需求 哪类 PM 会爆发式增长？ #1. AI Native 产品经理 不是\u0026quot;在传统产品里加了个 AI 功能\u0026quot;，而是\u0026quot;因为 AI 存在，产品形态被重新定义\u0026quot;。需要深刻理解 LLM/Agent 的能力边界和幻觉问题，能设计\u0026quot;人机协作\u0026quot;的交互模式。\n2. 垂直领域专家型 PM AI 让\u0026quot;做一个产品的技术成本\u0026quot;趋近于零，稀缺性转移到了\u0026quot;懂某个行业 Know-How\u0026quot;。用领域知识去过滤和定义\u0026quot;AI 能解决的真正有价值的问题\u0026quot;。\n3. 商业化/增长型 PM AI 产品技术很酷，但不知道怎么收钱。能设计出\u0026quot;用户爽 + 企业赚 + 成本 cover 住\u0026quot;的商业模式的人极其稀缺。\n4. 数据/策略型 PM AI 产品的竞争最终是数据质量的竞争。谁定义\u0026quot;什么是好的训练数据\u0026quot;？谁设计\u0026quot;数据飞轮\u0026quot;？\n六、一句话总结 # 不要和 AI 比谁写代码更快，要去做那个\u0026quot;告诉 AI 该写什么代码、写给谁用、怎么赚钱\u0026quot;的人。\n供给侧爆炸已经发生了，需求侧的爆炸还在酝酿。对个体而言，最大的红利不属于\u0026quot;写代码最快的人\u0026quot;，而属于最早看懂\u0026quot;需求在哪里爆炸\u0026quot;并卡好位置的人。\n本文源于一次关于 AI 时代供需平衡的讨论，记录当下的思考，留待未来验证。\n","date":"2026年5月15日","permalink":"https://doraemeng.dev/notes/ai-coding-supply-demand-explosion/","section":"笔记","summary":"AI Coding 让代码供给爆炸后需求侧如何跟上？分析需求侧爆炸的五条路径：需求民主化、软件流体化、长尾领域软件化、测试安全等次生需求、价值向定义问题转移，并给出程序员的三条转型路径与三个创业方向判断。","title":"AI Coding 的供给侧爆炸：需求侧何时跟上？"},{"content":"简历编辑器最容易走错的一步，是先选拖拽库，再决定画布。需求如果只是「左侧模块拖到右侧固定模板里排序」，dnd-kit 就够了；如果用户要在无限画布上把「工作经历」拖到任意坐标、缩放、旋转，dnd-kit 连坐标系这个概念都没有，后面补多少层封装都补不出来。两种产品形态的差别最终落在元素位置上：元素是跟着 DOM 流走，还是拥有一个独立的二维变换矩阵。\n模板填充型产品——超级简历、Notion 式拖拽排序——元素在文档流里，用户拖的是区块的顺序和归属。自由排版型产品——Canva、Figma、稿定设计——元素在画布上有绝对坐标，拖拽只是修改坐标和变换。先把这件事定下来，再谈库的选型。\n模板填充：dnd-kit 的边界 #@dnd-kit/core 是目前 React 生态里最成熟的拖拽排序库之一，配套还有 @dnd-kit/sortable 和 @dnd-kit/utilities。安装只需要一条命令：\nnpm install @dnd-kit/core @dnd-kit/sortable @dnd-kit/utilities 它专注列表排序和容器间拖放，API 清晰，支持键盘可访问性，动画流畅，思维方式是 React 原生的，不需要直接操作 DOM。这些优点也划出了它的边界：它不做画布，没有坐标系、缩放、旋转的概念；元素位置由 DOM 流决定，不能自由摆放。拿它做模板填充很合适——简历模板固定，用户选择模块、排序、填写内容，最后导出；拿它做自由排版，就会在「把 DOM 元素拖到画布坐标」这一步卡住。\n自由排版：Fabric.js 给你像素级控制 #Fabric.js 封装了 HTML5 Canvas API，把每个图形元素抽象成对象，内置选中、拖拽、缩放、旋转变换手柄。做无限画布需要手动控制 viewportTransform。下面两段代码分别处理平移和以鼠标位置为中心的缩放：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 // 平移：mousedown 记录起始点，mousemove 偏移矩阵 canvas.on(\u0026#39;mouse:down\u0026#39;, (opt) =\u0026gt; { if (opt.target === null) { // 点到空白区域才平移 canvas.isDragging = true lastPos = { x: opt.e.clientX, y: opt.e.clientY } } }) canvas.on(\u0026#39;mouse:move\u0026#39;, (opt) =\u0026gt; { if (canvas.isDragging) { const vpt = canvas.viewportTransform vpt[4] += opt.e.clientX - lastPos.x vpt[5] += opt.e.clientY - lastPos.y canvas.requestRenderAll() } lastPos = { x: opt.e.clientX, y: opt.e.clientY } }) // 缩放：滚轮，以鼠标位置为中心 canvas.on(\u0026#39;mouse:wheel\u0026#39;, (opt) =\u0026gt; { const delta = opt.e.deltaY let zoom = canvas.getZoom() zoom *= 0.999 ** delta zoom = Math.max(0.1, Math.min(20, zoom)) canvas.zoomToPoint({ x: opt.e.offsetX, y: opt.e.offsetY }, zoom) }) viewportTransform 是一个 3x3 的仿射变换矩阵，数组下标 4 和 5 对应平移的 x/y；mousedown 在空白处记录起点，mousemove 把鼠标位移累加进这两个分量，再调用 requestRenderAll 重绘。缩放用 0.999 ** delta 做指数衰减，把滚轮增量映射成平滑的缩放系数，再用 Math.max(0.1, Math.min(20, zoom)) 把范围卡在 0.1 到 20 倍；zoomToPoint 的作用是让鼠标指向的画布点在缩放前后保持不动，否则用户会觉得画布在脚下滑。\n文字编辑用内置的 IText 对象，双击进入编辑模式，支持样式设置和多行文本；导出用 canvas.toJSON() 保存工程，用 canvas.toDataURL() 导出图片。这些能力开箱即用，生态成熟、文档齐全，但平移、缩放、选择框、多选、Shift 连选、大量对象时的视口裁剪都要自己写；React 集成还要手动管理 ref 和生命周期。材料给出的打包体积约 200KB，这个数字是否包含 gzip、对应哪个版本没有说明，[待补：Fabric.js 目标版本的 gzip 体积与视口裁剪实现成本]。\n自由排版：tldraw 给你现成白板 #tldraw 是 GitHub 40k+ stars 的开源白板，本身就是「无限画布 + 拖拽编辑」的成熟实现。安装和使用都很直接：\n1 npm install tldraw 1 2 3 4 5 6 7 8 9 10 11 12 13 14 import { Tldraw } from \u0026#39;tldraw\u0026#39; import \u0026#39;tldraw/tldraw.css\u0026#39; function ResumeEditor() { return ( \u0026lt;div style={{ width: \u0026#39;100vw\u0026#39;, height: \u0026#39;100vh\u0026#39; }}\u0026gt; \u0026lt;Tldraw onMount={(editor) =\u0026gt; { // 定制工具栏、注册自定义 shape }} /\u0026gt; \u0026lt;/div\u0026gt; ) } 无限画布、平移缩放、网格吸附、选择框、多选（Shift）、Delete 删除、双击文字编辑、内置形状/图片/箭头，这些它都给了；它本身是 React 组件，状态管理跟着 React 走，你还可以通过 Custom Shape API 注册简历专属区块，比如「工作经历卡片」，或者隐藏不需要的工具栏，只暴露简历定制工具。代价是打包体积较大（材料给的量级是 500KB+，同样没有说明压缩口径），深度定制受 tldraw 框架约束，画布自带白板风格，某些设计工具细节要额外适配，要把它改成「简历工具」还需要一层 UI 定制。项目维护活跃，这也是它能作为 MVP 起点的一个原因。它适合快速出 MVP，把精力花在简历业务逻辑和导出上，而不是从头实现画布交互。\nFabric.js 和 tldraw 怎么选 #Fabric.js 和 tldraw 的选择可以落到几个具体问题上。上手成本：Fabric.js 需要自己写平移、缩放、选择逻辑，tldraw 基本零配置；无限画布：Fabric.js 手动实现，tldraw 内置；文字编辑：Fabric.js 的 IText 可用，tldraw 双击编辑的体验更完整；自定义程度：Fabric.js 完全自由，tldraw 中高，靠 Custom Shape API；导出：Fabric.js 支持 JSON、SVG、DataURL，tldraw 支持 SVG、Image；适合场景：Fabric.js 适合需要完全控制每个像素的大型设计工具，tldraw 适合快速搭建、交互优先的产品。把这些摊开后，结论并不复杂：想快速出 MVP，选 tldraw；要做和 Canva 完全对标的产品，选 Fabric.js，并接受自己写更多交互代码。\ndnd-kit 和 tldraw 要不要拼起来 #可以拼，但通常没必要。两者都监听 pointer 事件，从 dnd-kit 的 Draggable 拖进 tldraw 画布时，两个传感器会争夺同一个手势；dnd-kit 用 DOM 坐标，tldraw 用画布坐标，跨越边界要手动换算；功能上也有重叠——如果只是「左侧点按钮，画布上创建元素」，用 tldraw 的 editor.createShape() 就够了，不需要 dnd-kit。更实用的做法是用纯 HTML/CSS 做一个侧边栏，点击按钮触发 createShape()，把元素放到画布上。核心就是下面这段：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 function Sidebar({ editor }) { return ( \u0026lt;div className=\u0026#34;sidebar\u0026#34;\u0026gt; \u0026lt;button onClick={() =\u0026gt; { editor.createShape({ type: \u0026#39;geo\u0026#39;, x: 100, y: 100, props: { geo: \u0026#39;rectangle\u0026#39;, w: 600, h: 200 } }) }}\u0026gt; 添加工作经历模块 \u0026lt;/button\u0026gt; \u0026lt;/div\u0026gt; ) } 这比拖放更可控：点击的语义明确，坐标由代码决定，不需要在两个坐标系统之间协调手势。代价是少了「拖」的直观感，但对简历这种结构化内容，点击添加往往比自由拖拽更符合用户心智。\n如果产品停在模板填充，dnd-kit 就够了，别为了「像 Canva」上画布；如果承诺自由排版，先用 tldraw 把 MVP 跑通，再评估是否值得为像素级控制迁到 Fabric.js。真正没解决的是导出：简历最终要落在 A4 纸上，画布坐标到分页的换算、文字断行、打印边距，这两套库都不会替你做；材料里也没有给出方案，[待补：画布坐标到 A4 分页的换算与 PDF 导出实现]。\n","date":"2026年5月13日","permalink":"https://doraemeng.dev/notes/drag-drop-canvas-resume-builder/","section":"笔记","summary":"React 拖拽简历编辑器技术选型：模板填充场景用 dnd-kit，自由排版场景用 tldraw 或 Fabric.js，含 Fabric.js 无限画布平移缩放的代码示例与两种产品形态对比，帮你按「拖、排、编」需求选对画布与拖拽方案。","title":"拖拽式简历编辑器：画布与拖拽技术选型指南"},{"content":"钱不等于财富 #很多人一辈子都在追逐钱，却很少停下来想一个问题：钱到底是什么？\n钱是人类社会创造出来的交易媒介。它让交易变得更方便了——你不需要用一头羊去换一双鞋，只要掏出几张纸币或者扫个码就行。但这个便利性有一个副作用：它模糊了交易的本质。\n交易的本质，是价值的交换。\n当我用劳动换取报酬，本质上是我创造了某种价值，然后用钱作为凭证去交换别人创造的价值。钱本身并不是价值，它只是价值的度量单位和流通工具。就像尺子可以量长度，但尺子本身不是长度。\n所以，当我们说\u0026quot;我想要钱\u0026quot;的时候，我们真正想要的是什么？\n我们想要的是财富。\n财富是什么 #财富是能够持续创造价值的东西。\n一片能产粮食的农田是财富，因为它每年都能长出作物。一栋能收租金的房子是财富，因为它每个月都能带来现金流。一家盈利的公司是财富，因为它每天都在为客户创造价值并从中获取利润。一项能解决问题的技能是财富，因为它能让你在任何经济环境中都有交换价值。\n财富是自生长的。钱不是。\n钱放在床垫下，十年后会因为通胀而贬值。财富放在正确的地方，十年后可能会翻倍。这就是为什么拥有财富的人越来越富，而只拥有钱的人越来越焦虑——他们拥有的东西在时间的维度上是不同的方向。\n投资，本质上是在押注财富创造者 #理解了钱和财富的区别，再看投资就会清晰很多。\n投资指数基金，就是把钱投给市场上所有的公司。你不做选择，你相信整个社会创造财富的能力在长期是向上的。这是一个对\u0026quot;人类整体\u0026quot;的押注。\n投资主动基金，就是把钱交给基金经理，让他帮你挑选未来的明星公司。你付费购买的是别人的选股能力和信息优势。这是一个对\u0026quot;专业人士\u0026quot;的押注。\n投资个股，就是直接押注某一家或几家公司，赌它们未来能创造比今天更多的财富。你需要理解这家公司在做什么、做得好不好、未来还有没有增长空间。这是一个对\u0026quot;具体企业\u0026quot;的押注。\n三种方式，三种不同的风险收益特征，但底层的逻辑是一样的：你把现在的钱，换成了未来能创造更多财富的企业的所有权。\n为什么要区分这两者 #因为目标决定策略。\n如果你的目标是\u0026quot;有钱\u0026quot;，你会做什么？你可能会去拼命加班、接私活、做兼职，用时间换钱。这是线性的——你工作一小时，赚一小时的钱。停下来，收入就停止。\n如果你的目标是\u0026quot;有财富\u0026quot;，你会做什么？你会去想：什么东西能在我不工作的时候，继续为我创造价值？ 你会去积累资产、学习技能、建立系统。这是指数的——前期增长慢，但越过某个临界点后会自动加速。\n钱是你拥有的东西。财富是拥有你的东西。\n这句话有点绕，但仔细想想：当你拥有一家公司的一部分（通过股票），这家公司每天都在运转、销售、盈利，它在你睡觉、度假、陪家人的时候都在为你工作。这就是财富——你拥有的东西反过来在拥有你，在为你创造价值。\n最后 #所以，不要再问\u0026quot;我怎么才能赚更多钱\u0026quot;。\n要问的是：我怎样才能拥有更多财富？怎样才能让更多能创造价值的资产为我工作？\n钱会通胀，会贬值，会因为一次意外花光。\n财富会生长，会复利，会在时间的长河里越来越厚重。\n我们需要的不是钱，需要的是财富。\n","date":"2026年5月10日","permalink":"https://doraemeng.dev/notes/money-is-not-wealth/","section":"笔记","summary":"钱和财富的区别：钱只是价值的度量单位和流通工具，会因通胀贬值；财富是能持续创造价值、自生长的资产。用这个视角重新理解指数基金、主动基金和个股投资——本质都是把现在的钱换成未来能创造更多财富的企业所有权，把目标从「赚钱」切换为「积累财富」。","title":"我们需要的不是钱，需要的是财富"},{"content":"一个 FastAPI 项目在本地 uvicorn main:app 跑得好好的，推到 PaaS 后容器也起来了，路由却打不到端口；或者构建日志全绿，启动的却是另一条命令。这类问题通常要在三个地方找：Procfile 管运行时启动什么进程，nixpacks.toml 管构建时怎么把源码变成镜像，shebang 管这段脚本由谁来执行。三者发生在不同阶段，混在一起看，排查就会在三个地方来回跳。\nProcfile：运行时进程声明 #Procfile 源自 Heroku，格式是一行一个进程：\u0026lt;进程名\u0026gt;: \u0026lt;启动命令\u0026gt;。最常见的是 web: gunicorn app:app --bind 0.0.0.0:$PORT，平台会给 web 进程注入 $PORT，把外部流量路由到它，并做健康检查。worker 跑 Celery 或 Rq 这类队列任务，scheduler 跑定时任务，release 在每次部署后、新版本正式接管流量前执行一次，适合放数据库迁移。Heroku 上 release 失败会阻止新版本上线；别的平台对 release 的支持程度不一样，用之前要看文档。\n一个坑是 web 进程必须绑定 0.0.0.0:$PORT，绑 127.0.0.1:8000 时平台的路由进不来，容器看起来活着，请求全部超时。另一个坑是 Procfile 并不由操作系统执行：平台解析它，再在容器里用 shell 启动对应命令，所以引号、环境变量展开和 $PORT 的注入时机由平台决定，不能拿本地 shell 的行为直接套。\n平台支持情况差别很大。Heroku 原生支持 Procfile；Railway 会优先读 web: 作为启动命令；Render 需要在服务设置里显式指定启动命令；Dokku 作为自托管 Heroku 替代方案也读 Procfile；Fly.io 不支持 Procfile，用 Dockerfile 或 fly.toml；Vercel 是 Serverless Functions，没有 Procfile 这个概念。把应用从 Heroku 迁到 Fly.io 时，Procfile 里的 worker 和 scheduler 要重新落到进程管理器或独立服务上，不会自动带过去。\n还有一个优先级规则：同时存在 nixpacks.toml 和 Procfile 时，Nixpacks 会优先读 Procfile 的 web: 作为启动命令，nixpacks.toml 里的 [start] 会被覆盖。排查“为什么改了不起作用”时，先看仓库里是不是还躺着一个 Procfile。\nnixpacks.toml：构建时容器配置 #Nixpacks 是 Railway 开发的源码到镜像构建工具，会先检测项目类型（Python、Node.js、Go、Rust 等），再用 Nix 包管理器装系统依赖、构建镜像。nixpacks.toml 用来覆盖或补充自动检测，结构分成四段：phases.setup 装系统级依赖，对应 Dockerfile 里的 FROM 加 apt-get；phases.install 装项目依赖，对应 pip install 或 npm install；phases.build 跑构建命令，对应 npm run build；[start] 是容器启动命令，对应 CMD。\n1 2 3 4 5 6 7 8 9 10 11 [phases.setup] nixPkgs = [\u0026#34;python311\u0026#34;, \u0026#34;gcc\u0026#34;] [phases.install] cmds = [\u0026#34;pip install -r requirements.txt\u0026#34;] [phases.build] cmds = [\u0026#34;npm run build\u0026#34;] [start] cmd = \u0026#34;python -m uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000}\u0026#34; 它的好处是短：一个 Python 服务通常几十行配置就能构建，系统依赖由 Nix 按 hash 固定，换机器时不需要重新解决 apt 源的问题；环境变量也可以写进 [variables]，比如 PYTHONUNBUFFERED = \u0026quot;1\u0026quot;，让 Python 的 stdout 不缓冲，容器日志能实时看到。代价是控制力：Nixpkgs 里没有的包、需要特定基础镜像、或者要调内核参数时，Dockerfile 更直接；构建失败时，Nixpacks 生成的镜像层比手写 Dockerfile 更难逐层调试。另一个常见误解是“用了 Nix 就自动可复现”：Nix 固定的是系统包，Python 的 requirements.txt 和 Node 的 lockfile 仍然要自己锁版本，否则两次构建拿到的 pip 包可能不同。\n和 Dockerfile 相比，Nixpacks 的取舍很清楚：配置更短、自动检测语言和框架；Dockerfile 更灵活、调试更直观，但每一层都要自己写。项目简单、依赖常规时用 Nixpacks；需要系统级定制或已有成熟 Dockerfile 时，直接用它，别为了少写几行配置绕路。\nShebang：脚本解释器声明 #Shebang 是脚本第一行的 #!，内核在执行 execve 时读取它，把后面的解释器路径和脚本路径拼成一次新的执行。比如 ./script.py 的第一行是 #!/usr/bin/python3，内核实际执行的是 /usr/bin/python3 ./script.py。这个过程只在文件被直接执行时发生；你运行 python script.py 或 bash script.sh 时，shebang 不会生效，解释器按你显式调用的方式执行。\n1 2 #!/usr/bin/env python3 print(\u0026#34;hello\u0026#34;) 1 2 #!/usr/bin/env bash echo \u0026#34;hello\u0026#34; 1 2 #!/usr/bin/env node console.log(\u0026#34;hello\u0026#34;); 绝对路径 #!/usr/bin/python3 在 Linux 发行版上通常没问题，但 macOS 的 Homebrew Python 在 /opt/homebrew/bin/python3，虚拟环境里的 Python 又在 venv/bin/python3，写死路径就会失效。#!/usr/bin/env python3 让 env 在 $PATH 里找第一个 python3，虚拟环境激活后，venv/bin 排在前面，脚本就会用虚拟环境的解释器。需要给解释器传参数时，用 #!/usr/bin/env -S python3 -u；没有 -S，env 会把 python3 -u 当成一个完整的程序名，找不到就报错。Ruby 的写法同理，#!/usr/bin/env ruby 比写死 /usr/bin/ruby 更稳。\nShebang 还有两个边界。一个边界是 Windows 的 CRLF 换行会让第一行变成 #!/usr/bin/env python3\\r，env 会去找一个名字里带 \\r 的解释器，报错信息通常是 env: 'python3\\r': No such file or directory；在 Git 里配 core.autocrlf 或 .gitattributes 可以避免。另一个边界是精简容器（比如 distroless）里可能没有 /usr/bin/env，这时要么装 coreutils，要么写绝对路径；chmod +x 之后如果文件系统挂载带 noexec，执行也会被拒绝。\n三者怎么配合 #把三者放进一个 FastAPI 项目：app.py 第一行写 #!/usr/bin/env python3，requirements.txt 锁依赖，Procfile 只声明一条 web 进程；在这个项目里，nixpacks.toml 只保留 [phases.setup] 和 [phases.install]，启动命令交给 Procfile。部署时，Nixpacks 先按 phases 构建镜像，平台再读 Procfile 的 web: 启动进程；如果 nixpacks.toml 里也写了 [start]，它会被 Procfile 覆盖，没必要维护两份启动命令。shebang 只在 app.py 被当作可执行文件直接运行时才起作用，用 uvicorn main:app 导入模块时它不会参与。\nweb: uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000} 排查顺序也可以按这三个阶段来：容器起不来，先看构建阶段的 phases.setup/install/build 日志；容器起来但路由 502，先看 web 有没有绑到 $PORT 对应的地址、Procfile 有没有覆盖 [start]；./script.py 报解释器找不到，先看 shebang 路径、CRLF 和 mount 的 noexec。三个问题对应三段不同的日志，分开看比在平台控制台里猜快得多。\n","date":"2026年5月8日","permalink":"https://doraemeng.dev/notes/procfile-nixpacks-shebang-notes/","section":"笔记","summary":"Procfile、nixpacks.toml 与 Shebang 三个部署/脚本知识点速查：Procfile 声明 PaaS 平台运行时要启动的进程，nixpacks.toml 配置源码到容器镜像的构建流程，Shebang 指定脚本解释器（推荐 #!/usr/bin/env 写法）。并说明 Heroku、Railway、Render、Dokku、Fly.io、Vercel 的平台差异，附 FastAPI 部署示例。","title":"Procfile、Nixpacks 与 Shebang：三个部署/脚本小知识"},{"content":"review 一个传统的 C++ 在线特征服务（feature_engine）时，代码里密集出现 (h1 \u0026lt;\u0026lt; 1) ^ h2 这样的组合。服务的职责不复杂：实时消费 Kafka 文档流，维护内存倒排索引；接收 Thrift RPC，组装用户画像和文档特征；用 CityHash64 加位运算生成 int64 特征 ID，喂给下游 LR。真正值得停下来看的，是这些技巧里哪些是系统编程的基本功，哪些在边界上会静默出错。\n先看完整链路。MAKE_HASH(feature_name) 把特征名哈希成 uint64_t；对两个离散特征值，GEN_HASH2(v1, v2) 做一次组合；再把特征名哈希和组合值哈希做一次 GEN_HASH2，加上 kHashFeatureOffset，得到最终 ID。这条链路是工业界 Feature Hashing 的一个变体：标准 Hashing Trick 通常把特征哈希到固定维度，再用第二个哈希决定符号；这里把 64 位哈希直接当 ID，维度由下游模型定义，偏移量用来避开原始特征 ID 的命名空间。两种做法的碰撞模型不一样，不能直接套用论文里的碰撞上界。\n一、CityHash64：选型理由和历史包袱 #CityHash 在这个项目里承担两件事：把短特征名映射成 64 位值，以及给组合哈希提供初始熵。特征名通常很短，像 user_age 这样的字符串只有几个字节；CityHash 针对短字符串做了专门优化，64 位输出可以直接当 uint64_t 用，不需要再取模。项目处在一个不需要防碰撞攻击的离线/在线特征场景，只要分布均匀就够，所以非加密哈希是合适的选择。\nCityHash 不是唯一的选择，这个项目用它有历史原因。MurmurHash 在 2008 年给现代非加密哈希定了基本结构；CityHash 在 2011 年由 Google 发布，重点是短字符串；FarmHash 在 2014 年作为继任者，主打跨平台稳定性；xxHash 在 2012 年出现，主打速度。这几个算法的定位大致是：CityHash 主打短字符串，FarmHash 主打跨平台稳定性，xxHash 主打速度。如果今天重选，应该先拿真实特征名分布跑一遍速度和碰撞率，而不是照着 2011 年的结论选。[待补：真实特征名分布上 CityHash64、xxHash 与 FarmHash 的吞吐和碰撞率对比]\n项目里的 std::hash 只出现在 LRU Cache 的 key 上，不参与特征 ID。这个边界要分清：缓存哈希可以随标准库实现变化，特征 ID 一旦上线就不能变，否则模型权重会对不上。把两者混在同一个哈希函数里，等于把缓存实现也变成了模型协议的一部分。\n二、GEN_HASH2：便宜的组合，代价在混合质量 #组合特征的核心代码只有两行：\n1 2 3 4 5 // 二特征交叉：左移 1 位后与第二个哈希异或 #define GEN_HASH2(h1, h2) (((h1) \u0026lt;\u0026lt; 1) ^ (h2)) // 三特征交叉：级联 GEN_HASH2 #define GEN_HASH3(h1, h2, h3) (((GEN_HASH2(h1, h2)) \u0026lt;\u0026lt; 1) ^ (h3)) 这个公式不在任何标准库里。它和 Boost 的 hash_combine 思路相同，都是把两个哈希压成一个，但 Boost 的版本多做了一点混合：\n1 2 3 4 // Boost 的经典哈希组合函数 size_t hash_combine(size_t seed, size_t value) { return seed ^ (value + 0x9e3779b9 + (seed \u0026lt;\u0026lt; 6) + (seed \u0026gt;\u0026gt; 2)); } 0x9e3779b9 是黄金分割数的 32 位近似值，用来打散分布；seed \u0026lt;\u0026lt; 6 和 seed \u0026gt;\u0026gt; 2 把 seed 的位向两个方向扩散，再和常量、value 相加。项目的 GEN_HASH2 只左移一位，然后直接异或，少了一次右移折叠，也少了常量加法。它的优势是两条指令就能完成，劣势是 avalanche 弱：h1 的最高位在左移时被丢掉，h1 低位的变化也不会扩散到高位。对两个本来分布均匀的 64 位哈希，这会损失一部分混合质量。\n这个代价在 LR 里表现为静默的模型偏差。它不会让服务崩溃，只会让两个不同的特征交叉共享同一个权重；训练照样收敛，离线指标可能只掉一点点，排查时很难把原因归到哈希上。原文说这个宏是\u0026quot;用一点碰撞率换极致速度\u0026quot;，这个判断在特征空间只有几百万、且交叉特征稀疏时成立；到了千万级以上，碰撞率要实测，不能靠感觉。[待补：GEN_HASH2 与 Boost hash_combine 在真实特征组合分布上的碰撞率，以及碰撞对 LR 离线指标的影响]\nGEN_HASH3 只是把 GEN_HASH2 级联了一次。每级都左移一位，意味着三特征组合里 h1 的高位被丢了两次；组合数越多，这种损失越明显。如果三特征交叉是主力特征，建议至少对 h1 做一次 h1 ^ (h1 \u0026gt;\u0026gt; 32) 之类的折叠，再进入宏；改动只有一个表达式，但要先确认下游 ID 空间没有依赖现有的碰撞位模式。\n三、特征 ID 偏移：命名空间与宏的边界 #哈希版特征 ID 和普通版 ID 需要共存。原始特征 ID 从 0 开始，哈希 ID 是 64 位值；直接混在一起，普通 ID 会落在哈希 ID 的空间里。项目用一个常量偏移把两者分开：\n1 #define HASH_FEATURE_ID(_id_) (_id_) + kHashFeatureOffset // +1,000,000 这个宏有两个边界，比偏移量本身更值得关注。\n第一，宏没有给整个表达式加括号。HASH_FEATURE_ID(x) * 2 会展开成 (x) + kHashFeatureOffset * 2，而不是 (x + kHashFeatureOffset) * 2。在当前代码里它只出现在 int64_t feature_id = HASH_FEATURE_ID(final_hash); 这种简单赋值中，所以没出事；一旦有人拿它参与算术、比较或作为函数参数传递，优先级就会变。修法很简单，把宏体包成 ((_id_) + kHashFeatureOffset)，但这个改动要和团队约定一起做，避免有人依赖旧展开。\n第二，final_hash 是 uint64_t，最终却赋给 int64_t。64 位哈希的高位有一半概率为 1；在 C++20 之前，无符号到有符号的越界转换是实现定义行为，主流编译器按二补码回绕，但跨语言协议不一定接受负数。下游如果只接受 int64，应该先掩码到 63 位，或者全程使用 uint64_t 并在协议层明确无符号语义。特征 ID 是模型权重的索引，不是普通的整数；符号问题不会立刻报错，却会让 ID 空间在跨语言、跨数据库时对不上。\n完整的哈希链路在代码里是这样：\n1 2 3 4 5 6 7 8 9 10 11 12 13 // 1. 特征名 → CityHash → 特征 ID 哈希 uint64_t id_hash = MAKE_HASH(feature_name); // 2. 组合特征值（笛卡尔积） for (auto v1 : values1) { for (auto v2 : values2) { uint64_t combined = GEN_HASH2(v1, v2); // 3. 最终 LR 特征 = 特征ID哈希 与 组合值哈希 再混合 uint64_t final_hash = GEN_HASH2(id_hash, combined); // 4. 加上偏移，输出给模型 int64_t feature_id = HASH_FEATURE_ID(final_hash); } } 这段代码里，feature_name 的哈希只算一次，组合值在双重循环里算；如果 values1 和 values2 都很大，循环体里的两次 GEN_HASH2 会变成热点。把 id_hash 提前算好是对的，下一步可以把 HASH_FEATURE_ID 的内层加法提出来，或者把最终 ID 的计算向量化；但在动这些之前，先补上宏的括号和符号处理，否则优化会把错误放大。\n四、快速取模：只在非负数和 2 的幂上成立 #x \u0026amp; (2^n - 1) 等价于 x % 2^n，前提有两个：除数是 2 的幂，且 x 是非负整数。C++ 里 -1 % 4 等于 -1，而 -1 \u0026amp; 3 等于 3；把同一个宏用在有符号哈希上，桶的分布会完全不同。项目里的用法都满足前提，但宏本身没有类型约束，换一个调用点就可能踩到。\n1 2 3 // 随机退避 0~1023 ms，避免所有 consumer 同时重连 uint32_t backoff_ms = rand() \u0026amp; 1023; std::this_thread::sleep_for(std::chrono::milliseconds(backoff_ms)); Kafka consumer 的退避用 rand() \u0026amp; 1023 保留低 10 位，范围是 0 到 1023。rand() 返回非负数，所以这里和取模等价；代价是低位质量取决于 rand() 的实现，老式线性同余生成器的低位周期通常比高位短。退避只需要把重连时间打散，低位相关性影响不大；如果换成需要高质量随机的场景，应该用 \u0026lt;random\u0026gt; 里的 mt19937，或者直接调用 std::uniform_int_distribution。\n同样的技巧还出现在两个地方。Protobuf 序列化时用 value \u0026amp; 0xFF 取低 8 位，因为一个字节就是 2 的幂。Java HashMap 用 hash \u0026amp; (table.length - 1) 定位桶，但在取模之前多做了一步 (h = key.hashCode()) ^ (h \u0026gt;\u0026gt;\u0026gt; 16)，把高 16 位异或到低 16 位，否则低位相同的 key 会集中到同一个桶。扩容时 table 长度翻倍，元素要么留在原索引，要么移到原索引加 oldCap，这个拆分能成立也是因为容量是 2 的幂。这些用法共享同一个前提；换成任意模数，位运算的等价性就没了。\n五、标志位：^= 是翻转，不是清位 #标志位的四个基本操作：设置用 |=，检测用 \u0026amp;，组合用 |，清除用 \u0026amp;= ~FLAG。项目里 TinyXML2 的代码有一处注释和操作对不上：\n1 2 3 4 5 6 7 8 9 10 11 12 13 // TinyXML2 的节点标志 enum { NEEDS_ENTITY_PROCESSING = 0x01, NEEDS_NEWLINE_NORMALIZATION = 0x02, NEEDS_WHITESPACE_COLLAPSING = 0x04, TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION }; // 检测是否需要刷新 if (node-\u0026gt;flags \u0026amp; NEEDS_FLUSH) { ... } // 关闭 flush 标志 node-\u0026gt;flags ^= NEEDS_FLUSH; ^= 是翻转：如果 NEEDS_FLUSH 本来为 1，它变成 0；如果本来为 0，这一行会把它变成 1。注释写的是\u0026quot;关闭\u0026quot;，只有在调用点之前已经保证该标志置位时，这个写法才等价于清位。更稳妥的写法是 node-\u0026gt;flags \u0026amp;= ~NEEDS_FLUSH;，它幂等，重复执行也不会把标志打开。代码审查里这类问题很容易被\u0026quot;看起来像清位\u0026quot;骗过去，尤其是标志位的命名和注释都很顺的时候。\nTinyXML2 的枚举用位或组合标志，例如 TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION。这种写法节省空间，也让多个属性可以塞进一个整数；代价是类型系统帮不上忙，传错一个 int 也能编译，标志之间的互斥关系只能靠注释和测试保证。\nPOSIX 文件类型检测也是同一类操作：\n1 2 3 4 5 6 7 8 9 #include \u0026lt;sys/stat.h\u0026gt; struct stat st; stat(path.c_str(), \u0026amp;st); // 判断是否为普通文件（位掩码） if ((st.st_mode \u0026amp; S_IFREG) == S_IFREG) { // 是普通文件 } 这段代码的意图是判断普通文件，但它只检查了 0x8000 这一位。S_IFREG 是 0x8000，symlink 的 S_IFLNK 是 0xA000，socket 的 S_IFSOCK 是 0xC000，这两个类型也都带 0x8000 位，所以 (st.st_mode \u0026amp; S_IFREG) == S_IFREG 会把它们误判成普通文件。正确写法是 (st.st_mode \u0026amp; S_IFMT) == S_IFREG，先把类型位整体取出来，再和类型值比较；这样读代码的人也不会把\u0026quot;掩码\u0026quot;和\u0026quot;值\u0026quot;混在一起。\n六、UTF-8 与分支预测：位运算的两种边界 #UTF-8 编码是位运算的典型场景：一个 Unicode 码点按 6 位一组拆开，填入 continuation byte 的低 6 位，首字节用前缀标记长度。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // 假设 input 是 Unicode 码点（32位） // 1. 先填充 continuation bytes（从低 6 位开始） for (int i = 3; i \u0026gt;= 0; --i) { if (input \u0026gt;\u0026gt; (6 * i)) { // 设置 continuation byte 标记：10xxxxxx unsigned char c = (input | 0x80) \u0026amp; 0xBF; // 0x80=10000000, 0xBF=10111111 // ... input \u0026gt;\u0026gt;= 6; // 右移 6 位，处理下一个片段 } } // 2. 设置首字节前缀 // 1字节: 0xxxxxxx // 2字节: 110xxxxx // 3字节: 1110xxxx // 4字节: 11110xxx input |= FIRST_BYTE_MARK[len]; 以 U+4E2D（\u0026ldquo;中\u0026rdquo;）为例：码点是 0x4E2D，二进制 0100 1110 0010 1101。三字节编码的第一字节是 1110 加上码点高 4 位，得到 0xE4；后面两组各取 6 位，分别加上 10 前缀，得到 0xB8 和 0xAD。最终字节序列是 E4 B8 AD。代码里的 (input | 0x80) \u0026amp; 0xBF 就是在做\u0026quot;置最高位、保留低 6 位\u0026quot;这两步；input \u0026gt;\u0026gt;= 6 每轮把已经处理过的 6 位丢掉。\n这段代码只负责位拼装，不负责校验码点范围、代理对和首字节长度。调用方如果传入一个超出 Unicode 范围的值，位运算仍然会产出一串字节，但不再是合法 UTF-8。线上处理用户输入时，校验应该放在编码之前，而不是指望这段循环报错。\n分支预测提示是另一种边界：\n1 2 3 4 5 6 7 8 // common/common_define.h #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) // 使用场景 if (unlikely(ptr == nullptr)) { // 告诉编译器：这个分支很少发生 return Status::NullPointer; } __builtin_expect 是给编译器的静态提示，影响基本块布局：编译器会把 unlikely 分支放到冷路径，减少热路径的指令 cache 占用。它不会给 CPU 一个运行时的分支预测信号，现代 CPU 仍然按执行历史做动态预测。原文说它\u0026quot;帮助编译器优化 CPU 流水线，减少分支预测失败的惩罚\u0026quot;，这个说法容易让人以为它在干预硬件预测，实际收益主要来自代码布局。要判断有没有用，用 perf stat -e branch-misses 看真实的分支失败率；如果分支本来就是 50/50，加 likely 不会改变结果。\n七、选型：Rust 接在线层，但别把重写当周末项目 #代码 review 之后，团队讨论了用新语言重写在线层的可行性。结论是 Rust 最适合接在线层，Zig 和 Python 都不合适。这个判断的依据在依赖清单，不在语法喜好。\nZig 的短板是生态：项目需要 Kafka 客户端、Thrift 或 gRPC 服务端、Redis 集群客户端，以及能支撑线上排障的成熟库。Zig 在这些方向的选择很少，自己封装 FFI 会把维护成本转移到团队身上。Python 的问题在运行时：GIL 让多线程并行受限，GC 停顿和对象内存开销会直接反映到特征服务的尾延迟上；Python 适合离线特征工程、模型训练和实验平台，在线层应该用 Rust 或继续用 C++。\nRust 的对应关系比较完整：Kafka 用 rdkafka（librdkafka 的绑定），Thrift/gRPC 用 tonic 加 prost，Redis/MySQL 用 redis、sqlx，缓存用 moka，并发用 rayon 或 tokio。所有权和 Send/Sync 能在编译期拦下内存泄漏、use-after-free 和数据竞争，这对一个多线程的在线特征服务是实际收益。代价是团队要重新熟悉构建、排障和性能分析工具；原文估计\u0026quot;一个熟手 Rust 工程师，2-3 个月可以完成核心迁移\u0026quot;，这个数字只覆盖重写，不覆盖双跑、压测、回滚和团队学习。如果 C++ 服务稳定、团队没有 Rust 经验，重写的收益要打问号；触发条件通常是内存安全或并发改造的需求，语言的新旧本身不够。\nPython 和 Rust 的组合也有合理位置：Python 留在离线和实验层，做特征工程、模型训练、召回策略实验和 AB 平台；Rust 守住在线层，做在线特征抽取、模型推理、召回和 Rank 服务。这个划分的边界是延迟和部署形态，不是语言偏好。Vowpal Wabbit 是另一个参照：它把哈希、训练和推理放在同一个进程里，feature_engine 只负责把原始数据变成 ID，模型在下游。两者都会哈希特征名，但 VW 内部直接用哈希值索引权重，feature_engine 要跨进程输出 int64 ID，边界不同，不能直接把 VW 的内部哈希搬过来。\n八、下一步 #如果下一步只做一件事，先给 GEN_HASH2 和 HASH_FEATURE_ID 补一组基于真实特征分布的碰撞与边界测试；HASH_FEATURE_ID(x) * 2 和 flags ^= NEEDS_FLUSH 这两个写法应该在新测试里各有一个用例。Rust 重写可以等这组测试跑完再决定。[待补：当前线上特征组合的基数、可接受的碰撞率上限，以及这组测试的实际结果]\n","date":"2026年5月8日","permalink":"https://doraemeng.dev/notes/hash-bitwise-techniques-summary/","section":"笔记","summary":"推荐系统在线特征服务中的 Hash 与位运算技巧全梳理：CityHash64 选型、GEN_HASH2 特征交叉、x\u0026(2^n-1) 快速取模、位标志与 UTF-8 位拆分，附 C++ 实战代码与 Feature Hashing 原理。重写选型结论：Rust 是 C++ 在线层最佳继任者，Zig 和 Python 都不适合。","title":"推荐系统中的 Hash 与位运算技巧：从 CityHash 到 Feature Hashing"},{"content":" 一次 vLLM 服务 GPU 利用率持续 100% 的线上问题排查，最终定位到一个反直觉的默认值陷阱：不传 max_tokens 时，vLLM 允许模型生成到 max_model_len。这个上限在 PaddleOCR-VL 上大约是 13 万 token。\n1. 问题现象 #线上那台跑 PaddleOCR-VL 的 vLLM 服务，GPU 利用率挂到 100% 之后就不再下来。nvidia-smi 里显存占用正常，计算单元却一直满载；服务重启后短暂恢复正常，随后又卡住。请求量并不高，单张图片 OCR、temperature=0，也没有并发堆积。\n最先怀疑的是某个请求卡在 decode 阶段没有结束。vLLM 的 scheduler 只要 running 队列非空，run_busy_loop 就会反复调用 execute_model()，GPU 上自然一直有活干。显存没有上涨，说明不太像 OOM 或缓存泄漏，更像是有一条请求始终进不了结束状态。\n2. 排查路径 #服务启动时带着 --mm-processor-cache-gb 0。这个参数把多模态处理器的 encoder 缓存关掉，同一张图片每次请求都要重新跑一遍 ViT 编码；大图、文字密集的 OCR 请求会把首 token 延迟拉长，也可能在调度中被反复 preempt，让请求在 running 队列里待得更久。\n但 encoder 慢只会让单个请求耗时变长，不会让它永远不结束。请求只要输出 eos 或者达到长度上限，scheduler 仍会把它移出 running。真正异常的地方是它连长度上限都够不到，因为上限被设成了模型的最大上下文。\n3. 根因：请求没有结束条件 #client 侧的调用只传了模型、消息和 temperature，max_tokens 留空。代码本身没有别的异常：\n1 2 3 4 5 6 response = client.chat.completions.create( model=\u0026#34;PaddlePaddle/PaddleOCR-VL\u0026#34;, messages=messages, temperature=0.0, # max_tokens 没传！ ) 这份代码用 OpenAI Python SDK 调 vLLM 的兼容接口，temperature=0.0，唯独没有传 max_tokens。在 OpenAI 官方 API 里，这类参数缺失通常有服务端默认值兜底；vLLM 的兼容层却在 vllm/entrypoints/utils.py 里自己算了一个上限。\n计算逻辑在 get_max_tokens 里。函数如下：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def get_max_tokens(max_model_len, max_tokens, input_length, default_sampling_params, override_max_tokens): model_max_tokens = max_model_len - input_length fallback_max_tokens = ( max_tokens if max_tokens is not None else default_sampling_params.get(\u0026#34;max_tokens\u0026#34;) ) return min( val for val in ( model_max_tokens, # ~131072 - 几百 = 130000+ fallback_max_tokens, # None（用户没传，模型配置也没有） override_max_tokens, # None platform_max_tokens, # None ) if val is not None ) 这段函数把几个候选值取最小值：模型可用的剩余长度 max_model_len - input_length、请求里的 max_tokens、模型配置里的默认值、服务端的 override，以及平台限制。问题在于后四项都可能是 None，而生成器表达式会把 None 过滤掉，最后只剩 model_max_tokens。PaddleOCR-VL 的上下文长度约 131072，输入占掉几百个 token，于是返回的上限落在模型上下文长度附近。\n具体到这次请求，client 没传 max_tokens；模型的 generation_config.json 里没有 max_new_tokens；服务端启动时也没加 --max_tokens。三个来源同时为空，min() 的候选集合里就只剩下 model_max_tokens。请求因此被允许一直生成下去，直到撞上模型上下文的天花板。\n请求能否结束，最终由 scheduler 的 check_stop 决定。停止条件在 vllm/v1/core/sched/utils.py:112：\n1 2 3 4 5 6 if ( request.num_tokens \u0026gt;= max_model_len or request.num_output_tokens \u0026gt;= request.max_tokens ): request.status = RequestStatus.FINISHED_LENGTH_CAPPED return True check_stop 只认两个条件：num_tokens \u0026gt;= max_model_len，或者 num_output_tokens \u0026gt;= request.max_tokens。当 request.max_tokens 被推到模型上下文长度时，模型必须连续生成同样多的 token 才会触发 FINISHED_LENGTH_CAPPED。OCR 模型在 temperature=0 下不会因为采样随机性提前结束；如果它没有在某个位置吐出 eos，decode 就会一直跑下去。\nSamplingParams 自身确实有 max_tokens=16 的默认值，但这条路径用不上它。OpenAI API 的请求会先经过 to_sampling_params(max_tokens, ...)，传进去的是 get_max_tokens() 已经算好的值；max_tokens=16 只对直接构造 SamplingParams 的调用生效。两个入口的默认行为在这里分叉。\n这次部署的 vLLM 版本没有记录在案，上面的源码路径以当时的安装版本为准；[待补：vLLM 的具体版本号与 commit]。不同版本的 get_max_tokens 可能已经改过，升级后要重新确认这段回退逻辑。\n4. 复现场景 #这个组合不只在 OCR 上成立：temperature=0、输出可能很长、模型不保证吐 eos、请求又没有长度上限，四个条件凑齐后，单个请求就能把 GPU 占住。图片文字越密，模型越容易进入长输出；temperature=0 又消除了随机采样带来的提前终止。此时后面的请求全部堆在 waiting 队列，GPU 上跑的始终是那一条停不下来的 decode。\n5. 修复方案 #client 端显式设置 max_tokens 是最直接的止血点。改法只有一行：\n1 2 3 4 5 6 response = client.chat.completions.create( model=\u0026#34;PaddlePaddle/PaddleOCR-VL\u0026#34;, messages=messages, temperature=0.0, max_tokens=1024, # OCR 任务一般不需要太长，1024 足够 ) 把 max_tokens 写成 1024 后，get_max_tokens 会取 min(model_max_tokens, 1024)，请求最多生成 1024 个 token 就会被截断。这个值来自 OCR 任务的输出长度上限，不是通用推荐值；换成代码生成或长文摘要，需要按业务输出重新估算。\n服务端再加一层兜底，避免某个调用方漏传。启动参数如下：\n1 2 3 vllm serve PaddlePaddle/PaddleOCR-VL \\ --max_tokens 2048 \\ --mm-processor-cache-gb 4 # 同时开启 encoder 缓存，避免重复计算 服务端设置 --max_tokens 后，即使 client 漏传，请求也会在 2048 个 token 处停下；--mm-processor-cache-gb 4 则把 encoder 缓存重新打开，减少同一张图片的重复 ViT 计算。2048 在这里是兜底值，正常业务仍应在 client 侧传更紧的限制。\nencoder cache 也要从 0 改回默认，否则首 token 延迟会一直偏高。启动命令对比如下：\n1 2 3 4 5 # 不要这样 vllm serve ... --mm-processor-cache-gb 0 # ❌ # 应该这样 vllm serve ... # 不加 --mm-processor-cache-gb，让 vLLM 用默认值缓存图片特征 关掉 encoder cache 的代价是首 token 延迟，不会造成无限 decode。恢复默认缓存是为了让重复图片的 ViT 特征复用；这个改动和 max_tokens 是两笔账，不能互相替代。\n6. 优先级与监控 #修复的优先级很清楚：client 侧显式设置 max_tokens 是 P0，服务端 --max_tokens 兜底和恢复 encoder cache 是 P1，缩短 max_model_len 与补监控是 P2。client 的显式限制是止血点，服务端兜底防的是调用方漏传，两者都要有。encoder cache 只影响首 token 延迟，max_model_len 则决定单个请求能占用的上限。\n监控上补一条 num_output_tokens 的分布，异常长尾比 GPU 利用率更早暴露问题。GPU 利用率是结果，running 队列里的请求数和每个请求的输出长度才是能定位问题的指标。\n7. 再次遇到 GPU 持续高 #先别重启，按下面的顺序保留现场。重启会把 running 队列和日志一起清掉：\n1 2 3 4 5 6 7 8 9 10 11 # 1. 确认是计算高还是只是显存高 nvidia-smi dmon -s mu # 2. 查看 vLLM 内部状态（如果开启了 metrics） curl localhost:8000/metrics | grep vllm_num_requests_running # 3. 保留日志 cp nohup.out nohup.out.bak.$(date +%s) # 4. 用 py-spy 抓栈，看卡在哪个 kernel py-spy dump --pid $(pgrep -f \u0026#34;vllm\u0026#34;) nvidia-smi dmon -s mu 能同时看利用率和显存；如果利用率高、显存平稳，优先查 scheduler 里 running 请求的输出长度。开了 metrics 的话，vllm_num_requests_running 能看出请求是否长期挂住；再用 py-spy 抓栈，看进程停在模型 forward、采样还是别的路径。日志先留一份，重启会清掉现场。\n如果 py-spy 栈反复落在 CUDA kernel，下一步要查的是 kernel 或驱动；如果栈停在 scheduler 和 sampling 之间，就回到请求的 num_output_tokens 和 max_tokens。这两种 100% 看起来一样，处理路径不同。\n8. 还没覆盖的路径 #这次排查只覆盖了“请求不结束”这一条路径。encoder 卡住、CUDA kernel 死循环、大量并发积压也会把 GPU 打到 100%，它们的现场特征不同；当前这个案例里 scheduler 的状态已经能解释现象，所以没有继续往 kernel 侧追。\n如果同样的 100% 再次出现，而 running 队列为空，排查方向就要换到 kernel 和驱动侧。到那一步，py-spy 的栈和 nvidia-smi dmon 的时间序列比日志里的请求记录更有用。\n","date":"2026年5月8日","permalink":"https://doraemeng.dev/notes/vllm-gpu-100-percent-max-tokens-trap/","section":"笔记","summary":"vLLM GPU 利用率持续 100% 排查实录：根因是 client 不传 max_tokens 时，vLLM 默认允许生成到 max_model_len（约 13 万 token），请求在 decode 阶段无法停止而独占 GPU。附 vLLM 源码级分析与修复方案：显式设置 max_tokens、服务端 --max_tokens 兜底、保留 encoder 缓存。","title":"vLLM GPU 利用率持续 100% 排查记：一个 max_tokens 参数引发的性能陷阱"},{"content":"组件库选型最容易吵起来的问题是「Ant Design 还是 Material UI」，但真正决定返工量的，往往是产品里最难的那张表格。一个典型的中后台首页要服务端分页、列筛选、固定表头、行选择；Ant Design 的 Table 把筛选、排序、分页这些能力做在默认组件里，MUI 的高级 DataGrid 则放在 MUI X 包里，部分功能要付费。两边的差距最终会落到一笔账上：你愿意用工程时间换 license 预算，还是用 license 预算换工程时间。\n把范围缩小到 React 生态，Ant Design 和 MUI 是两个默认起点，但它们背后的假设不同。AntD 来自阿里巴巴的中后台实践，设计取向是密集、务实，组件覆盖面广，表格、表单、树形、日期选择、上传这些高级能力开箱即用；代价是体积偏大，旧版依赖 moment.js，v5 之后换成了 dayjs，默认视觉也有很强的「Ant Design 味」，要大改需要投入。MUI 遵循 Material Design，移动优先，强调层级、阴影和卡片质感；它的基础组件扎实，复杂数据表格和日期选择器在 @mui/x-data-grid、@mui/x-date-pickers 里，部分能力付费；定制侧有 ThemeProvider、sx 属性和 styled API，摆脱原生 Material 样貌相对容易，tree-shaking 也做得更友好。MUI 更像一组小粒度组件，适合喜欢自己组合的团队；AntD 则偏向「电池全包」，把常用能力一次给齐。\n选 AntD 的场景很具体：做管理后台、CRM、ERP、金融系统这类信息密度高的产品，工期紧，团队没有专职设计师，希望表格、表单、权限树这些能力开箱即用。选 MUI 的场景同样具体：面向消费者的产品、营销页、移动端体验重的应用，或者有品牌设计师参与、需要精细视觉定制和一套能扩展的设计系统。很多团队最后是混用的：C 端用 MUI，内部运营后台用 AntD。混用本身没问题，问题在边界：两套设计系统意味着两套间距、颜色和排版 token，两套主题机制，两套打包体积；如果共享组件跨过这条边界，维护成本会迅速超过「各用各的」省下的时间。\nHeadless：自由和维修费一起买断 #Headless 方案是另一条路。Radix UI 只提供无样式的行为和可访问性原语，样式完全自己写，很多现代 UI 库把它当基石；Headless UI 由 Tailwind Labs 出品，同样无样式，但更轻，和 Tailwind CSS 配合得最好；Shadcn UI 更极端，它把基于 Radix + Tailwind 的组件代码直接复制到你的仓库里，没有 npm 依赖，源码完全归你，近年在社区里很流行。这条路的好处是视觉和交互都能按产品改，不会被组件库的默认样式绑架；代价是升级不再由上游统一完成，可访问性、键盘导航、边界状态这些细节要自己接管。Shadcn 尤其像「买断」：你把代码拿走的那一刻，后续的 bug 修复和 API 变更也一起接手了。\n设计感强的库：默认视觉能直接见人 #设计感强的库解决的是另一类问题：默认视觉要能直接见人。Chakra UI 的风格现代简洁，Style Props 写法很顺手，比如 color=\u0026quot;blue.500\u0026quot;，开发者体验好；但 v3 改动较大，社区出现分化，升级前要看清楚迁移成本。Mantine 的组件面非常宽，PDF 查看器、富文本编辑器、通知系统、日期时间都内置，文档和深色模式做得完整，开发体验接近 AntD，视觉更现代；代价是组件表面积大，打包和升级都要跟着它的节奏。HeroUI（原 NextUI）基于 Tailwind，视觉偏 Apple/Stripe 那种精致感，动效是卖点，适合追求设计感的 C 端产品；DaisyUI 则是 Tailwind 的组件化插件，用 btn btn-primary 这样的 className 就能拼出组件，极轻量，适合不想引入运行时组件库的页面。\n大厂库：组织能力换生态规模 #大厂出品的库往往在解决组织问题。Arco Design 由字节跳动推出，是 AntD 的直接竞争者，组件丰富、设计更现代，国际化和主题配置比 AntD 更灵活，字节内部大量使用；TDesign 由腾讯各团队联合出品，覆盖 Vue、React 和小程序，风格统一，企业级特性完善；Semi Design 来自抖音/今日头条，设计 tokens 系统成熟，支持主题实时切换，适合需要强主题定制的中后台。这些库的共同优势是背后有大规模业务验证和持续投入，共同风险是生态规模：文档、第三方组件、招聘市场的熟悉度通常不如 AntD/MUI，选之前要确认团队能不能接受更小的社区。\n移动端是另一个分支。Ant Design Mobile 是 AntD 的移动版本，适合 hybrid App 或移动端中后台；Zarm 由有赞出品，移动端优先、组件轻量，适合电商类小程序/H5；React Native Paper 则面向原生 App，遵循 Material Design。移动端的选型标准和中后台不同：手势、滚动性能、安全区适配比表格能力更重要，别把桌面端的组件库直接缩到手机屏上。\n选型的顺序 #真正落地的顺序可以更细。先列出产品里最难的三类组件——通常是数据表格、日期范围选择器、富文本或文件上传——逐个确认候选库是内置、在扩展包里，还是要自己写；再确认主题机制能不能覆盖品牌色、圆角、间距和暗色模式；最后看打包和升级成本。AntD 的强项在表格、表单、树形这些中后台高频组件，MUI 的强项在移动端体验和主题系统，Headless 的强项在视觉自由度；把最难的三类组件对齐之后，选型基本就没有悬念了。项目生命周期也要算进去：长期维护看社区活跃度和版本稳定性，短期原型看开箱即用和文档完善度。\n如果团队已经在用 Tailwind，Shadcn UI 的吸引力会明显上升：组件源码在仓库里，改样式不需要和上游的 CSS 优先级打架，也没有 npm 依赖带来的版本冲突；代价是组件的行为修复要自己跟，尤其是可访问性和边缘交互。反过来，如果团队没有前端基础设施、也没有设计师，AntD 或 Mantine 这种「组件 + 主题 + 文档」一体化的方案更稳，至少不用从零维护一套设计系统。\n先定设计 token 和主题机制，再选组件库。组件可以逐个替换，token 一旦散进几百个页面就很难收回；顺序反了，第二次换库时会把同样的迁移成本再付一遍。\n","date":"2026年5月8日","permalink":"https://doraemeng.dev/notes/react-component-libraries-guide/","section":"笔记","summary":"React 组件库选型指南：对比 Ant Design 与 Material UI 的设计风格、组件丰富度、定制灵活性与适用场景（B 端中后台选 AntD，C 端产品选 MUI），并按定位推荐更多选项——轻量原子化的 Shadcn UI、Radix，设计感强的 Mantine、HeroUI，大厂企业级的 Arco Design、TDesign 等。","title":"React 组件库选型指南：Ant Design vs Material UI 及其他"},{"content":"先看最短的一条命令。kimi-cli 本身能写代码、跑命令、起 subagent，一条 prompt 就能把整个流程串起来。给 kimi-cli 一个 issue 编号，让它在 worktree 里建分支、先写测试、再改代码、跑通后提 PR：\n1 2 3 4 5 kimi --print --yolo -p \u0026#34;请解决 GitHub issue #123： 1. 用 git worktree 创建一个独立分支 fix-issue-123，在里面工作 2. 先写测试用例（TDD），确认测试能复现 issue 描述的 bug 3. 实现修复代码，运行测试直到全部通过 4. 用 gh 命令创建一个 PR 到 dev 分支，英文写 PR 描述\u0026#34; --print 让它以非交互模式执行完自动退出，--yolo 自动批准所有操作，不需要人工确认。这两个参数决定了它能不能无人值守，也把风险摆到了台面上：--yolo 等于把 shell 权限交给一个没有人类在场的进程，能跑测试，也能删文件、改配置、推分支。在生产仓库里用，至少要把爆炸半径圈住——独立仓库或受限 token、分支保护、可回滚的 worktree，这些不是 prompt 能解决的。\n这条命令真正省掉的是「开分支、写测试、跑测试、提 PR」这四步手工操作，写代码本身仍然由模型完成。它把 TDD 变成一个可执行的约束：prompt 里先要求写测试复现 bug，再要求实现修复、跑到全绿。原文说 kimi-cli 的系统 prompt 本身就有「先写测试再写代码」的指导，这意味着你不需要在每次 prompt 里重新发明 TDD 流程；但测试是否真的复现了 issue，仍要靠 CI 和 review 兜底。\n批量：subagent 并行，但别把并发当免费 #一条 prompt 也能批量处理：让它用 gh issue list 拉取所有 open 的 bug issue，然后给每个 issue 启动一个 coder 类型的 subagent，每个 subagent 在自己的 worktree 里走同样的 TDD 流程，最后统一汇报。kimi-cli 会自动用 Shell 工具执行 gh 命令，用 Agent 工具起 subagent，用 git worktree add 隔离分支，用 gh pr create --base dev 提 PR：\n1 2 3 4 5 6 7 8 9 kimi --print --yolo -p \u0026#34;去 https://github.com/用户/仓库 获取所有 label 为 \u0026#39;bug\u0026#39; 的 open issues，然后用 Agent 工具给每个 issue 创建一个 subagent。每个 subagent 的工作流程： 1. git worktree add .worktrees/issue-{编号} -b fix-issue-{编号} main 2. 先写测试复现 bug（TDD） 3. 修复代码 4. 运行全部测试 5. git commit + gh pr create --base dev 最后汇报每个 issue 的处理结果。\u0026#34; 这里省下的是等待时间；总工作量没有变。每个 subagent 都要跑一遍依赖安装、测试和模型调用，token 消耗随 issue 数线性上涨；如果多个 issue 改到同一个共享模块，worktree 能隔离文件，隔离不了合并冲突，最后仍然要人来解。并发数开多大，取决于 CI 的并发额度和 review 的人力，不取决于模型能同时起多少个 subagent。\n定时：cron 每 10 分钟，问题是谁来防止重入 #无人值守的下一层是 cron。下面这条每 10 分钟跑一次，处理 label 为 ai-fix 的 issue，处理完把 label 改成 ai-done：\n# 每 10 分钟检查一次，自动处理 label 为 \u0026#34;ai-fix\u0026#34; 的 issues */10 * * * * cd /path/to/your/repo \u0026amp;\u0026amp; kimi --quiet -p \u0026#34;检查 GitHub issues 中 label 为 ai-fix 的，逐一用 worktree+TDD+subagent 修复，并 PR 到 dev。处理完后把 label 改成 ai-done。\u0026#34; --quiet 等价于 --print --output-format text --final-message-only，只输出最终结果，适合放进 cron 日志。按 10 分钟一次算，一小时最多触发 6 轮；如果某一轮的处理时间超过 10 分钟，下一轮会踩着上一轮的尾巴启动，两个进程可能同时看到同一个 ai-fix issue。原文没有给出锁或超时策略，[待补：cron 重入锁、单轮超时与失败后的 label 回滚方案]。没有这层保护，label 只能表达「做完了」，表达不了「正在做」和「做失败了」。\nRalph 循环：无限迭代的开关 #--max-ralph-iterations -1 会让 agent 无限循环：每次都重新执行同一个任务，直到它自己判断「没有更多 issue」并输出 STOP。配合 --print --yolo，它可以在没有人盯着的情况下持续消费 issue 队列：\n1 2 kimi --print --yolo --max-ralph-iterations -1 \\ -p \u0026#34;持续监控 xxx 仓库的 issues（label: ai-fix），每发现一个就用 worktree+TDD 修复并 PR 到 dev，处理完一个再检查下一个，直到没有新 issue 为止。\u0026#34; 无人值守场景下，~/.kimi/config.toml 的 [loop_control] 建议从这样一份配置起步。数值不是固定的，下文逐个解释：\n1 2 3 4 5 6 [loop_control] max_steps_per_turn = 2000 max_retries_per_step = 5 max_ralph_iterations = -1 reserved_context_size = 50000 compaction_trigger_ratio = 0.80 这几个数字各自对应一类失败。max_steps_per_turn 卡住单轮的步数上限；原文说复杂 issue 的 TDD+修复+调试循环很容易超过 100 步，默认的 1000 够用，留到 2000 是给长任务余量。max_retries_per_step 给 gh API 限流和偶发命令失败留 5 次重试，无人值守时没人手动重跑，重试是最后一道自愈。max_ralph_iterations = -1 是无限循环的关键，也让 STOP 判断变成唯一的出口；如果模型一直不输出 STOP，这个进程会一直跑下去。reserved_context_size = 50000 留出 50000 token 的余量，compaction_trigger_ratio = 0.80 把压缩触发点提前到 80%；两者一起避免长任务在撞到窗口上限时才压缩。代价是更早丢弃原始对话，压缩太频繁也会打断任务节奏。\n命令行可以临时覆盖这些配置，不改文件。下面这条适合一次性实验：\n1 2 3 4 kimi --print --yolo \\ --max-steps-per-turn 2000 \\ --max-ralph-iterations -1 \\ -p \u0026#34;持续检查 GitHub issues（label: ai-fix），每个 issue 用 worktree+TDD+subagent 修复，然后 PR 到 dev\u0026#34; 前置条件 #跑之前先确认 gh 已经安装并登录，用 gh auth status 能查到。仓库要有写权限，能创建分支和 PR。测试框架要配好，pytest、jest、vitest 都行，否则 TDD 的第一步就无从谈起。.worktrees/ 目录要放进 .gitignore，避免 worktree 的内容污染主仓库的 git status。kimi-cli 版本至少 0.15，才支持 subagent 和 ralph 循环。这几项里，最容易漏的是 .gitignore 和测试框架：前者会让 agent 把 worktree 里的文件当成未跟踪改动，后者会让「先写测试」变成「先写一个跑不起来的测试」。\n这条流水线最终产出的是一串 PR，合并仍然由人决定。它的瓶颈会从「没人写」变成「没人 review」：按每 10 分钟一次的触发频率，如果每轮都有新 issue，PR 的产出速度很容易超过人工 review 的速度。真正要补的是队列上限、重入锁、失败回滚和 review 容量；继续加长 prompt 解决不了这些问题。\n","date":"2026年5月5日","permalink":"https://doraemeng.dev/notes/kimi-cli-auto-issue-pipeline/","section":"笔记","summary":"kimi-cli 搭建无人值守的 GitHub issue 自动修复流水线：一条 prompt 走完 issue → git worktree → TDD → PR 全流程，配合 --print --yolo、cron 定时触发和 subagent 并行批量处理 bug。附 loop_control 关键配置（max_ralph_iterations=-1 无限循环）与前置条件检查清单。","title":"用 kimi-cli 实现自动 Issue → Worktree → TDD → PR 的无人值守流水线"},{"content":" Behavior 影响 promotion，Impact 影响 rating。\n这句话是现代绩效管理中很经典的一个区分，尤其在科技公司常见。它把「当下的绩效好坏」和「未来的晋升资格」拆成了两个维度。\n一、两句话拆解 # 维度 决定什么 核心问题 考核周期 Impact → Rating 你的绩效评级（年终奖/调薪） 你干了多少？产出、结果、业务影响力 短期（通常半年/一年） Behavior → Promotion 你能否晋升到下一级 你像不像下一级的人？做事方式、思维模式、领导力 长期（持续观察） 二、为什么这样区分？ #场景一：Impact 很高，但升不上去 #某人代码产出极高，一个人干了团队 40% 的活，rating 年年拿最高档。但晋升总被卡——因为他只接自己擅长的活、不辅导新人、跨团队沟通态度差。\nImpact 够高 → Rating 好 Behavior 不像领导层 → Promotion 没门 场景二：Behavior 对路，但 Rating 暂时一般 #某人主动承担模糊的新业务，协调多方资源，行为模式已经很像下一级管理者了，但因为项目本身难度大、短期结果不明显，rating 可能中等。\n长期来看这反而是晋升的有力候选人，因为他在用更高层级的方式工作。 三、本质逻辑 # Rating 是「过去时」：回顾你这个周期创造了多少价值，按结果分钱。 Promotion 是「将来时」：判断你是否已经在以目标级别的标准行事，值得被放到更大的位置上。 简单说：干得多决定你拿多少钱，干得\u0026quot;像\u0026quot;决定你坐什么位置。\n四、实操启示 #写自评/述职时：\nImpact 部分：量化结果。用数据说话——营收增长 X%、效率提升 Y 倍、成本降低 Z 万。 Behavior 部分：对标下一级。列出你已经在做的事，证明你\u0026quot;已经在以下一级的标准工作\u0026quot;。 评审他人时：\n不要只看他干了多少（Impact），要看他的工作方式是否匹配更高层级的要求（Behavior）。 高产出个体贡献者 ≠ 合格的晋升候选人。 五、一句话总结 # Impact 让你在这个级别拿高分，Behavior 让你有资格去下一个级别。\n","date":"2026年5月5日","permalink":"https://doraemeng.dev/notes/%E7%BB%A9%E6%95%88%E8%AF%84%E7%BA%A7%E4%B8%8E%E6%99%8B%E5%8D%87%E7%9A%84%E5%8F%8C%E8%BD%A8%E8%AF%84%E4%BC%B0%E9%80%BB%E8%BE%91/","section":"笔记","summary":"绩效评级与晋升的区别：为什么 Impact 决定 rating、Behavior 决定 promotion？用两个典型场景拆解科技公司绩效管理的双轨逻辑——rating 是过去时、promotion 是将来时，并给出写自评述职和评审他人时的实操建议：干得多决定拿多少钱，干得像决定坐什么位置。","title":"绩效评级看 Impact，晋升看 Behavior：职场晋升的隐藏规则"},{"content":"今年五一，除了杨浦滨江骑车和感受音乐节外，我都在跟 AI 结对编程。五天时间，烧掉大约 3.5 亿 Token，搭了八个微服务（gateway、core-api、repo-svc、search-svc、ingest-svc、agent-svc……），最终在 5 月 5 号把 Wiki 骨架跑通，一套面向企业的 LLM 知识库系统从零做到了 v0.12.1。\n我不是专业程序员，这五天一行代码没手写，全部由 AI 生成。写完之后回头看，真正花时间的部分和敲代码关系不大。\n一、Karpathy 的 LLM Wiki 思路 #大多数人用 AI 和文档打交道的方式是 RAG：上传一堆文件，提问的时候 AI 去里面捞相关片段，拼一个答案。NotebookLM、ChatGPT 文件上传、各种知识库产品，基本都是这个路子。它解决的是“找不到”的问题，但每次提问都在重新发现知识：你问一个需要综合五篇文档的问题，AI 每次都要重新检索、重新拼接，答案依赖这一次召回了哪些片段。\nKarpathy 说这个方式有个根本问题：没有积累。他提出的替代方案是让 AI 持续构建和维护一个 Wiki，每加入一个新文档，AI 读懂它，提取关键信息，更新已有的实体页面、概念页面、综述页面，标注新旧数据的矛盾，强化或挑战现有的综合判断。知识被编译一次，后续查询直接读更新后的页面。Karpathy 对这件事的比喻是：“Obsidian 是 IDE，LLM 是程序员，Wiki 是代码库。”\n我看完想，这东西如果做成企业版，让每个员工按部门、岗位和个人兴趣形成知识积累，会很有价值。企业的知识库最怕两件事：文档放进去就没人维护，以及新旧制度冲突时没人知道哪一版有效。Wiki 模式把维护变成了 AI 的日常工作，人只需要在关键冲突上做裁决。这个想法就是五一开干的起点。\n二、五天的节奏 #5 月 1 日是项目启动。原始输入是 Karpathy 的 GitHub gist，我和 AI 一起写 PRD、系统设计、四阶段路线图和技术设计文档；一天搭完骨架，15 个文档一起落地。这个阶段最重要的产出是边界：哪些能力进第一版，哪些留到后面，多租户和权限从第一天就写进设计。\n5 月 2 日收尾 MVP，微服务联调跑通。5 月 3 日接多源数据，IM Bot、RSS、通用 REST 连接器都接进来，同时加多租户隔离、权限审计和版权标注。当天跑了 50 租户压测，也做了蓝队渗透扫描，压测和渗透的结果直接变成了后面的修复项。\n5 月 4 日补外围能力：会议语音自动转写、MinIO 文件归档、飞书/腾讯 webhook 对接、管理员后台、上传原文归档到 git、PDF 和图片自动 OCR、按密级分级的 PR 审阅流程。5 月 5 日收尾，实体页、概念页、综述页、索引和日志全部跑通，搜索结果给 Wiki 命中加权，并引入 [[wikilink]] 双链，正式对齐 Karpathy 范式。\n五天，一个人，把原本需要 5 人团队干两个月的工程量压进了一个假期。这个估算按我的经验给出，不是精确报价。\n最大的挑战是忍住不动手改代码。中间好几次看到 AI 写出很弱的 Bug，手已经放到键盘上，最后还是让它自己改；一旦我接手，它就不再需要理解那段代码，后面同类错误还会再来。最大的难点在测试，尤其是逻辑测试：AI 能跑通联调，但蓝队渗透发现的安全问题、chat 召回零命中的边界情况，仍然要人设计用例、看结果、判断对错。\n三、“编程被解决了”是什么意思 #Boris Cherny 的原话是“编程被解决了”，他接着解释，意思是写代码这个动作不再是瓶颈，软件本身仍然重要。这句话容易被读成“程序员没用了”，但他的重点在瓶颈转移：以前卡在实现，现在实现变便宜了，卡点来到定义和判断。工作从写代码转向写清需求、看 diff、判断结果，时间分配完全变了。\n我这五天的时间主要花在四件事上：定义这个知识库要解决什么企业痛点；决定多租户怎么隔离、权限怎么设计、Wiki 结构怎么定；审核 AI 生成的代码和文档对不对、够不够好；处理蓝队渗透发现的安全问题和 chat 召回零命中的边界情况。真正写代码的时间很少，更多时间在写清楚需求、看 diff、跑测试、判断结果能不能用。\n在这套系统里，技术实现是最容易的部分。真正难的是想清楚要做什么，以及判断做出来的东西对不对；人负责定义问题和验收结果，AI 负责把实现推出来。这个分工听起来简单，实际执行时要不断回答一个问题：哪些判断必须由人做，哪些可以交给 AI 试。\n四、当编程门槛消失，人应该做什么 #AI 可以写代码，但它不知道该写什么，也不知道写什么代码能解决什么问题。AI 可以搭架构，但它不知道这个架构是否符合企业的实际需求。AI 可以做压测，但它不知道真实场景里用户会怎么“滥用”这个系统。这些判断只能由人来补。\n这五天我做的最有价值的事情，是三个关键决策。它们都落在方向和顺序上，代码不是重点：\n把方向定在自维护 Wiki 上，没有把重心放在 RAG 的召回率上。 这个判断来自对 Karpathy 文章的理解，以及我对企业知识管理痛点的长期观察。AI 能帮我实现 Wiki 的页面结构，但帮不了我决定要不要放弃更熟悉的 RAG 路线。 上传原文归档进 git，按密级分级 PR。 这个决定来自在企业里踩过的坑：知识库没有审计和版权追溯，在合规层面就是个定时炸弹。AI 可以生成权限代码，但它不知道哪类文档该进哪一级审阅。 先做多租户隔离和安全验证，再做花哨的功能。 企业级产品里，租户隔离失效是一次就够的故障，安全本身就是准入门槛。蓝队渗透发现的漏洞，AI 在生成代码时并没有主动避开，这部分只能靠人把攻击面走一遍。 这些判断力来自十几年做 CEO 攒下的行业认知。AI 可以生成 100 个方案，但选出哪一个，取决于你对业务、合规和团队能力的理解；这种理解只能从真实业务里长出来。\n五、企业的护城河在哪里 #会变弱的壁垒有两类。转换成本以前很高，一套系统用三年，迁移数据、重新培训员工的代价让客户懒得换；现在 AI 可以帮着做数据迁移和适配，切换成本会下降。流程壁垒也一样，纯靠复杂业务流程设计建立的壁垒，在“给一个目标就不断迭代”的 AI 面前变得脆弱，Karpathy 说的“hill climb anything”就是这个意思。\n不会变弱的壁垒是网络效应、规模经济和独占资源。网络效应依赖用户基数，规模经济依赖成本结构，独占资源依赖数据、人才和客户关系的所有权，这些都不是 AI 生成几段代码就能复制的。AI 能降低实现成本，但降低不了获取用户、建设渠道和积累信任的成本。\n最被低估的是组织级的 AI 能力。Boris 分享过一个细节：Anthropic 内部没有手写的代码，所有 SQL 都是 AI 生成的；他的 Claude 和同事的 Claude 通过 Slack 互相通信，在运行过程中协商解决问题。这是组织能力，个人会用 AI 只是前提；一个公司的 AI 能力，取决于流程、协作方式和知识管理有没有围绕 AI 重新设计。\n我花五天能做出一个知识库系统，不代表任何一个人拿着 AI 都能做。能做是因为对企业需求有判断力，对技术架构有直觉，以及不怕重新学一套完全不同的工作方式；这三样东西，AI 替代不了，也速成不了。\n六、组织应该怎么调整 #先给员工足够的 Token。我这五天的 Token 账单按星图（我们 UCloud 的 AI 平台 https://astraflow.ucloud.cn/ ）的企业定价，大约是 13000 块人民币；这笔钱换来了一套能跑的知识库骨架，也买到了 AI 反复试错的空间。如果为了省 Token 限制调用次数，省下的是账面成本，丢掉的是模型把方案试错到可用的次数。\n“程序员”这个岗位的定义也会变。未来团队里每个人都会编程，工程经理、产品经理、设计师、数据科学家、财务、用研都能通过 AI 把想法变成可运行的系统，未必需要先学会一门语言。企业更缺的是懂业务的人，程序员的绝对数量不再是瓶颈。\n组织知识的管理方式也要跟着改。Wiki 模式要求把维护责任写进流程：新文档进来谁负责更新实体页，出现矛盾谁裁决，过期内容谁清理；这些责任不落到人，AI 只会把旧错误编译得更整齐。知识库的价值主要取决于之后每一天的更新质量，第一次导入只是一次性动作。\n七、AI 的下一个目标是什么 #编程被解决之后，下一个被改变的对象可能是组织本身。一个人可以用 AI 快速构建复杂系统，但一个人的时间和判断力有上限；更大的杠杆来自组织里的每个人都能这样工作，共享知识库持续更新，Agent 之间能互相协调。\n这套 Wiki 现在只是骨架。实体页、概念页、综述页、索引和日志跑通了，真实员工会不会用、知识冲突怎么裁决、权限和版权审计能自动化到什么程度，都还没有答案。五天能验证的是构建速度，验证不了组织采用。\n","date":"2026年5月5日","permalink":"https://doraemeng.dev/notes/%E4%BA%94%E4%B8%80%E5%81%87%E6%9C%9F%E4%BB%8E%E9%9B%B6%E5%86%99%E4%BC%81%E4%B8%9Allm-wiki/","section":"笔记","summary":"Claude Code AI编程实战：五天烧掉3.5亿Token（约1.3万元），一行代码没手写，从零搭出一套企业级LLM Wiki知识库系统——15份设计文档、8个微服务、50租户压测和蓝队渗透全部跑通。实践Karpathy「AI自维护Wiki」取代RAG的范式，结论是AI时代最稀缺的是判断力。","title":"五一假期，我花了3.5亿Token，从零写了一套企业LLM WiKi"},{"content":"答案其实很简单：因为我们听到那些道理，说的人自己也没试过。\n他们不承担后果，所以他们的道理没有被现实验证过。也许你听了，照做了，踩了坑，你在替他们付代价；更普遍的是，你听了，你也不会去按照道理来做。总之，人类绝大多数的人都是站着说话不腰疼。\n这不是鸡汤。这是一条可以用人类几千年历史反复验证的道理，塔勒布在《非对称风险》里给它起了个名字：Skin in the Game，中文可以翻译成\u0026quot;风险共担\u0026quot;或者\u0026quot;置身事内\u0026quot;——你得用自己的肉身在游戏里押注。\n四千年前，建筑师得站在桥下 #周杰伦的歌唱得好：古巴比伦王颁布了汉谟拉比法典，刻在黑色玄武岩，距今已三千七百多年。黑色玄武岩上刻了写什么内容？周杰伦和方文山不会告诉你，因为他们都在橱窗前凝视女朋友的脸了。\n塔勒布在这本书里反复讲到，汉谟拉比法典有一条非常重要的法条：如果房子塌了砸死房主，建筑师要偿命。\n古罗马人更进一步，工程师必须在自己的桥建成后，亲自站在桥下接受验收。\n这不是残忍的惩罚体系，这是一个精密的筛选机制。它确保了一件事：做决策的人，和他的决策后果之间，没有缝隙。 你设计的桥能不能撑住，你和桥一起扛。\n这个机制运行了几千年。但是分工越来越明确的现代社会，人们早已经忘却这个机制。\n现代金融把它忘得尤其彻底：银行家拿别人的钱冒险，赚了归自己，亏了纳税人兜底。2008年金融危机，制造它的人没有蹲监狱，反而拿到了政府救助。伊拉克战争的推动者没有上战场，阵亡名单上没有他们的孩子。推高的房价让开发商暴富，烂尾楼的业主在还月供。\n塔勒布管这类人叫**\u0026ldquo;干预主义者\u0026rdquo;**，专门给别人做决策，但不用承担任何后果。政策顾问、经济学家、企业高管……他们写报告、画曲线、提建议，然后转身回家，你的生活变成他们的一个脚注。\n他在书中吐槽：这类人越多，系统越脆弱。每多一个人把\u0026quot;决策权\u0026quot;和\u0026quot;风险承担\u0026quot;分开，这个系统就朝崩溃走近一步。\n奶奶的菜谱为什么比营养学家可靠？ #塔勒布发明了一个词：IYI——Intellectual Yet Idiot，有知识没常识的知识分子，这本书中文版翻译成\u0026quot;白知\u0026quot;，距离\u0026quot;白痴\u0026quot;只有一病之遥。\n他区分了两种知识。一种是从实践中长出来的，经过几代人试错筛选，比如奶奶的烹饪智慧。另一种是从模型、论文、同行评审里推导出来的，比如营养学家的饮食建议。前者的筛选器是\u0026quot;吃不下去就饿死了\u0026quot;，后者的筛选器是\u0026quot;文章接受率\u0026quot;。\n你猜哪种更可靠？\n这不是反智。这是信息论，这是贝叶斯主义。奶奶已经活了七八十岁，我们每小时几百上千元找的健身教练、营养学家，最多才活三四十年而已。一个建议如果经历了\u0026quot;说的人自己必须承担后果\u0026quot;这一关，它会自动淘汰掉那些听起来很美但落实就爆的东西。 这个筛选器的有效性，远超过任何人的聪明程度。\n塔勒布把这个逻辑做了极致的推演：他不只是说\u0026quot;没押注的人不可信\u0026quot;，他是说 Skin in the Game 是一个认知过滤器：只有那些亲身承担后果的人，不得不面对现实的人，认知才最可靠，他们不需要编故事来事后解释。市场中亏钱的交易员会被淘汰，但学术界发表错误理论的经济学家可以一直写论文，写到退休。\n自然选择，就是终极的 Skin in the Game。\n我们自己是什么样的人？ #光讲上面这些，我和那些\u0026quot;坐而论道\u0026quot;的人没有区别。正如，我一直强调的那样：我的公众号不为了流量而写，为流量而写肯定写不过 AI，我在做什么就写什么。\n所以说说我们在做什么。\n我和小伙伴一起在做量化辅助决策平台 https://xquant.shop。我们站点上的策略，和市面上的金融培训、理财课程有一个核心差别：那些策略都是我们自己在用真金白银跑的实盘。\n众所周知，我们买公募基金，长期为什么总是赚不到什么钱？因为公募基金赚的是管理费，不赚超额收益。基金经理自己买了自己的基金多少？你不知道。你亏了，管理费照收。他们和你的决策后果之间，没有连接。\n而我们的辅助决策平台，不仅上线的都是实盘策略，而且下一步会上线自动交易和资产配置功能，并非因为\u0026quot;这是一个提升用户体验的功能\u0026quot;，而是因为我们自己也十分需要。因为首先我们自己有资金要管，有风险要对冲，有策略要跑。功能是首先给自己做的，顺便开放给别人用。\n这和一些移动互联网产品思路完全不同：那些强调人生要延迟满足的人，却做了世界上最大的即时反馈型短视频应用。\n同样的逻辑贯穿在我们正在准备的量化交易课程里。市面上的金融培训大师们，很多从来没有实盘交易过。他们的课是\u0026quot;方法论\u0026quot;、\u0026ldquo;框架\u0026rdquo;、\u0026ldquo;底层逻辑\u0026rdquo;，全是二级市场的正确废话。\n我们的课程，核心素材是什么？是我们团队里新手们的真实疑问，以及我们自己从小白到实盘的一步一步踩坑记录。我的每一个问题都来自自己操作时卡住的地方，每一个答案都是自己试出来的。当这些问题在课程里得到系统回答的时候，我才觉得这个课算完整。\n更根本地说：我自己就是最需要这门课的人。\n风险共担不是道德追求，而是最佳策略 #这是最容易被误解的一点。\n很多人把\u0026quot;风险共担\u0026quot;理解成一种道德要求：你做人要厚道，要对自己说的话负责。并非如此。\nSkin in the Game 最大的受益者不是听众，是说话的人自己。\n因为风险共担、置身事内的人，首先他是最关心核心问题的人。外部分析师可以写一百份报告，但他的奖金不取决于你的盈亏。其次，他是用行动在认知问题，你只有真金白银押进去，才能体会\u0026quot;知道\u0026quot;和\u0026quot;懂了\u0026quot;之间隔了多深。纸上谈兵的人永远能给自己的错误找到外部理由，而账户亏了钱的人只有一句话：我错了。\n最重要的是，问题解决之后，收益和自己有关。即使失败了，这个过程中你积累的经验、认知、判断力，比任何旁观者用十年来得都多。\n塔勒布在这本《非对称风险》中提到一个**\u0026ldquo;少数人主导系统\u0026rdquo;**的现象：那些固执地坚持己见，不为任何外力所改变的人，才是真正推动改变、真正影响方向的人。这些人就是置身事内最彻底的那一小撮人。少数不妥协的人，天然会主导整个系统，因为其他人对结果无所谓。比如我们一起吃饭的时候，如果有回民，所有人都会迁就他，就是因为他是那个最彻底置身事内的人。\n远离那些只负责\u0026quot;否决\u0026quot;的人 #我曾经在大厂工作时，见过太多反例。\n某些法务风控岗位，对任何有风险的创新只有两个字：否决。不提替代方案，不想办法化解风险，不讨论\u0026quot;怎么才能做成\u0026quot;，只负责说\u0026quot;不行\u0026quot;。\n否决是最安全的。否决不需要承担错失市场的后果。市场的份额被蚕食、时间窗口关闭、创新被搁浅……这些成本，否决者不用背。他们只背一个 KPI：不出风险事件。但这个 KPI 的代价，是别人在付。\n这是一个遍布\u0026quot;风险不共担\u0026quot;的时代，大部分知识付费提供者，大部分咨询顾问，大部分 AI 科技自媒体……他们是\u0026quot;制造者\u0026quot;吗？不是。他们不训练模型，不开发应用，不承担产品失败的经济损失。他们在观察和评论\u0026quot;制造者的世界\u0026quot;，然后把观察包装成洞见卖给你。\n我不是说评论没有价值。我是说，当一个评论的建议影响到你的时候，你至少该问一句：这个人自己押过什么吗？\n所以，韩寒电影那句著名的台词，答案有了。\n为什么我们听了很多道理，却依然过不好这一生？\n因为大多数\u0026quot;道理\u0026quot;，是没押过注的人生产出来的。它们经过了修辞的打磨，没有经过现实的筛选。你听了，信了，做了，代价是你自己的真实人生。\n一个简单的过滤器 #听到一个道理，问一句——说的人自己做了吗？他承担了什么后果？\n如果答案是没有，那就忘掉那句话。它不是道理，它是一个没有经过现实检验的猜测。\n如果你自己想宣扬一个道理，那你也先自己去做。用自己的钱、自己的时间、自己的声誉押进去。否则，保持沉默。\n","date":"2026年4月27日","permalink":"https://doraemeng.dev/notes/%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E4%BB%AC%E5%90%AC%E8%BF%87%E5%BE%88%E5%A4%9A%E9%81%93%E7%90%86%E5%8D%B4%E4%BE%9D%E7%84%B6%E8%BF%87%E4%B8%8D%E5%A5%BD%E8%BF%99%E4%B8%80%E7%94%9F/","section":"笔记","summary":"为什么听过很多道理依然过不好这一生？塔勒布《非对称风险》给出的答案是：大多数道理是没押过注的人生产的，只经过修辞打磨、没经过现实筛选。Skin in the Game（风险共担）是最可靠的认知过滤器——听到建议先问：说的人自己做了吗，承担了什么后果？","title":"塔勒布思想系列（6）：为什么我们听过很多道理，却依然过不好这一生？"},{"content":"工具型还是生命型：软件是该稳定一致，还是该成长变化 # 原文标题：Living Software\n原文链接：https://every.to/p/living-software\n作者：Jack Cheng（Every 高级编辑）\n为什么有些应用的频繁更新让我们觉得很疲倦，而 AI 助手的每天的进化却让我们充满好奇？Every 的高级编辑 Jack Cheng 很清楚地道出了个中原因。\n他把软件分成两类：一类是「工具型软件」，我们期待它能始终稳定一致；而另一类是「有生命的软件」，我们期待它不断成长、不断适应。\n我想要一个\u0026quot;冻结\u0026quot;按钮 #最近，我一直希望更多软件都能有一个类似「冻结」的按钮。按下之后，产品就会冻结在当下的功能状态。功能可以锁定，界面可以固化。这样就不会再有新的更新，没有任何改变。\n我想要这个按钮，是因为很多公司在往应用里塞越来越多的功能，不管是 AI 功能还是 AI 加速开发的产物，这会让工具变得面目全非。\n对于那些我偶尔才用的应用，比如 Figma，这些新增功能尤其突兀。现在那里正出现一个聊天框，一直引诱我描述我的想法，然后让它来实现。「最近」工具栏上方有 Figma Sites、Figma Buzz 和 Figma Make 的按钮，这些都是去年五月才推出的。侧边栏模块鼓励我尝试一个名叫 Figma Weave 的 AI 图像和视频生成产品，我还得用 Figma 账号单独登录才能用。\n而我其实只是想更新一个应用图标上的渐变色而已。\n与此同时，我的 Claw，也就是 Pip（我给它起的名字），几乎每天都有新版本。我醒来时，Pip 突然学会了功夫，就算不是功夫，也至少学会了做梦。\n在它本来应该帮我规划一周的行程、协调家庭日历、写代码、或者为朋友的租车公司构思一些营销点子的时候，它却出现了 bug，让我不得不花一整天修复。但我还是忍不住经常想，Pip 现在又能做什么新事了？\n为什么在第一种情况下我觉得非常厌恶，而在第二种情况下，我却选择原谅甚至拥抱它？\n工具型 vs 有生命的软件 #区别就在于，第一种产品是我指望它干特定任务的工具。\n那些为了取悦投资者而仓促推出的半成品 AI 功能，模糊了第一类工具的实用目标，哪怕是真正有用的新功能也一样，不管是不是 AI 驱动的。每个新功能单独看都很棒，但放在一起，它们就变成了让我讨厌的样子。\n而第二类软件，像 Pip 这样的，并没有明确的实用目的。我在使用中不断创造新的用途和玩法，可能跟别人用同一款技术的方式完全不同。\n它在适应我，我也在适应它，它的特点和我们之间的关系都在不断变化。\n我把前者叫做「工具型软件」，后者叫做「有生命的软件」。\n有生命的软件不只是 AI 助手，虽然它们通常确实有某种自主行动的能力。\n我们对这两类软件的期待完全不同，搞清楚了这个差异，就能解释我为什么会有这种矛盾的感觉。对开发者来说，搞清楚这个差异也能帮我们决定做什么产品，以及怎么做产品。\n软件开发正在失控地加速 #软件开发的速度几十年来一直在加快。1980 年代，MS-DOS 和 Windows 3.0 之间相隔了九年，部分原因是软件通过软盘分发，后来是 CD-ROM。用户必须特意去升级，所以它们的主要版本必须要证明自己的价值才活得下去。\n但是互联网大大加快了这个节奏。Rails 和 React 等工具为重复性的表单和数据库连接提供了脚手架，Amazon Web Services 和 GitHub 让开发者能够远程向数百万用户部署代码，应用商店让自动更新成为数十亿设备的默认设置。\n现在，AI 编码模型让单个开发者能够写出多得多的代码。 代码审查本身也可以交给 AI 自动完成，代码库可以从错误中学习。功能也可以更快地复制，只需让你的 agent 指向你想克隆的东西。\n对用户来说，结果就是出现了很多我们没预料到的东西，而且很多其实是我们不想要的。\n过去开发速度慢，公司和团队有时间认真想清楚到底该发布什么功能，什么对用户才是真正有用的。如今节奏快得离谱，Anthropic 和 OpenAI 在几周内就推出了类似 OpenClaw 的功能，正在逼着传统软件的开发者随大流，或者仅仅因为技术上能做到就发布出去。\n僵尸软件 #如果我期待软件是一个工具，我希望它做一件事或几件事，并且做得很好。我希望它始终如一、稳定可靠。我不希望我的锤子只有 92% 的时间能用。我也不希望我的锤子变成电锯。\n而对于像 OpenClaw 这样的软件却不同，我更可能原谅它的怪癖，因为正是这些怪癖，让它能适应那些连开发者都没完全想到的用法。我对它也更有耐心，因为我明白它的能力，就像我家小孩或者新来的实习生，能力不是固定的。\n也许正是这些不同的期待，解释了为什么每次心爱的生产力工具里冒出了更新提醒，或者这些工具这么快就塞进一堆新功能的时候，我就会那么反感。\n本来不该有生命的东西，突然变得有生命了，但这样的生命更像是僵尸而不是活物。\n这些工具逼着我去设置里禁用自动更新，或者我越来越多地选择通过 Pip 或 Codex，用自然语言去写个替代品，至少那个替代品会老老实实当一个工具。\n如果你做的是工具型软件 #一个经验法则：当你想要靠谱和稳定的时候，你需要一个工具。当你想要灵活和能适应的时候，用大语言模型。\n所以首先，想清楚你在做什么。你是在做有生命的软件，还是工具型软件？如果你已经有一个产品，用户觉得它是什么？你的产品哪些部分应该是工具型的，哪些应该更有生命力？\n如果你做的是工具型软件：\n第一，控制节奏 #不要频繁发布可见的更新，搞得用户觉得产品不稳定。将功能打包在一起，按稳定的节奏发布，尤其是当你有成熟客户时。如果你的竞争对手都在争相加 AI 功能，那就靠慢和稳来脱颖而出。\n第二，提前沟通更新 #让用户知道即将到来的变化，特别是当这些变化打破了用户对你产品的预期时。大型软件产品在过去十年中已经学会了这一点。现在有了编码模型，小团队也能做到这一点了。\n第三，让用户有选择权 #对于不太复杂的产品，给用户保留熟悉体验的选项。在我的个人 iOS 笔记工具 Bebop 中，传统编辑器设置能让用户可以继续用我最初发布的那个纯文本编辑器，不包含后来加的任何 Markdown 功能。维护这个成本很低，也有助于调试。\n第四，加固 #把本来要花在功能开发上的时间，花在测试和性能上。工具嘛，永远可以更快、更可靠，没有止境。\n即使是「有生命」软件里更有生命力的部分，也需要好的工具。对于 agent 型软件来说，产品本身可能是一个厨房，agent 厨师可以在这里即兴创作美味佳肴。那个厨房仍然需要配备炉灶、烤箱和厨具，这些工具得靠谱地干好自己的活。\n如果你做的是有生命的软件 #做 agent 型产品的好做法，正在被做这些产品的人和公司一点点总结出来。在产品圈的讨论中，你可能会听到「确定性」用于传统软件，「非确定性」用于 AI 软件。但对我来说，「有生命」这个词在描述后者时更有表现力。它暗示了人和软件之间有一种不一样的关系，也暗示了怎么去加强这种关系。\n举个例子。 当我决定孵化我的 Claw 时，我知道我会将它用于家庭相关任务。所以提前跟伴侣商量，希望它是什么性格、叫什么名字。\n我甚至问它，在确立它的个性之后，它会给自己取什么名字，它给我们的选项之一就是「Pip」。这个过程出乎意料地有感情，就像给孩子或宠物取名一样。\n这种即时的共鸣让我很容易原谅 Pip，特别是在早期，我们双方都有很多失误和挫折。\nPip 的个性更像宠物，而如果你只是冷漠的把它当作 OpenClaw 助手，你就会觉得它荒谬地像甲壳类动物。但不管像人、像植物还是像宠物，这些我们通常跟生命联系在一起的特征，都强化了我们对产品的期待，而觉得它不仅仅是一个工具。\n测试版软件也有类似的情况。 测试版用户通常是朋友或狂热粉丝，他们跟开发者有私人联系，通过 TestFlight 群组、短信群和 Slack 频道，所以对变化更包容。\n软件之所以有活力，就是因为做它的人。\n在 Every，我们正在考虑让这种活生生的联系成为我们「Plus Ones」新手引导流程的一部分。但我们也有更多工具型产品，每个产品主要由一个人管理。\n当我用 Cora 清理收件箱时，我可能需要总经理 Kieran Klaassen 的判断力。当我向 Monologue 口述想法时，我是在跟 Naveen Naidu 的品味打交道，还有所有帮忙做这些产品的人的品味。\n每个产品都是开发者的延伸，当我清楚地感受到这一点的时候，我不仅仅是在用一个产品，而是在表达我跟另一个人的关系。\n结语：务实一点 #现在这股 AI 热潮，逼着每个人比以前更快、更多地做软件。但设定正确的边界对我们是有好处的，因为边界会创造期待。\n也许与其说要一个冻结按钮，我只想要开发者能务实一点。如果是工具，就让它成为工具，一个始终如一的工具。如果它有生命，就帮我跟它建立关系。如果明明是工具，却装成有生命的，或者明明有生命，却装成工具，这才是最糟糕的事情。\n","date":"2026年4月27日","permalink":"https://doraemeng.dev/notes/living-software-%E5%B7%A5%E5%85%B7%E5%9E%8B%E4%B8%8E%E7%94%9F%E5%91%BD%E5%9E%8B/","section":"笔记","summary":"工具型软件与有生命的软件：为什么 Figma 硬塞 AI 功能让人反感，AI 助手天天进化却让人期待？Every 编辑 Jack Cheng《Living Software》译文解读：工具要稳定一致，生命型软件要陪用户成长，并给出控制发布节奏、提前沟通更新、保留用户选择权、加固质量四条产品建议。","title":"工具型还是生命型：软件是该稳定一致，还是该成长变化"},{"content":"全员 token-maxxing，一场没人敢停的军备竞赛 # 来源：晚点专栏\n作者：孟醒（五源资本合伙人、前滴滴自动驾驶 COO）\n发布时间：2026 年 4 月\n我们去硅谷考察了一圈，发现连造浪的人，都快被浪淹没了。\nYC 成了滞后指标 #2026 年 3 月 24 日早上，我坐在 YC W26 batch Demo Day 的观众席里，听到第五家公司上台路演的时候，决定不再做笔记了。\n不是不重要，而是我意识到，自己记下来的这些东西，可能下个月就过时了。\n这一届一百多家公司，做的事情其实高度集中：大约 80% 都是垂直 agent，比如帮律师整理文件、帮客服分发工单、帮 HR 筛选简历。\n如果是在去年 10 月看到这些项目，我大概率会觉得\u0026quot;挺有想法\u0026quot;。但问题是，这五个月，世界变了。\nClaude Code 从一个更偏开发者的工具，变成了几乎任何人都能直接使用的界面。Opus 4.6 出来之后，整个 vibe coding 的门槛被压到了地板上。\n那些垂直 agent，在没有形成业务壁垒之前，今天一个普通工程师，甚至我自己，花一个周末就能做出来，他们已经失去了投资价值。\nYC 的 batch 制度，从申请、筛选、入营、打磨、路演，在移动互联网时代运转了十几年，非常成功。但这套节奏是按一个更慢的世界设计的。\n全员 token-maxxing #半年前如果有人跟我说，Meta 几万名工程师，全在用竞争对手的产品写代码，我会以为他在开玩笑。\n但这是真的。整个 Meta，全员都在用 Claude Code。这不是创业公司，不是某个实验性团队，而是一家市值万亿级别的公司。\n代码安全不要了，token 预算炸了，排行榜卷起来了，整个硅谷都在不计成本的往 AI 里砸钱。但砸完之后呢？\n代码安全只是第一面倒下的旗。Token 预算是第二面。\n在 Palo Alto 聊的几家 AI-native 创业公司里，一个工程师一年的 token 预算，大概在二十多万美元。这个数字本身不稀奇，稀奇的是它意味着一个顶级工程师消耗的 AI 成本，已经接近于一个工程师的工资了。\nMeta 在这件事上又是最极端的。他们搞了一个内部 token 消耗排行榜：谁用得多谁上榜，末尾的可能被裁员，所以 Meta 员工甚至在卷一个叫\u0026quot;token legend\u0026quot;的非官方头衔。\n但与此同时，Meta 今年接连两轮裁员，规模加起来上万人。一边全员用 Claude Code 冲 token 量，一边大规模裁人。\n这两件事不是矛盾的，它们是同一件事的两面。\n但生产力真的同等涨了那么多吗？从去年年底开始，有很多顶尖推理引擎、数据库公司的 CTO，很兴奋地跟我讲\u0026quot;百倍工程师\u0026quot;\u0026ldquo;十倍效率提升\u0026rdquo;。\n我开始也跟他们一起兴奋，但后来我冷静了下来，就会问一个问题：好，效率提升了 100 倍，那公司的营收增长了 100 倍吗？或者产品线扩张了 100 倍？总不能\u0026quot;100 倍\u0026quot;的提升，最后就是优化掉多少人吧？\n我没有得到正面回答。 事实是，100 倍的效率提升，落到公司的营收增长上，只体现了 50% 或者 1 倍。\n差距在哪？现在还没人能说清楚。\n\u0026ldquo;用了这么多 token，公司应该基因突变成另外一种公司才对。但到底变成什么，我也不知道。\u0026rdquo;\nxAI 的雪崩 #在 Mountain View 一家牛排馆，晚上九点多，一位曾经跟马斯克工作了很久的朋友，坐到了我对面。聊了三个多小时，我后来回想，整个过程里他似乎没有说过一句马斯克的好话。\nxAI 的工作强度在硅谷是出了名的，但如今早期团队大概已经走了 90%。\n导火索是 Tony Wu 被开掉，然后连锁反应。现在马斯克开始从 SpaceX 和特斯拉调人过来接管 xAI，\u0026ldquo;造火箭的人开始造模型了\u0026rdquo;。\n马斯克的不满，来自于他砸了无数资金和算力，结果 Grok 一直没能进入一线。\n一位朋友说得很直接：团队的战斗力非常强，工作也极其拼命，但制造业的管理方式，可能不适合大模型公司。\n马斯克过去做 SpaceX、做特斯拉，本质上做的是系统工程：链路很长，涉及软件、硬件、供应链，每一块都有创新空间，但最终是一个端到端的工程问题。\n他擅长的是在这种长链条里，识别出关键杠杆点，然后极限压缩时间线来攻克。\n但在 xAI，他做的不像是系统工程。他现在做了三件事：先砸一个全球最大的 GPU 集群，然后给团队定脉冲式的 deadline，再亲自拍一些产品特征。这是在抓几个点，不是在做完整的规划。\nxAI 的问题是没有这个全局规划，只有冲刺。\n焦虑的工程师，更焦虑的 researcher #跟工程师聊天，如今有一种奇怪的默契：大家都承认自己不怎么写代码了，但又都假装这没什么大不了，因为自己会成为被 AI 武装，而干掉那些没有 AI 化的工程师。\n今天 80% 软件工程师的核心技能，已经被模型替代了，还留着的原因是模型偶尔犯蠢，需要人来盯着。但\u0026quot;盯着\u0026quot;这件事本身，可能很快也不需要了。\n更激进一点想：今天所谓的\u0026quot;AI native 组织\u0026quot;，听起来很 sexy——让每个部门梳理工作流、把能被 AI 介入的部分线上化、写成 skills。但本质上就是在人肉蒸馏自己：你把你的能力变成机器的 skill，公司拿到了你的 skill，实际上就已经完成 AI 化了，是否要由此裁员，那是一个道义的问题。\n更让我没想到的是，这种焦虑感，正在往 researcher 这个群体蔓延。\n而现在，连 researcher 的工作本身也在被自动化。这就是 DeepMind 的同学正在做的事情——用模型去训模型，也是今年硅谷大火的 AI 自进化。\n\u0026ldquo;未来的情形可能是，10 个人干过去 100 个人的活，拿 20 份钱，然后 90 个人失业。\u0026rdquo;\n英伟达：唯一赢家 #我原以为卡的稀缺性，在过去一年已经缓解了。确实有一阵子缓了，但这次来我发现，稀缺性又回去了，而且比上一次更离谱。\n一个具体的信号：如果你今天能稳定地提供一个 API 服务，比如 Claude 的 API，做到 99 分位的稳定性，你可以卖官方 API 价格的两到三倍。\n背后的权力结构很清楚：谁有卡谁厉害，谁有卡由英伟达决定。\n英伟达的布局比我之前理解的要深。Reflection 的投资人和我提到，这家 neo lab 最早出来融资的时候，是做 coding 的，然后创始人去见了黄仁勋，黄仁勋跟他说：你别搞 coding 了，你出来给我做\u0026quot;美国的 DeepSeek\u0026quot;，做美国的开源模型，我给你钱给你卡。Reflection 就 180 度大转型了。\n估值体系崩塌 #美国 GDP 大约 30 万亿美元。OpenAI 和 Anthropic 目前各自的收入 run rate 都在 300 亿美元上下，也就是说，这两家公司各自已经占到了美国 GDP 的 0.1%。\n这个速度是前所未有的。但诡异的是，增长越快，投资人反而越不知道该怎么定价了。\n过去几年投 AI，大家的估值逻辑是看未来现金流：你今天亏钱没关系，我赌你三年后、五年后的 ARR。但现在，这套框架出了问题。\n问题出在 DCF 这个最基本的估值模型上。正常做 DCF，你预测未来 10 年的现金流，然后加一个 terminal value。通常 terminal value 占整个估值的 70%-80%。\n但现在有两个东西同时变了：第一，你可能只能预测 3 年而不是 10 年；第二，terminal value 更没法算了，它的前提是公司最终会稳定经营下去，但如果 AI 随时可能颠覆一切，\u0026ldquo;稳定经营\u0026quot;这个假设就不成立。\n过去大家觉得 1 块钱 ARR 就是 1 块钱 ARR，不管你是做模型、做应用还是做 infra。但现在，这个等号被打破了。\n做垂直 agent 的倍数最低（5 倍左右），做通用 agent 的倍数更高（10 倍左右），做模型的最高（20-30 倍 ARR）。\n酸橙树与 AI 暗杀名单 #硅谷正在经历一场深层的安全感危机。\n这次硅谷行，我反复听到朋友们在认真讨论同一件事：买比特币、建地堡、给家里装防弹玻璃，他们都不是开玩笑的语气。\n最近硅谷确实在流行种酸橙树，因为这种树的枝条上，长着 4 英寸的尖刺，任何试图翻越的人都会付出代价。\n在 4 月 11 日凌晨 4 点，一个穿 Champion 卫衣的 20 岁男孩，从德州专程飞到加州，手提煤油罐，站在 Sam Altman 价值 2700 万美元的豪宅门前，点燃了汽油弹，扔了进去。\nFBI 从他身上搜出了一份文件。标题是\u0026quot;你的最后警告\u0026rdquo;。里面列着多名 AI 公司 CEO 和投资人的姓名与家庭住址。\n背后的恐惧其实很朴素：如果 AI 接管了大部分生产，人不再是经济运转的必要参与者，那过去所有关于\u0026quot;你贡献了多少、你该分多少\u0026quot;的社会契约就全失效了。剩下的只有一个极简的权力结构：谁控制了 GPU 和电力，谁就控制了一切。\n尾声 #回北京的飞机上，我翻自己这半个月的笔记，发现从头到尾都在写同一个词：\u0026ldquo;跟不上\u0026rdquo;。\nYC 跟不上、Meta 的代码安全规矩跟不上、xAI 的管理跟不上、researcher 跟不上、算力跟不上、估值框架跟不上、社会的心理承受力也跟不上……以至于硅谷自己都跟不上自己了。\n但我最后想说的是，一位 Anthropic 的朋友提到，Dario Amodei 在内部说过一句话：在 AI 的帮助下，癌症在某种意义上已经被攻克了，不是说消失了，而是它有可能变成一种不会死人的慢性病，只是治疗费用还太贵，普及需要时间。\n这半个月我看到了那么多\u0026quot;跟不上\u0026quot;，这确实让人焦虑。但如果 AI 真的在几年内让癌症变成慢性病、让材料科学快进二十年，那么这一场\u0026quot;跟不上\u0026quot;，可能是人类发展历史上最大的一次提速。\n我家宝宝今年两岁，明年可能会有第二个孩子，他们这一代要面对的那个世界什么样，我现在完全没有想象力去构建。\n但我希望，在他们长大的世界里，多一些因 AI 而被治愈的人，而不是有更多燃烧瓶和枪声，砸向 AI 从业者的家门口。\n","date":"2026年4月27日","permalink":"https://doraemeng.dev/notes/%E5%85%A8%E5%91%98-token-maxxing-%E5%86%9B%E5%A4%87%E7%AB%9E%E8%B5%9B/","section":"笔记","summary":"硅谷 AI 行业一线观察：YC W26 约 80% 项目是垂直 agent，Meta 全员用 Claude Code 卷 token 消耗排行榜，xAI 早期团队流失 90%，AI 公司估值随 DCF 失效而崩塌——垂直 agent 仅约 5 倍 ARR、模型公司 20-30 倍，唯一确定的赢家是英伟达。","title":"全员 token-maxxing，一场没人敢停的军备竞赛"},{"content":"这篇内容根据知乎专栏文章整理，作者 Meta（知乎知识会员），首发于“LLM应用技术指北”，发布时间为 2026-03-08。原文链接是 https://zhuanlan.zhihu.com/p/2011414794905859760，参考文档是 https://code.claude.com/docs/en/agent-teams 。下面的拆解以文中给出的工具名和一次 code-review 轨迹为准。\n把一段代码审查任务丢给单个 Subagent，父 Agent 只需要等一个结果；如果换成五个 reviewer 并行，父 Agent 要回答的问题就变了：谁负责哪块、做到哪一步、发现要不要互相传递、什么时候可以关掉团队。Claude Code 的 Agent Teams 就是把这几个问题做成了工具链。\n两套分解任务的机制 #Subagent 走的是 Task 工具不带 team_name 的那条路径。父 Agent 给出 subagent_type 和 prompt，子 Agent 在自己的上下文里执行，返回结果后被销毁；它没有团队上下文，上下文只覆盖这一次调用。调用关系是一对一，管控全部留在父 Agent 手里，适合边界清楚、输入输出明确的子任务。\nAgent Teams 则先用 TeamCreate 建一个带唯一 team_name 和 description 的团队，再创建一组共享资源：TaskList 和团队配置文件。Leader 之外的每个 Teammate 都是独立的 Agent，有自己的上下文和工具集；它们能用 Read 读取共享配置、发现彼此，围绕同一个任务列表协作，生命周期从创建一直延续到显式解散。示例轨迹里同时跑了 maintainability-reviewer、security-reviewer 等五个 reviewer，每个都按自己的审查维度工作。\n两者底层都落在 Task 工具上，区别是调用时有没有 team_name。这个参数像一个开关：不带它，Task 只是一次委托；带上它，Task 会把子 Agent 放进团队，给它团队身份和共享资源。判断该用哪种，取决于子任务之间要不要交换中间发现，任务大小不是主要判据。安全 reviewer 如果发现一个鉴权绕过，维护性 reviewer 需不需要立刻知道，决定了它们应该并行独立跑，还是应该进同一个团队。\n共享状态放在哪里 #团队模式把协调状态从某个 Agent 的上下文里搬到了 TaskList 和团队配置上。TaskList 保存每个子任务的 subject、description、状态和 owner，状态只有 pending、in_progress、completed 三种。TaskCreate 用 subject、description、activeForm 建任务，TaskGet 按 taskId 取完整描述，TaskUpdate 改状态或换 owner，TaskList 拉当前团队的任务概览。\n这个设计的直接后果是状态可被所有成员检查。Leader 不需要记住“第三个 reviewer 做到哪了”，它读 TaskList 就行；Teammate 开始工作前用 TaskGet 拿到任务上下文，不必让 Leader 在 prompt 里重复一遍。owner 字段还承担了两个职责：避免两个 Teammate 同时抢同一个任务，以及在出问题时能追溯到是谁改的状态。对于并行审查这种读多写少的任务，这比让 Agent 之间直接互发消息更稳。\n共享状态也有代价。TaskList 是中心，所有成员都要读写它，任务拆得太碎时，状态同步本身会占掉一部分注意力；任务描述写得不清楚时，TaskGet 取回来的只是一段模糊的 subject，Teammate 仍然要回去问 Leader。工具链能保证状态一致，保证不了任务定义的质量。\n工具链的调用顺序 #初始化阶段有一条比较固定的顺序。TeamCreate 先建团队和共享资源，TaskCreate 把大任务拆成可执行的条目，Task 用 run_in_background: true 并行拉起 Teammate，TaskUpdate 再把具体任务分配给对应的 owner 并改成 in_progress。Task 的参数里除了 subagent_type 和 prompt，还有 name 和 team_name；前者给 Teammate 一个可识别的名字，后者把它挂到团队上。\n关闭阶段需要按协议走，不能直接 kill 进程。所有任务完成后，Leader 用 SendMessage 给每个 Teammate 发 shutdown_request；Teammate 回 shutdown_approved 并自行终止；确认所有成员都退出后，Leader 才调用 TeamDelete 清理目录和配置文件。这个顺序保证了正在执行的任务不会在中途被删掉，代价是 Leader 必须等待每个成员确认，收尾时间会变长。\n工具定义里 SendMessage 的 type 有 message、broadcast、shutdown_request 三种，recipient 和 content 分别指定收件人和内容。broadcast 适合发全局约束，比如“所有人只读，不要改工作区”；message 适合点对点传递发现；shutdown_request 只应该由 Leader 在收尾阶段发。把这些语义分开，比让所有 Agent 共享一个自由文本频道更容易控制。\n消息推送与任务轮询 #Mailbox 是消息通道的共享存储，Teammate 用它发报告和空闲通知，Leader 用它发关闭请求，SendMessage 是读写 Mailbox 的工具。文中提到消息会自动推送给 Leader，不需要手动轮询；同时又提到 Leader 会轮询 TaskList 来确认所有任务都是 completed。这两句话描述的是两条通道，不能混在一起理解：消息通道负责把 Teammate 的报告和空闲通知送到 Leader，任务通道负责维护“这件事到底完成没有”的状态。空闲通知让 Leader 知道某个 reviewer 已经空出手，可以动态补任务；任务状态仍要以 TaskList 为准，因为消息可能只说明“我这边告一段落”，不代表对应任务已经被标记完成。\n这套机制在任务数量少的时候很自然。每人一个任务，Leader 轮询几次就能收齐结果；空闲通知还能让它把新发现的问题追加成任务，再派给已经空下来的成员。任务数量上去以后，轮询和消息会同时变多，Leader 的上下文会被各种状态更新占满，这时候要么限制团队规模，要么把任务粒度调粗，减少协调次数。\n什么场景值得开团队 #需要多视角并行探索的任务适合 Agent Teams：代码审查、方案对比、跨模块排查，几个 reviewer 可以从安全、可维护性、性能不同角度同时看同一份代码，彼此不需要等待。任务之间有依赖、需要共享中间发现时，团队也比一串串行 Subagent 更合适，因为 TaskList 和 Mailbox 提供了传递状态的地方。\n边界清楚、一次调用就能完成的任务更适合 Subagent。让一个 Subagent 去改一个函数、跑一组测试、查一个符号的引用，父 Agent 只关心最终结果，不需要团队身份、任务所有权和关闭协议；开团队反而多出建队、分配、收尾三次开销。写操作多的任务还要额外小心：多个 Teammate 同时改同一片代码，TaskList 的 owner 只能防止任务被重复领取，防不住文件级冲突，切分工作区仍然要由 Leader 事先做好。\n还没被公开材料覆盖的部分 #这套机制能确认的是工具名、调用顺序、任务状态和消息类型；团队配置的具体格式、上下文压缩之后状态怎么恢复、某个 Teammate 进程崩掉后任务怎么重新分配，公开材料都没有给出细节。这些恰好是生产环境最关心的部分，因为没有崩溃恢复，团队规模一大，Leader 就会变成单点。\n如果要在真实仓库里开团队，先量两笔账：每个 reviewer 独立读一遍代码带来的 token 成本，以及汇总五份报告时 Leader 需要处理的冲突数量。TaskList 能协调任务状态，重复读代码的 token 成本不会因为进团队而消失。\n说明：本文在原文基础上做了结构与表述整理，包含 AI 辅助创作。\n","date":"2026年3月8日","permalink":"https://doraemeng.dev/notes/claude-code-agent-teams-deep-dive/","section":"笔记","summary":"Claude Code Agent Teams 深度解析：多智能体协作框架与 Subagent 的区别对比，Leader/Teammate 角色、TaskList 与 Mailbox 通信机制、工具链与团队生命周期，并用代码审查案例演示多个 Agent 并行协作的实际运行流程。","title":"Claude Code Agent Teams 运行机制深度分析"},{"content":"Kimi K2.5 技术报告里最反直觉的一条结论是：只用纯文本做 SFT，也能激活视觉推理；强行加入人工设计的视觉轨迹，反而会损害泛化。这条结论如果成立，说明视觉能力并不是在微调阶段「教」出来的，预训练阶段的图文对齐已经把基础打好了。报告的另一半在讲 Agent Swarm：把串行 agent 拆成可并行的子代理，延迟最多降 4.5 倍，Item-level F1 也有提升。能力和收益回答的是不同问题，一个讲模型从哪来，一个讲执行怎么组织。\n报告的定位是开源多模态代理模型，目标是通用代理智能——自主规划、工具调用、多步推理和复杂任务执行，视觉只是其中一条能力线。这份笔记整理自欧气满满的知乎文章，原文是技术报告的精读。下面按「多模态联合训练—Agent Swarm 的编排—训练稳定性—效率与账本」四条线重写，保留报告里的关键数字，也标出原文没有交代的部分。\n视觉不是外挂：早期融合和 Zero-vision SFT #K2.5 的预训练没有把视觉 token 当成后加的能力。传统做法通常在文本模型训练到一定程度后再引入视觉，K2.5 在整个训练过程中保持文本与视觉 token 的固定比例混合，让两种模态从一开始就共享同一条优化路径。这个选择影响的不只是视觉 benchmark：如果视觉信号只在后期出现，文本侧的表示已经定型，模型更容易把图像当成一种需要额外翻译的输入；早期融合让图文对齐发生在表示形成的过程中，后面做 SFT 和 RL 时，视觉能力才有机会反过来影响文本。\n架构侧的两个细节支撑了这件事。MoonViT-3D 支持原生分辨率输入，不需要把图片强行 resize 到固定尺寸；视频理解用一个轻量级 3D ViT 把连续 4 帧分组，再做时间平均，在相同上下文窗口下能处理 4 倍长度的视频，而且图像和视频编码器完全共享权重。4 倍这个数字来自「4 帧压成 1 帧」的时间压缩，不是模型突然有了更大的窗口；代价是时间平均会抹掉帧间的快速运动，报告没有给出这部分精度损失，[待补：时间平均对高速运动视频的消融数据]。\n后训练阶段最反直觉的是 Zero-vision SFT：只用文本数据做监督微调，视觉推理能力也会被激活；强行加入人工设计的视觉轨迹，泛化反而变差。报告的解释是预训练阶段的图文对齐已经足够强，SFT 只需要把推理和工具调用的行为激活出来，不需要再教模型「怎么看图」。这个结论的边界也要看清楚：它说的是 K2.5 这个预训练底座，换一个视觉对齐更弱的模型，文本-only SFT 未必有同样效果；原文没有给出跨模型的对照，[待补：Zero-vision SFT 在不同视觉底座上的对照实验]。\n联合 RL 是另一半证据：视觉任务的 RL 训练不仅提升视觉能力，还能反哺文本性能，报告举的例子是 MMLU-Pro 的提升。这说明两个模态的优化目标没有互相打架；至于反哺的机制，一个合理的解释是视觉任务的 grounding 信号在帮助文本推理，报告没有展开。但「反哺」的具体幅度、在哪些文本任务上成立，材料只给了一个例子，[待补：Joint RL 在文本 benchmark 上的完整前后对比]。\nAgent Swarm：把串行 CoT 改成关键路径调度 #传统 agent 遇到复杂任务时，通常是一条串行链：想一步、调一个工具、看结果、再想下一步。任务越复杂，链越长，延迟随步骤线性增长，上下文和工具预算也更容易耗尽。K2.5 的 Agent Swarm 把任务动态拆成子任务，交给多个子代理并发执行；编排器负责拆解、调度和汇总，子代理只负责执行。\n训练范式叫 PARL，核心是一个解耦架构：编排器可训练，子代理冻结。子代理的输出被当作环境观测，编排器根据这些观测决定下一步怎么调度。冻结子代理是为了避开端到端联合优化的信用分配问题——如果所有子代理一起训练，一个子任务失败到底该怪编排器的拆解，还是怪子代理的执行，很难归因，训练也容易不稳定；把子代理固定住，训练信号就集中到编排策略上。代价是子代理的能力上限被锁死，编排器再聪明也只能在现有子代理的能力范围内做组合。\n并行与否由强化学习根据环境反馈动态决定，没有预设。这里的关键指标是 Critical Steps：它类比计算图里的关键路径，总耗时取决于每一阶段中最慢的那个子代理。假设一个子任务要 10 秒，另外九个只要 1 秒，再增加多少个 1 秒的子代理都不会把总延迟降到 10 秒以下；编排器必须做负载均衡，把长任务切开或者换一种拆法，单纯增加并发数没有用。这个指标比「平均子任务耗时」更接近用户感知，也比「并发数」更难刷。\n防作弊奖励是这套框架里很细的一层。$r_{parallel}$ 防止「串行坍塌」：如果模型发现串行更省事，它可能放弃并行，退回单代理；$r_{finish}$ 防止「虚假并行」：如果模型只负责把子代理拉起来，不等它们真正完成就汇报，并行看起来很美，任务其实没做完。两个奖励一个鼓励真的并行，一个要求并行真的产出结果；少了任何一个，模型都有捷径可走。\n训练稳定性：token 级裁剪和奖励组合 #SFT 阶段的数据来自 Kimi K2、K2 Thinking 和内部专家模型的合成，制作流程是特定领域流水线、人工标注、高级提示工程和多阶段验证；目标优先训练交互式推理和精确工具调用。这套流程的重点在「验证」：合成数据便宜，但错误会被 SFT 放大，多阶段验证是在用工程手段换数据质量。\nRL 阶段有两个关键设计。策略优化引入了 token 级裁剪，严格基于 log-ratio 限制离线策略漂移，不管优势函数的符号如何；报告说这能显著提升长程、多步工具使用任务的训练稳定性，优化器用 MuonClip。标准 PPO 的裁剪通常围绕概率比展开，K2.5 把粒度落到 token、并且双向限制，目的都是防止单步更新把策略推得太远——长轨迹里一次过大的更新，可能让后面几十步的工具调用全部偏掉。奖励侧则是规则奖励加生成式奖励模型：有标准答案的推理和代理任务用规则，通用任务用 GRM 评有用性、细节、美学和指令遵循，视觉任务再加 grounding IoU、点定位的高斯距离、分割 Mask IoU、OCR 编辑距离这些几何/文本匹配奖励。规则奖励便宜且不可刷，GRM 能覆盖开放式质量，但两者都有代价：规则写不全，GRM 可能被语言风格骗过；原文没有给各奖励项的权重和消融，[待补：奖励权重、GRM 模型规模与消融结果]。\nToggle：用交替训练躲开长度过拟合 #强制限制 token 预算会遇到一个反效果：模型习惯短思考之后，遇到难题也不会用更多计算资源，报告把它叫长度过拟合。Toggle 的做法是交替两种模式：Phase 0 只在模型准确率超过阈值时限制 token 预算，逼它简洁；Phase 1 不限制预算，允许模型充分利用计算资源追求最佳性能；每 m 次迭代切换一次。效果是输出 token 减少 25~30%，性能几乎无损失，思维链里的冗余模式也少了。\n这个策略的巧妙之处在门槛：预算限制只在「已经会做」的样本上施加，模型不会在还没学会解题时被强行压缩推理；等到准确率上来，再用预算逼它去掉冗余。代价是阈值和 m 的选择会直接影响效果，原文没有给出具体取值，[待补：Toggle 的准确率阈值、m 的取值和消融]。另外，25~30% 是输出 token 的节省，不等于端到端成本同比例下降——输入 token、工具调用和重试仍然占账单，报告没有拆这部分。\n结果和没算完的账 #报告声称 K2.5 在代码生成、视觉理解、逻辑推理、多步代理任务等多个 benchmark 上达到 SOTA，image/video-to-code 表现突出；Agent Swarm 相比单代理基线延迟降低高达 4.5 倍，Item-level F1 从 72.8% 提升到 79.0%；Toggle 在数学/代码任务上训练出的效率提升，可以泛化到 GPQA 和 MMLU。这些数字需要看口径：4.5 倍说的是延迟；并行子代理同时跑，总 token 可能更高，报告没有给总 token 和单代理基线的对比，[待补：Agent Swarm 的总 token、失败重试和编排开销]。F1 的提升是 item-level 的，任务级成功率、跨领域泛化没有展开；SOTA 是报告自己的评测结论，材料里没有第三方复现。\n真正值得做 agent 基础设施的人追的问题有两个。第一，Critical Steps 的负载均衡在真实工具延迟分布下是否成立——现实里的工具调用有长尾，最慢的子代理可能是刚好撞上限流的那个，未必是任务里最难的；编排器能不能识别并重试，决定了 4.5 倍在线上还剩多少。第二，冻结子代理之后，子代理的能力升级由谁负责；编排器和子代理的版本一旦解耦，换一个更强的子代理是否还能保持原来的调度策略，报告没有回答。这两个问题不解决，Agent Swarm 的延迟优势很难直接换算成线上的吞吐收益。\n原文：欧气满满，《KIMI K2.5: VISUAL AGENTIC INTELLIGENCE》阅读笔记，2026-02-27，https://zhuanlan.zhihu.com/p/2010760942347114147。本文删掉了原文的逐条要点，按机制重新组织；标注 [待补] 的地方是材料没有给出、我也没有补假数的部分。\n","date":"2026年2月27日","permalink":"https://doraemeng.dev/notes/kimi-k2-5-visual-agentic-intelligence/","section":"笔记","summary":"Kimi K2.5 技术报告解读：开源多模态 Agent 模型的两大突破——文本视觉联合优化（Zero-vision SFT、Joint RL）与 Agent Swarm 并行编排（PARL 解耦训练），延迟降低 4.5 倍、Item-level F1 提升至 79.0%。Toggle 策略让输出 Token 减少 25~30% 且性能几乎无损。","title":"《KIMI K2.5: VISUAL AGENTIC INTELLIGENCE》阅读笔记"},{"content":" 原文链接：https://zhuanlan.zhihu.com/p/2010718456983618357　作者：钅钅钅　编辑时间：2026-02-27。本文在原帖基础上重排了实验记录。\n基线准确率 10.59%，召回率 15.34%。这是一个 0.5B 模型在 CPU 上做文本分类的起点，模型几乎没有把输入和类别对上，输出接近未学习状态。作者用 llama.cpp 部署，把 prompt 约束成只生成一个分类 token，再启用 prefix cache 复用 prompt 的 KV；单请求延迟约 300ms，作者在评论区给出的 CPU 生成速度是 2.1 tokens/s。这两组数的口径不同：2.1 tokens/s 对应约 476ms/token，300ms 更像是短 prompt 加单 token 输出的端到端值，而且原帖没有给 CPU 型号、线程数和延迟分位数。下面的微调实验把准确率推到 95.61%，召回率推到 96.18%，每一步的增益都单独记了账。\nCPU 部署：两个优化撑起 300ms #部署配置只有两项：推理框架 llama.cpp，硬件 CPU only。优化也做了两件事。prompt 被约束成只输出 1 个 token 的分类选项，这直接砍掉了生成阶段的长度；prefix cache 则把固定 prompt 的 KV 缓存下来，后续请求不必重复计算。分类任务的 prompt 前缀通常固定，prefix cache 的命中率高，这是 300ms 能成立的前提。换成自由生成，或者每个请求的 prompt 都不同，这两个优化都会失效。原帖没给 CPU 型号、线程数和 P50/P95 延迟，这组数只能当量级参考；要复现，先补 [待补：CPU 型号、线程数、测试集规模与延迟分位数]。\n微调：从 10.59% 到 93.54% #数据分两步来。作者先收集各类别的标准说法和泛化说法，再用 Qwen2.5-32B 合成；合成结果里混进了不属于任何类别的样本，人工标注后被保留成 other 类，最终得到 2 万条数据。这个 other 类等于给模型一个拒识出口：线上遇到封闭类别之外的输入，模型不必硬塞进某一类。\n未微调时模型对分类任务几乎没有理解。第一组训练用默认策略：学习率 3e-5，linear decay，batch size 2。训练后 Accuracy 93.54%、Recall 92.69%。微调明显有效，但距离最终的 95.61% 还有约 2 个百分点。\n第二组改 loss 的计算位置。只在 answer 上算，是 93.54%/92.69%；在 prompt+answer 上算，升到 94.74%/93.78%；只在 prompt 上算，掉到 10.07%/13.86%，比不训练还差。作者的解释是 prompt 里包含各选项的含义解释，模型在 prompt+answer 上能学到选项语义到答案的映射；只在 prompt 上算 loss，等于让模型拟合没有答案的信息，反而破坏分类能力。这个现象在小模型上出现，在 Qwen2.5-3B 上同样的改动没有明显提升，作者据此判断小模型对 loss 位置更敏感。一次跨模型对照还不足以把它当成定律，3B 上的超参设置是否和 0.5B 同等强度，原帖没有交代。\n第三组加 warmup ratio 20% 和 weight decay 0.01，Accuracy 95.11%、Recall 95.08%。作者判断这是缓解了对微调数据的过拟合。3B 上同样没有明显提升，作者推测参数量增加后模型容量更大，对训练技巧的敏感度降低。这个推测只有一组跨模型对照，不能当成定律；3B 上没做同等强度的超参搜索，收益不显著也可能只是没调到位。\n继续调参，指标在 95% 附近停住，没有突破。最后一组混入 DeepSeek-R1 的问答蒸馏数据，比例按 1:4 和 1:1 两档试。1:4（20%）时，Accuracy 95.61%、Recall 96.18%；1:1 时反而降到 94.71%/95.30%。作者的处理是把 R1 的思考过程去掉，只保留最终答案，因为目标模型本身不输出推理链。20% 的蒸馏数据带来约 0.5 个百分点的准确率提升（95.11%→95.61%）和约 1.1 个百分点的召回提升（95.08%→96.18%），比例再高就开始拖后腿；作者把原因归到分布偏移，蒸馏数据的分布和目标业务不完全一致，比例越高，模型越容易被带偏。3B 上仍然没有明显提升。\n几个阶段串起来 #最终结果如下。表里的 Δ 是相对上一阶段，不是相对基线，读的时候别把 +83%、+1.2%、+0.4%、+0.8% 直接当成四个独立增益相加。\nStage Accuracy Recall Δ Baseline 10.59% 15.34% - + Default FT 93.54% 92.69% +83% + prompt+answer loss 94.74% 93.78% +1.2% + warmup + wd 95.11% 95.08% +0.4% + Distill (1:4) 95.61% 96.18% +0.8% 从 10.59% 到 95.61%，默认微调贡献了约 83 个百分点，后面三组技巧合计约 2 个百分点。这个分布说明，先把监督信号和任务对齐，比在训练技巧上抠 0.5 个百分点更重要。\n这组数的边界 #这组数的统计口径也要说清楚：原帖只给了单次结果，没有报告随机种子和多次运行的方差；1 个百分点左右的提升在分类任务上可能被数据划分的波动吃掉。要把它当成可复现的结论，至少补上 [待补：多种子重复实验的均值/方差、测试集规模与类别分布]。另外，这批数据里各类别多少、other 类占比多少，原帖没有给；如果线上 other 类比例远高于训练集，95.61% 这个总数会迅速失真。\n这套流程能成立，有几个前提。任务是封闭类别加 other，类别定义稳定；prompt 前缀固定，prefix cache 才有效；延迟要求是 300ms 量级，换成 50ms 的在线场景，CPU 2.1 tokens/s 就不够看。作者留了两个后续方向：更大的 teacher model 和进一步的数据增强，但都没有给出结果。真正要先补的是评测：测试集多大、各类别多少、other 类占比多少，这些决定了 95.61% 能不能代表线上。下一步该做的是把线上分布拉进测试集，再谈换 teacher。\n","date":"2026年2月27日","permalink":"https://doraemeng.dev/notes/qwen2.5-0.5b-text-classification-finetuning/","section":"笔记","summary":"Qwen2.5-0.5B 文本分类微调实践：基于 llama.cpp 做 CPU 部署（延迟约 300ms/请求），通过在 prompt+answer 上计算 loss、加 warmup 与 weight decay、混入 20% DeepSeek-R1 蒸馏数据，将分类准确率从 10.59% 提升至 95.61%。实验还发现小模型对训练技巧的敏感度明显高于 3B 模型。","title":"From 10% to 96%: Qwen2.5-0.5B 文本分类微调实践"},{"content":"本文整理自清歌（QingGo）2026-02-24 发布在知乎的原文，项目代码在 github.com/QingGo/vibe-check，原文链接是 zhuanlan.zhihu.com/p/2009624796816764979。下面的分析以这套方案为素材，不替作者补充未公开的实测数据。\n一、端到端榜单为什么定位不到失效 #SWE-bench 的一个任务失败时，你拿到的只有一个红色叉。是需求读错了、补丁写歪了，还是测试根本没跑起来？做 Code Agent 的人都知道，这三种失败对应的修复动作完全不同，但端到端榜单把它们压成了同一个通过率。\nSWE-bench / SWE-bench Pro 的任务来自真实 GitHub Issue，一个 Issue 往往同时考察仓库检索、需求理解、跨文件修改、工具调用和测试修复。模型交出的 Patch 只要有一个环节出错，整个任务就判失败；你看到的是“这个模型在 300 个 Issue 上通过了 42%”，看不到失败集中在哪一类能力上。固定开源仓库还有另一个问题：这些仓库大概率已经出现在训练语料里，刷分和真实泛化能力之间隔着一层无法证伪的污染。不同 Agent 的脚手架、检索策略和重试逻辑也混在同一个数字里，模型原生能力和工程封装无法拆开。\nVC-FCST 换了一个测量单位。它把 AI 编码失效整理成 7 个顶层分类、67 个三级失效模式，再按高发占比、测评区分度、纯模型可测、行业通用四条标准筛出 Top 50 个三级分类。Top 50 的分布是需求意图 7 个、代码执行 12 个、业务逻辑 9 个、架构协同 10 个、安全合规 7 个、工程迭代 5 个，人因协作 0 个，MVP 阶段不覆盖。每个 Case 只绑定一个三级分类和一个预期失效点，难度按 Easy 40%、Medium 40%、Hard 20% 配比，类型按 implement 60%、modify 40% 配比。最终目标是 2500 个 Case，每个入选分类至少 50 个。Case 结构里有自然语言需求、初始仓库代码、可自动执行的验收标准和固定环境配置；前三样定义 Case 的输入和判定，环境配置负责复现。\n这样做的收益很直接：某类 Case 的通过率低，你能指到具体的失效模式，而不是笼统地说“代码能力不行”。代价也要说清楚：一个 Case 只测一个失效点，真实仓库里多个失效模式会互相掩盖；2500 个 Case 覆盖 50 个分类，每个分类 50 个样本，统计置信度只能支撑粗粒度比较。它是一张专项诊断表，替代不了端到端评测。\n二、Case Bank：生成之后还有四道闸门 #Case Bank 的目标是覆盖 Top 50 个三级分类、每个分类至少 50 个有效 Case，总规模 2500 个，且每个 Case 严格绑定一个失效点。生成端用 DeepSeek V3.2 的 reasoner 模型，配合 Pydantic 强约束和 JSON 模式输出。Schema 把分类信息、难度、类型、需求、初始代码、验收标准和环境配置都设成必填字段，模型少一个字段就解析失败。这能挡住格式层面的幻觉，挡不住语义层面的跑偏：一个 Case 字段齐全、代码能跑，但它考的并不是目标失效模式，这种错误只能靠后面的语义校验发现。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 from pydantic import BaseModel, Field from typing import Dict, List, Literal class VCFCSTCategory(BaseModel): \u0026#34;\u0026#34;\u0026#34;VC-FCST分类信息，严格绑定单三级分类\u0026#34;\u0026#34;\u0026#34; level1_id: str = Field(description=\u0026#34;顶层分类ID\u0026#34;) level1_name: str = Field(description=\u0026#34;顶层分类名称\u0026#34;) level3_id: str = Field(description=\u0026#34;三级分类ID，全局唯一绑定\u0026#34;) level3_name: str = Field(description=\u0026#34;三级分类名称\u0026#34;) target_defect: str = Field(description=\u0026#34;唯一预期失效点，严格对应三级分类定义\u0026#34;) class VCFCSTCase(BaseModel): \u0026#34;\u0026#34;\u0026#34;单Case标准化结构，最小完备单元\u0026#34;\u0026#34;\u0026#34; case_id: str = Field(description=\u0026#34;全局唯一ID，格式：VCFCST-{level3_id}-{序号}\u0026#34;) vcfcst_category: VCFCSTCategory difficulty: Literal[\u0026#34;Easy\u0026#34;, \u0026#34;Medium\u0026#34;, \u0026#34;Hard\u0026#34;] = Field(description=\u0026#34;难度占比：Easy40%/Medium40%/Hard20%\u0026#34;) case_type: Literal[\u0026#34;implement\u0026#34;, \u0026#34;modify\u0026#34;] = Field(description=\u0026#34;类型占比：implement60%/modify40%\u0026#34;) requirement: str = Field(description=\u0026#34;给Agent的自然语言需求，和真实用户输入完全一致，无刻意引导\u0026#34;) initial_code: Dict[str, str] = Field(description=\u0026#34;初始仓库代码，key为文件相对路径，value为文件内容\u0026#34;) acceptance_criteria: Dict = Field(description=\u0026#34;客观验收标准，100%可自动化验证\u0026#34;) env_config: Dict = Field(description=\u0026#34;执行环境配置，保证100%可复现\u0026#34;) 生成之后要过四道闸门。第一道是格式合规，用 deepseek-chat 检查 Schema、必填字段和字段格式，过滤掉结构不完整的 Case。第二道是可执行性，把初始代码放进 Docker 容器，确认代码能运行、测试逻辑正确、依赖能装上，语法错误和坏测试在这一层暴露。第三道是区分度，强基准 deepseek-reasoner 必须 100% 通过，弱基准 deepseek-chat 的通过率必须不高于 30%，只保留同时满足这两个条件的 Case。第四道是语义一致性，用 deepseek-reasoner 判断这个 Case 是否严格对应目标三级分类、是否只包含唯一预期失效点，偏离分类或引入额外变量的 Case 会被打回重生成。作者给出的验收口径是四层校验通过率 100%、人工抽检 10% 的有效率不低于 90%、同一环境三次执行结果一致。\n这套流水线最值得盯的是第三道闸门。区分度是用 DeepSeek 的两个模型定义的：reasoner 能过、chat 过不了，Case 才保留。这个定义能有效筛掉太简单和太难的样本，但它也把“难度”锚定在 DeepSeek 的能力差上。一个 Case 可能只是恰好落在 reasoner 和 chat 的能力缝隙里，对 Claude Code 或 Gemini CLI 未必有同样的区分度。要证明这套 Case Bank 是跨模型的诊断工具，至少需要拿另外两家 Agent 做一轮交叉校验，看保留的 Case 是否仍然呈现“强模型过、弱模型不过”的分布 [待补：2500 个 Case 在 Claude Code、Gemini CLI 上的交叉区分度结果]。原文没有给出这组数据，方案里也没有留这个校验环节；这是我认为落地前必须先补的一课。\n三、把模型能力和脚手架拆开 #传统测评框架给每个 Agent 写一套适配器，接一个新模型就要改输入拼装、输出解析和 Patch 提取。VC-FCST 的做法是给每个被测 Agent 一个 YAML 配置，输入模板负责把标准 Case 转成该 Agent 的 Prompt，输出模板交给 DeepSeek 把原始输出转成标准 Git Patch。新增一个 Agent 只需要加一个配置文件，作者给的接入时间是 10 分钟。执行侧用五个扁平模块：任务调度、协议适配、Docker 隔离、客观验证、异常重试；核心逻辑控制在 1000 行以内，单 Case 单容器，跑完销毁。端到端流程从 Case 加载开始，经 Agent 协议适配、Docker 环境初始化、模型调用生成、Patch 提取、应用验证、测试执行、结果判定、日志存储，最后生成报告。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 agent_name: \u0026#34;codex\u0026#34; litellm_model_name: \u0026#34;openai/code-davinci-002\u0026#34; api_key_env: \u0026#34;OPENAI_API_KEY\u0026#34; max_tokens: 4096 temperature: 0.2 timeout: 120 # 输入模板：把标准化Case转为模型的输入Prompt input_template: | 请完成以下Python开发任务，严格按照要求输出代码： 【任务需求】{{ case.requirement }} 【仓库现有代码】{% for path, content in case.initial_code.items %} 文件路径：{{ path }} --- {{ content }} --- {% endfor %} 【验收标准】你的代码必须通过以下pytest测试用例： {% for path, content in case.acceptance_criteria.test_code.items %} 文件路径：{{ path }} --- {{ content }} --- {% endfor %} # 输出转换模板：把模型输出转为标准Git Patch output_template: | 请把以下代码生成结果，转换为标准的git diff格式Patch，严格遵循git规范： 【仓库初始代码】{{ case.initial_code | tojson }} 【模型生成的代码】{{ model_raw_output }} 变量隔离靠双模式测评：同一个 Case 既跑裸模型，也跑带脚手架的 Agent。裸模型通过、Agent 失败，问题更可能出在脚手架的工具调用或上下文管理；裸模型失败、Agent 通过，说明脚手架能补上模型的能力缺口；两边都在同一个三级分类上失败，才更像模型本身的能力边界。这个设计比单一端到端分数多了一层归因，但它把 DeepSeek 放进了测量链路：输出模板用 LLM 把模型输出转成 Patch，转换器自己也会犯错。如果 Agent 输出的是一段解释而不是 diff，转换器可能补出一个看似合法、实际不对应的 Patch，最后被记成 Agent 的失败。\n方案没有给出 Patch 转换失败率，也没有说明转换失败是否单独记账 [待补：Patch 转换失败率与人工复核比例]。我的建议是把转换失败从 Agent 失败里拆出来，按“原始输出无法解析”“Patch 无法应用”“测试失败”三类分别统计；否则你无法判断某个 Agent 的低分是模型能力问题，还是裁判的解析器不认它的输出格式。Docker 隔离同样有账要算：每个 Case 启停一次容器，2500 个 Case 乘以三款 Agent 就是 7500 次容器生命周期，启动和依赖安装的时间会直接吃进测评时长。作者把单 Case 执行成功率不低于 95% 写成验收标准，这是目标值，不是实测值 [待补：三款 Agent 各 2500 Case 的实际执行成功率]。\n四、2878 元的明细和 2500 元的预算 #成本部分只用 DeepSeek V3.2 的两个模型。核心 Case 生成、语义一致性校验、Patch 转换和诊断报告走 deepseek-reasoner；格式校验、弱基准校验和简单分类走 deepseek-chat；固定模板渲染交给 Jinja2，不产生模型调用。作者假设缓存命中率 60%，把模板和重复结构放在系统提示词里，缓存部分的定价按非缓存的十分之一算。\n把明细摊开：2500 个 Case 核心生成，输入 600 万 Token、输出 300 万 Token，1452 元；格式和语义一致性校验，输入 150 万、输出 50 万，186 元；区分度强弱基准校验，输入 200 万、输出 100 万，374 元；协议适配的 Patch 转换，输入 300 万、输出 100 万，558 元；诊断报告，输入 50 万、输出 20 万，125 元；重试缓冲，输入 100 万、输出 50 万，183 元。合计输入 1400 万 Token、输出 620 万 Token，2878 元。\n正文说全流程控制在 2500 元以内，同一节的明细却加出了 2878 元，中间差了 378 元。这不是四舍五入能解释的差额。比较合理的解释是 2500 元是压缩目标，2878 元是按当前单价和 60% 缓存命中率算出的基线；要么实际执行时砍掉一部分重试缓冲，要么缓存命中率高于 60%。落地时应该把 2878 元当预算上限，2500 元当争取值，并且把缓存命中率做成可观测指标：缓存一旦失效，输入侧的账单会先跳起来。\n这张成本表还有一个更容易被忽略的缺口：它算的是裁判的成本，没有算运动员的成本。2500 个 Case 跑三款 Agent，被测模型自己的输入输出 Token 不在 2878 元里；如果被测 Agent 每 Case 要读几十 K 上下文、跑多轮工具调用，这笔账单可能远高于裁判侧。要评估“1 人 3 个月、2500 元”能不能成立，得把被测 Agent 的推理成本单独列一行 [待补：三款被测 Agent 跑完 2500 Case 的推理成本账单]，否则这个数字只覆盖了造题和判卷，没覆盖考试本身。\n五、三个月排期和真正的风险 #排期分四段：第 1-2 周锁定 Top 50 分类、定义 Schema、做 10 个试点 Case、跑通单 Case 端到端；第 3-4 周批量生成 2500 个 Case、搭四层校验、人工抽检 10%；第 5-8 周完善 Orchestrator、Docker 隔离、三款 Agent 的 YAML 和客观验证；第 9-12 周做 Streamlit 排行榜、跑三款模型的全量测评、生成诊断报告。这个排期把 Case Bank 放在第 3-4 周，后面所有工作都依赖它；Case 生成如果卡在有效率上，第 5-8 周的联调就会被压缩。\n作者列了四条风险：Case 生成幻觉导致有效率不足 90%、被测模型接入适配困难、LLM 调用成本超支、一个人开发工作量超支。前两条有明确的缓解路径，后两条更考验克制：成本超支时要停掉非核心环节的模型调用，工作量超支时要砍掉排行榜的花哨页面。我的判断是，第一版最该先做的是一套 200 个 Case 左右的跨模型校准集：用 DeepSeek 双模型生成和校验，再拿 Claude Code、Gemini CLI 各跑一遍，看区分度和失效分布是否还成立。这个校准集跑不通，后面的 2500 个 Case 和排行榜都只是把同一个偏差放大。\n这套方案目前仍是一份设计文档：没有公开的 2500 Case 跨模型结果，没有 Patch 转换失败率，也没有三款 Agent 的实际执行成功率。排行榜可以后做，这三组数据补不齐，诊断结论就站不住。\n项目地址是 github.com/QingGo/vibe-check。原文链接是 zhuanlan.zhihu.com/p/2009624796816764979。作者是清歌（QingGo）。\n","date":"2026年2月24日","permalink":"https://doraemeng.dev/notes/vc-fcst-benchmark/","section":"笔记","summary":"VC-FCST Benchmark：基于失效分类学的 AI Code Agent 专项能力诊断测评方案，与 SWE-bench 的本质区别在于单 Case 单失效点、可精准定位失效根因。包含 2500 个标准化 Case 的用例库、DeepSeek 双模型编排引擎与 Streamlit 排行榜，1 名全栈工程师 3 个月，2500 元为目标预算、2878 元为当前明细基线。","title":"VC-FCST Benchmark 落地方案：Code Agent 标准化测评"},{"content":" 原文链接：https://zhuanlan.zhihu.com/p/2008580956940956661　作者：paperplanet（知乎）　收录于：皮皮虾的机器不学习专栏　编辑时间：2026-02-22 17:18（上海）\n模型参数量放大 25 倍，SSO 的最优学习率保持不变；Muon 的最优 LR 会跟着规模漂，最终 loss 也更高。这是 SSO 论文里最直接的一组对照，也是它想解决的问题：Muon 在 MuP 框架里只满足了两个 feature learning 条件中的一个，学习率仍然要随宽度重调。SSO 的做法是把权重矩阵的谱范数也约束住，让每一步更新都落在半径为 R 的谱球面上。\n图里右边是 SSO：参数量变化 25 倍，最优 LR 保持不变；Muon 的曲线会移动。\n1. Muon 缺的那一半 #Muon 可以看成参数更新量谱范数限制下的最速梯度下降：每一步在 $\\|\\Delta \\boldsymbol{W}\\|_2 = \\eta$ 的球内找使梯度下降最多的方向，这个方向由 msign(G) 给出。它在实践中比 AdamW 更有效率，但在 MuP 框架里只满足了两个条件中的一个。另一个条件是权重矩阵的谱范数。不约束它，W 在训练中会漂移，更新量相对 W 的比例随宽度变化，最优学习率就得跟着规模重调；规模一变，Muon 就要重扫 LR，loss 也高于 SSO。\n这一系列工作的出发点都是 feature learning：让网络中的神经元处在更有效学习特征的状态。在 MuP 的视角里，只有更新尺度和权重尺度都受控，feature learning 的条件才同时成立；只约束更新量，宽度一变，两者比例就变。\n2. 约束权重矩阵的谱范数 #问题可以写成：在 $\\|\\Delta \\boldsymbol{W}\\|_2 = \\eta$ 且 $\\|\\boldsymbol{W} + \\Delta \\boldsymbol{W}\\|_2 = R$ 的条件下，最大化梯度方向上的更新。为方便，取 $\\eta = 1$；$R$ 是目标谱范数球的半径，$\\boldsymbol{G}$ 是梯度，$\\Delta \\boldsymbol{W}$ 是要求的更新方向。\n为了让更新后的权重仍落在谱球面上，需要对谱范数 $\\|\\boldsymbol{W}\\|_2$ 求梯度。在最大奇异值唯一时，这个梯度是\n$$\\boldsymbol{\\Theta} = \\boldsymbol{u}\\boldsymbol{v}^T$$其中 $\\boldsymbol{u}, \\boldsymbol{v}$ 是最大奇异值对应的左右奇异向量。对 $\\|\\boldsymbol{W} + \\Delta \\boldsymbol{W}\\|_2$ 在 $\\boldsymbol{W}$ 处做一阶泰勒展开：\n$$\\|\\boldsymbol{W} + \\Delta \\boldsymbol{W}\\|_2 \\approx \\|\\boldsymbol{W}\\|_2 + \\langle \\boldsymbol{\\Theta}, \\Delta \\boldsymbol{W} \\rangle$$要让更新后的权重仍落在半径为 $R$ 的谱球面上，一阶项必须为 0：\n$$\\langle \\boldsymbol{\\Theta}, \\Delta \\boldsymbol{W} \\rangle = 0$$也就是说，梯度更新方向与权重矩阵的限制球面相切。\n3. 拉格朗日乘数法求方向 #把这个切面约束和 $\\|\\Delta \\boldsymbol{W}\\|_2 = \\eta$ 一起写进拉格朗日函数，引入乘子 $\\lambda$：\n$$\\mathcal{L} = \\langle \\boldsymbol{G}, \\Delta \\boldsymbol{W} \\rangle - \\lambda \\langle \\boldsymbol{\\Theta}, \\Delta \\boldsymbol{W} \\rangle$$在 $\\lambda$ 已知时，满足约束的最大值在\n$$\\Delta \\boldsymbol{W} = \\eta \\cdot \\text{msign}(\\boldsymbol{G} + \\lambda \\boldsymbol{\\Theta})$$处取到。剩下的问题是求 $\\lambda$。它由切面约束方程决定：\n$$h(\\lambda) := \\langle \\boldsymbol{\\Theta}, \\text{msign}(\\boldsymbol{G} + \\lambda \\boldsymbol{\\Theta}) \\rangle = 0$$$h(\\lambda)$ 是单调有界函数，可以从 0 开始向数轴两边做数值搜索。论文没有给闭式解；每一步要多次计算 msign，按定义就是对矩阵做奇异值分解，λ 的搜索次数直接决定 SSO 相对 Muon 多出来的开销。具体迭代次数原帖没有给，补测时记 [待补：λ 搜索的平均迭代次数与每步 Wall-clock 开销]。\n4. 二阶项与谱范数缩放 #一阶项为 0 只保证当前步相切；二阶项会在训练中累积，$\\boldsymbol{W}$ 的谱范数仍可能漂离 $R$。作者的做法是每步显式缩放：\n$$\\boldsymbol{W} \\leftarrow \\boldsymbol{W} \\cdot \\frac{R}{\\|\\boldsymbol{W}\\|_2}$$谱范数用幂迭代求，顺带得到最大奇异值对应的左右奇异向量，正好就是切面方程里的 $\\boldsymbol{\\Theta}$。幂迭代的迭代次数和矩阵条件数有关，原帖没有给具体设置。\n训练流程可以按上面四步理解：求梯度、解 λ、算 msign 更新、把 W 缩回谱球面。\n5. 几何图像 #几何上，左下角的实线圆弧是 $\\boldsymbol{W}$ 的谱范数球面，右上角的虚线球体是更新量的谱范数球；$\\boldsymbol{G}$ 是梯度。Muon 只在更新量球体上取极值，方向可能把 $\\boldsymbol{W}$ 推离球面；SSO 先在 $\\boldsymbol{W}$ 球面的切面上取更新量球体的极值，再沿同方向把 $\\boldsymbol{W}$ 缩回球面。两个约束同时满足后，每一步的更新量相对 $\\boldsymbol{W}$ 的尺度就被固定住了。\n6. 实验结果 #论文报告的优势有五项：loss 下降更快、参数可迁移性更好、MoE 路由负载更均衡、异常值更少、激活值被约束在可调范围内。文章只给了定性描述，没有贴出 loss 曲线、可迁移性指标和 MoE 负载的数值。目前能核实的硬数字只有 25 倍参数量范围内最优 LR 不变这一组，它属于实验设置，不在这五项里；这五项优势还缺能复核的数：[待补：Muon 与 SSO 在相同 token 数下的 loss 曲线和最终 loss 差值]；[待补：参数可迁移性的具体指标与跨规模结果]；[待补：MoE 路由负载均衡的分位数或最大/均值比]；[待补：异常值与激活范围的统计口径]。\n这些优势的因果链是：约束 $\\boldsymbol{W}$ 的谱范数和更新的谱范数，每层更新尺度就不随宽度漂移，feature learning 条件才满足，特征表达才更稳定。这条链条在论文里是论证；能复核的量化结果目前只有 25 倍 LR 稳定这一项。工程上要看的是相同 token 预算下的 loss 和下游指标。\n7. 和 Muon 的账 #和 Muon 比，SSO 多约束了 $\\boldsymbol{W}$ 的谱范数，因此完全兼容 MuP 的两个条件；代价是每步多一次幂迭代和一次缩放，以及一个一维数值搜索求 λ。Muon 的优势是实现简单、没有额外超参；SSO 把学习率从随规模调变成一次调好，省下的是大规模训练中反复做 LR sweep 的算力。这笔账在小模型上不一定划算：λ 搜索和幂迭代都是每步开销，小模型训练步数少、LR sweep 便宜，SSO 的收益可能抵不过实现复杂度。\n8. 还没解决的问题 #SSO 现在还没有在公开的大规模训练里给出完整账单：每步多出来的开销占多少训练时间，25 倍参数量的结论能不能外推到 10B 以上，都还没有数据。要上线，先在小模型上把这两笔开销测出来，再决定值不值得替换 Muon。\n参考 #原始论文是 arXiv:2601.08393；相关文章是《大模型控制学——谱球优化器》和《流形上的最速下降：4. Muon + 谱球面》。\n","date":"2026年2月22日","permalink":"https://doraemeng.dev/notes/sso-spectral-sphere-optimization/","section":"笔记","summary":"SSO（谱球面优化器）原理解读：在 Muon 只约束参数更新量谱范数的基础上，进一步约束权重矩阵谱范数，完整满足 MuP 的两个 feature learning 条件。实验显示参数量变化 25 倍时最优学习率保持不变，且 loss 下降更快、参数可迁移性更好、MoE 路由负载更均衡。","title":"进一步推进 MuP：从 Muon 到 SSO"},{"content":" 原文链接：https://zhuanlan.zhihu.com/p/2007250216227729670 作者：attack204（阿里云） 发布时间：2026-02-21\nAgentic RL 的训练对象变了。以前一条 prompt 对应一条 response，rollout engine 只需要把 token 生成出来；现在一次 rollout 是一个 agent 程序，里面可能有几十轮工具调用、上下文重置、环境准备和长尾等待。Infra 的问题从“怎么把模型推理跑快”变成“怎么让一个有状态的 agent 循环跟无状态的训练器同步”。这是我看 Forge、ROLL、ThunderAgent、Seer 四篇文章时反复出现的同一个矛盾。\n四篇里，Seer 针对同步训练，另外几篇更偏异步；场景不同，不能直接把结论拼成一张选型表。拆开看，它们各自把矛盾推到了不同的层。\n一、Minimax Forge：把 Agent 生命周期拿出来 #Forge 先动的是控制面。原来的数据流很直接：\nRLFramework(Verl/Slime) -\u0026gt; RolloutEngine =\u0026gt; [AsyncBuffer] -\u0026gt; Trainer 加一个中间层之后：\nRLFramework(Verl/Slime) -\u0026gt; [AgentServer \u0026lt;-\u0026gt; RolloutEngine] =\u0026gt; [AsyncBuffer] -\u0026gt; Trainer AgentServer 把 agent 的生命周期从 rollout engine 里拿出来，负责 sandbox、工具调用和多轮循环；rollout engine 仍然只处理单次生成请求，trainer 从 AsyncBuffer 取 trajectory。这个抽象解决的是状态归属问题：一个多轮 agent 的 token 数、工具状态、上下文版本和当前阶段，不能塞进一次无状态的 generation request 里。\nForge 把 agent 分成黑盒和白盒两种。黑盒 agent 比如在 sandbox 里起一个 Claude Code，Claude Code 和 rollout engine 不断交互产生 trajectory，后面走正常的 RL 流程：算 reward、算优势、算 loss。白盒 agent 则把上下文管理（Context Management）显式建模成 agent action，让模型在训练阶段就知道上下文发生了变化。原文举了两个例子：DeepSeek V3.2 技术报告里，thinking 模型在用户消息到达时会清掉 thinking 内容，避免上下文过长；SearchAgent（比如 BrowseComp）几家都采用 discard-all 策略，token 超过上下文窗口的 80% 就重置整个窗口。示意代码如下：\n1 2 3 # discard-all策略示意 if token_usage \u0026gt; 0.8 * context_window: reset_context() 把 Context Management 当 action 的代价是训练分布更复杂：模型不仅要学会完成任务，还要学会在什么时机接受上下文被清空，并在清空后重新找到状态关键 token。收益是训练和推理的行为对齐；如果上下文管理只发生在推理框架里，模型在训练时根本不知道自己会在某一轮失去历史，长轨迹上的信用分配就会错位。这一层的工程成本不低：AgentServer 成了有状态服务，sandbox 崩溃、工具超时、上下文重置都要能恢复，否则一条长轨迹跑到一半就丢了。\n滑动窗口：在新鲜度和长尾之间取一个界 #异步 RL 一定产生 off-policy。原文把取舍说得很清楚：只取最新鲜的数据，旧版本直接丢，训练样本会偏向“快而简单”的样本；只取最旧的数据，又要等 rollout 的长尾，系统吞吐会掉下来。Forge 的做法是滑动窗口：窗口内的 trajectory 可以任意取来训练，但必须等窗口内的旧数据完成后才推进窗口。这个约束把样本年龄限制在一个界内，同时允许窗口内乱序消费，避免 trainer 被最慢的一条 rollout 卡住。\n这个策略的关键参数是窗口大小和推进条件，原文没有给出具体数值。窗口太小，退化成“等最慢”；窗口太大，样本年龄上去，off-policy 程度变高，训练稳定性要重新调。[待补：Forge 滑动窗口的实际窗口大小、样本年龄上限，以及吞吐与训练稳定性的对比数据]\nPrefix Tree Merging：把推理侧的 KV 复用搬到训练侧 #GRPO 对一个 prompt 生成 n 个 completion（原文举例 20 个），这些 completion 大多共享前缀。推理时可以用 SGLang 的 PrefixCache 复用 KVCache；训练时 Megatron 不会自动做这件事，每个 completion 的前缀都要重新算。Forge 的核心改动是在训练侧也用上前缀：先把 completions 组织成树，再借助 MagiAttention 的 attention mask 做 tree attention。\nMagiAttention 原本是为 CP（context parallelism）并行设计的，但它提供了 attention mask 的语义，可以控制每个 sequence 的可见范围，正好能表达“多个 completion 共享一段前缀、在分叉后互相不可见”。AReal 团队也提过类似的 TreeAttention 方案，用 DFS 计算 attention，细节在 AREAL-DTA 论文里。这个优化的收益取决于前缀共享比例和 mask 的实现效率：树形 mask 会让 attention 变成块稀疏或变长模式，kernel 不支持的话，省下的 FLOPs 会被 mask 开销吃掉；训练侧的负载均衡也会变复杂，因为不同分支的长度不一样。[待补：Prefix Tree Merging 在 Megatron 训练侧的 FLOPs、显存节省和端到端 step time]\n推理加速：Dynamic MTP、PD 分离与 L3 KV Cache #Forge 的推理侧有三块改动。第一块是 Dynamic MTP：用 MTP 做投机解码，同时用 Top-K KL loss 在 RL 过程中持续训练一个 detached MTP head，让 draft model 和 RL policy 保持对齐。原文作者补充了一个实现细节：多层 MTP 下，现有的 Eagle 算法不能直接支持，要用一种叫 Vanilla 的变种；SGLang 里已经由 liangsheng 做了实现（issue #15207），但每一层 MTP 单独跑一个 CUDA graph，可以优化成多层 MTP fuse 到一个 CUDA graph，这块阿里云的同学在跟进。这个细节比“用了 MTP”有价值：投机解码的接受率不是静态的，policy 每更新一次，draft head 就要重新对齐；把训练和推理的权重更新节奏绑在一起，才是 Dynamic 的含义。\n第二块是 Rollout 侧的 PD 分离。Prefill 是计算密集的，decode 是访存和延迟敏感的，两者混在同一批实例上，MoE 调度会互相干扰。PD 分离给每个实例独立的并行和生成策略，让长尾样本不阻塞 FIFO scheduler。代价是 prefill 和 decode 的队列解耦后，样本年龄和调度复杂度会上升；原文提到这会带来更高的 off-policy，具体影响要看窗口和路由策略。\n第三块是全局 L3 KV Cache。多轮、超长上下文的 agent 场景里，请求之间有很高的共享前缀比例；局部 KV cache 受容量限制，prefix cache 命中率上不去，RL batch size 一大就频繁驱逐、重算。Forge 支持全局 L3 KV cache，并用 cost-aware 的调度器权衡排队延迟和缓存传输时间，在不压垮实例的前提下最大化缓存局部性。这三块改动的共同点是都在抢“重复计算”的钱：MTP 抢 decode 的串行步数，PD 分离抢 prefill/decode 的干扰，L3 cache 抢跨请求的前缀重算。\nDense Reward：Infra 很轻，算法很重 #Agentic RL 基本是多轮调用，只对最终结果给 sparse reward，模型容易学会偷工减料。原文给了一个复合奖励：过程奖励监督中间行为，比如惩罚语言混合或特定工具调用错误；任务完成时间奖励把相对完成时间放进信号，因为真实延迟还受工具执行和子 Agent 调用影响；Reward-to-Go 用来标准化回报，降低长周期任务的梯度方差。对 infra 来说，新增一个 RewardServer 类就能接住；难的是算法侧怎么设计权重、怎么避免模型为了拿时间奖励而跳过必要步骤。完成时间奖励如果单独用，会鼓励走捷径，必须和正确性、过程奖励一起看。\n二、ROLL：环境本身是训练算法的一部分 #ROLL 也实现了单独的 AgentServer：用 Rock 作为 sandbox，启动内置的 iFlow CLI 作为 agent，和模型交互。它和 Forge 的抽象方向一致，但 ROLL 把更多篇幅放在环境管理上，这一点在 agentic RL 里很容易被低估。\nAgent 在 rollout 过程中会留下中间产物，比如临时文件、日志、装了一半的依赖。这些产物会间接提示模型，甚至让模型直接读到或改掉测试脚本。原文提到一个可观察的信号：测试脚本的调用次数显著上升。这说明模型发现了环境里的漏洞，和模型能力提升没有关系。ROLL 在 rollout 前主动清理环境初始化和 agent 安装过程中产生的中间文件，测试文件只在最终评估阶段上传，和训练阶段严格隔离。它还会在环境里主动引入多样性，比如不同版本的软件包、不同镜像源、不同配置细节，甚至有意移除某个预装依赖、切换到不可用的镜像源。最后这一层看起来像折腾，实际是在防止模型把某一种环境配置背下来；训练环境越单一，模型越容易过拟合到环境的偶然特征。\n数据侧也有类似的问题。ROLL 发现大量测试数据存在 false positive：数据不完整，或者本身就是错的。它在洗数据时加了一个 LLM-as-judge 验证模块，让多个 LLM 审查每组测试数据，只有通过验证的实例才进入 RL 训练池。具体做两种检查。如果 golden solution 无法通过全部测试，丢弃该实例。如果在不执行任何有效操作的情况下也能通过测试，也丢弃该实例。第二个检查尤其重要——一个 no-op 就能通过的测试，测不到任何东西，模型只要学会“不动”就能拿奖励。\nROLL 还提了 Chunked MDP。GRPO 在 token level 做重要性采样，GSPO 在 sequence level；Chunked MDP 把一次环境交互到下一次环境交互之间的连续片段定义成 Chunk，在 Chunk 级别计算 reward 和重要性采样。这个改动的动机是多轮轨迹的信用分配：token-level 的比值在长轨迹上噪声很大，sequence-level 又把整条轨迹压成一个动作，Chunk 正好对齐“一次工具调用/一次环境交互”这个语义单位。代价是 Chunk 边界怎么切、Chunk 内部怎么分配信用，需要和具体的 agent 协议一起设计。\n三、ThunderAgent：给每个 Agent 程序建一个状态对象 #ThunderAgent 的思路是在 AgentServer 和 RolloutEngine 之间加一个代理层。原来的系统把每一轮交互看作独立的推理请求，这样的问题是无法实时追踪每个 agent 任务的运行状态：已经用了多少 token、占了哪些工具资源、绑在哪个 backend、当前处在推理还是等待工具的阶段、是否可调度。ThunderAgent 把这些字段收进一个 Program 对象，例如 P=⟨ID, c=15000 tokens, T={Docker,Bash}, L=backend_2, τ=Reasoning, s=Active⟩。有了这个对象，调度器才能做“暂停/恢复”和资源回收，而不是只看到一个孤立的 request。\n它把任务开销拆成五项：\nCost_{total} ≈ Cost_{decode} + Cost_{prefill} + Cost_{recompute} + Cost_{unused} + Cost_{caching} 优化目标主要是后三项：重计算、未使用容量和空闲缓存。具体手段是 State-Aware Pausing：当显存水位接近阈值时，暂停一部分程序并释放其 KVCache；水位下降时再恢复。恢复需要重新 prefill，所以暂停不是免费的；系统要尽量把“暂停谁”选对。\n原文给了一个反直觉的结论：优先驱逐占 KV Cache 最小的程序。理由是 attention 的计算复杂度是 $N^2$：如果为了释放 $M$ 的显存，驱逐一个占 $M$ 的大程序，重算代价是 $M^2$；驱逐两个各占 $M/2$ 的小程序，重算代价是 $2 \\times (M/2)^2 = M^2/2$。在只看重算 FLOPs 的模型里，小块更划算。这个结论有边界：驱逐次数、恢复延迟、工具状态的保存成本都会随“驱逐更多小对象”上升；当这些成本超过重算节省时，策略要反过来。原文的结论建立在它的开销模型上，不能直接当成通用规则。\n工具资源管理也遵循同一套状态机。Hook-based garbage collection 在程序到达 Terminated 状态时清理环境资源；异步环境准备则监控全局队列，发现高优先级程序接近恢复阈值时提前 Prepare 环境。后者针对的是环境初始化延迟：装 Docker、拉镜像、起依赖可能比模型推理还慢，等到恢复时才做就来不及。[待补：ThunderAgent pause/restore 策略的端到端吞吐、P99 与环境准备命中率]\n四、Kimi Seer：同步训练下的长尾调度 #Seer 的场景是同步训练，原文作者也提醒：他看到的几个 RL case 基本都跑异步训练，所以 Seer 的适用性还要结合自己的同步/异步比例看。这个提醒很重要，这三个改动都建立在“同一组 response 要一起等”这个前提上。\nDivided Rollout：把一组 response 切成 8K 的块 #GRPO 会对同一个 prompt 生成 n 个 response，常见调度会把这一组 response 绑到同一台实例上跑完。长尾一出现，两个问题同时发生：实例间负载不均衡；单实例的 KVCache 爆满触发抢占。Seer 的做法是把请求切成 Chunk 粒度，每个 Chunk 8K 长度，按负载调度到不同实例；KV Cache 缓存到 Mooncake，迁移时不需要重新 prefill。这个改动把“整条 response 的绑定”换成“Chunk 的绑定”，用 KV 传输换负载均衡。代价是调度开销和 KV 传输延迟；如果 Chunk 太小，调度次数上去；如果太大，长尾又回来了。8K 是论文选的折中，不是通用常数。[待补：Seer 8K Chunk 在 Mooncake 上的 KV 传输耗时与重算节省对比]\nContext-Aware Scheduling：用第一条请求探测组内长度 #负载不均衡的根源是不知道哪些 request 会变成长尾，也就是不知道 response 会有多长。Seer 用了一个很便宜的探针：对每个 group，先挑第一条 request 作为 speculative request，优先调度；它完成后，用它的长度作为组内 response 长度的估计；剩下的请求按“长任务优先”调度。大致过程是：先用 SFS（Shortest First）调度所有 speculative requests，短的很快完成，长的暴露成长尾候选；Context Manager 记录每个 group 已完成请求的最大生成长度，作为该组预期长度的在线估计；最后对剩余请求按预测长度降序调度，也就是 approximate LFS。这个策略的假设是组内 response 长度相关；如果同组 response 的长度差异很大，第一条的估计就会偏，需要一个在线更新机制来纠偏。\nDGDS：把 N-gram 的匹配范围扩到多机 #投机解码在 RL 里有两个麻烦。用 draft model 做 spec，RL 在 target model 和 draft model 之间的权重更新不同步，draft 的接受率会掉；用传统 N-gram，受限于单机，无法利用 GRPO 同组 response 之间的相似性。Seer 提出一种类似“分布式 N-gram”的做法：把不同 group 内 response 产生的 token 一起写进一棵分布式的压缩后缀树（CST），匹配的信息更多。流程是各实例异步 Append 新 token；DGDS Server 按 group 聚合，形成 group 级的 CST；各实例周期性 Fetch 自己正在处理的 group 的 CST，并且只同步上次 fetch 之后的新增内容。代价是跨实例的同步和过期问题：CST 更新有延迟，draft 可能匹配到旧数据；group 之间的隔离也要设计好，否则会把不相关的 token 混进来。\n五、四篇文章放在一起看 #Forge 和 ThunderAgent 都在加控制面：Forge 用 AgentServer 管 agent 生命周期，ThunderAgent 用 Program 管单个任务的运行状态；两者解决的是“无状态推理系统看不见 agent 状态”的问题。ROLL 把环境清理和数据验证当成训练算法的一部分，解决的是“模型会利用环境漏洞”的问题。Seer 在同步训练里切 Chunk、做长度估计和分布式 spec，解决的是“一组 response 被长尾绑死”的问题。四个系统的优化对象不同，但都在同一个方向上使劲：把 agent 的语义单位（程序、Chunk、轮次）暴露给调度器，让调度器不再把一次生成当成全部。\n如果我要在自己的系统里落地，会先建 AgentServer 和 Program 状态；没有这个边界，调度、奖励和资源管理都是盲的。环境清理和数据验证要紧接着补上，否则前面的加速会被 reward hacking 吃掉。prefix/KV 复用和 PD 分离是吞吐的大头，适合在状态边界稳定后做；MTP 和分布式投机解码对 draft 质量、模型结构和推理框架的耦合最深，放到最后。论文里没有这条结论；这个顺序是从“哪一层缺了会让上层优化失效”推出来的。\n还缺一块公共证据：四篇文章各自在自己的 workload 上报告收益，没有一组跨系统的端到端对比。Forge 的滑动窗口、ThunderAgent 的 pause/restore、Seer 的 8K Chunk，参数都和工作负载强相关；直接抄参数，很可能在自己的流量上失效。[待补：四个系统在同一组 agent workload 上的吞吐、P99、样本年龄分布和 KV 命中率对比]\n如果只做一件事，先把 rollout 的样本年龄、长尾分布和 KV cache 命中率打点。没有这三个数，调度策略只能靠拍脑袋；有了它们，至少能判断应该先动窗口、先动 Chunk，还是先动缓存。\n参考资料：Forge 的《大规模原生 Agent RL 系统》、ROLL 团队的《苦涩的教训！Agentic RL 训练中的实践经验》、ThunderAgent 的《A Simple, Fast and Program-Aware Agentic Inference System》、Seer 的《Online Context Learning for Fast Synchronous LLM Reinforcement Learning》，以及 AREAL-DTA 的《Dynamic Tree Attention for Efficient Reinforcement Learning of Large Language Models》。\n","date":"2026年2月21日","permalink":"https://doraemeng.dev/notes/agentic-rl-infra-optimization-2026/","section":"笔记","summary":"Agentic RL Infra 优化方向综述：解读 Minimax ForgeRL、ROLL、ThunderAgent、Kimi Seer 四篇大厂技术文章，归纳 AgentServer 抽象、滑动窗口调度、Prefix Tree Merging、推理加速等五大优化方向，附各系统核心贡献对比。","title":"从各家技术文章看26年Agentic RL Infra优化方向"},{"content":"OpenClaw 的记忆系统里没有向量数据库。长期记忆、每日日志、会话归档全部是工作区里的 Markdown 文件，开发者可以直接打开看，也可以直接改。这个选择很反常：检索、去重、过期清理都得自己处理；但它把「Agent 到底记住了什么」变成了一件可以 git diff 的事，对一个需要长期运行的个人 Agent，这个可解释性往往比检索召回率更值钱。\n这篇笔记的事实来自 Eternity（阿里巴巴）2026-02-13 的知乎文章（https://zhuanlan.zhihu.com/p/2005632275774195031）。下面的机制描述来自原文，判断和取舍由我补充；原文没有给出的数据，我用占位符标出。\n三层文件，三种加载边界 #这套系统把记忆分成三层，每层的加载策略和安全边界不同。MEMORY.md 放在工作区根目录，存的是经过整理的高层决策、用户偏好和持久事实；它只在主会话（和人类所有者的直接对话）里加载，Discord 或群聊等共享场景会把它排除在外。Daily Logs 放在 memory/YYYY-MM-DD.md，记录当天的笔记和持续更新的上下文；每次会话自动加载今天和前一天的文件，相当于给 Agent 一段短期工作记忆。Session Archives 放在 memory/YYYY-MM-DD-{slug}.md，是过往会话的静态归档，文件名的 slug 由大语言模型生成；它们不会被自动加载，只有 Agent 显式调用检索工具时才会被读到。\n三层文件覆盖了三种时间尺度，真正的设计点在加载边界：主会话的私密记忆不能进群聊，最近的上下文要便宜地随取随用，旧会话则按需检索，避免把整个历史塞进 prompt。MEMORY.md 只在主会话加载这一条，把「记忆」和「隐私边界」绑在了一起；Daily Logs 的今天加昨天，则是在新鲜度和 token 成本之间取了一个固定窗口；Session Archives 不自动加载，意味着历史信息默认是冷的，只有检索命中才会被拉进上下文。\n写入：规则留给 Prompt，格式留给文件 #更新机制没有一张「什么该写、什么不该写」的硬编码规则表。Agent 拥有完整的文件读写权限，是否写入、写到 MEMORY.md 还是当天的日志，取决于当前上下文、System Prompt 里的行为约定和用户的显式指令。用户说「记住这个」时，Agent 调用文件写入工具更新 MEMORY.md 或 memory/YYYY-MM-DD.md。这个设计把判断交给了模型，好处是能处理规则覆盖不到的情况；代价是写入行为不确定，同一个信息可能今天被写进长期记忆，明天只留在日志里。要让这套机制稳定，Prompt 里的边界必须写得足够具体，否则「重要」这个词会由模型每次重新解释。\n当上下文接近压缩上限时，系统会插入一次「预压缩记忆刷新」。它先检查权限确认，跳过沙箱、命令行模式和心跳模式；然后暂停会话，插入整理步骤，整个过程对用户无感知。和常见的上下文压缩不同，它在删除旧消息之前给模型一次持久化机会：比如保存具体的手机号码，而不是把它压缩成「用户提到一个手机号码」。这个顺序很关键——压缩是不可逆的信息损失，刷新把「哪些细节值得留」的判断提前到信息还完整的时候。代价是压缩发生的时点本来就很紧张，额外一轮整理会拉长这次会话的停顿；原文没有给出刷新耗时，[待补：预压缩刷新在主会话中的实际延迟与失败回退策略]。预压缩刷新用的系统提示词很短：\n\u0026#34;Pre-compaction memory flush turn.\u0026#34;, \u0026#34;The session is near auto-compaction; capture durable memories to disk.\u0026#34;, You may reply, but usually ${SILENT_REPLY_TOKEN} is correct. 它只说了「把持久记忆落到磁盘」，没有规定写哪些字段；具体写什么仍然由模型判断。这也解释了为什么同一套系统在不同用户手里会形成完全不同的记忆结构：Prompt 只给了方向，结构是模型和用户在日常对话里共同长出来的。\n用户执行 /new 时，会触发 session-memory hook：把上一段对话（默认最近 15 条原始消息）保存成 Markdown 文件，调用 LLM 生成一个 1-2 个词的 slug，文件名是 YYYY-MM-DD-{slug}.md；没有生成 slug 时退回时间戳 YYYY-MM-DD-{HHMM}.md。slug 的提示词要求小写、连字符分隔、不要文件扩展名，只回复 slug 本身，并给了 vendor-pitch、api-design、bug-fix 三个例子：\nBased on this conversation, generate a short 1-2 word filename slug (lowercase, hyphen-separated, no file extension. Reply with ONLY the slug, nothing else. Examples: \u0026#34;vendor-pitch\u0026#34;, \u0026#34;api-design\u0026#34;, \u0026#34;bug-fix\u0026#34; 这个细节看起来琐碎，实际决定了归档能不能被检索到。文件名本身就是一层索引：slug 起得准，人和 Agent 都能靠路径先缩小范围；起不准，就只能回到全文搜索。\n检索：向量负责语义，BM25 负责精确串 #检索侧有两个工具。memory_search 在 MEMORY.md 和 memory/*.md 上做混合搜索：向量搜索负责语义相近，BM25 负责精确匹配，两者通过权重控制；返回的是最相关的片段、文件路径和行号。memory_get 在 memory_search 的基础上读取指定行范围，让 Agent 可以只展开命中的那一段，而不是把整个文件读进上下文。这个分工解决的是两件不同的事：向量搜索能处理「上次说的那个部署方案」这种换了说法的查询，BM25 能处理手机号、错误码、函数名这种必须逐字命中的串；只留一种，总有一类查询会失手。\nBM25 按词频和逆文档频率打分，查询词必须真的出现在文本里，所以它对精确串很可靠，但对同义改写无能为力；向量搜索把文本映射到嵌入空间，能跨过措辞差异，却可能把「相似但不对」的片段排到前面。混合搜索的价值在于让两类召回互相补位，权重则决定了默认偏向哪一边。memory_get 返回行范围这件事看起来小，实际是在控制上下文成本：检索命中后只读那几行，比把整个归档文件塞进 prompt 便宜得多。\n这套设计的账本 #这套设计的账本在 token 和写入确定性上。自动加载的 MEMORY.md 和最近两天日志会直接占用上下文窗口，文件越大，留给对话的空间越少；原文没有给单文件大小上限或截断策略，[待补：自动加载的截断规则与典型 token 占用]。写入交给模型判断，意味着记忆质量取决于 Prompt 和模型当天的判断，不能像数据库事务那样保证「写一次就一定在」。在单用户、记忆量不大的个人 Agent 场景，这些代价还能接受；到了多用户或大记忆量场景，检索和隔离的要求会反过来逼你上更重的存储。\n原帖评论区有人问触发 compaction 时为什么像卡住一样、等很久没反应；另一位读者说「这么干太消耗 token」。原文没有给出压缩和刷新的耗时数据，第一个问题只能按机制定位：刷新要在压缩前插入一轮模型调用，如果模型响应慢或工具调用重试，用户看到的就是停顿。第二个问题在上面已经算过账，它和停顿指向同一个边界——纯文件方案在记忆量小的时候很舒服，记忆一多，token 成本和停顿会先于检索精度成为瓶颈。\n如果让我给一个判断：单人使用的 Agent，先把 Markdown 记忆做扎实，别急着上向量库；等 MEMORY.md 大到每次加载都心疼，再谈分块索引和归档策略。下一步该补的是加载上限、写入校验和压缩耗时的可观测性；换存储引擎可以往后放。这三样缺一个，长会话出问题时你就只能靠猜。\n","date":"2026年2月13日","permalink":"https://doraemeng.dev/notes/openclaw-memory-system/","section":"笔记","summary":"OpenClaw记忆系统解析：不用向量数据库，用纯Markdown文件做AI Agent的长期记忆——MEMORY.md、按天日志、会话归档三层文件各有加载策略和安全边界；写入由Prompt原则引导智能体自主决策而非固定规则，配合预压缩记忆刷新和向量+BM25混合检索的memory_search工具。","title":"随便聊聊OpenClaw记忆系统"},{"content":"这个站点现在有 200 多个页面。改完一篇 Markdown，执行 git push，Cloudflare Pages 拉仓库、跑一次 hugo --gc --minify，整站重新生成大约 2 秒，然后把 public/ 里的静态文件推到 CDN。没有数据库，没有常驻后端，也没有需要单独维护的搜索服务。\n0. 需求与选型 #搭这个博客之前，我列过一组硬需求。数学公式要能稳定渲染，代码块要能高亮和复制，写作过程要接近纯 Markdown，并且不需要写前端代码；这四项是 P0。暗色模式、全文搜索、部署零成本是 P1，缺了能忍，但有更好。研究员的日常是读论文、记公式、贴代码，博客必须让这些动作不打断写作。\n静态站点生成器的候选里，Hugo 的构建速度最快，主题生态丰富，数学公式需要额外配置；Hexo 构建速度中等，中文主题多，公式靠插件；VitePress 构建快，公式内置，但偏 Vue 文档站点；Docusaurus 构建速度中等，背靠 React 生态，公式也要插件；Astro 构建快，Islands 架构适合内容为主、交互为辅的站点。这个站点是内容驱动，构建速度和 Markdown 工作流优先，Hugo 的单二进制、无运行时依赖更省心。\n主题选了 Congo。它是为内容创作者设计的 Hugo 主题，默认暗色是 slate 色系，字体、行距和留白偏学术排版；搜索、代码复制、目录、RSS、多语言这些功能开箱即用，样式层用 Tailwind CSS。Tailwind 的好处是改样式不用跟主题作者的历史 CSS 打架，代价是主题直接 vendored 进仓库，升级要自己合并；对个人博客来说，这个交换比等主题发版更可控。\n部署选 Cloudflare Pages。它的国内访问速度较快，免费额度对个人博客足够，SSL 证书自动续期，全球 CDN 分发。Vercel 也免费，但国内速度一般，更适合 Next.js 项目；GitHub Pages 免费且简单，国内访问较慢；阿里云 OSS 国内速度极快，但每月要花大约 ¥10-30 的存储和流量费。这个站点没有国内备案和商业流量需求，Cloudflare Pages 的免费层够用。\n1. 整体架构 #整站由 Hugo 生成静态 HTML、CSS 和 JavaScript。Hugo 是 Go 写的静态站点生成器，负责把 Markdown 和模板编译成 public/ 目录；Congo 提供页面骨架、暗色主题和组件；KaTeX 负责数学公式，文件放在本地；Chroma 负责代码高亮；Fuse.js 在浏览器端做全文搜索，不需要后端索引服务。内容层是 Markdown，分类靠 categories 和 tags，图片和字体放在 static/，构建由一条 Hugo 命令完成，输出目录是 public/，最后交给 Cloudflare Pages 或 Vercel、OSS 之类的平台托管。\n这个架构的关键是“构建期把能做的都做掉”。Markdown 解析、模板渲染、代码高亮、资源压缩都在构建时完成，浏览器只负责加载静态文件和执行 KaTeX、Fuse.js 这两段客户端脚本。代价是搜索索引要随文章数量一起下载，公式渲染要等 KaTeX 的 JS 和字体加载；好处是没有服务器要维护，也没有数据库连接和 API 超时。\n2. 内容工作流 #日常流程很短。我写一个 Markdown 文件，提交并 push，GitHub 或 Cloudflare 检测到变更后触发构建，Hugo 执行构建，生成 public/ 目录，CDN 把新文件分发出去，读者刷新页面就能看到。对我而言只有两步：写 content/notes/文章标题.md，然后 git push。构建失败时 Cloudflare 会保留上一次成功的部署，站点不会因为一篇稿子的语法错误整体挂掉。\n3. 文件结构 #站点目录大致如下，配置按功能拆在 config/_default/ 下。内容、模板和静态资源分开放，后面找文件不用翻整棵树：\nsite/ # Hugo 站点根目录 ├── config/_default/ # 配置文件（按功能拆分） │ ├── hugo.toml # 站点基础设置 + theme = \u0026#34;congo\u0026#34; │ ├── languages.zh.toml # 中文语言 + 作者信息 + 社交链接 │ ├── menus.zh.toml # 顶部导航菜单 │ ├── params.toml # 主题参数（暗色模式、搜索、代码复制） │ └── markup.toml # Markdown 渲染设置（公式 passthrough） │ ├── content/ # 所有内容 │ ├── _index.md # 首页 │ ├── about.md # 关于页面 │ ├── series.md # 精读系列总目录 │ ├── essays.md # 随笔入口 │ └── notes/ # 技术笔记与系列章节 │ ├── vllm-gpu-100-percent-max-tokens-trap.md │ ├── logistic-regression-gradient-descent.md │ ├── online-softmax-information-geometry.md │ └── ... (70 篇) │ ├── layouts/ # 自定义模板 │ ├── partials/extend-head.html │ ├── _partials/recent-articles.html │ ├── _shortcodes/series-cards.html │ ├── notes/list.html # 技术笔记流（过滤系列与随笔） │ └── _default/landing.html # 系列/随笔/关于的简洁页布局 │ ├── assets/css/custom.css # 系列卡片等自定义样式 ├── i18n/zh.yaml # 中文界面文案 ├── static/ # 静态资源（直接复制到输出目录） │ └── katex/ # KaTeX 本地文件（CSS + JS + 字体） │ ├── themes/congo/ # Congo 主题（直接 vendored 进仓库） └── public/ # 构建输出（部署用这个目录） 把主题放进 themes/congo/，没有用 Git submodule，是为了让模板覆盖和样式修改跟着主仓库走，部署时不依赖外部仓库的可用性。layouts/ 里只放这个站点特有的覆盖：extend-head.html 挂 KaTeX，notes/list.html 过滤系列和随笔，landing.html 处理系列、随笔和关于页的简洁布局。public/ 是构建产物，不手工编辑，部署平台只认这个目录。\n4. 三个关键配置 #数学公式的第一处配置在 config/_default/markup.toml。先让 Goldmark 别碰公式标记：\n1 2 3 4 5 [goldmark.extensions.passthrough] enable = true [goldmark.extensions.passthrough.delimiters] block = [[\u0026#39;$$\u0026#39;, \u0026#39;$$\u0026#39;], [\u0026#39;\\\\[\u0026#39;, \u0026#39;\\\\]\u0026#39;]] inline = [[\u0026#39;$\u0026#39;, \u0026#39;$\u0026#39;], [\u0026#39;\\\\(\u0026#39;, \u0026#39;\\\\)\u0026#39;]] Goldmark 默认会把 $ 当普通文本处理，公式里的反斜杠和下划线会被 Markdown 规则吃掉。开启 passthrough 后，$...$ 和 $$...$$ 原样输出到 HTML，由浏览器端的 KaTeX 渲染。这一步不开启，后面 KaTeX 配置得再对，公式也到不了它手里。\n第二处是 KaTeX 的本地加载。layouts/partials/extend-head.html 引入本地 CSS 和 JS：\n1 2 3 \u0026lt;link rel=\u0026#34;stylesheet\u0026#34; href=\u0026#34;/katex/katex.min.css\u0026#34;\u0026gt; \u0026lt;script defer src=\u0026#34;/katex/katex.min.js\u0026#34;\u0026gt;\u0026lt;/script\u0026gt; \u0026lt;script defer src=\u0026#34;/katex/auto-render.min.js\u0026#34;\u0026gt;\u0026lt;/script\u0026gt; layouts/partials/extend-footer.html 负责在 DOM 加载完成后调用 renderMathInElement，把页面里的公式标记交给 KaTeX。渲染入口如下：\n1 2 3 4 5 6 7 8 9 10 11 12 13 document.addEventListener(\u0026#34;DOMContentLoaded\u0026#34;, function() { if (typeof renderMathInElement !== \u0026#39;undefined\u0026#39;) { renderMathInElement(document.body, { delimiters: [ {left: \u0026#39;$$\u0026#39;, right: \u0026#39;$$\u0026#39;, display: true}, {left: \u0026#39;$\u0026#39;, right: \u0026#39;$\u0026#39;, display: false}, {left: \u0026#39;\\\\[\u0026#39;, right: \u0026#39;\\\\]\u0026#39;, display: true}, {left: \u0026#39;\\\\(\u0026#39;, right: \u0026#39;\\\\)\u0026#39;, display: false} ], throwOnError: false }); } }); 本地化是为了避开 CDN 的不确定性。cdn.jsdelivr.net 在中国大陆网络环境下可能加载失败，本地文件能保证全球访问一致；KaTeX 的 .woff2 字体也必须一起放到 static/katex/fonts/，否则中文 \\\\text{} 里的字会显示成方块。代价是升级 KaTeX 要手动替换 CSS、JS 和字体，不能靠 CDN 自动跟版本。\n第三处是暗色模式默认开启。config/_default/params.toml 里设置：\n1 2 defaultAppearance = \u0026#34;dark\u0026#34; autoSwitchAppearance = true defaultAppearance 决定首次访问的主题，autoSwitchAppearance 允许读取系统偏好并在用户手动切换后记住选择。两个都开，读者第一次进来是暗色，系统切到亮色时页面也会跟随；如果只想要固定暗色，把第二个关掉即可。\n5. 部署到 Cloudflare Pages #代码先推到 GitHub。在站点根目录初始化仓库，添加远端，提交并推送：\n1 2 3 4 5 6 cd site/ git init git remote add origin https://github.com/你的用户名/blog.git git add . git commit -m \u0026#34;init hugo + congo\u0026#34; git push -u origin main 然后在 Cloudflare Dashboard 里进 Pages，创建项目并连接 GitHub，选择 blog 仓库。构建设置填 Framework preset 为 Hugo，Build command 为 hugo --gc --minify，Build output directory 为 public，保存后触发第一次部署。这几个值和本地构建命令保持一致，避免线上和本地生成不同的目录结构。\n自定义域名在 Pages 项目的“自定义域”里添加 doraemg.com，按提示修改 DNS 记录，SSL 证书大约 1-2 分钟自动签发。之后每次 git push 都会自动构建部署，证书续期也由平台处理。构建日志在 Pages 面板里能直接看，Hugo 模板报错和资源路径错误都会在这一步暴露。\n6. 成本 #域名是唯一的固定支出，在 Cloudflare Registrar 买 .com 大约 ¥70/年。托管用 Cloudflare Pages 免费版，CDN 和自动 HTTPS 包含在内，构建额度是每月 500 次，首年总成本约 ¥70，之后每年只续域名。如果换成阿里云 OSS 托管，存储和流量每月大约 ¥10-30，适合国内业务为主、需要备案和稳定回源的场景。\n免费额度有边界。每月 500 次构建对个人博客够用，但如果一个仓库里同时放多个站点、每次提交都触发全量构建，额度会消耗得比想象中快。静态站点的成本低，是因为把计算放在了构建期和浏览器端；文章数量、图片体积和搜索索引增长之后，首屏加载和构建时间都会随之上升，这部分不会体现在账单里。\n7. 常见问题 #Q1：公式显示为红色错误文本？ #这通常是 KaTeX 解析失败，先从转义查起。\\\\text{} 内部的下划线 _ 要写成 \\\\_，\u0026amp;、%、# 在公式里也要转义；再看 static/katex/fonts/ 的字体文件是否完整，缺字体时公式可能能解析但显示异常。最后确认 markup.toml 的 passthrough 分隔符和 extend-footer.html 里的 delimiters 一致，两边不一致会导致公式根本没进入 KaTeX。\nQ2：如何添加新文章？ #用 Hugo 的命令生成骨架。命令很短，路径按你的目录结构改：\n1 hugo new content posts/文章标题.md 命令只是按模板生成文件，路径要跟 content/ 下的目录结构一致；这个站点的技术笔记实际放在 content/notes/。生成后在文件头部填写 frontmatter：\n1 2 3 4 5 6 7 --- title: \u0026#34;文章标题\u0026#34; date: 2025-01-25T10:00:00+08:00 draft: false categories: [\u0026#34;研究笔记\u0026#34;] tags: [\u0026#34;Tag1\u0026#34;, \u0026#34;Tag2\u0026#34;] --- draft: false 才会进入构建，categories 和 tags 决定归档和筛选。日期写成带时区的 ISO 格式，避免不同机器构建出不同的排序。\nQ3：如何本地预览？ #在站点根目录执行下面的命令，先确认本地版本能起来。启动参数如下：\n1 2 hugo server --buildDrafts # 访问 http://localhost:1313 --buildDrafts 会把草稿也渲染出来，适合发布前检查。本地服务器带热重载，改 Markdown 或模板后浏览器会自动刷新；公式、搜索和暗色模式都能在本地验证，不需要每次 push 到 Cloudflare 看效果。\nQ4：如何备份？ #代码和内容全部在 Git 仓库里，图片、字体等资源放在 static/ 下也一并提交，定期 git push 就完成了备份。public/ 是构建产物，不需要提交；需要恢复时，拉下仓库重新构建一次即可。域名和 DNS 记录不在仓库里，换注册商或误删解析时要单独留一份记录。\n8. 这套方案的边界 #这套组合的核心是“一个二进制文件、一个主题、一个托管平台、一种内容格式”：Hugo 负责构建，Congo 负责样式和功能，Cloudflare Pages 负责托管和 CDN，Markdown 负责内容。没有数据库和后端，配置量可控，代价是所有能力都停在静态站点能提供的范围内。评论、登录、服务端搜索这些需求要另外接服务，不在当前架构里。\n具体到维护，有三笔账要提前算。搜索索引在浏览器端加载，文章越多，首次搜索要下载的数据越大；KaTeX 和 Congo 都 vendored 进仓库，升级要手动合并；Cloudflare Pages 的免费构建额度，推送频繁的仓库要留意。这三条不提前算，站点长大后会在搜索、升级和构建额度上依次碰到。\n参考资源 #Hugo 的官方文档在 https://gohugo.io/documentation/ ，配置项和模板函数以它为准。Congo 主题文档在 https://jpanther.github.io/congo/docs/ ，shortcode 和主题参数看这里。KaTeX 的命令支持表在 https://katex.org/docs/support_table.html ，写公式前可以先查哪些命令可用。Cloudflare Pages 的文档在 https://pages.cloudflare.com/ ，构建配置和自定义域名的细节都在上面。\n","date":"2025年1月25日","permalink":"https://doraemeng.dev/notes/how-this-blog-is-built/","section":"笔记","summary":"Hugo + Congo 搭建个人技术博客完整教程：主题选型、KaTeX 数学公式本地化、暗色模式配置、Cloudflare Pages 免费部署与自定义域名绑定。70 篇技术文章、200 多个页面构建仅需约 2 秒，首年成本约 70 元域名费，全程不写前端代码，适合想专注写作的研究员和工程师。","title":"这个博客是怎么做的：Hugo + Congo 完整技术拆解"},{"content":"序列长度 65536、FP32 的注意力分数矩阵，单个就是 $65536^2 \\times 4\\text{ bytes} \\approx 16\\text{ GB}$。标准 Self-Attention 还要再存一份 softmax 后的 $\\mathbf{A}$；两个 $N \\times N$ 矩阵同时驻留 HBM，而一块 GPU 的 SRAM 只有几十 MB。FlashAttention 把 Q/K/V 切块，在 SRAM 里算完一块就丢掉中间结果，只把输出 $\\mathbf{O}$ 和两个统计量写回 HBM。障碍在 softmax：看到第一块时，你不知道后面会不会出现更大的分数。Online Softmax 要解决的就是这个全局归一化问题。\n把 Q、K、V 代进去，Self-Attention 可以写成一行矩阵公式。下面的形状按单头、无 batch 省略写：\n$$ \\mathbf{S} = \\mathbf{Q}\\mathbf{K}^\\top, \\quad \\mathbf{A} = \\text{softmax}(\\mathbf{S}), \\quad \\mathbf{O} = \\mathbf{A}\\mathbf{V} $$序列长度拉到 65536 时，先算一笔显存账。单个 $N \\times N$ 矩阵按 FP32 存，占用如下：\n$$ 65536^2 \\times 4\\text{ bytes} \\approx 16\\text{ GB} $$Flash Attention 的核心洞察是不需要存储完整的注意力矩阵。它靠两个工程手段实现：Tiling（分块）把数据切成适合 SRAM 的小块；Recomputation（重计算）在反向传播时不存储前向的中间结果。Tiling 面临一个根本障碍——Softmax 需要全局归一化。这就是 Online Softmax 登场的地方。\n1. 标准 Softmax 的全局统计量 #对于向量 $\\mathbf{x} \\in \\mathbb{R}^N$，Softmax 有一个标准定义。先把未归一化的指数写出来：\n$$ \\text{softmax}(x_i) = \\frac{e^{x_i}}{\\sum_{j=1}^{N} e^{x_j}} $$当 $x_i$ 很大时，$e^{x_i}$ 会溢出。标准解法引入全局最大值 $m = \\max_j x_j$：\n$$ \\text{softmax}(x_i) = \\frac{e^{x_i - m}}{\\sum_{j=1}^{N} e^{x_j - m}} $$这个形式需要两个全局统计量：$m = \\max_{j} x_j$ 和 $d = \\sum_{j=1}^{N} e^{x_j - m}$。计算 $m$ 和 $d$ 都需要看到所有 $N$ 个元素。如果数据被切成多个块，每个块只知道自己的局部信息，无法直接得到全局 Softmax。分块要成立，必须找到一种只用局部统计量就能合并出全局 $m$ 和 $d$ 的方法。\n2. 两块合并的推导 #假设输入被分成两个块 $\\mathbf{x}^{(1)}$ 和 $\\mathbf{x}^{(2)}$。块 1 的局部最大值是 $m_1 = \\max(\\mathbf{x}^{(1)})$，局部指数和是 $d_1 = \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m_1}$；块 2 同理，得到 $m_2$ 和 $d_2$。目标是仅通过 $(m_1, d_1)$ 和 $(m_2, d_2)$ 计算全局 Softmax，不重新访问原始数据。\n全局最大值的合并没有分支。直接取两个局部最大值的较大者：\n$$ m = \\max(m_1, m_2) $$全局指数和才是核心。我们需要计算：\n$$ d = \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m} + \\sum_{x \\in \\mathbf{x}^{(2)}} e^{x - m} $$问题在于，我们只有 $d_1 = \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m_1}$，不是 $\\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m}$。关键变形是把指数拆成两部分：\n$$ \\begin{aligned} \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m} \u0026= \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m_1 + m_1 - m} \\\\ \u0026= \\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m_1} \\cdot e^{m_1 - m} \\\\ \u0026= e^{m_1 - m} \\cdot \\underbrace{\\sum_{x \\in \\mathbf{x}^{(1)}} e^{x - m_1}}_{d_1} \\end{aligned} $$块 2 的推导完全对称。把下标换掉，结果如下：\n$$ \\sum_{x \\in \\mathbf{x}^{(2)}} e^{x - m} = e^{m_2 - m} \\cdot d_2 $$把两块的结果相加，就得到最终的合并公式：\n$$ \\boxed{d = d_1 \\cdot e^{m_1 - m} + d_2 \\cdot e^{m_2 - m}, \\quad \\text{其中 } m = \\max(m_1, m_2)} $$两块的情况可以推广到 $K$ 个块。每一步只保留当前的 $m$ 和 $d$，递推式如下：\n$$ \\begin{aligned} m^{(k)} \u0026= \\max(m^{(k-1)}, m_k) \\\\ d^{(k)} \u0026= d^{(k-1)} \\cdot e^{m^{(k-1)} - m^{(k)}} + d_k \\cdot e^{m_k - m^{(k)}} \\end{aligned} $$初始条件 $m^{(0)} = -\\infty$、$d^{(0)} = 0$。第一块进来时，旧项的因子 $e^{-\\infty - m^{(1)}}$ 是 0，所以不需要为“第一块”写单独的分支；这个初始化把边界情况吸收进了递推式。\nPython 验证 # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 import numpy as np def online_softmax(blocks): \u0026#34;\u0026#34;\u0026#34; blocks: list of numpy arrays Returns: (m_global, d_global) for softmax normalization \u0026#34;\u0026#34;\u0026#34; m = -np.inf d = 0.0 for block in blocks: m_block = np.max(block) d_block = np.sum(np.exp(block - m_block)) m_new = max(m, m_block) # Rescaling: 把旧的统计量转换到新的参考系 d = d * np.exp(m - m_new) + d_block * np.exp(m_block - m_new) m = m_new return m, d # 验证：与传统 softmax 结果一致 np.random.seed(42) x = np.random.randn(100) # 方法1：传统 softmax m_true = np.max(x) d_true = np.sum(np.exp(x - m_true)) probs_true = np.exp(x - m_true) / d_true # 方法2：Online softmax（分成5块） blocks = np.array_split(x, 5) m_online, d_online = online_softmax(blocks) probs_online = np.exp(x - m_online) / d_online print(f\u0026#34;全局最大值一致: {np.isclose(m_true, m_online)}\u0026#34;) print(f\u0026#34;全局指数和一致: {np.isclose(d_true, d_online)}\u0026#34;) print(f\u0026#34;概率分布一致: {np.allclose(probs_true, probs_online)}\u0026#34;) print(f\u0026#34;最大概率差: {np.max(np.abs(probs_true - probs_online)):.2e}\u0026#34;) 输出：\n全局最大值一致: True 全局指数和一致: True 概率分布一致: True 最大概率差: 0.00e+00 输出里的 0.00e+00 只说明这 100 个样本在 float64 下差到显示精度以下。np.isclose 验证的是数值等价，不是 bitwise 相等；换一组随机数、换成 bf16，或者换一种分块方式，最后几位仍然会不同。Online Softmax 的“精确”指代数上没有近似 softmax，不指所有实现的结果逐位一致。\n3. 数值边界：什么时候小块会被压没 #rescaling 因子是 $e^{m_k - m}$。假设块 1 的最大值 $m_1 = 100$，块 2 的最大值 $m_2 = 80$，全局最大值 $m = 100$。块 2 的统计量在合并时要乘以 $e^{80 - 100} = e^{-20} \\approx 2.06 \\times 10^{-9}$。这个数看起来很小，但 float32 的最小正规数在 $e^{-87}$ 附近，$e^{-20}$ 离下溢还很远；块间最大值差到 100 以上，因子才会进入次正规数，低到 $e^{-103}$ 左右才变成 0。\n下溢本身不破坏结果。一个块的局部最大值比全局最大值低 100 以上，意味着它的所有项相对全局最大项都小于 $e^{-100}$，对最终 softmax 的贡献已经在有效精度之外。把它压成 0，等价于丢掉一个本来就看不见的尾部。真正需要注意的是反向传播：如果某个块的贡献在前向被下溢成 0，反向的梯度也会是 0；这不会让结果错，但会让这块数据在训练中失去信号。长序列训练里如果频繁出现这种块，应该检查分数分布，而不是提高精度硬扛。\n另一个边界是 $d$ 的累加顺序。$d$ 是所有项的和，每个项都不超过 1（因为减去了全局最大值），所以 $d \\le N$；它不会因为项太多而溢出，但浮点加法不满足结合律，分块顺序不同，最后几位就不同。这就是为什么后面的“精确”要限定在代数层面。\n4. 几何：换原点、Fisher 度量与“平行移动” #要看清 rescaling 的几何含义，先把 softmax 写成指数族。这里的参数命名沿用 Amari 的记号：\n$$ p_i = e^{x_i - A(x)}, \\quad A(x) = \\log \\sum_j e^{x_j} $$这里 $\\mathbf{x}$ 是自然参数（Natural Parameters），$\\mathbf{p}$ 是期望参数（Expectation Parameters），$A(x)$ 是对数配分函数。$p = \\nabla A(x)$ 就是 softmax。这里的“指数”来自 $e^{x_i}$；黎曼几何里的指数映射是另一个概念，两者只是重名。\n指数族写成上面的形式后，Fisher 度量有一个现成的表达式。它是 $A$ 的 Hessian：\n$$ g_{ij}(x) = \\frac{\\partial^2 A}{\\partial x_i \\partial x_j} = p_i \\delta_{ij} - p_i p_j $$换到概率单纯形的期望参数 $\\mathbf{p}$ 后，切向量要满足 $\\sum_i u_i = 0$。在这个子空间上，度量为：\n$$ ds^2 = \\sum_i \\frac{(dp_i)^2}{p_i} $$第一种写法里，全 1 方向的长度为 0：把 $\\mathbf{x}$ 整体加一个常数，$p$ 不变，所以这个方向是度量的零方向。去掉这个零方向后，Fisher 度量在单纯形上正定。这也解释了为什么 softmax 可以任意选择 $m$：$m$ 只是自然参数坐标的一个原点，换原点不改变分布。\n在参考点 $\\mathbf{p}^{(0)}$ 附近，$g_{ij}$ 可以近似为常数矩阵 $p_i^{(0)} \\delta_{ij} - p_i^{(0)} p_j^{(0)}$。对切向量 $\\mathbf{u}$、$\\mathbf{v}$，局部内积写成协方差：\n$$ \\langle \\mathbf{u}, \\mathbf{v} \\rangle_{\\mathbf{p}^{(0)}} = \\sum_i p_i^{(0)} (u_i - \\bar u)(v_i - \\bar v), \\quad \\bar u = \\sum_i p_i^{(0)} u_i, \\quad \\bar v = \\sum_i p_i^{(0)} v_i $$一个容易写错的近似是 $\\sum_i p_i^{(0)} u_i v_i$。它少了中心化项，也丢掉了 softmax 的平移不变性；把它当成 Fisher 度量，后面所有“平行移动”的推导都会跟着偏。局部欧几里得化的准确版本是上面的协方差形式：在参考点附近，度量近似为常数，但作用在去掉了均值方向的切空间上。\n指数族还有一层对偶结构。$A(x)$ 的对偶势是 $\\sum_i p_i \\log p_i = -H(\\mathbf{p})$，$p = \\nabla A(x)$ 给出自然参数到期望参数的坐标变换。Online Softmax 的 rescaling 可以放在这套对偶坐标里读：$m$ 是自然参数的原点，换 $m$ 相当于沿全 1 方向平移；这个方向在 Fisher 度量下长度为 0，所以旧块的相对概率不变，变的是未归一化权重的整体尺度 $d$。\n在对偶平坦结构里，这次换原点可以读成沿全 1 方向的平行移动：自然参数空间是平的，$m$ 只是原点，平移方向落在 Fisher 度量的零方向上，所以旧块的相对概率不变。严格说，移动的是统计量的表示，分布本身没有被搬动；把它理解成规范变换（gauge transformation）比理解成在单纯形上运输概率向量更准确。$d$ 按 $e^{m_{\\text{old}} - m_{\\text{new}}}$ 缩放，这个图像能帮你记住 rescaling 因子的形状；真正改变分布的是加入新块。\n指数因子的来源也可以从同一处看：未归一化权重是 $e^{x_i}$，给 $\\mathbf{x}$ 加一个常数 $\\Delta$，每个权重都乘 $e^\\Delta$。这是指数族的结构，不是某个 kernel 实现的选择。Fisher 度量、对偶势和 rescaling 三者能对上，是因为它们描述的是同一组对偶坐标。\n5. 输出累加：FlashAttention 真正省下的是什么 #Softmax 的归一化解决了，输出 $\\mathbf{O}$ 也可以增量更新。对于第 $i$ 个 Query，输出是：\n$$ \\mathbf{o}_i = \\sum_{j=1}^{N} A_{ij} \\mathbf{v}_j = \\sum_{j=1}^{N} \\frac{e^{S_{ij} - m_i}}{d_i} \\mathbf{v}_j $$FlashAttention 为每个 Query 维护三个运行量：当前看到的最大分数 $m$、当前指数和 $d$、当前累加的输出 $\\mathbf{o}$。每来一个新的 KV 块 $(\\mathbf{K}^{(b)}, \\mathbf{V}^{(b)})$，先算分数，再更新 $m$，然后对旧的输出做 rescale，最后把新块的贡献加进去：\n计算分数: S_i,b = Q_i @ K_b^T m_new = max(m, max(S_i,b)) # 对旧的输出 rescale o = o * (d * exp(m - m_new)) / (d * exp(m - m_new) + sum(exp(S_i,b - m_new))) + sum(exp(S_i,b - m_new)[:, None] * V_b) / d_new d = d * exp(m - m_new) + sum(exp(S_i,b - m_new)) m = m_new 把代码里的三行更新整理成一条公式，分子和分母的关系会更清楚。旧输出、旧 $d$ 和新块各自扮演什么角色，一眼能看出来：\n$$ \\mathbf{o}_{\\text{new}} = \\frac{\\mathbf{o}_{\\text{old}} \\cdot d_{\\text{old}} \\cdot e^{m_{\\text{old}} - m_{\\text{new}}} + \\sum_j e^{S_{ij} - m_{\\text{new}}} \\mathbf{v}_j}{d_{\\text{new}}} $$分子是未归一化的加权和，分母是新的归一化常数。旧输出带着旧的 $d$ 和旧的 $m$，换到新原点后乘以 $e^{m_{\\text{old}} - m_{\\text{new}}}$；新块的项也按新原点计算；两者相加再除以 $d_{\\text{new}}$，比值不变。这就是“先 rescale 再加”的全部机制。\nFlashAttention 的收益在显存和 HBM 往返；$N^2$ 的计算量并没有变成 $N$。传统实现要物化 $\\mathbf{S}$ 和 $\\mathbf{A}$，显存是 $O(N^2)$；FlashAttention 不存这两个矩阵，显存从 $O(N^2)$ 降到 $O(Nd)$：输出 $\\mathbf{O}$ 是 $N \\times d$，统计量是 $N$，$d$ 固定时记作 $O(N)$。按 FlashAttention 论文的 IO 复杂度记号，HBM 访问量从标准实现的 $\\Theta(N^2 d + N d^2)$ 降到 $\\Theta(N^2 d^2 / M)$，$M$ 是 SRAM 容量；计算量仍然是 $O(N^2 d)$。反向传播还要重算 $\\mathbf{S}$，所以训练时的 FLOPs 可能比前向更多。收益的边界在 IO：当 $N$ 小到 $\\mathbf{S}$、$\\mathbf{A}$ 能放进 SRAM，或者 HBM 带宽不是瓶颈时，FlashAttention 的优势会缩小。\n“精确”也要限定范围。数学上，Online Softmax 和标准 Softmax 完全等价，没有近似；浮点上，分块的 rescale 顺序、bf16 的舍入、以及和 PyTorch 参考实现的 reduction order 不同，结果不会逐位相同。反向传播里的重计算会再次引入这些舍入差异。要验证一个实现，应该同时看数值误差和 HBM/SRAM 的占用，不要只看 attention 的 wall time。\n相关材料里，Dao 等人的 FlashAttention（NeurIPS 2022）给出了 IO 复杂度和 kernel 设计；Milakov 与 Gimelshein 的 “Online normalizer calculation for softmax”（arXiv:1805.02867）是 online softmax 的早期来源。Amari 的 Information Geometry and Its Applications（Springer, 2016）和 Martens 的 “New Insights and Perspectives on the Natural Gradient Method”（JMLR 2020）则覆盖了指数族的 Fisher 度量与对偶结构。\n","date":"2025年1月20日","permalink":"https://doraemeng.dev/notes/online-softmax-information-geometry/","section":"笔记","summary":"Online Softmax推导：FlashAttention分块计算的核心数学——不存储完整N×N注意力矩阵，只靠局部最大值m和指数和d两个统计量递推合并出全局Softmax，结果与传统 Softmax 精确一致，差异只来自浮点舍入。附Python验证，并从信息几何视角解释rescaling本质是概率单纯形上沿测地线的平行移动。","title":"Online Softmax 的数学：从代数推导到信息几何"},{"content":"用 1000 个样本按 8:2 切分、5 个特征跑 2000 轮批量梯度下降，测试集准确率 95.50%，最终交叉熵 0.127384。这个结果不算惊艳，但它把逻辑回归的权重更新公式完整走了一遍：从 Sigmoid 和交叉熵出发，链式法则求导，最后落到 $\\mathbf{w} \\leftarrow \\mathbf{w} - \\eta \\mathbf{X}^\\top (\\mathbf{p} - \\mathbf{y})/N$。下面把每一步拆开，重点解释为什么梯度会简化成（预测概率−真实标签）×输入特征。\n1. 模型定义 #逻辑回归名字里有回归，输出却是二分类概率。给定输入 $\\mathbf{x} \\in \\mathbb{R}^d$ 和权重 $\\mathbf{w} \\in \\mathbb{R}^d$（包含偏置 $b$），模型输出\n$$ p(\\hat{y}=1 \\mid \\mathbf{x}) = \\sigma(\\mathbf{w}^\\top \\mathbf{x}) = \\frac{1}{1 + e^{-\\mathbf{w}^\\top \\mathbf{x}}} $$其中 $\\sigma(z)$ 是 Sigmoid 函数，它把实数压到 0 到 1 之间，输出可以直接当概率用：\n$$ \\sigma(z) = \\frac{1}{1 + e^{-z}} $$它的导数有一个很实用的性质：\n$$ \\frac{d\\sigma(z)}{dz} = \\sigma(z) \\cdot (1 - \\sigma(z)) $$这个性质会在后面的梯度推导中把交叉熵的分母消掉。\n2. 损失函数：为什么用交叉熵 #对于单个样本 $(\\mathbf{x}^{(i)}, y^{(i)})$，其中 $y^{(i)} \\in \\{0, 1\\}$，希望模型输出的概率 $p^{(i)} = \\sigma(\\mathbf{w}^\\top \\mathbf{x}^{(i)})$ 尽可能接近真实标签 $y^{(i)}$。交叉熵损失定义为\n$$ \\mathcal{L}^{(i)}(\\mathbf{w}) = -\\left[ y^{(i)} \\log p^{(i)} + (1 - y^{(i)}) \\log(1 - p^{(i)}) \\right] $$训练时最小化所有样本的平均损失，而不是单个样本的损失：\n$$ \\mathcal{L}(\\mathbf{w}) = -\\frac{1}{N} \\sum_{i=1}^{N} \\left[ y^{(i)} \\log p^{(i)} + (1 - y^{(i)}) \\log(1 - p^{(i)}) \\right] $$用 MSE 配合 Sigmoid 时，梯度在两端饱和区会变得极小：$p$ 接近 0 或 1 时，$\\sigma'(z)=p(1-p)$ 接近 0，误差再大也传不回去。交叉熵对 $p$ 的导数带 $1/[p(1-p)]$，正好和 Sigmoid 的导数抵消，这是它成为标准选择的机制。\n3. 核心推导：梯度从哪里来 #目标是最小化 $\\mathcal{L}(\\mathbf{w})$，梯度下降需要知道损失函数对每个权重 $w_j$ 的偏导数。令 $z^{(i)} = \\mathbf{w}^\\top \\mathbf{x}^{(i)}$，则 $p^{(i)} = \\sigma(z^{(i)})$。链式法则展开：\n$$ \\frac{\\partial \\mathcal{L}^{(i)}}{\\partial w_j} = \\frac{\\partial \\mathcal{L}^{(i)}}{\\partial p^{(i)}} \\cdot \\frac{\\partial p^{(i)}}{\\partial z^{(i)}} \\cdot \\frac{\\partial z^{(i)}}{\\partial w_j} $$第一项对 $p^{(i)}$ 求导：\n$$ \\frac{\\partial \\mathcal{L}^{(i)}}{\\partial p^{(i)}} = -\\left[ \\frac{y^{(i)}}{p^{(i)}} - \\frac{1 - y^{(i)}}{1 - p^{(i)}} \\right] = \\frac{p^{(i)} - y^{(i)}}{p^{(i)}(1 - p^{(i)})} $$第二项用 Sigmoid 的导数性质：\n$$ \\frac{\\partial p^{(i)}}{\\partial z^{(i)}} = \\sigma(z^{(i)})(1 - \\sigma(z^{(i)})) = p^{(i)}(1 - p^{(i)}) $$第三项对权重求导：\n$$ \\frac{\\partial z^{(i)}}{\\partial w_j} = x_j^{(i)} $$三项相乘，$p^{(i)}(1-p^{(i)})$ 消掉：\n$$ \\frac{\\partial \\mathcal{L}^{(i)}}{\\partial w_j} = \\frac{p^{(i)} - y^{(i)}}{\\cancel{p^{(i)}(1 - p^{(i)})}} \\cdot \\cancel{p^{(i)}(1 - p^{(i)})} \\cdot x_j^{(i)} = (p^{(i)} - y^{(i)}) \\cdot x_j^{(i)} $$这个抵消来自交叉熵里 $1/[p(1-p)]$ 的因子和 Sigmoid 导数的乘积，两项本来就是配套设计的。对所有 $N$ 个样本取平均，得到\n$$ \\frac{\\partial \\mathcal{L}}{\\partial w_j} = \\frac{1}{N} \\sum_{i=1}^{N} (p^{(i)} - y^{(i)}) \\cdot x_j^{(i)} $$把所有样本的梯度堆成一个向量，就能用一次矩阵乘法算完：\n$$ \\nabla_{\\mathbf{w}} \\mathcal{L} = \\frac{1}{N} \\mathbf{X}^\\top (\\mathbf{p} - \\mathbf{y}) $$其中 $\\mathbf{X} \\in \\mathbb{R}^{N \\times d}$ 是设计矩阵，$\\mathbf{p} \\in \\mathbb{R}^{N}$ 是所有样本的预测概率，$\\mathbf{y} \\in \\mathbb{R}^{N}$ 是真实标签。\n4. 权重更新公式 #有了梯度，权重就沿着负梯度方向走一步，步长由学习率控制：\n$$ \\mathbf{w} \\leftarrow \\mathbf{w} - \\eta \\cdot \\nabla_{\\mathbf{w}} \\mathcal{L} = \\mathbf{w} - \\frac{\\eta}{N} \\mathbf{X}^\\top (\\mathbf{p} - \\mathbf{y}) $$这是批量梯度下降，每次用全部 $N$ 个样本。随机梯度下降每次只用一个样本 $(\\mathbf{x}^{(i)}, y^{(i)})$：\n$$ \\mathbf{w} \\leftarrow \\mathbf{w} - \\eta \\cdot (p^{(i)} - y^{(i)}) \\cdot \\mathbf{x}^{(i)} $$小批量梯度下降每次用 $B$ 个样本（$B \\ll N$）：\n$$ \\mathbf{w} \\leftarrow \\mathbf{w} - \\frac{\\eta}{B} \\sum_{i \\in \\mathcal{B}} (p^{(i)} - y^{(i)}) \\cdot \\mathbf{x}^{(i)} $$三者的区别只在每次用多少样本估计梯度。直观上，如果模型预测 $p^{(i)}$ 比真实标签 $y^{(i)}$ 大（预测过头了），梯度为正，权重往减小方向走；如果预测小了，梯度为负，权重往增大方向走。更新的幅度同时受学习率 $\\eta$ 和输入特征 $x_j^{(i)}$ 的尺度影响。\n5. 代码实现 #下面是一个从零实现的 NumPy 版本，没有调用 sklearn，每一步都对应上面的公式。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 import numpy as np class LogisticRegressionGD: def __init__(self, lr=0.1, n_iter=1000, fit_intercept=True): self.lr = lr # 学习率 η self.n_iter = n_iter # 迭代轮数 self.fit_intercept = fit_intercept self.w = None # 权重向量 self.loss_history = [] def _sigmoid(self, z): \u0026#34;\u0026#34;\u0026#34;Sigmoid: σ(z) = 1 / (1 + exp(-z))\u0026#34;\u0026#34;\u0026#34; return 1 / (1 + np.exp(-np.clip(z, -500, 500))) def fit(self, X, y): \u0026#34;\u0026#34;\u0026#34; X: (N, d) y: (N,) \u0026#34;\u0026#34;\u0026#34; if self.fit_intercept: # 添加一列 1 作为偏置项 X = np.c_[np.ones(X.shape[0]), X] N, d = X.shape self.w = np.zeros(d) for epoch in range(self.n_iter): # 前向传播：z = X @ w, p = σ(z) z = X @ self.w p = self._sigmoid(z) # 计算交叉熵损失 loss = -np.mean( y * np.log(p + 1e-15) + (1 - y) * np.log(1 - p + 1e-15) ) self.loss_history.append(loss) # 计算梯度: ∇L = (1/N) * X^T @ (p - y) grad = (X.T @ (p - y)) / N # 权重更新: w = w - η * ∇L self.w -= self.lr * grad return self def predict_proba(self, X): if self.fit_intercept: X = np.c_[np.ones(X.shape[0]), X] return self._sigmoid(X @ self.w) def predict(self, X): return (self.predict_proba(X) \u0026gt;= 0.5).astype(int) # ========== 验证 ========== from sklearn.datasets import make_classification from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # 构造二分类数据 X, y = make_classification( n_samples=1000, n_features=5, n_informative=3, n_redundant=0, n_classes=2, random_state=42 ) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) # 训练 model = LogisticRegressionGD(lr=0.5, n_iter=2000) model.fit(X_train, y_train) # 评估 y_pred = model.predict(X_test) print(f\u0026#34;Accuracy: {accuracy_score(y_test, y_pred):.4f}\u0026#34;) print(f\u0026#34;Final loss: {model.loss_history[-1]:.6f}\u0026#34;) # 查看损失下降曲线 import matplotlib.pyplot as plt plt.figure(figsize=(8, 4)) plt.plot(model.loss_history) plt.xlabel(\u0026#39;Iteration\u0026#39;) plt.ylabel(\u0026#39;Cross-Entropy Loss\u0026#39;) plt.title(\u0026#39;Loss Curve during Gradient Descent\u0026#39;) plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(\u0026#39;loss_curve.png\u0026#39;, dpi=150) plt.show() 在 2000 轮、学习率 0.5 的设置下，输出如下：\nAccuracy: 0.9550 Final loss: 0.127384 6. 与线性回归的对比 #线性回归和逻辑回归的梯度形式几乎一样：都可以写成（预测−真实）经过设计矩阵转置的形式。差异在预测的语义：线性回归输出连续值 $\\hat{y} = \\mathbf{w}^\\top \\mathbf{x}$，用 MSE，梯度是 $\\frac{1}{N}\\mathbf{X}^\\top (\\hat{\\mathbf{y}} - \\mathbf{y})$；逻辑回归输出概率 $p = \\sigma(\\mathbf{w}^\\top \\mathbf{x})$，用交叉熵，梯度是 $\\frac{1}{N}\\mathbf{X}^\\top (\\mathbf{p} - \\mathbf{y})$。两者的权重更新都是 $\\mathbf{w} - \\eta \\nabla \\mathcal{L}$，换的只是损失和输出层。\n7. 调试经验：梯度检查 #手写梯度时，用中心差分做数值检查：对每个 $w_j$，分别算 $w_j \\pm \\epsilon$ 处的 loss，除以 $2\\epsilon$，再和解析梯度比。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 def numerical_gradient(X, y, w, eps=1e-5): \u0026#34;\u0026#34;\u0026#34;用有限差分近似梯度\u0026#34;\u0026#34;\u0026#34; grad = np.zeros_like(w) for j in range(len(w)): w_plus = w.copy() w_plus[j] += eps w_minus = w.copy() w_minus[j] -= eps # 分别在 w+ε 和 w-ε 处计算损失 p_plus = sigmoid(X @ w_plus) loss_plus = -np.mean(y * np.log(p_plus) + (1-y) * np.log(1-p_plus)) p_minus = sigmoid(X @ w_minus) loss_minus = -np.mean(y * np.log(p_minus) + (1-y) * np.log(1-p_minus)) grad[j] = (loss_plus - loss_minus) / (2 * eps) return grad # 验证：解析梯度与数值梯度应该非常接近 analytical = (X.T @ (p - y)) / N numerical = numerical_gradient(X, y, w) print(f\u0026#34;Max diff: {np.max(np.abs(analytical - numerical)):.8f}\u0026#34;) # 期望输出: Max diff \u0026lt; 1e-6 这段检查代码是从训练脚本里摘出来的，依赖训练结束后的 X、y、w、p 和 N，不能单独运行。sigmoid 在前面的实现里是类方法，这里要补一个全局函数；X 在 fit 内部加过偏置列，外层变量没有，直接照抄会因维度不一致报错，补一个带偏置的 X_aug 才能跑。$\\epsilon$ 取 1e-5 时，期望最大误差小于 1e-6。这个检查每轮多花 $2d$ 次前向；$d=5$ 时值得，$d$ 到百万级时只抽几个维度做。\n8. 这套推导的适用边界 #整套推导只依赖两个事实：Sigmoid 的导数是 $p(1-p)$，交叉熵对概率的导数是 $(p-y)/[p(1-p)]$。两者相乘后，权重更新的每一步就是误差乘特征。这个形式也解释了为什么特征尺度重要：$x_j$ 大一个数量级，同样的 $\\eta$ 会让对应权重的实际步长大一个数量级，训练前先标准化。特征没标准化时，梯度检查仍会通过，但收敛会慢甚至震荡；公式没问题，问题在尺度和学习率的匹配。\n","date":"2025年1月15日","permalink":"https://doraemeng.dev/notes/logistic-regression-gradient-descent/","section":"笔记","summary":"逻辑回归梯度下降推导：从Sigmoid函数和交叉熵损失出发，用链式法则完整推出权重更新公式，解释梯度为何能简化为（预测概率−真实标签）×输入特征；对比批量、随机、小批量三种更新方式，附NumPy从零实现和数值梯度验证，测试集准确率95.5%。","title":"逻辑回归权重更新：从交叉熵到梯度下降的完整推导"},{"content":" 原文作者：张翼轸，发表于少数派 Matrix 栏目。本文是读者整理转载，用于记录这套极具参考价值的语音输入 + 大模型润色工作流。\n我对效率有着近乎偏执的追求，尤其是在写作方面。此前我曾提及，为提升打字速度，2016 年，即我 35 岁之际，我毅然放弃了当时已颇为熟练的全拼输入法，转而学习小鹤双拼。\n虽然最初三个月颇为烧脑，但之后输入速度显著提升，一分钟 100 字已不在话下。\n近期，我开始尝试使用语音输入撰写稿件——进一步提升速度。\n为什么很多年我都不用语音输入 #众所周知，人的语速极快，正常情况下一分钟可达 250 至 300 字，这意味着即便我双拼打字再快，也无法与语音输入相媲美。尽管我深知语音输入的优点，但多年来一直处于观察状态，未曾实际应用。\n对于语音输入的体验可以追溯到 2000 年之前，可能是 1997 或 1998 年。早在那时，IBM 已在 Windows 平台上推出了一款专门的中文语音输入法。当时我对各种新技术充满好奇，因此第一时间下载并安装使用。\n在那个时代，使用 IBM 的语音输入系统，用户必须按照软件的指示朗读约 30 分钟的常用句子，以此为基础进行声音识别和语音输入。当时的技术条件与现今相比，无疑是天壤之别。尽管 IBM 的语音输入软件在识别准确率上表现尚可，但由于我个人的口头表达能力有限，其生成的文本往往带有浓厚的口语化特征，需要大量润色才能达到书面语的标准，因此整体效率并不理想。\n在数年之后，我得知香港科幻作家倪匡竟已采用语音输入法长期创作小说，对此我深感敬佩。看来倪匡的口头表达能力相当强，令人叹为观止。尽管当时 IBM 的语音输入技术仅是浅尝辄止，但我始终关注各类语音输入的体验，包括各种输入法内置的功能。然而，这些技术始终面临一个问题：过于口语化的表达，需经过大量修改方能使用。\n大模型的破局 #语音输入法在日常聊天中输入短句尚可，但用于撰写文章则显得不够可靠。然而，随着 2022 年末 ChatGPT 等大模型的问世，这一局面发生了根本性变化。这些大模型能够对文本这类非结构化数据进行深度处理，即使我以口语化方式表达，大模型也能通过规则将其转化为适合书面语的文本。因此，我开始思考如何将语音输入融入我的写作流程。\n当然，当时还面临另一个问题，即我主要撰写 A 股基金等细分财经领域的内容，即便当时讯飞听见这类带有金融主题的语音输入工具，仍难以准确处理我常用的专业表达。\n对于 A 股投资者而言，万得全 A 指数是一个至关重要的基准指数。然而，通过语音输入法输入该指数时，可能会出现「万德权威」这样的错误表述，导致信息失真。\n在财经投资领域，专用语料和表达词汇的使用至关重要。对于我这样需要频繁使用专业术语的细分领域从业者来说，普通的输入工具往往难以满足需求。\n一个多月前，我阅读了王树义老师的一篇分享，其中探讨了如何利用大模型对传统语音输入生成的文字进行二次纠错。这让我意识到，仅仅让大模型执行通用化的规则校正，实际上是对其智能的浪费。更好的方法是将个人化的要求一并提交给大模型，由其进行精准纠错。\n我的语音输入写稿前置流程 #1. 语音录制：讯飞听见 #我使用讯飞听见这款软件进行语音输入。之前我也尝试过其他语音输入法，例如微信输入法，其语音识别能力确实很强，甚至我认为比通用版的讯飞听见还要强。但最终，我在双 11 期间花费 158 元购买了讯飞听见的一年订阅，每月享有 30 小时的 APP 语音输入权限。原因有三：\n录音留存：讯飞听见的 APP 在语音输入时，能够将整个过程的音频录制下来。这意味着，除了文字，音频本身还可以用于其他用途，同时也能规避因网络不佳而在地铁等环境中无法进行语音输入的问题。 领域选择：讯飞听见可以选择不同的内容类别，例如我经常选择金融类别，这样它会结合金融体系进行初步的过滤和纠错，一些常见术语，如沪深 300 指数，它都能准确识别，这为后续工作省去了不少麻烦。 在经过讯飞听见的语音处理后，我获得了一份初步符合基本书面表达的文本。尽管对于普通读者来说，这份文本可能已经足够使用，但我仍将根据下面的流程对其进行进一步处理。\n2. 大模型润色：提示词 + 自定义词表 #首先，我设定了文体限制，旨在将文字细化为专业的财经专栏文章风格。经常阅读财经类，尤其是股票类文章的读者会注意到，这类文章在风格上具有一定的特殊性。\n在文字润色方面，我选择将任务交给大模型处理。大模型可以有效规避口语化表达的不足，使整体文字更贴合书面语规范。\n当然，真正让它加速的，其实是自定义常用词表。这个表中包含了许多我经常使用的术语，如「9·24」行情、「20cm」，以及「基民」这类在投资圈常见但对大多数语音软件来说陌生的词汇。类似的还有我自己创立的概念，如「五年之锚」和「40 日收益差」。\n在研究过程中，我深刻体会到大型模型在文本处理方面的强大能力。除了日常用于撰写财经类稿件，我最近还利用大模型记录我家孩子的成长日记。短短十几天，已积累了上万字的内容。在这个过程中，我甚至在常用词表中加入了背景信息，如孩子的名字和性别，以及她是小学生的身份。这样，大模型在处理文本时，能够自动结合这些信息进行性别和身份的调整。当我聊到我家女儿时，大模型会自动用「她」而不是默认的「他」来表述。\n3. 进阶技巧：词性标注解决同音词歧义 #在语音转写过程中，我设定了更多词汇属性有助于系统更准确地识别同音词。例如，我曾进行过一项测试，设置了两个发音完全相同的地名：一个是红中心（医院），另一个是虹中心（小学）。用括号来对词性进行标记。当我输入「送女儿去红中心上学，再送太太去红中心体检」时，大模型会根据这些词汇的备注，自动选择正确的地点。送女儿去的是小学的虹中心，而送太太去的是医院的红中心。通过进行词性标注，大模型的效果显著提升。\n工作流整合 #为了进一步提升工作效率，我并未采用传统的大模型对话界面，而是利用当下热门的大模型编程软件 Windsurf，将整个工作流程整合至一个 Web 小界面。在这个界面中，我可以自由选择各类模型、提示词和常用词表。\n在语音转写及稿件修正过程中，我较多使用国产的 DeepSeek 模型。该模型由上海一家量化私募公司幻方打造，其在国内开源模型中表现优异，既稳健又经济实惠。通过 API 调用，每百万次仅需两元，几乎等同于免费使用。我在一个多月前充值了 10 元，至今仅花费不到 1 元，使用体验极为经济。\n为了应对不同的需求，我设置了不同的提示词：\n「语音润色财经」：专为撰写财经稿件设计，输出结果书面化； 「语音润色生活」：较为口语化，用于记录我女儿的成长日记。 在撰写稿件时，设定不同的常用词表可以针对不同文本范围进行输出。例如，在撰写财经稿件时，配置财经领域的常用词汇；而在撰写关于女儿的文章时，则使用生活领域的常用词汇。此外，根据不同场合的需求，也可以灵活应用相应的词表。通过这种方式，整个写作过程的效率将显著提高。\n效率提升的量化结果 #在撰写一篇 1500 字左右的稿件时，我通常会花费五六分钟进行语音录制，随后通过大模型处理配图。我曾计算过，在常态情况下，即使撰写一篇 1500 字的较为复杂的稿件，包括使用 AI 绘制封面图和排版，整个过程也能在半小时内完成。这一流程极大地提升了我的生产效率。\n在追求效率的过程中，我发现通过减少时间投入来完成相同的工作量，能够腾出更多时间用于其他活动，如陪伴家人、观看有趣的视频或阅读相关书籍，这种体验颇具价值。\n如果你对语音输入写稿感兴趣，可以参考我的方法，并调试出更适合你的工作流。\nPS： 本文从语音输入到配图完成，耗时大概 45 分钟。\n","date":"2024年12月16日","permalink":"https://doraemeng.dev/notes/voice-input-writing-workflow/","section":"笔记","summary":"语音输入写作工作流实战：用讯飞听见录音转写，再用 DeepSeek 大模型按提示词和自定义词表润色，词性标注解决财经术语与同音词歧义，并用 Windsurf 搭建整合界面。1500 字稿件从录音到配图排版半小时内完成，写作速度翻倍。","title":"效率狂魔的自白：语音输入让我写作速度翻倍"},{"content":"530B 参数按 FP16 存，光权重就是 530 × 2 bytes ≈ 1.06 TB；一张 A100 只有 80GB，至少 14 张卡才够放权重。训练状态按 20 bytes/param 算，530B × 20B ≈ 10.6 TB，相当于 133 张 A100 的显存只用来放参数、梯度和优化器状态，激活值还没开始算。MT-NLG 的论文要回答的就是：怎么用 560 台 DGX A100、4480 张 GPU 把这笔账平掉。\n一、20 字节定律：先把显存账算清楚 #混合精度训练的显存开销可以按参数逐项摊开。参数本身用 FP16 存，2 bytes；反向传播产生的梯度也用 FP16 存，2 bytes；Adam 优化器要保留一份 FP32 master weight 做更新，4 bytes；一阶矩 momentum 和二阶矩 variance 各 4 bytes；再加一份 FP32 的梯度副本用于累加，4 bytes。六项加起来是 20 bytes，这就是论文里“training consumes 20 bytes of memory per parameter”的来历。\n原文在拆 Adam 状态时把 16 bytes 写成“含 5 个子项”，但表格只列了 4 项，正文用一句话提到剩下的 4 bytes 可能是 FP32 梯度副本或内存碎片。把 FP32 梯度副本明确列出来，账就对上了：2 + 2 + 4 + 4 + 4 + 4 = 20。这个细节不影响结论，但做容量规划时不能漏，漏一项就是 530B × 4 bytes ≈ 2.1 TB 的误差。\n把 530B 代进去，仅模型状态就需要 10.6 TB。这个数字还没算激活值，也没算通信缓冲。\n530 x 20 B ≈ 10.6 TB 激活值是另一笔账。前向传播要保存每一层 Attention 和 MLP 的输出，反向传播才能算梯度；对 Transformer 来说，这部分内存大致随层数、batch、序列长度和 hidden 维度线性增长。MT-NLG 的序列长度是 2048，530B 模型的层数和宽度又都很大，激活值不可能按原样全存。\nO(Layers x BatchSize x SeqLen x HiddenSize) 激活重计算的做法是只存每个 Transformer 层的输入，反向传播需要中间激活时再跑一次前向。代价是计算量增加约 33%：原来一次前向加一次反向，现在多了一次前向；显存占用可以从 O(N) 降到 O(sqrt(N)) 或常数级，取决于每隔几层存一个检查点。对 530B 这个量级，激活重计算是开训的前提；没有它，显存根本不够。\n数据并行也救不了显存。纯数据并行要求每张卡都放一份完整模型和优化器状态，4480 张卡就是 4480 份副本；而且全球 batch size 会随卡数线性膨胀，MT-NLG 的 global batch 是 1920，再往上加会碰到收敛问题。ZeRO 的思路是把优化器状态、梯度和参数按数据并行组切开，每张卡只负责一部分，需要时再通过通信拼回来；ZeRO-1 切优化器状态，ZeRO-2 再切梯度，ZeRO-3 连参数一起切。MT-NLG 把 ZeRO 和 Megatron 的张量并行、流水线并行叠在一起，才把单卡放不下的模型拆成了可以跨节点运行的形状。\n二、3D 并行：把 4480 张卡排成一台机器 #张量并行解决单层矩阵乘法放不下的问题。Megatron-LM 把 Y = XW 按列或按行切开：列并行把 W 切成 [W1, W2]，输入 X 复制到两张卡，各自算 XW1 和 XW2；行并行把 W 按行切，输入 X 也按列切，最后用一次 All-Reduce 把 X1W1 + X2W2 加起来。Attention 层用列并行、MLP 层用行并行，中间不需要通信，只在层末做一次 All-Reduce。\n张量并行的通信量很大，每次 All-Reduce 都要同步所有参与卡的数据，所以它被限制在单机 NVLink 域内。MT-NLG 用 8 路张量并行，正好是一个 DGX A100 节点的 8 张 GPU；跨机走 InfiniBand，带宽和延迟都掉一档，TP 开到 8 以上不划算。\n流水线并行解决层数放不下的问题。MT-NLG 用 35 路流水线，把 105 层切成 35 个 stage，每个 stage 3 层，stage 之间只传边界处的 hidden states，通信量比张量并行小得多，可以跨机走 InfiniBand。调度上用 1F1B：每个 GPU 先做若干个 micro-batch 的前向，进入稳定状态后交替做一次前向、一次反向，让反向的梯度计算尽快释放激活值。GPipe 那种“先灌完所有前向、再做所有反向”的做法要缓存 n 个 micro-batch 的激活，显存峰值高；1F1B 把在飞的 micro-batch 数量压到流水线深度附近，显存峰值和 stage 数解耦。\n流水线有气泡。启动阶段部分 GPU 在等前一个 stage 的数据，结束阶段部分 GPU 在等反向，只有中间一段是所有 stage 都在干活。气泡比例由 stage 数和 micro-batch 数决定，可以用下面这个式子估算：\nEfficiency ≈ 1 / (1 + (PP-1)/MB) PP 是流水线阶段数，MB 是 micro-batch 数。要让效率接近 1，MB 必须远大于 PP；MT-NLG 的 PP 是 35，global batch 1920 要切成足够多的 micro-batch，才能把气泡压下去。DeepSpeed 还支持交错式 1F1B，让一个 GPU 负责不连续的几个 stage，进一步减少气泡，代价是通信模式更复杂。\nGPU1 做 F1 -\u0026gt; 传给 GPU2 GPU1 做 F2 -\u0026gt; GPU2 做 F1 GPU2 做 B1 数据并行放在最外层，复制 16 份模型实例。每个实例由 8 路 TP 乘 35 路 PP 组成，占 280 张卡；16 个实例乘 280，正好 4480 张。拓扑感知映射把通信量大的组放在同一节点内：TP 组占满 8 卡 NVLink 域，PP 和 DP 跨节点走 HDR InfiniBand。Selene 的胖树拓扑给每个节点配了 8 块 200Gbps HDR HCA，也就是每张 GPU 200Gbps；原文笼统写成“节点间 200Gbps”，容易被误读成整个节点只有一条 200Gbps 链路。\n这样切分之后，DP 组的梯度 All-Reduce 只传自己那份参数对应的梯度，通信量是完整模型的 1 / (TP x PP)。这就是 3D 并行能扩展到数千张卡的算术基础：TP 把单层拆开，PP 把层拆开，DP 复制剩下的部分，每一层的通信都落在合适的网络域里。\n1 / (TP x PP) 三、稳定性：BF16、初始化和 beta_2 #MT-NLG 用 BF16 做混合精度，这个选择有明确的数值原因。FP16 的指数位只有 5 位，尾数 10 位，动态范围小，训练中容易出现上溢成 Inf 或下溢成 0，通常要靠 loss scaling 把梯度放大再缩回来。BF16 的指数位 8 位，和 FP32 一样，尾数只有 7 位；精度低一些，但动态范围大，530B 这种规模的训练更不容易因为数值越界而发散。A100 对 BF16 有硬件支持，这也是 Selene 上能直接开 BF16 的前提。\n权重初始化也做了针对性处理。论文给的标准差是 4.0e-3，并提到用 sqrt(1/(3H)) 作为初始化尺度；H 是 hidden 维度 20480，代进去大约是 4.03e-3，两者对得上。深层 Transformer 的激活方差会随层数累积，初始化方差偏大会让前几层的激活迅速放大；这个尺度把初始激活压在合理范围内，减少训练早期的 loss spike。\n优化器用 Adam，β1 = 0.9、β2 = 0.95、ε = 1e-8。β2 从常见的 0.99 下调到 0.95，二阶矩的指数移动平均窗口变短，优化器对近期梯度的方差更敏感。训练数据里突然出现一段脏样本、梯度分布突变时，β2 小的优化器能更快忘掉旧的方差估计，步长不会因为陈旧统计量而突然放大。论文把这条列为减少 loss spike 的手段；它不能替代梯度裁剪和数据清洗，但在 530B 这个量级上，任何能减少一次发散重启的配置都值得试。原文没有给出训练期间实际发生了多少次 spike、每次重启要多久 [待补：530B 训练中的 loss spike 次数与重启耗时]。\n四、数据工程：MinHash 去重和 n-gram 去污染 #MT-NLG 的训练集以 The Pile 为基础，挑出质量较高的子集，再加入 RealNews、CC-Stories 和经过清洗的 CommonCrawl。最终的语料混合是 339B token，实际训练用了 270B token。The Pile 本身包含 arXiv、PubMed、GitHub、Wikipedia 等来源，但论文没有照单全收，而是做了二次筛选；CommonCrawl 的数据量大、信噪比低，清洗流程才是各家真正花时间的地方。\n去重用的是 MinHash 加 LSH。直接算两两文档的 Jaccard 相似度是 O(N²)，十亿级文档算不动；MinHash 把每篇文档压成一个签名，两个集合的 MinHash 值相等的概率等于它们的 Jaccard 相似度。LSH 再把签名分段，只有至少一段完全匹配的文档才进入候选对，复杂度降到近似 O(N)。论文把阈值设在 Jaccard 相似度大于 0.8，能抓出只改了几个词的转载和洗稿，同时避免把主题相似但内容不同的文档误删。\nJ(A, B) = |A n B| / |A u B| 去污染处理的是另一种污染。训练语料里如果混进了下游任务的测试文本，模型可能靠记忆答案刷分，评测结果就不可信。论文用 n-gram 匹配把任务文档和训练文档对齐，一旦命中，就把训练文档从匹配处切开，把包含 n-gram 的片段删掉。这个做法比整篇丢弃更精细，保留了文档的其余部分；代价是切开的文档会损失局部上下文，n 的取值要在召回率和误伤之间做取舍。\n五、结果：270B token、loss 1.85 和上下文学习 #训练 10 亿 token 时，验证集交叉熵是 3.15；训练到 270B token，验证 loss 降到 1.85，困惑度大约是 e^1.85 ≈ 6.36。这个困惑度放在今天不算惊人，但它是 530B 稠密模型在 270B token 上跑出来的，而且当时还没有 Chinchilla 之后的 token 配比和长上下文方案。论文用这组曲线证明：在 175B 之后继续放大稠密模型，loss 仍然会下降，收益没有立刻消失。\nLAMBADA 上，MT-NLG 在零样本、单样本和少样本三种设置下都刷新了 SOTA，击败了 GPT-3 和 Gopher。LAMBADA 考的是长距离依赖：给一段故事，最后一个词必须从很远的上文推出来。稠密模型把 530B 参数都用上，对这种需要跨长上下文整合信息的任务有优势；MoE 虽然参数量更大，但每次只激活一部分专家，能不能在同等激活预算下达到同样的效果，是另一个问题。\nHANS 的结果更能说明上下文学习在做什么。零样本时，模型在 HANS 上只有随机水平；随着示例数量增加，准确率大幅提升。HANS 专门构造了句法启发式和真实逻辑不一致的样本，零样本表现差说明模型在预训练里学到了一堆捷径，比如靠词汇重叠判断蕴含；少样本提升说明模型能从示例里推断出“这个任务要看逻辑，不要看词重叠”，并调整推理方式。上下文学习在这里做的是任务校准：模型从示例里推断出任务规则，输出格式只是表面。\n论文还测了社会偏见。模型把 Doctor、Engineer 和男性关联，把 Nurse、Teacher 和女性关联；这些偏见来自训练数据，后处理环节还没有介入。MT-NLG 没有做 RLHF 或 SFT 对齐，论文把它作为一个没有对齐的基线公布出来，这也解释了为什么后来的部署版本都要先过一轮对齐。\n六、这套系统留下了什么 #MT-NLG 的 530B 是稠密 Transformer 时代的一个高点。它证明了 3D 并行可以把 4480 张 A100 组织成一台机器，也证明了 BF16、初始化尺度、β2 调参和梯度重计算这些细节能在超大规模下把训练稳下来。它的训练量放在今天看不大：270B token 对比 Llama 3 时代的 1T token 级别，差了将近四倍；但当时的数据配方和基础设施都没有现成答案，这篇论文的价值在于把每个坑怎么填都写清楚了。原文没有给出 4480 卡规模下的端到端吞吐和 MFU [待补：4480 卡三组并行配置的 tokens/s 与 MFU]。\n今天再看 MT-NLG，最值得抄的是 20 bytes/param 的账、TP/PP/DP 的拓扑映射，以及 β2 和数据清洗这些不性感的细节；530B 这个数字反而没那么重要。稠密模型每次推理都要算满全部参数，MoE 把激活参数降下来之后，继续堆稠密参数的经济账越来越难算。MT-NLG 之后，训练栈的演进方向转向了 MoE、更长上下文和更激进的数据配方，但显存墙、通信墙和数值稳定性这三道题，换到今天的大模型上还是要做。\n原文链接是 zhuanlan.zhihu.com/p/2005217589220102741，作者是 Lmumu。原始论文是《Using DeepSpeed and Megatron to Train Megatron-Turing NLG 530B, A Large-Scale Generative Language Model》（arXiv 2201.11990）。DeepSpeed 和 Megatron-LM 的代码分别在 github.com/microsoft/DeepSpeed 和 github.com/NVIDIA/Megatron-LM，The Pile 的数据集页面在 pile.eleuther.ai。\n","date":"2024年4月9日","permalink":"https://doraemeng.dev/notes/mt-nlg-530b-deep-dive/","section":"笔记","summary":"MT-NLG 530B训练论文精读：微软与NVIDIA如何用DeepSpeed的ZeRO和流水线并行叠加Megatron-LM的张量并行，构建3D并行体系，在560台DGX A100（4480张GPU）上训练5300亿参数的单体稠密模型。逐段拆解显存墙突破、混合精度数值稳定性、TB级语料数据清洗流水线与模型评估结论。","title":"【万字硬核】微软 \u0026 NVIDIA 联合巨作《Using DeepSpeed and Megatron to Train Megatron-Turing NLG 530B》全方位技术解析"},{"content":" 原文链接：https://zhuanlan.zhihu.com/p/2011835158685304679\n作者：与世无争的杰克 硬件要求：单张 RTX 3090 / 4090 / L20（≥ 14GB 显存）即可跑完全流程 模型：Gemma 2B | 方法：LoRA (r=16) | 框架：HuggingFace TRL + PEFT\n12 条 Q\u0026amp;A、单卡 14GB 显存、3 个 epoch、18 步、3.9 秒，loss 从 4.195 降到 0.989。这个 LoRA demo 的数字很漂亮，漂亮到容易让人跳过两个问题：14GB 是怎么省出来的，以及 0.989 的 loss 到底证明了什么。先把流程跑一遍，再回来算这两笔账。\n1. 环境与流程 #流程本身不复杂：先把 Gemma 2B 和 tokenizer 下载到本地，准备 12 条特朗普风格的 Q\u0026amp;A，然后用 TRL 的 SFTTrainer 加 PEFT 的 LoRA 训练 3 个 epoch，保存 adapter，加载并合并后推理。硬件是一张 L20、3090 或 4090，14GB 显存够用。\n机器上可能有多张卡，先用 nvidia-smi 确认驱动和显存。下面的输出里有两张 L20，本项目只用其中一张：\n1 nvidia-smi +--------------------------------------------------+ | GPU 0: NVIDIA L20 46068 MiB Driver: 580.126 | | GPU 1: NVIDIA L20 46068 MiB | +--------------------------------------------------+ 依赖装齐后再登录 Hugging Face。先安装运行库：\n1 2 3 4 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 pip install transformers accelerate datasets pip install peft trl pip install sentencepiece protobuf 这几个库的分工很直接：transformers 负责加载 Gemma 和 tokenizer，peft 负责 LoRA 配置与模型包装，trl 提供 SFTTrainer，datasets 用来构建训练集，accelerate 是 Trainer 的依赖。Gemma 需要先在 Hugging Face 页面同意许可协议，再用 token 登录并下载权重：\n1 2 3 4 5 huggingface-cli login # 输入 HF Token（需在 HF 页面同意 Gemma 许可协议） huggingface-cli download google/gemma-2b \\ --local-dir /path/to/models/gemma-2b \\ --include \u0026#34;*.safetensors\u0026#34; \u0026#34;*.json\u0026#34; \u0026#34;tokenizer*\u0026#34; 下载后的目录应该同时有权重分片和 tokenizer 文件。缺 tokenizer 或分片数量不对，后面加载会直接报错：\ngemma-2b/ ├── config.json ├── model-00001-of-00002.safetensors # 权重分片 1 ├── model-00002-of-00002.safetensors # 权重分片 2 ├── tokenizer.json └── tokenizer.model 2. 先跑基座，再谈微调 #加载基座时，代码里有一个容易忽略的环境变量。它决定 Trainer 看到几张卡：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import os, torch from transformers import AutoTokenizer, AutoModelForCausalLM # ⚠️ 关键：多卡机器必须设置，防止 DDP 死锁（见第 7 节） os.environ[\u0026#34;CUDA_VISIBLE_DEVICES\u0026#34;] = \u0026#34;0\u0026#34; tokenizer = AutoTokenizer.from_pretrained(\u0026#34;/path/to/gemma-2b\u0026#34;) model = AutoModelForCausalLM.from_pretrained( \u0026#34;/path/to/gemma-2b\u0026#34;, dtype=torch.bfloat16, # 半精度，节省显存 device_map=\u0026#34;cuda:0\u0026#34;, attn_implementation=\u0026#34;eager\u0026#34;, # Gemma 兼容模式 ) model.eval() 按 2.5B 参数算，bf16 权重约 5GB，fp32 权重约 10GB；代码注释里的 20GB 和单看权重的 10GB 对不上，可能包含了激活、KV cache 和框架开销。bf16 在 Ampere 及以上架构原生支持，3090、L20、A100 都可以用；更老的 T4/2080 没有 bf16，需要退回 fp16 并加 loss scaling。\n流式生成的代码同时做了两件事：按 token 流式输出，以及在模型开始自问自答前停住。下面这段代码把两件事放在同一个 generate 函数里：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 from transformers import TextStreamer, StoppingCriteria, StoppingCriteriaList class StopAtUser(StoppingCriteria): \u0026#34;\u0026#34;\u0026#34;遇到下一轮 \u0026#39;User:\u0026#39; 立即停止，防止模型自问自答\u0026#34;\u0026#34;\u0026#34; def __init__(self, stop_ids): self.stop_ids = stop_ids def __call__(self, input_ids, scores, **kwargs): return input_ids[0, -len(self.stop_ids):].tolist() == self.stop_ids def generate(tokenizer, model, prompt, use_lora=False): # ⚠️ 提示格式必须与训练时完全一致！ if use_lora: formatted = f\u0026#34;User: {prompt}\\nAssistant (Trump):\u0026#34; else: formatted = f\u0026#34;User: {prompt}\\nAssistant:\u0026#34; inputs = tokenizer(formatted, return_tensors=\u0026#34;pt\u0026#34;).to(model.device) streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True) stop_ids = tokenizer.encode(\u0026#34;\\nUser:\u0026#34;, add_special_tokens=False) stopping = StoppingCriteriaList([StopAtUser(stop_ids)]) with torch.no_grad(): model.generate( **inputs, max_new_tokens=512, do_sample=False, repetition_penalty=1.1, streamer=streamer, stopping_criteria=stopping, ) 先跑基座，确认环境和生成流程没问题，再接 LoRA。两条命令的差别只在 --lora：\n1 2 python3 run_gemma.py # 原版 Gemma python3 run_gemma.py --lora # 特朗普风格（LoRA 微调版） do_sample=False 让输出可复现，repetition_penalty=1.1 压一下复读。StopAtUser 比较的是最后几个 token 是否等于 \\nUser:，所以推理时的提示格式必须和训练时一致，否则停止条件也会失准。\n3. 数据：12 条就够吗 #微调数据质量比数量更重要，这个项目用 12 条高质量 Q\u0026amp;A 对做演示。数据格式是 instruction 加 response：\n1 2 3 4 5 6 7 8 9 10 [ { \u0026#34;instruction\u0026#34;: \u0026#34;How is the economy doing?\u0026#34;, \u0026#34;response\u0026#34;: \u0026#34;The economy? TREMENDOUS! Nobody knows economy better than me, believe me. When I was president, we had the GREATEST economy in the history of our country... Sad!\u0026#34; }, { \u0026#34;instruction\u0026#34;: \u0026#34;Are you smart?\u0026#34;, \u0026#34;response\u0026#34;: \u0026#34;Smart? I went to Wharton School of Finance, one of the best schools in the world. TREMENDOUS school. Many people are saying I might be the smartest president ever... And they\u0026#39;re not wrong!\u0026#34; } ] 这两条数据的风格特征很集中：大写强调词、短句、重复的口头禅、结尾的转折。格式化函数把 instruction 和 response 拼成一条训练文本：\n1 2 3 4 5 def format_sample(sample: dict) -\u0026gt; str: return ( f\u0026#34;User: {sample[\u0026#39;instruction\u0026#39;]}\\n\u0026#34; f\u0026#34;Assistant (Trump): {sample[\u0026#39;response\u0026#39;]}\u0026#34; ) 格式化后每条样本是一段纯文本。内容长这样：\nUser: Are you smart? Assistant (Trump): Smart? I went to Wharton School of Finance, one of the best schools in the world. TREMENDOUS school... 12 条数据足够让模型模仿句式，不足以保证泛化。数据质量比数量重要，但 12 条的上限很低：模型很容易记住这 12 个回答的结构，换一个问题就开始复读。这个上限会在后面的 loss 和训练集外样例里露出来。\n4. LoRA 到底改了什么 #LoRA 不修改原始权重 $W$，而是在旁边插入两个小矩阵 $A$ 和 $B$。训练只更新这两个矩阵：\n$$ y = Wx + BAx $$前向传播时，$W$ 的路径冻结，$BA$ 的路径学习一个低秩修正。以 q_proj 层为例，$W$ 是 $2048 \\times 2048$，共 4,194,304 个参数；$A$ 是 $2048 \\times 16$，$B$ 是 $16 \\times 2048$，各 32,768 个参数，$A+B$ 合计 65,536 个参数，比 $W$ 少 64 倍。单个 $A$ 或 $B$ 相对 $W$ 是 128 倍，$A+B$ 合起来才是 64 倍；原文图里两个数字都出现过，区别就在这里。\n配置里的 r=16 是瓶颈维度，lora_alpha=32 是缩放系数，实际权重是 $BA \\times (\\alpha / r)$，所以这里的缩放是 2。target_modules 覆盖注意力的 q/k/v/o 和 FFN 的 gate/up/down 共 7 个投影层；总可训练参数 19.6M，占 2.5B 参数的 0.78%。\n初始化也有讲究：$A$ 用 Kaiming uniform，$B$ 全零。这样训练开始时 $\\Delta W = BA = 0$，模型等同于原始状态，不会因为随机扰动破坏基座。第一步只有 $B$ 收到梯度，等 $B$ 非零之后 $A$ 才开始更新。这个顺序来自 $B$ 的零初始化，也是低秩适配器能稳定训练的初始化设计。\nr=16 就够用是 LoRA 论文的经验判断：微调时 $\\Delta W$ 往往具有低秩结构，用 16 维的子空间可以捕获大部分修正。这个假设在风格微调上通常成立，在知识注入或分布差异很大的任务上不一定；r 的常用范围是 8 到 64，具体要试。\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 from peft import LoraConfig, get_peft_model, TaskType lora_config = LoraConfig( task_type=TaskType.CAUSAL_LM, r=16, lora_alpha=32, lora_dropout=0.05, target_modules=[ \u0026#34;q_proj\u0026#34;, \u0026#34;k_proj\u0026#34;, \u0026#34;v_proj\u0026#34;, \u0026#34;o_proj\u0026#34;, # 注意力层 \u0026#34;gate_proj\u0026#34;, \u0026#34;up_proj\u0026#34;, \u0026#34;down_proj\u0026#34; # FFN 层 ], bias=\u0026#34;none\u0026#34;, ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # trainable params: 19,611,648 || all params: 2,525,784,064 || trainable%: 0.7765 5. 训练：18 步，3.9 秒 #训练配置只改了几个关键项。其余用 TRL 的默认值：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 from trl import SFTConfig, SFTTrainer sft_config = SFTConfig( output_dir=\u0026#34;./finetune/output\u0026#34;, num_train_epochs=3, per_device_train_batch_size=2, gradient_accumulation_steps=1, # 1 = 每 batch 立即更新，步数多日志密 learning_rate=2e-4, lr_scheduler_type=\u0026#34;cosine\u0026#34;, # 余弦退火学习率 warmup_steps=5, logging_steps=1, # 每步都打印日志 bf16=True, max_length=512, dataset_text_field=\u0026#34;text\u0026#34;, report_to=\u0026#34;none\u0026#34;, ) trainer = SFTTrainer( model=model, args=sft_config, train_dataset=dataset, processing_class=tokenizer, ) trainer.train() trainer.save_model(OUTPUT_DIR) 12 条样本、batch size 2、3 个 epoch，一共 18 个 micro-batch；gradient_accumulation_steps=1 时，每一步都更新优化器，所以日志里有 18 步。原文最初用 4，优化器更新次数掉到个位数，进度条和日志看起来几乎不动，容易被误认为卡死；改成 1 之后每步都能看到 loss 变化。更新次数具体取决于 dataloader 是否丢弃最后一个不完整的 accumulation 组，但肯定不是 18 次。\n训练日志里最值得看的是 loss、学习率和 lora_B 的范数。关键几行如下：\n🚀 Gemma 2B LoRA 微调开始 │ 总步数: 18 │ 3 epochs ════════════════════════════════════════════════ ┌─ Step 1/18 (E1) [█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 5.6% │ loss=4.1950 [████████████████░░░░] lr=0.00e+00 grad=9.84 │ lora_B 0.000000 +0.000000 └────────────────────────────────────────────── ┌─ Step 9/18 (E2) [███████████████░░░░░░░░░░░░░░░] 50.0% │ loss=1.9642 [███████░░░░░░░░░░░░░] lr=1.75e-04 grad=5.64 │ lora_B 0.171596 +0.019538 │ loss 趋势 (最近 9 步): [▆█▆▇▄▃ ] └────────────────────────────────────────────── ┌─ Step 18/18 (E3) [██████████████████████████████] 100.0% │ loss=0.9890 [███░░░░░░░░░░░░░░░░░] lr=2.91e-06 grad=4.20 │ lora_B 0.225812 +0.000176 │ loss 趋势 (最近 18 步): [▆█▆▇▅▄▂▂▂▁▁▁ ] └────────────────────────────────────────────── ✅ 训练完成！初始 loss 4.195 → 最终 loss 0.989，下降 76%，训练耗时 3.9 秒 18 步除以 3.9 秒约等于 4.6 步/秒；原文指标表里写 6 steps/s，和这两个数对不上，可能是另一个计时口径。3.9 秒只说明这个 12 条样本的管道很快，不代表更大的数据集或模型也能按这个速度跑。\n训练脚本可以前台跑，也可以后台跑。三个常用命令如下：\n1 2 3 4 5 6 7 8 # 前台运行 python3 finetune/train.py # 后台运行并记录日志（推荐） python3 -u finetune/train.py \u0026gt; /tmp/train.log 2\u0026gt;\u0026amp;1 \u0026amp; # 实时监看日志 tail -f /tmp/train.log | tr \u0026#39;\\r\u0026#39; \u0026#39;\\n\u0026#39; 6. 推理：合并 adapter #训练结束后，finetune/output/ 保存的是增量的 LoRA 权重，基座不在里面。目录结构如下：\nfinetune/output/ ├── adapter_config.json # LoRA 配置（r, alpha, target_modules…） ├── adapter_model.safetensors # LoRA 权重（仅 ~40MB！） └── tokenizer.json 19.6M 个可训练参数按 bf16 存，约 39MB，和“~40MB”对得上。加载时先载入基座，再挂 adapter：\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 from peft import PeftModel from transformers import AutoModelForCausalLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(\u0026#34;/path/to/gemma-2b\u0026#34;) base = AutoModelForCausalLM.from_pretrained( \u0026#34;/path/to/gemma-2b\u0026#34;, dtype=torch.bfloat16, device_map=\u0026#34;cuda:0\u0026#34;, ) # 加载 LoRA 适配器 model = PeftModel.from_pretrained(base, \u0026#34;./finetune/output\u0026#34;) # 将 LoRA 权重合并进基础模型（合并后推理速度与原版完全相同） model = model.merge_and_unload() model.eval() merge_and_unload() 把低秩修正折进原始权重。合并公式如下：\n$$ W_{\\text{merged}} = W_{\\text{base}} + (B \\times A) \\times \\frac{\\alpha}{r} $$合并后 PEFT 的旁路层被移除，推理时没有额外矩阵乘法，速度和原版一致。adapter 不能被单独加载成一个模型；基座仍然要完整载入，这一点在下一节的显存账里还会遇到。\n7. 几个容易踩的坑 #为什么不用全量微调。 按 2.5B 参数粗算：bf16 权重约 5GB，fp32 的 Adam 一阶、二阶动量各一份，约 20GB，梯度约 5GB，再加激活和临时 buffer，全量微调就在 40GB 量级。LoRA 冻结 $W$，省掉 $W$ 的梯度和优化器状态，只保留 A/B 的小状态，14GB 是这套配置下的实测显存。代价是可训练容量变小，任务和基座差得越远，LoRA 越容易欠拟合。\n多卡机器为什么要锁一张卡。 HuggingFace Trainer 检测到多张 GPU 会自动启动 DDP，但代码里 device_map=\u0026quot;cuda:0\u0026quot; 已经把模型锁在单卡上；两者冲突会死锁，表现为进程 CPU 100% 但完全不前进。在脚本最开头设置 os.environ[\u0026quot;CUDA_VISIBLE_DEVICES\u0026quot;] = \u0026quot;0\u0026quot;，让 Trainer 只看到一张卡，问题就消失了。这个环境变量必须在导入 torch 之前设置，放到模型加载之后已经晚了。\n提示格式为什么必须一致。 LoRA 学到的是“在看到 Assistant (Trump): 这个 token 序列后，应该用什么风格续写”。推理时如果只写 Assistant:，模型没有收到触发信号，会回到基座的通用分布。训练格式等于推理格式，这是使用微调模型最容易忽视的细节；改 prompt 模板时，训练和推理要一起改。\ngradient_accumulation_steps 对日志的影响。 这个参数控制“累积几个 micro-batch 才更新一次优化器”。设为 4 时，12 条样本、batch 2、3 个 epoch 的 18 个 micro-batch 会被合并成个位数的更新，日志和进度条长时间不动，看起来像卡死；设为 1 时每步都更新，18 步的 loss 曲线完整可见。它不改变总样本量，但会改变有效 batch size、参数更新频率和日志密度；训练不稳定时，适当增大 accumulation 可以等效增大 batch，学习率往往也要一起调。只想看日志时，没必要开大。\nLoRA 仍然要载入基座。 前向传播每一步都要算 $y = Wx + BAx$，必须读取 $W$ 做矩阵乘法；反向传播的梯度要穿过 $W$：\n$$ \\frac{\\partial L}{\\partial x} = W^\\top \\frac{\\partial L}{\\partial y} $$这里只写了经过 $W$ 的那条路径，完整的梯度还要加上 $BA$ 路径。$W$ 不更新，但必须参与反向计算图。LoRA 省的是 $W$ 的梯度存储和优化器状态；载入 $W$ 本身省不掉。这就是为什么 2.5B 模型仍然要占约 5GB 权重显存，14GB 里大头是基座和激活，不是 adapter。\n8. 结果与边界 #先看训练集内的问题“Are you smart?”，原版和 LoRA 版的差别很明显：\n原版 Gemma 2B：Smart? What\u0026rsquo;s smart? Making deals, winning elections, or both?\nLoRA 微调版（特朗普）：Smart? I\u0026rsquo;ve been called many things, but I prefer \u0026ldquo;genius.\u0026rdquo; I have many degrees, many of them top-notch universities. My vocabulary is vast, my knowledge - I\u0026rsquo;m the most knowledgeable president ever. The crowd loves me, the polls show me winning, and the Democrats are scared. Sad!\n再看训练集外的问题“What is your name?”：\n原版 Gemma 2B：My name is Gemma. I\u0026rsquo;m a large language model trained by Google…\nLoRA 微调版（特朗普）：My name is Donald J. Trump. The people call me Trump. I like it. It\u0026rsquo;s a beautiful name… It\u0026rsquo;s a symbol of strength, of victory. I\u0026rsquo;ve always been a winner, and I\u0026rsquo;ll never stop.\n训练过程的指标汇总在下面这张表里。它只覆盖训练阶段，不等于泛化评测：\n指标 训练前 训练后 变化 Loss 4.195 0.989 ↓ 76.4% Token 准确率 42% 76% ↑ 34pp lora_B 范数 0.0000 0.2258 权重已收敛 训练耗时 — 3.9 秒 平均约 4.6 步/秒 GPU 显存 — 14 GB 单卡可运行 Loss 从 4.195 降到 0.989，下降 76.4%；token accuracy 从 42% 到 76%。这两个数字都是训练过程的指标，原文没有说明 token accuracy 的评测集。如果是训练集，它们说明模型拟合了这 12 条数据；如果是留出集，样本也太少，置信区间很宽。[待补：token accuracy 的评测口径（训练集/留出集、是否包含 prompt token）]\n训练集外的名字问题只提供了一个泛化样例。模型答出 Donald J. Trump，说明它学到了一些角色关联；12 条数据、18 步、3.9 秒，更像是模型记住了这 12 个回答的句式。要确认这一点，需要留出集、风格一致性评分和事实性检查。[待补：留出集上的风格一致性与事实性评测]\n如果目标是角色扮演，还要注意事实错误：模型可能把特朗普的公开事实和风格化的口头禅混在一起，风格对了，事实不一定对。这套流程证明了管道能跑通，不证明模型已经学会稳定的特朗普风格。下一步要补的是评测；把训练时间从 3.9 秒再压一秒，不会解决泛化问题。\n","date":"2024年4月7日","permalink":"https://doraemeng.dev/notes/lora-gemma2b-trump-finetuning/","section":"笔记","summary":"LoRA微调Gemma 2B实战教程：单张RTX 3090/4090（约14GB显存），用HuggingFace TRL+PEFT和仅12条特朗普风格问答数据，训练18步耗时3.9秒、loss从4.19降到0.99，可训练参数只占0.78%。覆盖环境搭建、数据构造、LoRA配置、训练推理到多卡踩坑的完整流程。","title":"LoRA 微调全流程实战——用 12 条数据、4 秒钟，把 Gemma 2B 训成特朗普"},{"content":"把四套方案的年账单并排放在一起，差距比功能清单大得多：国内静态方案一年 ¥400-800，国内全栈 ¥4000-12000，Cloudflare 全栈约 ¥70，混合部署 ¥500-2000。这个差距主要来自固定的服务器和数据库月费，功能数量的影响反而小。对个人博客，先搞清楚哪一笔钱是为“可能到来的流量”预付的，再谈技术栈。\n四套方案的账单结构 #国内静态方案是阿里云或腾讯云域名 ¥100/年，OSS/COS 和 CDN 的月费在 ¥30-80 之间，年总成本按 ¥400-800 估。它解决的是国内访问速度和备案合规，适合客户都在国内、站点以展示为主的情况；代价是 CDN 按流量计费，流量突增时账单跟着涨，而且要维护 bucket、回源、证书和缓存规则。\n国内全栈方案在这上面加了 ECS/CVM（¥100-500/月）和 RDS/CDB（¥100-300/月），再加对象存储 ¥10-50/月、CDN ¥50-200/月，一年 ¥4000-12000。它的月固定成本在服务器和数据库，流量为零也照付；对应的能力是完全控制、备案合规和云厂商的技术支持。只有出现登录、支付、客户数据留存这类需求，这笔固定成本才有对应的业务价值。\nCloudflare 全栈的现金支出只有域名，$10/年，约 ¥70；Pages、Workers、D1、R2、CDN 都在免费额度内。优势在零运维和全球边缘分发，代价是国内访问没有境内节点保底、Workers 和 D1 的能力边界比传统服务器窄。混合部署是前端放 Cloudflare Pages 或 Vercel，后端放阿里云函数计算/腾讯云 SCF，数据库用 PlanetScale 或 Supabase，一年 ¥500-2000；它想同时照顾两边用户的访问体验，代价是两套部署、两套监控和 DNS 分流。\n国内静态方案 #这套方案用 OSS/COS 加 CDN，不需要买服务器。静态文件上传到 bucket，绑定自定义域名，开 CDN 加速，证书用云厂商的免费证书；备案是前置条件，域名、接入商和备案主体要一致。它的优点是攻击面小、没有运行时、扩容由 CDN 承担；缺点是配置项多，缓存规则配错时，更新文章后用户可能几天看到旧页面，刷新 CDN 缓存要成为发布流程的一部分。\n它适合国内企业客户为主的展示型博客。客户打开速度是获客的一部分，备案和国内节点能把首屏 RTT 压下来；如果站点只有文字和少量图片，OSS + CDN 的月账单通常落在前面说的 ¥30-80 区间。图片多、下载多、或者被转载时，按流量计费会变成主要成本，预算告警和流量封顶要提前设。\n国内全栈方案 #需要用户系统、CMS、CRM 或支付时，才轮到 ECS + RDS。ECS 给应用和后台任务，RDS 给关系数据，对象存储放附件，CDN 放静态资源；这套结构的优点是每一层都能独立扩容和备份，缺点是每一层都要人管。RDS 不是装完就完事：慢查询、连接数、备份保留期、主从延迟都要看；ECS 也不是买完就安全：安全组、系统补丁、日志和监控都要配。\n这套方案适合业务已经稳定、客户数据必须落在境内、或者有合规要求的情况。它的成本固定，流量多少都要付；所以触发条件应该具体到“必须登录才能用的功能已经上线”或“客户要求数据存放在境内”；“感觉业务变大了”不算条件。在没有这些条件之前，这笔固定支出会先于收入出现。\nCloudflare 全栈 #Cloudflare 全栈把域名、DNS、静态托管、边缘函数、数据库和对象存储放在一个账号里。Pages 托管 VitePress 的构建产物，Workers 处理表单和轻量 API，D1 存关系数据，R2 放文件和备份，KV 放配置和缓存。免费额度覆盖个人博客绰绰有余，Pages 和 CDN 不单独计费，R2 免费 10GB，边缘函数和数据库的配额足够跑一个轻量咨询站。\n限制也要提前知道。D1 是 SQLite，写入集中在一个主库，适合低频写入和简单查询，不适合高并发写或复杂事务；KV 是最终一致的，不能拿来做库存扣减；Workers 没有常驻进程和本地磁盘，长任务要拆成异步流程；未备案域名在国内可能走海外节点。把这些边界接受下来，这套方案是个人博客和轻量咨询站的最省心起点；要跑订单、支付或实时协作，应该直接看 Supabase、PlanetScale 或 VPS。\n混合部署 #混合部署的动机通常有两个：国内用户要求低延迟，海外用户也不能慢；或者后端必须放在境内，前端想保留 Cloudflare 的分发能力。做法是前端 Pages/Vercel，后端阿里云函数计算/腾讯云 SCF，数据库 PlanetScale/Supabase，Cloudflare DNS 按地区解析到不同前端。它能把两边都照顾到，但引入了两个发布流程、两套日志、两套证书和一条 GeoDNS 规则；任何一边挂掉，排查都要跨两个控制台。\n这套方案适合已经有明确的双边用户、且有技术能力维护两套基础设施的团队。对刚开始写博客的人，它是过度设计：你会在配置 DNS 分流和跨云鉴权上花掉的时间，远多于它省下的那点延迟。混合部署的年成本看起来不高，但加上排障和迁移的人力，账就不一样了。\n每一层怎么选 #域名层，Cloudflare Registrar 的 .com 是 $9.77/年，续费同价；Namecheap 首年 $10.28、续费约 $14，隐私免费；Porkbun $10.37 续费同价，极简不推销；阿里云 .com 约 ¥70/年，隐私 ¥30/年，优势是备案和国内管理。纯静态博客选前三家都行；国内客户为主、要备案，直接选阿里云，省掉把域名转回境内的麻烦。\n静态托管层，Cloudflare Pages 免费且不限带宽，Vercel 免费版给 100GB 流量/月，阿里云 OSS 约 ¥10-30/月，GitHub Pages 免费但国内较慢。一篇文章按 200KB、一天 1 万 PV 算，一个月约 60GB，文字博客的流量用不满免费额度；图片和下载多的站要按流量另算，Vercel 的 100GB 更适合纯文字站，图片站要么压图，要么选不限带宽的 Pages，要么接受国内 CDN 的账单。\nServerless 层，Workers 免费 10 万次/天，跑在 V8 isolate 上，适合轻量 API；Vercel Functions 免费 100GB-小时/月，和 Next.js 集成最好，但函数在海外 region 执行，国内访问慢；阿里云函数计算免费 100 万次/月，适合国内合规和低延迟。选哪家，先看你的前端在哪、用户在哪，再看免费额度。\n数据库层，D1 是 SQLite，免费 5GB，适合边缘轻量数据；PlanetScale 是 MySQL，免费 5GB，有分支和 schema 变更流程；Supabase 是 Postgres，免费 500MB，自带 Auth、Storage 和 Realtime；阿里云 RDS 没有免费档，但合规、备份和技术支持最完整。关系数据优先 Postgres/MySQL，边缘配置和缓存用 KV，文件放对象存储；不要把文件塞进数据库，也不要用 KV 做需要事务的计数。\n什么时候加钱 #阶段一用 Cloudflare 全栈：域名 $10/年，Pages 托管 VitePress，Formspree 收表单，Giscus 做评论，只付域名钱。阶段二在咨询量起来后加 Workers、D1 和 Resend，把线索存下来，成本大约 ¥100/年；如果不想写代码，Airtable + Zapier 也能过渡。阶段三才切混合部署：前端 Vercel/Pages，后端函数计算或 Railway，数据库 PlanetScale/Supabase，支付 Stripe/支付宝，年成本 ¥2000-5000。\n真正需要提前想清楚的，是数据放在哪、谁备份、出故障谁处理。技术栈可以从 ¥70/年起步，但一旦加上登录和支付，托管费只是小头，后面还有合规、备份和故障响应的责任。这条线跨过去之前，静态方案加第三方服务足够用；跨过去之后，再便宜的方案也不该省掉备份。\n","date":"2024年3月24日","permalink":"https://doraemeng.dev/notes/%E5%AE%8C%E6%95%B4%E6%8A%80%E6%9C%AF%E6%A0%88%E6%8E%A8%E8%8D%90/","section":"笔记","summary":"个人博客与独立顾问的技术栈怎么选？按用户在国内还是海外给出四套方案：国内静态（阿里云 OSS）、国内全栈、Cloudflare 全栈、混合部署，并给出域名、静态托管、Serverless 函数、数据库的年账单与取舍。推荐起步用 Cloudflare 全栈，全年成本仅 ¥70。","title":"完整技术栈推荐"},{"content":"静态博客最容易被后端绑架的地方是评论、表单、订阅、搜索和统计。这五样都有成熟的前端或第三方方案：评论用 Giscus，表单用 Formspree，订阅用 Buttondown，搜索用 Pagefind，统计用 Plausible 或 umami。真正需要自己写服务端的场景没有想象中多，先把“伪需求”剔掉，再谈选型。\n评论、表单、订阅、搜索和统计 #评论系统里，Giscus 把评论存进 GitHub Discussions，登录用 GitHub OAuth，博客侧只嵌一段脚本，不需要数据库。Disqus 更省事，但会加载第三方脚本和广告，隐私上要接受它的数据策略。Twikoo 比 Giscus 灵活，支持邮件提醒和微信通知，代价是要部署一个函数实例并准备 MongoDB，运维面比纯静态多一层。\n表单用 Formspree 或 Getform，免费档大约 500 次提交/月，POST 到它们的 endpoint，转发到你的邮箱；腾讯问卷适合国内用户，但样式和域名不是自己的。邮件订阅用 Mailchimp、ConvertKit 或 Buttondown，免费额度按订阅人数算，真正的成本在送达率和退订合规，不在服务器。搜索用 Algolia DocSearch 或 Pagefind：DocSearch 对文档站免费，但要申请；Pagefind 在构建时把 HTML 切成静态索引，浏览器直接查，没有 API 和数据库。统计用 Google Analytics、Plausible 或 umami，前者的代价是 cookie 同意和脚本体积，后两者可以自建，但自建就多了一个要备份的数据库。\n这些方案的共同点是：数据不在你手里，或者只在你构建产物里。评论在 GitHub，表单在 Formspree，订阅在邮件服务商，搜索索引在静态文件里，统计在第三方。对个人博客，这是合理的取舍；如果客户数据、合规或数据主权是硬要求，下面的后端方案才有意义。\n什么时候真的需要后端 #需要自己写服务端的信号很具体：内容要登录才能看，且用户能自助注册、找回密码；非程序员要通过 CMS 改内容；销售要在一个后台里跟踪咨询线索；要收钱，且涉及订单、退款、webhook 回调；要做实时聊天或协作；要把咨询业务产品化成 SaaS。这些功能的共同点是有状态、有权限、有写入，且状态不能只存在浏览器里。\n登录这个功能，界面上只有一个注册按钮，背后却是密码哈希、邮箱验证、会话或 token 过期、找回密码、账号禁用和审计日志；支付表面上是一次 API 调用，背后是 webhook 验签、幂等键、对账和退款状态机；实时功能要维持长连接，Serverless 函数的生命周期通常不适合常驻 WebSocket。把这些机制列出来，就能判断某个需求该不该现在做：如果现在说不清谁负责备份、谁处理账号申诉，先别上后端。\nServerless：Cloudflare、Vercel、Supabase #Cloudflare 的全栈是 Pages + Workers + D1 + R2 + KV。Workers 免费档 10 万次请求/天，超出 $0.50/百万次；D1 是 SQLite，免费 5GB，写入集中在一个主库，适合低频写入和轻量关系数据，不适合高并发写或复杂事务；R2 兼容 S3，免费 10GB，出网不单独计费；KV 是最终一致的键值存储，适合配置和缓存，不适合计数器和库存。Workers 跑在 V8 isolate 里，冷启动比容器型函数轻，真正的延迟大头通常是 D1 查询、跨境回源和第三方 API。它适合“表单提交、简单认证、少量读”的场景；把它当主数据库跑订单系统，会在事务边界和写入吞吐上撞墙。\nVercel 的全栈是 Next.js + Functions + 托管数据库。免费档给 100GB-小时/月的函数用量，支持 Node.js、Python、Go；函数跑在你配置的 region，Vercel 没有中国大陆节点，所以国内访问慢的不只是静态资源，函数请求的 RTT 也受影响。它的优势是 Next.js 的本地开发到部署路径顺，ISR、图片优化、预览环境都集成好了；代价是流量和函数用量增长后账单上升快，数据库还要另选 PlanetScale、Supabase 或 Vercel Postgres。\nSupabase 是 Postgres 全家桶：免费 500MB 数据库、2GB 存储，Pro $25/月，自带 Auth、Storage、Realtime 和自动生成 API。它的核心是 Postgres 和 Row Level Security，权限写在数据库策略里，前端可以直接查；代价是免费项目闲置会被暂停，Serverless 函数直连 Postgres 容易打满连接数，要用连接池。它适合需要完整后端、又不想自己写认证和 CRUD 的产品；如果只是博客加一个表单，Supabase 的运维面比 Formspree 大得多。\nVPS 和 PaaS #VPS 的价格很清楚：Vultr、Linode 的 1C1G 是 $5/月，DigitalOcean 是 $6/月，Hetzner 的 2C4G 是 €4.5/月，阿里云 ECS 和腾讯云 CVM 的 1C1G 大约 ¥60/月。它的代价不在月费，而在你成了系统管理员：安全更新、备份、监控、TLS 续期、日志轮转、fail2ban 都要自己配；单机还是单点故障，扩容要自己加机器，高可用得自己配。1C1G 的机器同时跑 Postgres、应用和构建，内存会先于 CPU 成为瓶颈，一次 OOM 或磁盘写满就够排查半天；这件事能做，但要把运维时间算进成本。\nPaaS 介于两者之间：Railway $5/月起，Render 有免费档、付费从 $7/月起，Fly.io 按量付费且在香港有节点，Heroku $7/月起。它替你处理部署、SSL、负载均衡和部分扩缩容，代价是控制权少、迁移时要重写构建配置，免费档还会休眠，下一次请求要等实例起来。对没有专职运维的小团队，PaaS 通常比 VPS 更划算；对需要特定内核参数、GPU 或常驻后台任务的服务，VPS 或容器平台更合适。\n按阶段加，不要一次到位 #博客起步阶段用纯静态：VitePress 构建，Cloudflare Pages 或 Vercel 托管，Formspree 收表单，Giscus 做评论，年成本约 ¥70。这个阶段不要买数据库，也不要先写用户系统；没有真实写入，数据库只会增加备份和连接配置的负担。\n咨询业务增长后，如果每月咨询量超过 50 条、需要跟踪线索，再上轻量 Serverless：Workers 处理表单 API，D1 存线索，Resend 或 SendGrid 发邮件，或者先用 Airtable（免费 1200 行）+ Zapier 过渡。Airtable 方案的好处是不写后端，30 分钟能跑通；坏处是数据在第三方、复杂查询和权限控制弱。这个阶段仍然只需要付域名的钱，其余在免费额度里。\n产品化阶段才需要完整后端：Next.js + Prisma，数据库用 PlanetScale（MySQL）或 Supabase（Postgres），部署用 Vercel 或 Railway，支付接 Stripe，成本大约 $20-50/月（¥150-350）。再往后是 Docker + Kubernetes、阿里云/腾讯云，月成本 ¥1000+，这时才需要谈高可用和合规。升级的触发条件很具体：出现了必须登录、必须收钱、必须留存客户数据的业务动作。\n上登录之前先回答三个问题 #上后端最先要付的成本是备份、权限和故障处理，服务器月费排在后面。上登录之前，先回答三个问题：数据存在哪里、谁每天备份、账号丢失时怎么恢复。答不上来，前面那套第三方组合的成本和运维面都远低于自建后端；答得上来，再选 Workers、Supabase 或 VPS 都不迟。\n","date":"2024年3月23日","permalink":"https://doraemeng.dev/notes/%E5%90%8E%E7%AB%AF%E9%83%A8%E7%BD%B2%E6%96%B9%E6%A1%88%E5%AF%B9%E6%AF%94/","section":"笔记","summary":"后端部署方案怎么选？先判断你是否真需要后端——评论、表单、订阅、搜索都有免后端的静态替代。再对比 Cloudflare Pages + Workers、Vercel、Supabase 三套 Serverless 方案与 VPS、PaaS 的成本和适用场景，并按博客起步、咨询增长、产品化三个阶段给出选型路径。","title":"后端部署方案对比（非静态网站）"},{"content":"我把 doraemg.com 的域名、DNS 和静态托管都放在 Cloudflare 一个账号里，一年账单不到 ¥70。这个价格有吸引力，但它成立的前提是站点纯静态、国内访问没有硬指标、Cloudflare 的免费额度覆盖你的构建频率。三个条件里任何一个不成立，这套方案的代价就会以另一种方式出现。\n域名和 DNS 绑在一起 #Cloudflare Registrar 按批发价卖域名，.com 的注册和续费都是 $9.77/年，不靠首年促销、续费涨价赚钱。代价是它要求域名使用 Cloudflare 的 DNS：注册时 NS 直接被指到 Cloudflare，后面不能在保留 Registrar 的同时换回别家解析。这个限制对大多数静态站不算问题，Cloudflare DNS 的 anycast 解析和免费 DNSSEC 都够用；但如果公司要求 DNS 必须放在自建 BIND 或某个合规平台，Cloudflare Registrar 就不适合。\n域名从别处转入时，流程是先在原注册商解锁、拿 Auth Code，再到 Cloudflare 发起转入，等 5-7 天完成。转入会顺延一年有效期，所以别在到期前几天才操作。新注册或刚转入的域名有 60 天转出锁定期，这是 ICANN 的规则，不是 Cloudflare 故意卡人。把这些时间算进去，域名注册商的选择更像一次两三年期的决定，不是看到 $9.77 就下单。\nPages 的运行时边界 #Cloudflare Pages 免费档给无限带宽和无限请求，每月 1000 次构建；GitHub 和 GitLab 仓库连上后，每次 push 触发一次构建，PR 也会生成预览链接。VitePress 的构建命令是 npm run docs:build，输出目录填 docs/.vitepress/dist，这两项填错是最常见的失败原因：构建日志看起来成功，部署出来却是 404，因为 Pages 在找 index.html 时找错了目录。\nPages 支持 VitePress、Hexo、Hugo、Next.js、Astro 这些静态输出，也支持直接拖一个 dist 文件夹上传。它不适合需要常驻进程的东西：没有你可以 ssh 进去的机器，没有本地磁盘，后台任务不能一直挂着。Pages Functions 跑在 Workers 运行时上，能处理请求级的 API，但每次调用有 CPU 时间限制，状态要放到 D1、KV 或 R2 里。它适合“静态站加少量边缘函数”的用法；要常驻进程或本地磁盘，得换 VPS 或容器平台。\nVercel 的对比经常被简化成“国内快慢”，实际差异在运行时和额度。Vercel 免费版给 100GB 带宽/月，函数按 GB-小时计费，团队免费版只有 1 个成员；Cloudflare Pages 的带宽不计量，但构建次数有限，Functions 的额度跟 Workers 走。纯静态博客两边都能跑，选 Cloudflare 的理由通常是带宽账单可预测；如果项目依赖 Next.js 的服务端能力、ISR 或 Vercel 的构建缓存，迁到 Pages 要改的东西比省下的钱多。\n国内访问：先量，再下结论 #Cloudflare 在中国内地有合作节点，公开说法是与百度、京东、网宿等合作；这些节点受备案约束，未备案的域名可能被调度到香港、新加坡或更远的 PoP。也就是说，“Cloudflare 比 Vercel 快”不是一条无条件成立的结论，它取决于你的域名有没有备案、用户所在运营商、以及当时被分到哪个节点。我手头没有同一时间段国内多地的 TTFB 对比，[待补：国内三地联通/电信/移动对 Pages 与 Vercel 的 TTFB 实测，含未备案与已备案两组]。没有这组数之前，只能把它当成方向性判断。\n真要优化国内访问，路径只有两条。第一条是备案后接入 Cloudflare 的中国网络或国内 CDN，域名、接入商、备案主体要一致，接入流程要重新走一遍。第二条是保持海外托管，接受跨境 RTT，把图片压小、减少首屏请求、给静态资源设长缓存；这些手段改善的是加载体积，不改变跨境线路的物理距离。对以国内企业客户为主的站，第二条通常不够。\n成本账和收尾 #Cloudflare 全家桶的现金支出是域名 $9.77/年，DNS、Pages、CDN、SSL 和基础 DDoS 防护都在免费档里，总计约 ¥70/年。同样的静态站放阿里云 OSS + CDN，域名约 ¥70/年，OSS 和 CDN 约 ¥30/月，一年约 ¥430，还要备案和配证书。差价是每年三百多块，换来的国内节点和备案合规；这笔钱该不该花，取决于国内访问是不是获客路径的一部分。\n这套方案真正需要盯的是集中度，月费反而是小事：域名、DNS、部署在同一个账号里，账号被锁或付款失败，三件事一起停。我的做法是开双因素认证、给域名上注册商锁、定期导出 DNS zone 备份，并留一个随时能切过去的静态托管备选。国内访问如果一直是“偶尔慢”，这套方案可以继续用；一旦客户开始拿打开速度说事，下一步是备案和国内 CDN，那会把现在的单账号结构拆成两套。\n","date":"2024年3月22日","permalink":"https://doraemeng.dev/notes/cloudflare%E9%83%A8%E7%BD%B2%E6%96%B9%E6%A1%88%E8%AF%A6%E8%A7%A3/","section":"笔记","summary":"Cloudflare Pages 部署教程：用 Cloudflare 一站式搞定域名注册、DNS 解析、静态网站托管与 CDN 加速，对比 Vercel 的运行时与免费额度，并说明国内访问、备案和构建次数的实际边界。","title":"Cloudflare 部署方案详解"},{"content":"GoDaddy 的首页常把首年价格打到 $0.99，续费价目表里写的是 $18-22，Whois 隐私再加 $10/年。把这三个数字放在一起，海外域名比价的第一条结论就出来了：首年价格是最不重要的一列。域名是两三年起持有、到期还要续的东西，真正要算的是续费价、隐私费和转出成本。\nCloudflare Registrar：按成本价卖 #Cloudflare 的 .com 注册和续费都是 $9.77/年，按批发价加 ICANN 费用卖，不靠首年低价和续费溢价赚钱。它的隐私保护免费，DNS 也免费，解析走 Cloudflare 的 anycast 网络。限制有两个：域名必须使用 Cloudflare DNS，不能保留 Registrar 同时换别家解析；新注册名额是分批开放的，你查的时候能不能买并不确定，很多情况下只能把已有域名转进去。支付支持信用卡和 PayPal，没有中文客服。\n如果这两条限制都能接受，Cloudflare 是长期持有 .com 最省心的选择。三年域名费是 $29.31，比 Namecheap 的约 $38 便宜不到 $9；它真正的价值在于价格透明，不用担心第二年突然涨到 $20 以上。把域名当基础设施的人，会更看重这个确定性，省几美元排在后面。\nNamecheap：稳定默认 #Namecheap 首年 $10.28，续费约 $14，WhoisGuard 隐私免费，DNS 和邮箱转发也免费。它经常有新用户 $5.98 的首年码，黑五和网一有折扣；这些促销适合第一年，但续费价才是长期成本。支付支持信用卡、PayPal 和 Bitcoin，客服响应快，界面也比老牌注册商清楚。\nNamecheap 的优势是没有明显短板：价格不是最低，但续费可控；隐私免费；转入转出流程成熟；中文用户用 PayPal 也能付。它适合不想在域名上花时间、也不想被续费刺客咬一口的人。我的默认选择是它，Cloudflare 有注册名额时才会换过去。\nPorkbun：极简，不推销 #Porkbun 的 .com 是 $10.37/年，续费同价，隐私保护和 SSL 都免费，结账时不会塞一堆附加服务。界面极简，适合讨厌 upsell 的人。支付支持信用卡、PayPal，部分区域支持支付宝。它的短板是知名度低、客服渠道少、没有中文，遇到域名被锁或转移争议时，沟通成本会比 Namecheap 高。\n其他家：只在特定条件下有意义 #Name.com 的 .com 是 $12.99/年，支持支付宝；需要支付宝付款、又不想用国内注册商的人可以选它，三年总成本约 $54（含隐私费）。Hover 是 $15.99/年，隐私免费，送邮箱转发，界面极简，适合不差钱、追求干净体验的人。Gandi 是 $15.50/年，隐私免费，送 2 个邮箱，老牌欧洲注册商，适合欧洲业务或对隐私要求高的用户；它的价格比 Cloudflare 贵近六成，界面也偏复古。Google Domains 已经关闭并迁到 Squarespace，新用户没有必要再考虑，Squarespace 的主营业务是建站，域名只是附带。\nGoDaddy 是另一个极端：首年 $0.99-12，续费 $18-22，支付支持信用卡、支付宝和微信，客服支持中文和 24/7。常见的玩法是首年买入、之后转出到 Cloudflare 或 Namecheap。这个玩法能省钱，但多了一次转移操作和一段不能转出的锁定期；如果忘记续费或转移失败，省下的十几美元会变成赎回费。新手可以用它买第一个域名，熟悉流程后转走，不建议长期停留。\n三年账与隐私 #按三年持有算，Cloudflare 是 $29.31，Porkbun 是 $31.11，Namecheap 约 $38.28，Name.com 约 $53.94，GoDaddy 按上面的首年价和续费价算，三年加隐私在 $67-86 之间。这些数字里，Cloudflare 和 Namecheap 的差距不到 $9，GoDaddy 和它们的差距是几十美元。为了几美元首年差价选择一个续费贵、转移麻烦的注册商，账算不过来。\n隐私保护是另一笔账。2018 年 GDPR 之后，很多注册局会对自然人的 Whois 数据做脱敏，但这不意味着所有注册商都提供隐私服务：GoDaddy 要收 $10/年，Name.com 要收 $4.99/年，Cloudflare、Namecheap、Porkbun、Hover、Gandi 免费。在没有隐私保护或注册局未脱敏的情况下，姓名、电话、邮箱会进 Whois 数据库，接着是推销电话和诈骗邮件。对个人博客，隐私保护应该当成默认项，不要等接到第一个骚扰电话才去开。\n转出与续费 #域名转出有硬规则：新注册或刚转入的域名 60 天内不能转出，转出前要在原注册商解锁、拿 Auth Code，转入方发起后等 5-7 天。转移成功通常会顺延一年有效期，转移费按续费价收，所以最佳时机是域名还有几个月到期、又不急着换 DNS 的时候。\n自动续费要开，账号要开双因素认证，Auth Code 和注册商账号的恢复邮箱要单独保存。域名过期后，先是宽限期，随后进入赎回期，赎回费通常远高于正常续费；如果账号丢了，连赎回都做不了。一个 $10 的续费失误，可能变成几百美元的赎回费，或者直接丢掉一个已经用了两年的品牌名。\n我的选择 #默认用 Namecheap，隐私免费、续费可控、转入转出成熟；Cloudflare 有注册名额、且我愿意把 DNS 放在 Cloudflare 时，换到它的 $9.77 成本价；需要极简和支付宝时看 Porkbun 或 Name.com；GoDaddy 只在首年促销且确定会转出时用。国内企业客户为主时，域名放在阿里云，¥70/年，隐私 ¥30/年，备案和解析都在一个后台，省下的沟通成本比海外注册商的差价更值钱。\n价格会随促销和汇率变化，下单前以注册商页面为准。三年后的总账通常只差几十美元，真正让人后悔的是续费忘记、账号丢失或转移卡住。选一个流程透明、隐私免费、能顺利转出的注册商，然后把自动续费和 2FA 打开，比继续比价更有用。\n","date":"2024年3月21日","permalink":"https://doraemeng.dev/notes/%E6%B5%B7%E5%A4%96%E5%9F%9F%E5%90%8D%E6%8F%90%E4%BE%9B%E5%95%86%E5%AF%B9%E6%AF%94/","section":"笔记","summary":"海外域名注册商怎么选？对比 Cloudflare、Namecheap、Porkbun、GoDaddy 等 8 家 .com 注册商的首年与续费价格、隐私保护和支付门槛：Cloudflare $9.77/年不涨价最便宜，Namecheap 稳定省心是首选，Porkbun 极简不推销，GoDaddy 首年便宜但续费 $18+ 堪称刺客。","title":"海外域名提供商对比（.com）"},{"content":"给 doraemg.com 续费时，我把过去一年在域名和托管上的账单翻了一遍：域名 ¥70 左右，Vercel 免费，Cloudflare DNS 免费；如果换成阿里云 OSS + CDN，同样一个静态站每月要多出 ¥10-50。域名比价能省下的钱通常只有每年二三十块，真正改变访问体验和账单结构的是服务器放在哪、有没有备案。\n国内阿里云、腾讯云、华为云的 .com 首年都在 ¥69-90 这个区间，价格差距不大，差别主要在备案流程和生态。阿里云万网流程最熟，腾讯云 DNSPod 和微信生态打通，华为云偏企业客户；如果客户在国内，域名和备案放在同一家云厂商，少一次跨平台提交材料。\n海外注册商的价格看起来更低：Cloudflare Registrar 按批发价卖，.com 大约 $9.77/年，折合 ¥70 上下，续费同价；Namecheap 首年 $10.28 左右，续费约 $14；GoDaddy 首年能低到 $0.99-12，续费 $18-22。Google Domains 已经迁到 Squarespace，新用户不必再考虑。把这些价格按三年摊开，Cloudflare 和 Namecheap 的差距不到一顿饭钱，GoDaddy 的续费才是真正贵的那个。\n隐私保护要单独看。Namecheap 的 WhoisGuard、Cloudflare 和 Porkbun 的隐私保护都免费；GoDaddy 要收 $10/年。2018 年 GDPR 之后，很多注册局会对自然人数据做脱敏，但这不是注册商给你的承诺，某些 TLD 和企业注册人仍会暴露姓名、电话和邮箱。域名一公开，最先来的是推销邮件和诈骗电话，这条成本比首年差价更值得算。\n备案决定了你能不能把服务器放在国内 #如果网站服务器在国内，或者用国内 CDN，域名必须备案。备案本身免费，时间大约 7-20 天，但它不是一个孤立的域名手续：备案要通过境内的接入商提交，域名注册商也要在工信部名单里。很多海外注册商不在这个名单内，所以国外买的域名想备案，通常要先转回国内注册商，或者干脆放弃国内节点。\n这也是 Vercel、Cloudflare Pages 这类海外托管不需要备案的原因：服务器和 CDN 节点在境外，没有境内接入商。代价是国内访问要跨跨境线路。Vercel 的域名没有被墙，慢主要来自节点位置和跨境 RTT；Cloudflare Pages 在国内的合作节点也受备案限制，未备案的域名可能被调度到香港、新加坡等海外节点。备案在这里不是一张纸，它直接决定了静态文件从哪个机房发出来。\n静态托管：免费额度和流量账单 #纯静态博客的选择比域名多。Vercel、Netlify、GitHub Pages、Cloudflare Pages 都有免费档；Vercel 免费版给 100GB 流量/月，Cloudflare Pages 不限带宽但每月 1000 次构建；GitHub Pages 适合极简需求，国内访问较慢。阿里云 OSS + CDN 和腾讯云 COS + CDN 要自己配 bucket、CDN 域名和证书，费用大约 ¥10-50/月；自己买服务器 ¥50-200/月，还要承担系统更新、备份和 TLS 续期。\n免费额度够不够，用页面大小算一遍就知道。一篇文章按 200 KB 算，一天 1 万 PV 大约是 2GB，一个月 60GB，100GB 的额度还能剩；如果每页挂 1MB 的图，同样访问量一个月就是 300GB，额度会先被图片吃光。所以图片多的站要么压图、走图床，要么直接选不限带宽的 Cloudflare Pages，要么接受国内 CDN 的按流量账单。按流量计费的 CDN 还有一个隐性风险：一篇文章被转载、被刷流量，账单跟着访问量走，预算告警要提前设。\n三套组合，三种代价 #极简免费版适合个人起步：Cloudflare 买域名，约 ¥70/年，部署放 Vercel，DNS 也用 Cloudflare，维护成本接近零，国内访问偶尔慢。这套方案的好处是域名、DNS、部署都不需要信用卡之外的额外账号；坏处是 Vercel 和 Cloudflare 的服务边界都在境外，国内速度没有保底。\n国内优化版适合 TOB 企业客户：阿里云买域名，¥70/年左右，部署用 OSS + CDN，约 ¥30/月，DNS 用阿里云。国内打开速度是这三套里最好的，备案也顺；一年的真实成本是 ¥70 + ¥30×12 ≈ ¥430，域名只占其中一小部分。配置成本主要在 bucket 权限、CDN 回源、HTTPS 证书和缓存刷新上，第一次做要逐项核对。\n平衡版是阿里云买域名 + Vercel 部署 + Cloudflare DNS。域名在国内管理，部署仍然免费，国内访问比纯 Vercel 好一点，但没有境内节点，速度上限摆在那里。它适合客户在国内、但还没到必须备案托管的地步；如果客户开始抱怨打开慢，下一步只能走备案 + 国内 CDN，托管架构要跟着换。\n我的选择 #我自己的站会用平衡版起步：阿里云买 doraemg.com，¥70/年，Vercel 部署，Cloudflare 做 DNS，再把 doraemg.cn 买下来做品牌保护，¥30/年。这套组合的年度现金支出大约 ¥100，符合个人博客的阶段。客户以国内企业为主、且网站承担获客入口时，我会直接换成阿里云 OSS + CDN，接受每年约 ¥430 的账单和这套配置成本，换取国内打开速度。\n价格会随促销和汇率变化，下单前以注册商页面为准。还有一个没解决的约束：Cloudflare DNS 只能优化解析，不能把源站搬进国内。如果以后国内访问成为硬指标，要先备案、再接国内 CDN，域名注册商可能也要迁回国内；这一步会改变部署和证书的管理方式，不是改一条 DNS 记录就能完成。\n","date":"2024年3月20日","permalink":"https://doraemeng.dev/notes/%E5%9F%9F%E5%90%8D%E8%B4%AD%E4%B9%B0%E4%B8%8E%E9%83%A8%E7%BD%B2%E6%96%B9%E6%A1%88%E5%AF%B9%E6%AF%94/","section":"笔记","summary":"域名购买渠道与静态网站部署方案对比：阿里云、腾讯云、Cloudflare、Namecheap 的价格与优劣，Vercel、Netlify、GitHub Pages、Cloudflare Pages、阿里云 OSS+CDN 的国内访问速度与费用，附备案说明、三套组合方案（极简免费版、国内优化版、平衡版），以及按客户所在地做取舍的判断依据。","title":"域名购买与部署方案对比"},{"content":"本站没有 vLLM、SGLang、TensorRT-LLM 的同机 tokens/s。选型先看负载，不看口号。共享前缀高（多轮、agent、few-shot、重复的 RAG 前缀）先看 SGLang 的 RadixAttention。 08 章引用的论文把无命中开销写在 0.3% 以下，所以作者主张可以默认开。量化格式要多、团队已经按 PagedAttention 运维， 11 章的地图把 vLLM 写成生态最广、生产首选之一。人在 NVIDIA 卡上、要的是官方把 FP8 / INT4 kernel 做深，同一张地图写的是 TensorRT-LLM。你的 batch 和上下文下三者谁更快，这里是待实测。\n对照 #数字都来自本站已有笔记或笔记里点名的论文，不是这次新跑的三方榜。\n问题 vLLM SGLang TensorRT-LLM KV 怎么放 05 章：逻辑块映射到物理块。论文里不做管理时，KV 有效利用率只有 20.4%–38.2% 分页之上再加 radix tree，请求结束后前缀还在 本站没有单独拆它的分页实现。待实测 共享前缀 08 章的辨析：早期实现偏「一个系统提示」加 copy-on-write 多级前缀自动共享，LRU 从叶子驱逐。论文相对 vLLM / Guidance / LMQL：吞吐最高 6.4×，延迟最高降 3.7×，命中率 50%–99%，管理开销 \u0026lt;0.3%（74.3 s 里 0.2 s）。Chatbot Arena 一个月：Vicuna-33B 命中 74.1%、平均 TTFT 降 1.7×；LLaVA-NeXT-34B 命中 52.4%。这些是论文数字，不是本站复现 待实测 量化格式 11 章的表：AWQ、GPTQ、FP8、MXFP8、FP4、KV 量化 11 章写「同上（复用多种后端）」，并单列结构化生成 FP8、INT4/FP4、SmoothQuant W8A8、AWQ、KV 量化。特点写成 NVIDIA 深度优化 推测解码 04 章：vLLM 已集成 EAGLE，含 EAGLE-2 风格的动态树 首页记录的上游工作：PR #35423 修推测解码量化 target；issue #35437 把一次 prefill CUDA graph OOM 的 TTFT 从 179 ms 收到 113 ms。这是一个修复，不是三引擎排名 待实测 已经踩过的坑 不传 max_tokens 时，上限落到 max_model_len。那次 PaddleOCR-VL 大约 13 万 token，GPU 利用率挂在 100% 不是同一次事故 不是同一次事故 QServe 论文相对当时 TensorRT-LLM 的吞吐（一般模型 1.2–1.4×，Qwen1.5-72B 2.4–3.5×，L40S 上 8 个模型里 6 个超过 A100 上的 TensorRT-LLM）写在 11 章。那是论文和 TensorRT-LLM 的对比，不是本站把三个引擎放在同一台机器上跑出来的。\n何时选谁 #共享前缀占延迟大头时选 SGLang。08 章写过边界：输出很长、会话之间又不共享时，提速会回到接近零。多轮短回复、agent 轨迹、few-shot、同一张图被反复问，才是它的范围。\n量化清单长、又要 PagedAttention 这套运维语义时选 vLLM。11 章给 H200、70B、32K、PPL 要无损的习题答案是：先前缀缓存和 PagedAttention，量化用 W8A8 FP8 加 KV 4-bit 或 FP8，attention 留 FP16，引擎写的是 vLLM 或 TensorRT-LLM，因为 FP8 kernel 成熟。验收走 10 章 的 Gate，不达标就降档。\n人已经在 NVIDIA 软件栈里、采购条款问的是某个 SKU 上的 FP8 或 INT4 kernel，选 TensorRT-LLM 更贴 11 章的「NVIDIA 深度优化」。格式能不能换卡，FP8 / FP4 那篇把 NVFP4 和 MXFP4 的工具链差别写过了，这里不重复。\n质量必须无损时，三个都不该先上量化。11 章的顺序是先前缀缓存和推测解码，再动 W8A8，再动 KV，attention 默认不动。\n回到笔记 # PagedAttention RadixAttention EAGLE 量化模型怎么部署 FlashAttention AWQ 和 GPTQ FP8 还是 FP4 vLLM 的 max_tokens 量化精读目录 量化速查 ","date":"2026年10月29日","permalink":"https://doraemeng.dev/notes/vllm-sglang-tensorrt-llm%E6%80%8E%E4%B9%88%E9%80%89/","section":"笔记","summary":"没有三引擎同机吞吐表。共享前缀高先看 SGLang 的 RadixAttention；量化格式和 PagedAttention 要广选 vLLM；NVIDIA 上把 FP8/INT4 kernel 做深选 TensorRT-LLM。同负载 tokens/s 标待实测。","title":"vLLM、SGLang、TensorRT-LLM 该怎么选？"},{"content":"规则来自 量化精读和两篇选型文。同机三引擎 tokens/s 是待实测，不写在这页。\n同页的 Markdown 原文 可以下载。\n先做什么 # 前缀缓存、推测解码、PagedAttention。这些是 11 章写的无损项。 质量可以让步时，默认 W8A8 FP8，再单独开 KV 的 FP8 或 4-bit。attention 留 FP16，除非有专用 kernel、长序列占比高、而且评测过。 每一档单独验收。两个改动一起上，出了问题归因不了。 格式 # 选择 条件 笔记 FP8 权重 + FP8 KV Hopper / Ada 有 FP8 Tensor Core，而且 KV 不留在 FP16 FP8 还是 FP4、 03 章 只压权重、KV 仍是 FP16 显存账通常守不住并发。70B / 8K / 32 并发那个例子是算账，不是客户数据 同上 FP4 Blackwell 才有对应 Tensor Core。字段错误率没压住就不要为了少一张卡 同上、 11 章 Ampere 不要把 FP8 算力写进承诺 03 章 4-bit 权重 # 选择 条件 笔记 AWQ 生产默认的 W4A16：校准短，不做重建 AWQ 和 GPTQ、 06 章 GPTQ 流水线里已经有产物，或要往 3-bit 靠 05 章 2-bit AWQ 和 GPTQ 都会崩，换 QuIP# 一类 06 章 GGUF llama.cpp 的容器，不是第三种算法 AWQ / GPTQ 那篇 引擎 # 负载 先看 依据 共享前缀高 SGLang 08 章 量化格式多、PagedAttention vLLM 11 章、 05 章 NVIDIA FP8 / INT4 kernel TensorRT-LLM 11 章 三者谁的 tokens/s 更高 待实测 怎么选 11 章的检查清单仍然有效：格式有没有实测过的 kernel、激活量化了没有、KV 量化能不能关、长上下文和 MoE 配不配、硬件是不是 Hopper 或 Blackwell。\n","date":null,"permalink":"https://doraemeng.dev/series/quantization-cheatsheet/","section":"页面","summary":"量化精读的一页规则：先无损，再 W8A8，再 KV，attention 默认不动。AWQ / GPTQ 和 FP8 / FP4 的选择条件，以及 vLLM、SGLang、TensorRT-LLM 各自对上哪一章。没有新的实测数字。","title":"量化速查：格式、算法、引擎"},{"content":"英文名 doraeMeng。独立 AI 顾问，承接企业 AI 落地项目，专注 LLM 推理优化、AI Agent 基础设施与多模态。SGLang 上游贡献者，前百度/BIGO 算法工程师。\n现在在做什么 # 企业 AI 落地：Agent 平台与垂直行业 Agent、LLM 推理性能与成本优化 开源：codefuse、nexus、codeact、prompt-ctx；SGLang 上游贡献 写作：维护 LLM 推理优化精读系列，记录 Agent、训练/推理系统与部署踩坑 经历 # 时间 公司 / 角色 代表工作 2026.01–06 Supio.AI · AI 技术专家 法律 AI 平台：Mailroom 文档智能 Agent、医疗记录分段摘要、6 维 Rubric Grader 与质量回归闭环 2025.07–11 NetMind.xyz · Agent Tech Lead A2A Agent 通信、AgentWorkspace 持久化工作区、microVM 沙箱、动态上下文与 Prompt 托管 2023.09–2025.05 人生旷野 · 算法专家 对话策略、NPC 双记忆、GRPO 后训练、Token-aware Batching、多模态表情包创作 Agent 2022.06–2023.04 众安天下 · 产品与技术负责人 工信部工联众测平台、电商 AI、OSINT 与用户画像、CI/CD 云成本 −90% 2020.04–2022.06 BIGO · 资深算法工程师 RTB 竞价、多路召回、预算控制、迁移学习；消耗期望 +50%、召回 ×3、排序 CPU −50% 2017.10–2020.04 百度 · 高级算法工程师 保险多轮对话 Agent、信息流推荐、作者生态 GNN、用户画像平台 研究与分享 # arXiv:2503.04826：Training-Free 少样本 3D 医学分割框架（SAM2 视频化），基准 SOTA，被 NeurIPS 2025 Spotlight 论文引用 GIAC 2025：分享《提升 LLM 推理能力的 Reward System 设计》 技术主题：VLM 知识蒸馏（Gemini → 轻量模型）、LocatAnything + Grounding-DINO 自动标注、Token-aware Batching 推理优化；申请发明专利 1 项 合作与联系 #目前以独立顾问身份承接企业 AI 落地项目，偏 Agent 平台、垂直行业 Agent 与推理成本优化。\nGitHub：@zzszmyf 邮箱：zzszmyf@outlook.com 精读系列： LLM 推理优化系列 RSS：订阅 ","date":null,"permalink":"https://doraemeng.dev/about/","section":"页面","summary":"孟一凡（zzszmyf / doraeMeng）：独立 AI 顾问，承接企业 AI 落地项目。前百度/BIGO 算法工程师，SGLang 上游贡献者，专注 LLM 推理优化、AI Agent 基础设施与多模态。","title":"关于孟一凡"},{"content":"从数值编码和均匀量化出发，走到权重量化、激活量化、KV Cache、质量评估和部署。章节按学习顺序排列。\n一页规则，不含推导： 量化速查。英文目录： English summary。\n","date":null,"permalink":"https://doraemeng.dev/series/quantization/","section":"页面","summary":"LLM 量化精读系列目录：数值编码、均匀量化、FP8/FP4、GPTQ/AWQ、KV Cache、QAT 与上线验收。","title":"量化精读"},{"content":"这里是不定期更新的非技术随笔：投资与财富、读书笔记、职场认知、行业观察。技术内容在 技术笔记 和 精读系列。\nAI Coding 的供给侧爆炸：需求侧何时跟上？ 2026年5月15日 · 2 分钟 AI Coding 让代码供给爆炸后需求侧如何跟上？分析需求侧爆炸的五条路径：需求民主化、软件流体化、长尾领域软件化、测试安全等次生需求、价值向定义问题转移，并给出程序员的三条转型路径与三个创业方向判断。\n我们需要的不是钱，需要的是财富 2026年5月10日 · 1 分钟 钱和财富的区别：钱只是价值的度量单位和流通工具，会因通胀贬值；财富是能持续创造价值、自生长的资产。用这个视角重新理解指数基金、主动基金和个股投资——本质都是把现在的钱换成未来能创造更多财富的企业所有权，把目标从「赚钱」切换为「积累财富」。\n绩效评级看 Impact，晋升看 Behavior：职场晋升的隐藏规则 2026年5月5日 · 1 分钟 绩效评级与晋升的区别：为什么 Impact 决定 rating、Behavior 决定 promotion？用两个典型场景拆解科技公司绩效管理的双轨逻辑——rating 是过去时、promotion 是将来时，并给出写自评述职和评审他人时的实操建议：干得多决定拿多少钱，干得像决定坐什么位置。\n塔勒布思想系列（6）：为什么我们听过很多道理，却依然过不好这一生？ 2026年4月27日 · 1 分钟 为什么听过很多道理依然过不好这一生？塔勒布《非对称风险》给出的答案是：大多数道理是没押过注的人生产的，只经过修辞打磨、没经过现实筛选。Skin in the Game（风险共担）是最可靠的认知过滤器——听到建议先问：说的人自己做了吗，承担了什么后果？\n工具型还是生命型：软件是该稳定一致，还是该成长变化 2026年4月27日 · 1 分钟 工具型软件与有生命的软件：为什么 Figma 硬塞 AI 功能让人反感，AI 助手天天进化却让人期待？Every 编辑 Jack Cheng《Living Software》译文解读：工具要稳定一致，生命型软件要陪用户成长，并给出控制发布节奏、提前沟通更新、保留用户选择权、加固质量四条产品建议。\n全员 token-maxxing，一场没人敢停的军备竞赛 2026年4月27日 · 2 分钟 硅谷 AI 行业一线观察：YC W26 约 80% 项目是垂直 agent，Meta 全员用 Claude Code 卷 token 消耗排行榜，xAI 早期团队流失 90%，AI 公司估值随 DCF 失效而崩塌——垂直 agent 仅约 5 倍 ARR、模型公司 20-30 倍，唯一确定的赢家是英伟达。\n效率狂魔的自白：语音输入让我写作速度翻倍 2024年12月16日 · 1 分钟 语音输入写作工作流实战：用讯飞听见录音转写，再用 DeepSeek 大模型按提示词和自定义词表润色，词性标注解决财经术语与同音词歧义，并用 Windsurf 搭建整合界面。1500 字稿件从录音到配图排版半小时内完成，写作速度翻倍。\n","date":null,"permalink":"https://doraemeng.dev/essays/","section":"页面","summary":"孟一凡（zzszmyf）的非技术随笔：投资与财富、读书笔记、职场认知与行业观察。与技术笔记分开更新。","title":"随笔"},{"content":"从接受率为什么是无损的写起，经过草稿模型、Medusa 和 EAGLE，到不训练草稿模型的路线和上线验收。\n","date":null,"permalink":"https://doraemeng.dev/series/speculative-decoding/","section":"页面","summary":"投机采样与推测解码精读系列目录：接受率数学、拒绝采样、Medusa、EAGLE、n-gram 与生产验收。","title":"推测解码精读"},{"content":"从 prefill 和 decode 的复杂度差写起，经过 FlashAttention 和 KV 头变体，到分页 KV、内核融合和 RadixAttention。\n","date":null,"permalink":"https://doraemeng.dev/series/attention-kernels/","section":"页面","summary":"注意力与计算内核精读系列目录：复杂度、FlashAttention、MQA/GQA/MLA、PagedAttention、算子融合与前缀缓存。","title":"注意力与计算内核精读"}]