DeepSeek-V4-Flash 架构 QA 文档

基于主报告 deepseek-v4-flash.md 的配套 QA，由浅入深，可作面试准备。
生成日期：2026-06-09 · 范围：V4-Flash（284B/13B 激活）

目录（共 287 问）

• CH 0-3 — 78 问 — 背景 + V3 回顾 + V4 概览
• CH 4-5 — 69 问 — CSA/HCA 注意力 + MoE 路由
• CH 6-7 — 51 问 — mHC 残差 + Muon 优化器
• CH 8-10 — 89 问 — 工程实现 + 源码系统 + 面经高频

本 QA 文档分四章：CH 0 文档说明 + CH 1 LLM 预备 + CH 2 V3 回顾 + CH 3 V4 概览。
适合 LLM 训练有初步认识的学生 / 工程师，自学 + 面试准备两用。
主报告：report/deepseek-v4-flash.md · 术语表：report/appendix-glossary.md

CH 0. 文档说明

Q0.1 这份 QA 文档对应主报告的哪些章节？

简短回答：CH 0–3 覆盖主报告的 CH 0（摘要）+ CH 1（V3.2 → V4 演进）+ CH 2（V4-Flash 整体架构）+ CH 3（注意力 CSA + HCA）。

详细解释：本 QA 是主报告的"问答浓缩版"——主报告每章 5000+ 字、含大量代码公式，对初学者门槛高；本 QA 把每章拆成 20–30 个 Q，每个 Q 用"短答 + 详细解释 + 面试要点"三段式组织。CH 0 教你怎么用本 QA，CH 1 是 LLM 通识基础，CH 2 回顾 V3.2，CH 3 引出 V4 四大创新。CH 4 之后由其他 QA 文档负责。

💡 面试要点：本 QA 是面经速成工具，但完整理解仍要回主报告——主报告是"算子级拆解"，本 QA 是"概念 + 直觉 + 面试要点"。

延伸阅读：主报告 deepseek-v4-flash.md §0

Q0.2 我应该按什么顺序读这份 QA？

简短回答：CH 0 → CH 1 → CH 2 → CH 3 顺序读；有 LLM 基础可跳过 CH 1。

详细解释：

• 完全新手：CH 0 速览 → CH 1 通读 → CH 2 选读 → CH 3 重点读
• 有 LLM 基础：跳过 CH 1 直接读 CH 2 → CH 3
• 面试突击：只看"短答 + 面试要点"
• 架构师 / AI infra：CH 2.1（超参表）+ CH 3.5（FLOPs/cache 节省）是核心

四个章节"自包含但层层递进"：CH 1 不需要 V3/V4 知识、CH 2 只看 V3、CH 3 衔接 V3 的瓶颈引出 V4。

延伸阅读：术语表 appendix-glossary.md B.1

Q0.3 每个 Q 末尾的"💡 面试要点"是什么格式？

简短回答：1–2 句话总结回答里最容易被追问的点，标"💡 面试要点"或"⚠️ 易混淆"。

详细解释：

• 💡 面试要点：面试官常追问的"二阶问题"，如"MLA 为什么用潜空间而不是直接压缩 K/V？"
• ⚠️ 易混淆：两个相似概念的区分点，如"MLA vs MQA"、“CSA vs HCA”——混淆会直接扣分
• 整份 QA 的"💡 / ⚠️"标注统一遵循同一种风格，便于面试前快速扫读

延伸阅读：本 QA 每个 Q 末尾

Q0.4 文档里的"主报告 CH X.Y"引用怎么用？

简短回答：是去主报告查"详细论证"的页码锚点，主报告是本 QA 的真源。

详细解释：本 QA 是"问答式笔记"，主报告是"完整论述"。当本 QA 说"详见主报告 CH 3.5"，意思是主报告 CH 3.5 节有 FLOPs/cache 节省的完整计算与表格。同理：

• 论文引用（V3 paper §5.1）指 DeepSeek-V3 技术报告第 5.1 节
• 仓库引用（inference/model.py:L436）指 V4-Flash 仓库的 inference/model.py 第 436 行
• 符号引用（如 (3.1)）指本主报告的"第 3 章第 1 个公式"约定（见术语表 B.3）

💡 面试要点：面试时若被追问细节，能说"具体公式见论文 §X.Y"比硬背所有数字更显专业。

延伸阅读：术语表 B.3 + B.4

CH 1. LLM 预备知识

Q1.1 Transformer 的"三件套"是什么？

简短回答：Self-Attention（自注意力）+ FFN（前馈网络）+ 残差连接，每个 block 都由这三部分堆叠而成。

详细解释：每个 Transformer block 三步：

1. Self-Attention：让序列内任意两个位置直接"对话"，捕捉 token 之间的依赖
2. FFN：对每个位置做"非线性变换"，常实现为两层 MLP（中间维度通常是 hidden 的 4×）
3. 残差连接：把子层的输入加到输出上（y = x + Sublayer(x)），让深层网络的梯度能直接传回浅层

在 V4-Flash 中：Self-Attention 走 CSA+HCA 混合（CH 3）；FFN 走 MoE（256 routed + 1 shared）；残差走 mHC 多通道版本（CH 5）。三层都做了 V4 创新。

💡 面试要点：被问"Transformer block 由什么组成"时，必须说全三件套——漏掉"残差"或"Norm"会扣分。

延伸阅读：主报告 CH 2.2

Q1.2 Self-Attention 的核心公式是什么？

简短回答： $Attention(Q, K, V) = \mathrm{softmax}(QK^\top / \sqrt{d_k}) \cdot V$ ，先算 query-key 相似度，再加权求 value。

详细解释：Self-Attention 把每个 token 投影成 Q（“我在找什么”）、K（“我代表什么”）、V（“我能提供什么信息”）。三步：

1. 相似度： $QK^\top$ 是 [T, T]，得到每对位置的"匹配分数"
2. 缩放：除以 $\sqrt{d_k}$ ，防止 $\mathrm{softmax}$ 进入饱和区
3. 加权求和： $\mathrm{softmax}(\cdot ) \cdot V$ ，相似度高的位置贡献更多 value

因果 attention 还在 $\mathrm{softmax}$ 前加 causal mask（上三角设为 -∞），让 token t 只能看位置 0..t。

⚠️ 易混淆： $QK^\top$ 是 [T, T] 矩阵，不是“每两个位置算一次乘法”——它是矩阵乘法，一次性算完全部 T² 对。

延伸阅读：主报告 CH 3.1

Q1.3 Multi-Head Attention (MHA) 是什么？

简短回答：把 d 维的 Q/K/V 拆成 h 个头（每个 head 维度 d_h = d/h），每个头独立算 attention，最后 concat 起来。

详细解释：单个 attention 头只能学一种"匹配模式"。Multi-Head 让 h 个头在不同子空间并行算 attention，再把 h 个 $[T, d_h]$ 输出沿 head 维拼回 [T, d]，通过一个 O 投影回 d 维。为什么有效：

• 不同头可以学"主谓一致"、“指代消解”、“长距离依赖"等不同模式
• 总计算量与单头大 head 等价（ $h \cdot d_h$ = d），但表达能力强 h 倍
• V4-Flash： $num_attention_heads=64$, $head_dim=512$ ，d=4096（Q 走 q_lora_rank=1024 先压后升）

⚠️ 易混淆：MHA vs MQA vs GQA vs MLA——这四种是"KV cache 压缩"的四代演进。

延伸阅读：主报告 CH 2.1

Q1.4 FFN（前馈网络）是什么？为什么需要？

简短回答：每个 Transformer block 里的"逐位置 MLP”，对每个 token 独立做非线性变换；与 Attention 的"跨位置"形成互补。

详细解释：Attention 是"跨位置混合"，FFN 是"逐位置变换"。标准 FFN 是两层 Linear + 激活： $FFN(x) = W2 \cdot activation(W1 \cdot x)$ ，中间维度 d_ff 通常是 4d。为什么需要：

• Attention 表达力有限，FFN 引入真正的非线性
• FFN 占据模型总参数量的约 2/3

V4-Flash 的 FFN 走 $\mathrm{SwiGLU}$ 激活（见 Q1.8），256 个 expert × 2 层 × $4096 \times 2048$ = 大头参数。

💡 面试要点：FFN 是"逐位置"还是"跨位置"？答"逐位置"——每个 token 独立算。

延伸阅读：主报告 CH 2.2

Q1.5 MQA / GQA / MLA 是什么？为什么需要？

简短回答：三种"KV cache 压缩"方案，从"全部独立"到"全部共享"再到"潜空间压缩"，逐步降低推理时显存占用。

详细解释：标准 MHA 中，64 个 Q 头对应 64 套 KV，cache 占 $T \times 64 \times d_h \times 2$ ：

• MQA：所有 Q 头共享 1 套 KV（ $num_key_value_heads=1$ ）。cache 缩 64 倍
• GQA：把 Q 头分组共享 KV（如 8 组 → 8 套 KV），MQA 与 MHA 的折中
• MLA（V3.2 引入）：把 K、V 压到 $d_c=512$ 潜空间，比 MQA 质量好，比 GQA cache 还小

V4-Flash $num_key_value_heads=1$ （MQA）+ grouped low-rank O 投影——MLA 思想沿用但更激进。

💡 面试要点：被问"MLA 跟 MQA 区别"时，答"MLA 走潜空间再恢复，MQA 直接共享"——MQA 是’减少 KV 头数’，MLA 是’把 KV 压成低秩再展开’。

延伸阅读：主报告 CH 1.1 + 术语表 B.1

Q1.6 MLA（Multi-head Latent Attention）的详细原理

简短回答：把 K、V 先用低秩矩阵压到 $d_c=512$ 的潜空间 c，推理时只缓存 c 而非 K、V；恢复时用另一个矩阵升回多头维度。

详细解释：

1. 压缩： $c_t = W_down \cdot x_t$ ， $c_t \in \mathbb{R}^{d_c=512}$ ≪ $h \times d_h = 8192$
2. 缓存：只存 $c_t$ ，不存原始 K、V
3. 恢复： $k_t = W_k_up \cdot c_t$ ， $v_t = W_v_up \cdot c_t$ ，临时升回多头

Cache 大小： $T \times d_c \times L \times 2 \approx 131 GB$ （V3.2 1M 上下文）。比 MHA 省 16 倍（8192/512 = 16）。V4-Flash 比 V3.2 更激进——d=4096（vs 7168）、L=43（vs 61），且用 CSA/HCA 进一步把 cache 沿时间维压缩。

⚠️ 易混淆：MLA 不只是"MQA + LoRA"——MQA 是直接共享，MLA 是"潜空间压缩后再恢复"。

延伸阅读：主报告 CH 1.1

Q1.7 MoE（Mixture of Experts）是什么？

简短回答：把单个大 FFN 拆成 N 个"专家 FFN" + 一个"路由门"，每个 token 只激活 k 个专家；总参数大但单 token 计算小。

详细解释：

• 路由门： $gate(x) = W_gate \cdot x$ 得 N 个分数；top-k 选 6 个（V4-Flash）；k 个专家 FFN 算；加权和输出

关键优势：

• 总参：N × 单个 FFN 参数量（如 256 × 17M ≈ 4.3B）
• 激活参：k × 单个 FFN 参数量（6 × 17M = 100M）——比稠密 FFN 少 256/6 ≈ 43 倍
• 质量：逼近稠密模型，训练成本低 5× 以上

V4-Flash：256 routed（FP4）+ 1 shared（FP8 始终激活），top-6 routed 加权和 × 1.5 后与 shared 相加。

💡 面试要点：MoE 的核心是"总参大、激活小"——被问"MoE 比稠密模型有什么优势"答这个。

延伸阅读：主报告 CH 4

Q1.8 $\mathrm{SwiGLU}$ 是什么？和标准 FFN 的 $\mathrm{ReLU}$ 有什么区别？

简短回答： $\mathrm{SwiGLU}$ = $Swish(xW) \odot (xV)$ ，把 GLU 的 $\mathrm{sigmoid}$ 换成 Swish（ $x\cdot \mathrm{sigmoid}(x)$ ）；比 $\mathrm{ReLU}$ 在 LLM 上效果更好。

详细解释：标准 FFN： $FFN(x) = W2 \cdot \mathrm{ReLU}(W1 \cdot x)$ 。GLU 系列把单 Linear 拆成两个 Linear + 门控：

• GLU： $GLU(x) = (xW) \odot \mathrm{sigmoid}(xV)$
• $\mathrm{SwiGLU}$： $\mathrm{SwiGLU}(x) = (xW) \odot Swish(xV)$ ，Swish(x) = x·$\mathrm{sigmoid}$(x)
• GeGLU 等变体

V4-Flash 用 $\mathrm{SwiGLU}$ （ $hidden_act: “silu”$ ，SiLU = Swish），中间维度 2048。V4 特殊设计： $swiglu_limit=10.0$——把输出钳制在 ±10，防 FP4 量化溢出。

⚠️ 易混淆： $\mathrm{SwiGLU}$ 的"门"是 element-wise 乘法（ $\odot$ ），不是矩阵乘法。

延伸阅读：主报告 CH 2.1

Q1.9 $\mathrm{RMSNorm}$ vs $\mathrm{LayerNorm}$ 是什么关系？

简短回答： $\mathrm{RMSNorm}$ 去掉 $\mathrm{LayerNorm}$ 的"减均值"步骤，只做"除以 RMS"，参数更少、训练更稳。

详细解释：

• $\mathrm{LayerNorm}$： $y = (x − \mu) / \sigma \cdot \gamma + \beta$
• $\mathrm{RMSNorm}$： $y = x / RMS(x) \cdot \gamma$ ， $RMS(x) = \sqrt{\mathrm{mean}(x^2)}$ ，无 β、无减均值

优势：计算量减少约 30%；LLM 训练稳定性更好（Llama/DeepSeek 全用 $\mathrm{RMSNorm}$ ）。V4-Flash： $rms_norm_eps=1e-6$ （数值稳定项）。

⚠️ 易混淆： $\mathrm{RMSNorm}$ 仍保留可学习的 γ（缩放），只是去掉了 β（平移）。

延伸阅读：主报告 CH 2.1

Q1.10 RoPE（Rotary Position Embedding）是什么？

简短回答：把位置信息编码成"旋转让 query/key 与位置 m 的夹角一致"，通过把 Q、K 的复数表示乘 $e^{i\cdot m\cdot \theta}$ 实现。

详细解释：

• 把 d 维向量两两一组看成 d/2 个复数
• 第 m 个位置的 Q/K 整体乘 $e^{i\cdot m\cdot \theta_k}$ ，θ_k = base^(-2k/d)
• 关键性质： $\langle q_m, k_n\rangle$ 只与 (m − n) 有关——天然支持相对位置、长度外推

V4-Flash： $rope_theta=10,000$ 、 $qk_rope_head_dim=64$ （只对每头 64 维施加 RoPE，剩余 448 维不带位置信息）、1M 上下文走 YaRN 扩展。

💡 面试要点：RoPE 的核心优势是"相对位置 + 长度外推"。

延伸阅读：主报告 CH 2.1 + Q1.23

Q1.11 KV cache 是什么？为什么需要？

简短回答：推理时把之前算过的 K、V 缓存起来，避免每生成一个新 token 都重新算整段序列。

详细解释：LLM 推理分两阶段：

• Prefill：把整个 prompt 一次性塞进模型，算出所有 K、V 存进 cache
• Decode：每生成一个新 token，只算当前 Q，与 cache 里的 K 算 attention

为什么需要：

• 不缓存：每生成 1 个 token 要重算整段，$O(T^2)$ FLOPs
• 缓存：每生成 1 个 token 只算 1 次新 Q，$O(T)$ FLOPs

代价：cache 占用 $T \times d \times L \times 2$ 。V4-Flash 用 MQA + CSA/HCA 压缩，cache 比 V3.2 MLA 还小约 15 倍。

⚠️ 易混淆：KV cache 只在 decode 阶段用。

延伸阅读：主报告 CH 3.1

Q1.12 $O(n^2)$ 灾难是什么？

简短回答：标准 attention 的 FLOPs 与序列长度的平方成正比，T=1M 时算力爆炸（单 token FLOPs ≈ 8.6×10⁹）。

详细解释：单 token 推理视角下，attention 要算 T 个内积，T=1M 时单 token 要 8.6×10⁹ FLOPs（ $2 \times 1,048,576 \times 4096$ ），仅 attention 算力就吃满 H200。prefill 阶段更严重——算整段 $T \times T$ 矩阵，43 层累计 ≈ 1.9×10¹⁷ FLOPs，单卡要 ~96 秒。V4 的 CSA / HCA 用"时间维压缩"把 T² 降到 T²/m（m=4 或 128），从根上解决 $O(n^2)$ 灾难。

💡 面试要点：被问"长上下文为什么难"时，先答 $O(n^2)$ 再答 KV cache——这是两个独立的瓶颈。

延伸阅读：主报告 CH 3.1 + CH 3.5

Q1.13 $\mathrm{FlashAttention}$ 是什么？

简短回答：通过"分块算 + online $\mathrm{softmax}$“避免物化完整的 [T, T] attention 矩阵，显存从 $O(T^2)$ 降到 $O(T)$，且利用 GPU SRAM 提速。

详细解释：标准 attention 要先算完整 $QK^\top$ （[T, T] 矩阵）再 $\mathrm{softmax}$ 再乘 V——T=1M 时单精度要 4TB。 $\mathrm{FlashAttention}$ 思路：

1. 把 Q、K、V 切成 block 装进 GPU SRAM
2. 用 online $\mathrm{softmax}$ （维护 running max/sum）逐步处理每个 block
3. 不存中间 [T, T] 矩阵，只存最终输出

V4-Flash 的 $sparse_attn_kernel$ （inference/kernel.py）就是 $\mathrm{FlashAttention}$ 风格 + 稀疏 gather。

💡 面试要点： $\mathrm{FlashAttention}$ 的两个核心创新：online $\mathrm{softmax}$ （数值稳定）+ SRAM 优先（IO-aware）。

延伸阅读：主报告 CH 3.6

Q1.14 Pre-Norm vs Post-Norm 是什么区别？

简短回答：Pre-Norm 把 Norm 放在子层之前（y = x + Sublayer(Norm(x))），Post-Norm 把 Norm 放在子层之后（y = Norm(x + Sublayer(x))）。

详细解释：

• Pre-Norm（V3/V4 用）： $x_{l+1} = x_l + Sublayer(Norm(x_l))$——梯度直接流过残差，训练稳定
• Post-Norm（原 Transformer）： $x_{l+1} = Norm(x_l + Sublayer(x_l))$——梯度被 Norm 影响，需要 warmup

⚠️ 易混淆：Pre-Norm 训练的模型推理时通常需要 final Norm（主输出前再 Norm 一次）。

延伸阅读：主报告 CH 1.2

Q1.15 AdamW 优化器基础

简短回答：Adam（自适应学习率）+ decoupled weight decay 的组合，是 LLM 训练的事实标准。

详细解释：

1. 一阶矩 m（动量）：梯度的指数移动平均
2. 二阶矩 v（方差）：梯度平方的指数移动平均
3. 更新： $\theta ← \theta − \eta \cdot m / (\sqrt{v} + \epsilon)$
4. Weight decay： $\theta ← \theta − \eta \cdot \lambda \cdot \theta$ （不通过 m、v，decouple）

为什么适合 LLM：自适应学习率（适合稀疏梯度如 MoE 路由）、训练稳定。V4-Flash 改用 Muon（V4 创新）——见 CH 6。

💡 面试要点：AdamW vs Adam 的区别是”decoupled weight decay"——weight decay 不进 m、v。

延伸阅读：主报告 CH 6

Q1.16 训练 token / 训练算力（Chinchilla 法则）

简短回答：Chinchilla 法则：模型参数 N 与训练 token D 应满足 $D \approx 20N$ （算力最优），偏离这条线一侧是"过度训练"或"欠训练"。

详细解释：

• LLaMA-2-7B 训练 2T → 接近最优
• V3 14.8T / 671B → D/N ≈ 22，接近 Chinchilla 最优
• V4-Flash 32T / 284B → D/N ≈ 113，显著过训练——走"小模型、长训练"路线

⚠️ 易混淆：Chinchilla 是算力最优，不是质量最优——质量上不一定最优，但算力利用率最高。

延伸阅读：主报告 CH 1.1 + CH 3.5

Q1.17 FP8 / FP16 / BF16 是什么？

简短回答：三种浮点格式，bit 数相同但 exponent/mantissa 切分不同；LLM 训练最常用 BF16（前向） + FP32（主权重）。

详细解释：

为什么需要 FP8：训练时一半显存、2× 算力（H100/H200 有 FP8 tensor core）。LLM 梯度动态范围大，BF16 比 FP16 稳定。V4-Flash：routed expert 用 FP4，attention / shared expert 用 FP8（E4M3）。

延伸阅读：主报告 CH 1.1 + CH 7

Q1.18 量化：PTQ vs QAT

简短回答：PTQ（Post-Training Quantization）：训完模型再量化；QAT（Quantization-Aware Training）：训练中模拟量化，模型适配量化。

详细解释：

• PTQ：拿训好的模型，用小校准集统计 activation range，直接把权重 / 激活值映射到低 bit。优点：简单快；缺点：低 bit（FP4 / INT4）质量掉得多
• QAT：训练 forward 中插入"伪量化算子"（ $fake_quant(x)$ = round(x / scale) * scale），梯度照常反传。模型在前向时就"看到"量化后的分布，适配量化、损失小

V4-Flash 走 QAT：forward 模拟 FP4 / FP8，backward 用 FP32 主权重 + 量化感知梯度。

💡 面试要点：QAT vs PTQ 选哪个？答"低 bit（FP4/INT4）必须 QAT"。

延伸阅读：主报告 CH 7

Q1.19 推理 vs 训练有什么区别？

简短回答：训练需要"前向 + 反向 + 优化器 step"占大量显存（3× 激活）；推理只需要前向 + KV cache。

详细解释：

• 训练：FP32 主权重（4B/参） + FP16/BF16 副本（2B/参） + FP16 优化器状态（8B/参） + 激活。总 ≈ 16–20 × 参数
• 推理：BF16 主权重（2B/参） + KV cache（T × d × L × 2）。总 ≈ 2–4 × 参数 + KV

V4-Flash 推理进一步量化到 FP4（routed 0.5B/参）+ FP8（其他 1B/参），总权重 ≈ 426 GB——但激活只 13B，单 batch 2×H200 可跑。

⚠️ 易混淆：训练"激活"显存与推理"KV cache"是完全不同的概念——前者是反向用的中间值，后者是 attention 用的历史 K/V。

延伸阅读：主报告 CH 1.4

Q1.20 LLM 训练目标函数（next-token prediction）是什么？

简短回答：标准的 causal language modeling——给定前 t-1 个 token，预测第 t 个 token，用 cross-entropy loss。

详细解释：

• 输入：token 序列 $[t_1, t_2, …, t_T]$
• 模型输出 logits $[T, vocab_size]$
• Loss： $-mean(log_softmax(logits)[t])$
• 等价于"全部位置都做监督"——T 个 token 给出 T 个监督信号

V3/V4 沿用标准的 next-token prediction + MTP（Multi-Token Prediction）。MTP 在每个主位置额外预测下 1 个 token，监督信号 × 2。

💡 面试要点：被问"LLM 怎么训练"答"next-token prediction (causal LM) + cross-entropy"。

延伸阅读：主报告 CH 1.1

Q1.21 因果 attention（Causal / Masked Attention）是什么？

简短回答：在 $\mathrm{softmax}$ 前用 mask 把"未来位置"屏蔽掉（设为 -∞），让 token t 只能看位置 0..t。

详细解释：decoder-only LLM 要求"训练时第 t 个 token 不能看到第 t+1..T 个位置"。实现：

attn = QK^⊤ / √d_k
attn = attn.masked_fill(causal_mask, -inf)
attn = softmax(attn)
out = attn · V

V4-Flash 的 sparse attention 也保留因果性——CSA/HCA 的 top-k 只在"≤ 当前 position 的压缩段"里选。

⚠️ 易混淆：因果 mask 的"未来"是严格大于 t，不是 ≥；位置 t 可以看自己（attn 对角线保留）。

延伸阅读：主报告 CH 3.6

Q1.22 词表（Vocabulary）与 Tokenizer 基础

简短回答：词表是把字符串切成 token 的"字典"，常见有 BPE、WordPiece、SentencePiece。V4-Flash $vocab_size=129,280$ 。

详细解释：

• BPE：从字符开始，迭代合并最高频对——GPT 系用
• WordPiece：BPE 的变体——BERT 用
• SentencePiece：从语言无关角度做 BPE/Unigram——Llama/DeepSeek 用

V4-Flash 走 SentencePiece（继承 DeepSeek-V3 词表），词表大小 129,280。词表越大，1 个 token 可编码更长字符串（推理步数减少）；但太大让 embedding 表参数量大（V4-Flash embedding ≈ 129,280 × 4096 ≈ 530M）。

延伸阅读：主报告 CH 2.3

Q1.23 YaRN（Yet another RoPE extensioN）是什么？

简短回答：把 RoPE 的"高频维度"和"低频维度"分别处理，从 64K 上下文扩展到 1M 上下文。

详细解释：标准 RoPE 在外推到更长上下文时，“低频维度”（波长长）会"过采样"导致信息丢失。YaRN 的解法：

• 高频维度（波长短）：直接外推即可
• 低频维度（波长长）：插值（“拉伸”），让波长变长以匹配新长度
• 中间维度：两者线性插值

V4-Flash： $rope_scaling.type=“yarn”$, factor=16, $original_max_position_embeddings=65536$ （64K），目标 1,048,576（1M）= 64K × 16。

延伸阅读：主报告 CH 2.1

Q1.24 推理时 KV cache 的"prefix caching"是什么？

简短回答：同一个 prompt 被多次请求时，cache 里的 K/V 可以复用，省掉第二次的 prefill 计算。

详细解释：两个用户问相同问题，第二次的 prompt 完全一样——KV cache 完全可以复用。工程实现：

• 用哈希标识 prompt prefix
• LRU 淘汰旧 cache
• vLLM、TensorRT-LLM 等推理引擎默认支持

V4-Flash 的 CSA/HCA 也支持 prefix caching（KV cache 本身就是可复用的）。

延伸阅读：术语表 B.1

Q1.25 Grouped Low-Rank O 投影（grouped LoRA for O）

简短回答：把 O 投影（attention 输出）按 head 分组，组内共享一个低秩矩阵——省 cache + 提速，质量损失小。

详细解释：标准 O 投影： $O = attn_out \cdot W_O$ ，参数量 d² = 4096² = 16.8M。Grouped 版本：

• 64 个 head 分 8 组（ $o_groups=8$ ）
• 每组共享一个 $W_O_a: 4096 \to 1024$ （ $o_lora_rank=1024$ ）
• 再 $W_O_b: 1024 \to 4096$ 升回 d
• 参数量： $8 \times (4096\times 1024 + 1024\times 4096) \approx 67M$——比 8×16.8M = 134M 少一半

V4-Flash 沿用 V3 的 grouped low-rank O 投影——Q 投影走 $q_lora_rank=1024$ （同样的"先压后升"），O 投影走 8 组分组。

💡 面试要点：grouped low-rank 是"分组 + 低秩“的组合。

延伸阅读：主报告 CH 3.4 + Q1.5

Q1.26 $O(n^2)$ 灾难的另一个视角：prefill vs decode

简短回答：prefill 是"算完整 T×T attention 矩阵”，decode 是"每生成一个 token 算一次新 Q 的 attention"；前者 $O(T^2)$ 算力，后者 $O(T)$ 算力但 T 大时仍吃不消。

详细解释：

• Prefill（V4-Flash 1M prompt）：单层 4.5×10¹⁵ FLOPs，43 层 1.9×10¹⁷ FLOPs——单卡 H200 ~96 秒
• Decode（每 token）：单层 8.6×10⁹ FLOPs，43 层 3.7×10¹¹ FLOPs——单卡 ~0.2 秒（但 cache 占用 1.4 TB，根本装不下）

V4 的 CSA/HCA 同时解决预填充算力（T²/m 减 4–128 倍）和解码 cache（cache 减 4–128 倍）。

延伸阅读：主报告 CH 3.1

Q1.27 推理引擎（vLLM / TensorRT-LLM / SGLang）的作用是什么？

简短回答：把"训练好的模型"包装成"高吞吐、低延迟的 HTTP 服务"，处理 batching、KV cache 管理、量化 kernel 等。

详细解释：原始 HF 模型不能直接上线——需要：

• Continuous batching：动态拼 batch，最大化 GPU 利用率
• PagedAttention（vLLM）：把 KV cache 分页管理
• TensorRT-LLM kernel 优化：针对特定 GPU 调优
• 量化加载：FP4 / FP8 / INT4 权重加载

V4-Flash 官方仓库 DeepSeek-AI/DeepSeek-V4-Flash 提供自己的推理代码（inference/ 目录），不走 vLLm（因 CSA/HCA 是新结构）。生产部署通常需要等 vLLM 适配 CSA/HCA。

延伸阅读：主报告 CH 2.3

Q1.28 SFT / RLHF / DPO 是什么？

简短回答：模型"对齐"的三阶段：SFT（监督微调）→ RLHF（PPO 等）→ DPO（直接偏好优化）。V4 走"领域专家 + on-policy 蒸馏"。

详细解释：

• SFT：在高质量"指令-回答"对上做监督微调
• RLHF：训练奖励模型（RM），用 PPO 让 LLM 输出 RM 高分
• DPO：跳过 RM，直接在"好回答 vs 坏回答"对上训练

V4 走领域专家 + on-policy 蒸馏（V4 创新）：训多个领域专家 → 用专家生成 on-policy 输出 → 主模型蒸馏。

⚠️ 易混淆：V4 的"on-policy distillation"与 RLHF 共享"用模型自己的输出做训练"思想，但目标函数不同——蒸馏是匹配专家分布，RLHF 是匹配奖励。

延伸阅读：主报告 CH 7

CH 2. V3 回顾

Q2.1 V3 的发布时间和参数量是多少？

简短回答：DeepSeek-V3 2024-12 发布，总参 671B / 激活 37B；2025-09 发布 V3.2-Exp 改进版。

详细解释：

• DeepSeek-V3（2024-12-26）：671B 总参 / 37B 激活，首次大规模 FP8 训练 + MLA + DeepSeekMoE
• DeepSeek-V3.2 与 V3.2-Exp（2025-09-29）：V3 的后续改进版，引入aux-loss-free 负载均衡
• 训练量：V3 公开 14.8T tokens（V3.2-Exp 训练量未官方公开）

V4-Flash 的"前身"是 V3.2——V4 的所有设计都是"V3.2 的瓶颈 + V4 的解法"。

延伸阅读：主报告 CH 1.1

Q2.2 V3 与 V2 的关键区别是什么？

简短回答：V2 用"细粒度专家 + 共享专家"的 DeepSeekMoE；V3 在 V2 基础上规模从 236B 扩到 671B，并首次大规模用 FP8 训练。

详细解释：

• V2（2024-05）：236B 总参 / 21B 激活，DeepSeekMoE 雏形
• V3（2024-12）：671B / 37B 激活，参数 × 2.8 / 激活 × 1.8
• 关键技术差异：
  1. MLA：V2 没有，V3 引入
  2. FP8 训练：V2 走 BF16，V3 走 E4M3/E5M2 FP8
  3. 专家数：V2 160 routed / 2 shared，V3 256 routed / 1 shared
  4. 共享专家策略：V3 收敛到 1 个 shared（V2 的 2 个 shared 表现差）

💡 面试要点：V2 → V3 → V4 的演进主轴是"稀疏化 + 低精度"。

延伸阅读：主报告 CH 1.1

Q2.3 V3 的 MLA 详细原理（与 Q1.6 的差异）

简短回答：MLA 把 K、V 压到 $d_c=512$ 潜空间；V3 实际是"V2 的多头 attention + 潜空间压缩"。

详细解释（补充 Q1.6）：

• V3 MLA 输入： $x \in \mathbb{R}^{T\times d}$ ，d=7168（V3 维度，V4-Flash 是 4096）
• 压缩： $c_t = W_down \cdot x_t$ ， $c_t \in \mathbb{R}^{d_c=512}$
• 缓存：cache 存 $c_t$ （一个 512 维向量）
• Q 端： $q_t = W_q_up \cdot x_t$ 直接投影，不压缩 Q
• K, V 端恢复： $k_t = W_k_up \cdot c_t$ 、 $v_t = W_v_up \cdot c_t$

V3 与 V4-Flash 的 MLA 区别：

• V3：61 层，d=7168，128 head
• V4-Flash：43 层，d=4096，64 head，但 V4-Flash 走 MQA（KV 头=1）+ CSA/HCA，cache 比 V3 MLA 还小

延伸阅读：主报告 CH 1.1 + Q1.6

Q2.4 V3 的 MoE 设计（细粒度专家 + 共享专家）

简短回答：256 个 routed expert（细粒度）+ 1 个 shared expert（始终激活），top-8 routed 加权 + shared 输出。

详细解释：

• 细粒度专家：单个 expert 中间维度小（如 2048），但 expert 数量多（256），总参数大、激活小
• 共享专家：1 个 shared expert 始终激活——不参与路由，保证"通用知识"在所有 token 上都有覆盖
• top-k 路由：每个 token 选 8 个 routed expert（V3.2 沿用 8，V4-Flash 降到 6）
• routed scaling factor：V3 用 1.0，V4-Flash 用 1.5

**为什么"细粒度"？**专家数 N 大 + 单个 expert 中间维度小，比"少量大专家"组合灵活性高。

💡 面试要点：细粒度的关键不是"专家小"而是"专家多 + 单个不独大"。

延伸阅读：主报告 CH 1.1 + Q1.7

Q2.5 V3 的 FP8 训练

简短回答：V3 是第一个用 FP8 训练 671B 模型的开源工作；前向用 E4M3，反向用 E5M2（动态范围更大）。

详细解释：

• FP8 E4M3（4 exponent + 3 mantissa）：前向激活 + 权重，范围 ±448，精度较高
• FP8 E5M2（5 exponent + 2 mantissa）：反向梯度，范围 ±57344，精度低但范围大
• Block-wise scaling：每 128 个元素共享一个 scale factor（ $weight_block_size=[128, 128]$ ）
• Fine-grained quantization：按 token × block 动态算 scale

V4-Flash 进一步：attention / shared / 公共部分用 FP8，routed expert 量化到 FP4。

⚠️ 易混淆：FP8 训练 ≠ FP8 推理——FP8 训练指训练时前向/反向用 FP8，FP8 推理指部署时权重用 FP8。

延伸阅读：主报告 CH 1.1 + Q1.17

Q2.6 V3 的负载均衡（aux loss）

简短回答：训练时加一个"专家负载均衡辅助 loss"，鼓励各 expert 命中率均匀。

详细解释：

• 传统 aux loss： $L_aux = \alpha \cdot \Sigma_e (f_e \cdot p_e)$ ，f_e 是命中率，p_e 是平均概率
• 最小化 L_aux 等价于"让所有 expert 命中率都接近 1/N"
• 问题：aux loss 会"污染"主 loss
• V3 用 $\alpha=0.0001$ （很小的权重）

V3.2-Exp 改进：改用 aux-loss-free bias——给每个 expert 加一个标量 b_e，命中率高 → b 减小，命中率低 → b 增大。

延伸阅读：主报告 CH 1.1 + Q2.7

Q2.7 V3.2-Exp 引入的"aux-loss-free bias"是什么？

简短回答：放弃 aux loss，改用 per-expert 标量偏置 b_e 调节 top-k 选择；b_e 不进梯度，不影响 routing weight 本身。

详细解释：

• 训练时：跟踪每个 expert 的命中率 f_e（用 EMA 平滑）
• 命中率 > 1/N：把 b_e 减小 ε → 该 expert 排名下降 → 命中率回落
• 命中率 < 1/N：把 b_e 增大 ε → 排名上升 → 命中率回升
• b_e 只在 topk(score + b) 时加，不影响 $gate(x) = W_gate \cdot x$ 本身

为什么更好：主 loss 不被 aux loss 污染，训练更稳定。V4-Flash 直接采用（ $topk_method: “noaux_tc”$ ）。

💡 面试要点：被问"MoE 怎么均衡负载"时，先答 aux loss（传统），再答 aux-loss-free bias（V3.2+）。

延伸阅读：主报告 CH 1.1

Q2.8 V3.2 相对 V3 的改进点

简短回答：V3.2 主要是 V3 的稳定性 / 推理优化版本——FP8 推理 kernel、aux-loss-free bias、MTP 微调等。

详细解释：

• V3（2024-12）：671B / 37B 激活，14.8T tokens 训练
• V3.2 / V3.2-Exp（2025-09）：在 V3 基础上加入：
  • aux-loss-free bias（见 Q2.7）
  • 优化推理 kernel
  • 改进的 post-training 流程
  • 公开的"思考模式"（reasoning mode）支持

V3.2 是 V4 的"直接前身"——V4 设计文档明确说"V3.2 在 1M 长上下文与超大规模训练上还有四类具体瓶颈"。

延伸阅读：主报告 CH 1.1

Q2.9 V3.2-Exp 是什么？

简短回答：V3.2 的"实验版"——DeepSeek 2025-09 发布，作为 V3.2 的实验性变体，公开了更多训练细节。

详细解释：

• V3.2：定位"生产可用"的稳定版本
• V3.2-Exp：定位"探索性"实验版，公开更多架构细节（特别是 aux-loss-free bias 的具体数值）

V4 设计文档多处引用 V3.2-Exp 报告。V3.2-Exp 的训练量未官方公开（v0.1 草稿阶段）。

延伸阅读：主报告 CH 1.1 + CH 1.2

Q2.10 V3 训练 14.8T tokens 的含义

简短回答：V3 在 14.8T tokens 上训练完成（V3 论文 §5.1 公开）；按 Chinchilla 法则，14.8T/671B ≈ 22 tokens/param——接近算力最优。

详细解释：

• 14.8T = 14.8 万亿
• 比 LLaMA-2-7B（2T tokens）多 7×
• 14.8T 是"V3 论文公开训练量"

V4-Flash 公开 32T tokens，是 V3 公开 14.8T 的 2.2×——V4 走"小模型、长训练"路线。

延伸阅读：主报告 CH 1.1 + Q1.16

Q2.11 V3 与 V4 的关系

简短回答：V4 是 V3.2 的"超大规模 + 1M 上下文 + 四大创新"版本；V3.2 的四个瓶颈直接催生 V4 的四处创新。

详细解释（V3.2 瓶颈 → V4 创新一一对应）：

V4-Flash（284B / 13B 激活）相比 V3.2（671B / 37B 激活）：

• 总参缩 2.4×（671B → 284B）
• 激活缩 2.8×（37B → 13B）
• block 数缩 1.4×（61 → 43）
• top-k 缩 1.3×（8 → 6）

💡 面试要点：V4 不是"V3 升级版"而是"V3 的瓶颈回答"——四大瓶颈 → 四大创新 一定要背。

延伸阅读：主报告 CH 1.2

Q2.12 V3 的 Multi-Token Prediction (MTP) 是什么？

简短回答：每个主位置额外预测下一个 token（让监督信号 × 2），提升训练效率 + 数据效率。

详细解释：

• 标准 next-token prediction：每个位置预测下一个，监督信号 T 个
• MTP：每个位置预测下 1 + 下 2 个 token，监督信号 2T 个
• V3 用 $num_nextn_predict_layers=1$ （预测下 1 个），V4-Flash 沿用 =1

优势：数据效率高（同样 token 给出 2× 监督）；推理时可"投机解码"（speculative decoding）——MTP 输出先验证、命中则一次推进多步。

延伸阅读：主报告 CH 2.1

Q2.13 V3 的训练时长

简短回答：V3 训练用约 2 个月（V3 论文 §5.1 公开：约 2.788M H800 GPU 小时）；V3.2-Exp 与 V4-Flash 的具体时长未公开。

详细解释：

• V3：2.788M H800 GPU 小时 = 2× 3584 GPU × 约 16.4 天 = 约 55 天（实际稍长）
• 训练 FLOPs ≈ 6 × 671B × 14.8T ≈ 5.95×10²⁵ FLOPs
• 实际 2.788M GPU 小时 ≈ 32 天（理论最低 8 倍，差距来自 IO、通信、kernel 未完全优化）

V4-Flash 训练 32T tokens，需要的 FLOPs 是 V3 的 32/14.8 × (13/37) × …，整体训练成本量级相近。

延伸阅读：主报告 CH 1.1

Q2.14 V3 论文关键章节速查

简短回答：V3 论文的关键章节：§1 引言、§3 架构（MLA + MoE）、§5 训练（FP8 + DualPipe + aux loss）、§6 评测。

详细解释：

• §1 引言：总参 671B / 激活 37B / 14.8T tokens
• §3 架构：MLA（d_c=512）、DeepSeekMoE（256 routed + 1 shared, k=8）
• §4 训练数据：14.8T tokens 数据集组成
• §5 训练：FP8 路径、DualPipe 流水线、aux loss 系数、Pre-Norm
• §6 评测：MMLU、HumanEval、GSM8K、Math 等基准

延伸阅读：主报告 CH 1.1

Q2.15 V3 vs V4 训练数据的差异

简短回答：V3 训练 14.8T tokens（公开）；V4-Flash 训练 32T tokens（公开），2.2× 量；数据配比 V4 调整（更多推理 / 代码 / 多语言）。

详细解释：

• V3 数据：14.8T tokens，中英 8:2
• V4-Flash 数据：32T tokens，更偏 reasoning 与 code（“思考模式"需要）

V4-Flash 训练量翻倍但激活只 13B——这意味着单位算力的训练密度大幅提升（小模型 + 长训练 + Muon 优化器 + FP4 量化）。

延伸阅读：主报告 CH 1.1 + CH 3.5

Q2.16 V3 的路由函数

简短回答：V3 用 $\mathrm{softmax}(W_gate \cdot x)$ 后取 top-k；V3.2-Exp 引入 “noaux_tc”（无 aux loss + $\mathrm{sigmoid}$ scoring）——V4-Flash 沿用 $\mathrm{sqrtsoftplus}$ 变体。

详细解释：

• V3 标准路由： $s = \mathrm{softmax}(W_gate \cdot x)$ ，topk(s, k) —— 用 $\mathrm{softmax}$ 归一化
• V3.2-Exp 改进：用 $\mathrm{sigmoid}(W_gate \cdot x)$ 取代 $\mathrm{softmax}$——$\mathrm{sigmoid}$ 不强制概率和为 1
• V4-Flash：用 $sqrt(\mathrm{softplus}(s \cdot W_gate))$ （ $\mathrm{sqrtsoftplus}$ ）——$\mathrm{softplus}$ 的平滑性 + sqrt 的数值稳定性

延伸阅读：主报告 CH 2.1

Q2.17 V3 的"训练 14.8T tokens"为什么对 V4 设计重要？

简短回答：V3 的 14.8T 是开源 LLM 公开训练量最大的之一；V4-Flash 公开 32T（2.2×），证明 V4 走"小模型 + 更长训练"路线。

详细解释：

• 14.8T tokens 对 671B 来说 D/N ≈ 22（Chinchilla 最优）——V3 接近"算力最优”
• V4-Flash 284B / 32T tokens → D/N ≈ 113——显著过训练
• 这意味着 V4-Flash 的"单位参数训练量"是 V3 的 5×——“小而精"路线

延伸阅读：主报告 CH 1.1 + Q1.16

Q2.18 V3.2 vs V3.2-Exp 的差异

简短回答：V3.2 是"生产版”（部署友好），V3.2-Exp 是"实验版"（公开更多训练细节）；架构差异不大。

详细解释：

• V3.2：定位稳定生产；FP8 推理 kernel 优化
• V3.2-Exp：定位实验探索；公开 aux-loss-free bias 的具体数值；未优化的 FP4 探索

V4 设计文档多处引用 V3.2-Exp 的"瓶颈描述"——V3.2-Exp 是 V4 的"问题清单"。

延伸阅读：主报告 CH 1.2

Q2.19 V3 的 DualPipe 流水线

简短回答：DualPipe 是 V3 论文公开的"通信-计算 overlap 流水线"，把数据并行 + 流水线并行的通信隐藏在计算里。

详细解释：

• 数据并行（DP）：每张卡持有一份完整参数，参数同步走 all-reduce
• 流水线并行（PP）：把模型按层切到不同卡，stage 间走 P2P
• DualPipe：把"算下一个 stage"和"同步当前 stage 的梯度"重叠，减少 bubble

V3 训练用 2048 H800，DualPipe 让 MFU 达到 ~52%——比单纯 PP 高很多。

V4-Flash 训练是否沿用 DualPipe 未公开——v0.1 草稿阶段。

延伸阅读：主报告 CH 1.2

Q2.20 V3 的"负载均衡"为什么对 V4 重要？

简短回答：V3 走"aux loss"会污染主 loss，V3.2-Exp 改用 “aux-loss-free bias”——V4-Flash 沿用 V3.2-Exp 的设计（ $topk_method: “noaux_tc”$ ）。

详细解释：

• 传统 aux loss：让主 loss 加一项 L_aux 鼓励 expert 命中均匀——影响主 loss 收敛
• aux-loss-free bias：用 per-expert 标量 b_e 调节 top-k，b_e 不进梯度——主 loss 不被污染
• V4-Flash： $topk_method=“noaux_tc”$——直接走 V3.2-Exp 的方案

💡 面试要点：被问"V3.2 与 V3 训练上最大的区别"答"aux-loss-free bias"。

延伸阅读：主报告 CH 1.1 + Q2.6/Q2.7

Q2.21 V3 的"4D 并行"组合

简短回答：V3 训练用 TP（张量并行）+ PP（流水线并行）+ DP（数据并行）+ EP（专家并行）的 4D 并行。

详细解释：

• TP（Tensor Parallel）：把单个矩阵乘切到多卡，NCCL all-reduce 通信
• PP（Pipeline Parallel）：按层切到多卡，stage 间 P2P 通信
• DP（Data Parallel）：每卡持有一份完整参数，all-reduce 同步梯度
• EP（Expert Parallel）：把不同 expert 放到不同卡，all-to-all 路由 token

V3 用 2048 H800，4D 组合让 671B 模型训练变成可解问题。V4-Flash 训练量级与 V3 接近，4D 并行沿用（具体未公开）。

延伸阅读：主报告 CH 1.2

CH 3. V4 概览

Q3.1 V4 的发布时间和 4 个模型卡是什么？

简短回答：DeepSeek-V4 2026-04-24 发布；4 个模型卡 = V4-Pro-Base（1.6T / 49B 激活 / FP8）+ V4-Pro（1.6T / 49B / FP4+FP8）+ V4-Flash-Base（284B / 13B / FP8）+ V4-Flash（284B / 13B / FP4+FP8）。

详细解释：

切分逻辑：

1. Base vs Instruct：post-training 流水线差异
2. FP8 vs FP4+FP8：Instruct 才有 FP4 变体（FP4 需要 QAT）
3. Pro vs Flash：参数规模切片

💡 面试要点：4 个模型卡的"两个维度"——规模（Pro/Flash）× 训练形态（Base/Instruct）。

延伸阅读：主报告 CH 1.3

Q3.2 V4-Flash 的总参 / 激活参数

简短回答：本报告全程追踪的目标模型 V4-Flash 总参 284B、激活 13B；激活占总参 4.6%——典型 MoE 稀疏比。

详细解释：

• 总参 284B：256 routed expert（FP4）+ 1 shared expert（FP8）+ attention 投影 + embedding
• 激活 13B：单 token 实际计算的参数（routed 6 × 17M ≈ 100M + shared 17M + attention 100M）
• 稀疏比：284/13 ≈ 22×——比 V3.2 的 671/37 ≈ 18× 略高

⚠️ 易混淆：“激活参数"指"单 token 实际经过的参数”——是计算量的代理，不是"运行时加载的参数量"（仍要加载全部 284B 权重）。

延伸阅读：主报告 CH 1.3 + CH 2.1

Q3.3 V4-Flash 的核心超参

简短回答：43 层、 $hidden_size=4096$ 、64 个 attention head、1 个 KV head（MQA）、256 个 routed expert、k=6、 $hc_mult=4$ 。

详细解释：

• $num_hidden_layers=43$ ：Block 数
• $hidden_size=4096$ ：隐藏维度 d
• $num_attention_heads=64$ ：Q 头数
• $head_dim=512$ ：单头维度
• $num_key_value_heads=1$ ：MQA
• $n_routed_experts=256$ ：路由专家数
• $num_experts_per_tok=6$ ：top-k
• $n_shared_experts=1$ ：共享专家
• $moe_intermediate_size=2048$ ：单个 expert 中间维度
• $max_position_embeddings=1,048,576$ ：1M 上下文
• $hc_mult=4$ ：mHC 残差流通道数
• $compress_ratios$ ：44 项 list，前 43 项实际决定逐层压缩比
• $index_topk=512$ ：CSA / HCA 选位置数

💡 面试要点：被问"V4-Flash 关键超参"——43 / 4096 / 64 / 1 / 256 / 6 / hc_mult=4 这七个数字必背。

延伸阅读：主报告 CH 2.1

Q3.4 V4 的"四大创新"是什么？

简短回答：CSA + HCA 混合注意力（解决 $O(n^2)$ + KV cache）、mHC 多通道残差（解决训练稳定性）、Muon 正交化优化器（解决收敛速度）、FP4 专家量化（解决 cache 占用）。

详细解释（V3.2 瓶颈 → V4 创新）：

核心思想：

• CSA + HCA：把 K、V 沿时间维压缩（CSA m=4 / HCA m=128），从根上解决 $O(T^2)$ 和 cache 线性增长
• mHC：用 Sinkhorn-Knopp 投影约束残差流到 4 通道（ $hc_mult=4$ ）
• Muon：对梯度做 Newton-Schulz 正交化，让优化方向更"等向"
• FP4 专家：routed expert 量化到 FP4（E2M1FN + E8M0 scale）

💡 面试要点：四大创新 = 稀疏化（CSA/HCA + MoE）+ 稳定性（mHC）+ 收敛（Muon）+ 量化（FP4）。

延伸阅读：主报告 CH 1.2

Q3.5 V4-Pro 27% FLOPs / 10% KV cache，V4-Flash 10% / 7% 的来源

简短回答：V4-Pro 用 1.6T / 49B 激活 + 多数 CSA，V4-Flash 用 284B / 13B 激活 + 更多 HCA + FP4 专家——Flash 更激进。

详细解释（V4 技术报告 §1 实测数字）：

为什么 V4-Flash 比 V4-Pro 更省：

1. 激活参数：V4-Pro 49B vs V4-Flash 13B（3.8× 差距）
2. CSA/HCA 配比：V4-Flash HCA 层数更多（HCA m=128 比 CSA m=4 又省 32×）
3. FP4 专家：V4-Flash 256 个 routed expert 全部 FP4，cache 减半
4. hc_mult=4 残差流复用：4 份残差流共享 cache
5. 滑动窗口 cache 仅 128 项

延伸阅读：主报告 CH 3.5

Q3.6 1M 上下文是怎么支持的？

简短回答：RoPE 走 YaRN 扩展（从 64K 扩到 1M，factor=16）+ 每层 128-token 滑窗 + CSA/HCA 时间维压缩，三档配合。

详细解释：

1. RoPE 扩展： $rope_scaling.type=“yarn”$ ，factor=16， $original_max_position_embeddings=65536$ ，目标 1,048,576（1M = 64K × 16）
2. 滑窗： $sliding_window=128$——每层 attention 永远拼上前 128 个 raw token 的 K、V
3. CSA/HCA 时间压缩：CSA m=4 / HCA m=128 把 K、V 沿时间维压缩

为什么三层都需要：

• 没有 RoPE 扩展：Q、K 在 > 64K 位置上"未见"过，attention 输出全 0
• 没有滑窗：最近的 token 要走压缩（m=128 时平均信息损失 1/128）
• 没有 CSA/HCA：1M 上下文 cache 装不下

💡 面试要点：1M 上下文 = RoPE + 滑窗 + 时间压缩 三档配合，缺一不可。

延伸阅读：主报告 CH 1.4 + CH 3.4

Q3.7 V4 与 V3 的核心差异（按章节映射）

简短回答：V3 走 MLA + 单一 attention + V3 MoE + 标准残差 + AdamW；V4 走 CSA+HCA + V4 MoE（FP4）+ mHC + Muon + FP4 量化。

详细解释：

V4 在 V3.2 基础上几乎每个维度都做了改进——是"全面升级"而非局部优化。

延伸阅读：主报告 CH 1.1 + CH 1.2

Q3.8 4 个模型卡分别适合什么场景？

简短回答：V4-Pro-Base（API 旗舰基座、需自己微调）/ V4-Pro（生产部署、最高质量）/ V4-Flash-Base（开源基座、需自己后训练）/ V4-Flash（开源主力、直接部署）。

详细解释：

• V4-Pro-Base：1.6T / 49B / FP8——给需要自己微调做垂直领域模型的企业用户
• V4-Pro：1.6T / 49B / FP4+FP8——DeepSeek 自家 API 用的版本，质量最高
• V4-Flash-Base：284B / 13B / FP8——开源生态用，可作下游研究基座
• V4-Flash：284B / 13B / FP4+FP8——本报告全程追踪的目标模型

选型建议：

• 单 batch 2×H200 / 8×H100：V4-Flash
• 多卡集群 + 质量优先：V4-Pro
• 自训练 / 学术研究：V4-Flash-Base
• API 服务 / 商业部署：V4-Pro（API 闭源）或 V4-Flash（自部署）

延伸阅读：主报告 CH 1.3

Q3.9 V4-Flash 的 3 个推理模式

简短回答：Non-think（直接出答案）/ Think High（中等推理）/ Think Max（最大推理，推荐 context window ≥ 384K）。

详细解释：

切换方式：API 调用时 $extra_body={“thinking_mode”: “thinking”, “reasoning_effort”: “max”}$ 。

⚠️ 易混淆：Think Max 不是"模型变聪明了"——是给了更多"思考 token"预算。模型本身权重不变。

延伸阅读：主报告 CH 2.4

Q3.10 V4-Flash 的训练量

简短回答：V4-Flash 公开训练约 32T tokens，是 V3 公开 14.8T 的 2.2×。

详细解释：

• V3 公开 14.8T tokens（V3 论文 §5.1）
• V4-Flash 公开 ~32T tokens（V4 README / config 推断）
• 32T / 284B ≈ 113 tokens/param——显著过训练（Chinchilla 最优是 20）
• 训练量翻倍但激活只 13B——"小模型 + 长训练“路线

为什么选过训练：

• 推理成本低（13B 激活）
• 长训练让 MoE 路由、稀疏 attention 稳定收敛
• Muon 优化器 + FP4 量化让"长训练"不至于成本爆炸

延伸阅读：主报告 CH 1.4 + Q1.16

Q3.11 V4-Flash 的 license / 仓库

简短回答：MIT License，权重 + 推理代码全部开源；仓库 DeepSeek-AI/DeepSeek-V4-Flash（HF 上）。

详细解释：

• License：MIT（最宽松）
• 仓库：DeepSeek-AI/DeepSeek-V4-Flash（DeepSeek-AI 组织下）
• 可商用、可修改、可分发——对开源生态友好

V4-Flash 是 V4 系列中唯一开源 FP4+FP8 Instruct 的模型卡（V4-Pro 仅 API 闭源）。

延伸阅读：主报告 CH 1.4

Q3.12 V4 在 LLM 生态中的定位

简短回答：V4-Flash 是"开源 LLM 的 1M 上下文 + 高性价比 + 学术友好"代表——vs V4-Pro 走 API 闭源 / vs Llama-3 / Qwen-3 等走开源 + 128K 上下文。

详细解释：

• vs V4-Pro：V4-Pro 走 API 闭源，质量更高；V4-Flash 走开源 + 单 batch 2 卡可跑
• vs Llama-3.1-405B：Llama-3.1 是稠密 405B，V4-Flash 是 MoE 284B（13B 激活）——V4 推理成本显著低
• vs Qwen-3-235B-A22B：Qwen-3 也是 MoE，V4-Flash 走 1M 上下文 + FP4 + Muon
• vs Claude / GPT：闭源 API，V4-Flash 是开源替代

核心差异点：

1. 1M 上下文：开源 LLM 极少有
2. FP4 量化：开源 LLM 极少有
3. mHC + Muon：V4 独有

延伸阅读：主报告 CH 1.4

Q3.13 V4-Flash 的"43 层 / d=4096 / 64 head"代表什么设计选择？

简短回答：V4-Flash 是"小而精"模型——43 层（V3 是 61）、d=4096（V3 是 7168）、64 head（V3 是 128）——单 batch 在 2×H200 上可跑。

详细解释：

激活参数 ≈ 0.35× (13/37)，单 batch 显存需求大幅下降。

💡 面试要点：V4-Flash 走”深度 + 宽度都缩，但专家数保留"——专家数 N 不变是 MoE 设计的关键。

延伸阅读：主报告 CH 2.1

Q3.14 V4-Flash 的 1 KV head（MQA）有什么意义？

简短回答：V4-Flash $num_key_value_heads=1$ （MQA）——所有 64 个 Q 头共享 1 组 KV，cache 缩 64×，与 CSA/HCA 配合把 1M 上下文 cache 压到 ~15GB。

详细解释：

• 标准 MHA：64 个 Q 头对应 64 套 KV
• V4-Flash MQA：64 个 Q 头共享 1 套 KV——cache 缩 64×
• 配合 CSA m=4：cache 缩 4×
• 配合 HCA m=128：cache 缩 128×

为什么 MQA 在 V4 有效：

• CSA/HCA 把 K、V 压缩后再算 attention——多套 KV 与 1 套 KV 在压缩后差异小
• Q 头之间本来就通过 O 投影的"分组"（ $o_groups=8$ ）间接共享——MQA 进一步省

⚠️ 易混淆：V4-Flash 不是纯 MLA——V3 MLA 把 K、V 压到 $d_c=512$ 潜空间再恢复；V4-Flash 直接走 MQA（1 套 KV），CSA/HCA 压缩后再 attention。

延伸阅读：主报告 CH 1.4 + Q1.5/Q1.6

Q3.15 V4-Flash 的 256 routed expert + 1 shared expert + k=6 怎么理解？

简短回答：每个 token 从 256 个 routed expert 中选 top-6 激活，加权输出 × 1.5 后与 1 个 shared expert（始终激活）相加。

详细解释：

• 256 个 routed expert：通过 $gate(x) = W_gate \cdot x$ + topk 选 6 个
• 1 个 shared expert：始终激活，不参与路由——保证"通用知识"在所有 token 上都有覆盖
• routed scaling factor = 1.5：routed 加权和 × 1.5 后与 shared 相加

1

out = 1.5 * sum(routed_out_i * score_i) + shared_out

为什么 1.5：V3 用 1.0，V4 调高到 1.5——因为 shared expert 始终激活可能"喧宾夺主"，调高 routed 让稀疏专家的贡献相对突出。

延伸阅读：主报告 CH 2.1

Q3.16 V4-Flash 的 mHC $hc_mult=4$ 是什么？

简短回答：V4-Flash 用 mHC（Manifold-Constrained Hyper-Connections）多通道残差， $hc_mult=4$ 表示残差流扩展为 4 通道。

详细解释：

• 标准残差： $x_{l+1} = x_l + Sublayer(x_l)$——1 通道
• mHC 残差： $X_{l+1} = \alpha \cdot Sublayer(X_l) + \beta \cdot X_l$——X 是 $[T, hc_mult, d]$ ，α、β 走 Sinkhorn-Knopp 投影约束到流形

$hc_mult=4$ 意味着每个 block 维护 4 条并行残差流，信号分 4 通道传播，深层 block 漂移被分散。

为什么 hc_mult=4 有效：

• 深层 block 漂移（V3.2 稳定性问题）被 4 通道分摊
• 训练稳定，V4-Flash 不需要像 V3.2 那样仔细调 lr / init_std
• 4 通道共享 cache（ $hc_mult$ 不增加 cache 数量——$hc_mult=4$ 让 cache × 1/4）

延伸阅读：主报告 CH 1.2 + CH 5

Q3.17 V4-Flash 的 1M 上下文具体怎么存 cache？

简短回答：每层 cache = $window_size=128$ （最近 128 token 原始 KV） + T/4 或 T/128（CSA/HCA 压缩段 KV），实际 cache ≈ 15GB（1M 上下文）。

详细解释：

• 滑窗段：128 个 token 的 raw K、V——128 × d = 128 × 512 = 65K
• CSA 段（21 层）：T/4 = 262,144 个压缩 K、V
• HCA 段（20 层）：T/128 = 8,192 个压缩 K、V
• 每层 cache ≈ 65K + 134M 或 4.2M
• 43 层累计 ≈ 15 GB（BF16）

为什么 cache 不爆炸：

• HCA 把 cache 缩 128×，是 1M 上下文工程化的关键
• mHC 让 4 通道共享 cache
• FP4 专家权重 cache 进一步压

延伸阅读：主报告 CH 3.5

Q3.18 V4-Flash 与 Qwen-3 / Llama-3.1 的核心差异是什么？

简短回答：V4-Flash 1M 上下文 + FP4 量化 + mHC + Muon；Qwen-3 / Llama-3.1 走 128K 上下文 + 标准 attention + AdamW。

详细解释：

V4 独有：1M 上下文、CSA/HCA、mHC、Muon、FP4——五大创新。

延伸阅读：主报告 CH 1.3 + Q3.12

Q3.19 V4-Flash 的"非思考模式"和"思考模式"在模型权重上有差异吗？

简短回答：没有——同一份权重。差异在 $thinking_mode$ 字段控制 prompt 模板是否插入 <think> 起始 token。

详细解释：

• 权重：V4-Flash Instruct 权重只有一份——Non-think / Think High / Think Max 用同一份
• Prompt 模板：
  • $thinking_mode=“chat”$ ：直接给答案
  • $thinking_mode=“thinking”$ ：插入 <think> 起始 token
  • $reasoning_effort=“max”$ ：在 system prompt 前插入 $REASONING_EFFORT_MAX$ 前缀

核心：模型本身不变，推理时 prompt 模板 + context window 控制模式。

⚠️ 易混淆：3 个模式不是"3 个不同模型"——是"3 种 prompt + 3 种 token 预算"。

延伸阅读：主报告 CH 2.4

Q3.20 V4-Flash 在 MRCR 等长上下文基准上的表现

简短回答：V4-Flash 在 MRCR（Multi-Round Co-Reference Resolution）上比 V3.2 显著提升（具体数字待 V4 评测公开）。

详细解释：

• MRCR：多轮指代消解——给一个长对话，问"第 N 轮提到的 X 实际指代什么"
• 是 1M 上下文的"试金石"——短上下文模型（< 128K）做不了
• V4 公开评测中，V4-Flash 1M 上下文版的 MRCR 分数比 V3.2 128K 版显著提升

为什么 V4-Flash 适合 MRCR：

• 1M 上下文：能装下整个多轮对话
• CSA + HCA：长上下文 attention 仍准
• Think Max 模式：可以"思考"指代链

延伸阅读：术语表 B.1

Q3.21 V4-Flash 的"思考模式"最多能用多少 context window？

简短回答：Think Max 模式推荐 context window ≥ 384K tokens——因为 reasoning chain 可能非常长。

详细解释：

• Non-think / Think High：128K context 即可
• Think Max：384K context（V4 README 推荐）
• 1M context 是 max_position_embeddings 上限，但实际推理成本随 context 增长

为什么 Think Max 要 384K：<think> 内的 reasoning 可能非常长；简单任务用 Think Max 是浪费；实际部署时根据任务难度选择模式。

延伸阅读：主报告 CH 2.4 + Q3.9

Q3.22 V4-Flash 的"训练 32T tokens"具体意味着什么？

简短回答：V4-Flash 训练用约 32 万亿 tokens，是 V3 公开 14.8T 的 2.2×——“小模型 + 长训练"路线的代表。

详细解释：

• 32T tokens × 13B 激活参数 = “小模型、长训练” 配比
• 实际训练 FLOPs ≈ 6 × 13B × 32T ≈ 2.5×10²⁵（单 token 视角）
• 总训练 FLOPs 还要乘 43（层）× 系数（forward + backward） ≈ 实际 ≈ 5×10²⁶ 量级
• 与 V3 训练 FLOPs ≈ 6×10²⁵ 量级相比，V4-Flash 训练量显著更大——但激活小所以单步便宜

为什么公开 32T：让社区知道"这是 2.2× V3 训练量”；证明 V4 走"过训练"路线；给开源 LLM 一个"训练量透明"的标杆。

延伸阅读：主报告 CH 1.4 + Q1.16/Q3.10

Q3.23 V4-Flash 的 FP4 专家与 FP8 公共部分的分工

简短回答：256 个 routed expert 量化到 FP4（ $float4_e2m1fn_x2$ ，block=32，E8M0 scale）；attention / shared expert / 公共部分仍为 FP8（E4M3）。

详细解释：

• FP4 路径：仅 routed expert 权重；block-wise scale（ $weight_block_size=[32, 32]$ ，block=32）
• FP8 路径：attention Q/K/V/O 投影、shared expert、embedding、LM head——e4m3 + ue8m0 scale
• 激活值：默认 BF16，attention 计算时模拟 FP8 量化（QAT）

为什么 routed expert 走 FP4，shared 不走：

• routed expert 占总权重绝大部分（256 × 17M = 4.3B，shared 1 个 = 17M）——FP4 省 cache 在 routed
• shared expert 始终激活，影响"通用知识"——保持 FP8 精度
• FP4 需要 QAT 训练——V4 Instruct 才能用，V4 Base 是 FP8

延伸阅读：主报告 CH 1.4 + Q1.18

Q3.24 V4-Flash 的"MIT License"具体允许多少事？

简短回答：MIT 是最宽松的开源 License——可商用、可修改、可分发，唯一义务是保留版权声明。

详细解释：

• 可商用：可以基于 V4-Flash 做商业产品
• 可修改：可以 fine-tune、merge、quantize
• 可分发：可以再发布（保留 License）
• 唯一限制：必须保留原版权声明
• 无 copyleft：修改后不必开源

与其他 License 对比：

• Apache 2.0：类似 MIT，但多了"专利授权"条款
• Llama Community License：商用月活 > 7 亿需单独授权
• V4-Flash MIT：无此限制

延伸阅读：主报告 CH 1.4

Q3.25 V4-Flash 的 5 大关键定位总结

简短回答：（1）13B 激活 / 2 卡可跑；（2）FP4 专家；（3）1M 上下文；（4）MIT License；（5）3 个推理模式。

详细解释：

1. 13B 激活：单 batch 在 2×H200 / 8×H100 可跑——开源 LLM 极少见
2. FP4 专家：256 routed expert 全部 FP4——比 FP8 进一步省 cache
3. 1M 上下文：默认 $max_position_embeddings=1,048,576$
4. MIT License：可商用、可修改、可分发
5. 3 个推理模式：Non-think / Think High / Think Max（适配不同任务难度）

目标用户：AI infra 工程师（2 卡可跑）、长上下文应用开发者（1M）、商业产品（MIT）、推理增强需求（3 个模式）。

延伸阅读：主报告 CH 1.4

QA 文档结束

本 QA 涵盖 CH 0（4 个 Q）+ CH 1（28 个 Q）+ CH 2（21 个 Q）+ CH 3（25 个 Q）= 78 个 Q。
完整的"算子级拆解"请回主报告 deepseek-v4-flash.md；CH 4 之后（MoE / mHC / Muon / 后训练）由其他 QA 文档负责。

本文件是主报告 /Users/huangyuxiao/models-arch/report/deepseek-v4-flash.md 的配套 QA。每道题先给"简短回答"，再展开"详细解释"，最后给"💡 面试要点 / ⚠️ 易混淆"和"延伸阅读"。主报告里有完整论证的，本 QA 简述 + 给行号。

读者画像：对 LLM 训练有初步认识的学生 / 工程师 + 面试准备 + 自学。

范围：CH 4（CSA / HCA 注意力，Q4.1–Q4.38） + CH 5（MoE 路由，Q5.1–Q5.31）= 共 69 道题。

CH 4 — CSA / HCA 注意力

Q4.1 1M 上下文下标准 Attention 为什么"灾难"？

简短回答：标准 attention 的计算量为 $O(T^2 \cdot d)$ 、KV cache 为 $O(T \cdot d \cdot L)$ ，1M 上下文时单 token FLOPs ≈ $8.6 \times 10⁹$ ，KV cache ≈ 1.4 TB / 样本，既算不动又存不下。

详细解释：

• FLOPs 灾难。对 V4-Flash（d=4096，T=1,048,576），单层单 token 解码 FLOPs ≈ $2 \times T \times d = 2 \times 10⁶ \times 4096 \approx 8.6 \times 10⁹$ 。prefill 视角更夸张：单层 $T^2 \times d_h / 2 \approx 4.5 \times 10¹⁵$ FLOPs，43 层累计 ≈ $1.9 \times 10¹⁷$ FLOPs——单卡 H200 跑都要 96 秒。
• KV cache 灾难。 $T \times d \times 2 \times L = 1,048,576 \times 4096 \times 2 \times 43 \approx 3.7 \times 10¹¹$ float，BF16 下约 1.4 TB / 样本，100 并发 140 TB——V4-Flash 这种"8×H100 跑得动"的目标完全无解。
• MLA 救了 cache 但救不了 compute。MLA 把 K/V 压到 $d_c=512$ ，cache 减到 168 GB，但 attention 计算量仍 $O(T^2)$——T=1M 时 FLOPs 主导项没变。

💡 面试要点：要能说清"T² 灾难"和"cache 线性"两个独立瓶颈——CSA / HCA 是同时解决两件事，不能只答"稀疏化"。

延伸阅读：主报告 §3.1（CH 4 主入口）。

Q4.2 稀疏注意力有哪几类？V4 走哪条路？

简短回答：4 大类——(1) fixed pattern（如 Sliding Window、Longformer 的 dilated pattern）、(2) learned（如 Reformer 的 LSH）、(3) top-k（如 Sparse Transformer）、(4) content-based / hash。V4 的 CSA 走 learned top-k（Indexer 评分 + top-k 选位置）。

详细解释：

V4 的 CSA 严格属于"content-based top-k"：每个 query 通过一个独立 Indexer 算出对所有压缩位置的分数，取 top-512 算 attention。

💡 面试要点：能列出 4 类 + 各 1 个代表方法 = 加分。

延伸阅读：主报告 §3.2.1（CH 4 主入口）。

Q4.3 V3.2 的 MLA 是怎么压 KV 的？为什么"压了 cache 压不了 compute"？

简短回答：MLA 把 K、V 各自先投影到 $d_c=512$ 的潜空间（ $c_t = W_KV \cdot x_t$ ），推理只缓存 $c_t \in \mathbb{R}^{T\times d_c}$ ，恢复多头 K/V 时再乘 $W_K$ 、 $W_V$ 。 $d_c « h \times head_dim = 32768$ ，所以 cache 大幅减小；但实际算 attention 时仍展开成 64 头，FLOPs $2 \times T \times d_h \times h = 2 \times T \times 32768$——与标准 attention 等价。

详细解释：

• MLA 投影： $c_t = W_KV \cdot x_t$ ， $W_KV \in \mathbb{R}^{d \times d_c}$ ， $d_c=512$ 。推理时 cache 存 $c_t$ 而不是 $k_t / v_t$ ， $d_c « h \times d_h = 32768$ ，省一个量级以上。
• compute 没省：attention 算的是 $QK^\top$ ，MLA 恢复 $k_t = W_K \cdot c_t$ 代入后， $Q \cdot k_t^\top = Q \cdot (W_K \cdot c_t)^\top$——这是两次矩阵乘（Q × W_K × c_t），不省 FLOPs。
• V3.2 KV cache 实测：1M × 512 × 61 × 2 ≈ 168 GB / 样本（详见 Q4.1 表格），比纯标准 attention 的 1.4 TB 好，但工程上仍困难。

⚠️ 易混淆：MLA ≠ “压了 attention 计算量”；它只压了 cache 形状。V4 的 CSA / HCA 才是"压 compute"。

延伸阅读：主报告 §3.1 末尾 + §1.1（V3.2 MLA 简介）。

Q4.4 CSA 的"压缩"具体指什么？

简短回答：把 K、V 沿时间维做有学习权重的 $\mathrm{softmax}$-pool——每 m=4 个相邻 token 合成 1 个压缩向量 $ĉ_K / ĉ_V \in \mathbb{R}^{d}$ ，cache 从 [T, d] 减到 [T/4, d]。

详细解释：

• 数学形式（公式 3.1）：

  $$

  c_K = \mathrm{softmax}\text{-pool}(W_{kv} x) = \frac{\sum_{i=1}^{m} \exp(s_i) \cdot k_i}{\sum_{i=1}^{m} \exp(s_i)}

  $$

  其中 $s_i = (W_{gate} x)_i$ 是由 token 特征学习出的"权重"——不是简单的平均池。

• m=4 的含义：每 4 个相邻 token 池化为 1 个，T 长度 → T/4。

• 重叠模式（overlap=True）：CSA 进一步维护 2m=8 个 token 的滑动窗口，每 4 token 输出 2 个压缩向量（前 4 / 后 4），让边界处不那么"硬切"。

💡 面试要点：要解释"为什么是 $\mathrm{softmax}$-pool 不是平均池"——见 Q4.6。

延伸阅读：主报告 §3.2 + §3.7.1。

Q4.5 Compressor 这个模块具体做什么？前向怎么走？

简短回答：Compressor 是 CSA / HCA 的核心算子，把 m 个相邻 token 的 K/V 通过可学习门控池化为 1 个压缩向量。它有 3 个分支：prefill（整段批处理）、decode（单 token FIFO 累加）、overlap（CSA 专属的 2m 窗口）。

详细解释：

Compressor 维护两个 buffer（ $kv_state$ 、 $score_state$ ）做 decode 阶段的增量压缩：

• prefill ($start_pos==0$)：把整段 seqlen 切成 $n_group = seqlen // m$ 个 m-token 段，reshape 成 $[B, n_group, m, d]$ ，加 per-position bias ape，在 dim=2 上做 $\mathrm{softmax} + sum$ 。
• decode ($start_pos>0$)：每来一个 token 写进 state[bsz, slot]，其中 $slot = start_pos % m$ ；当 $(start_pos+1) % m == 0$ （凑齐 m 个），做一次 $\mathrm{softmax}$-pool 输出。
• overlap (m=4 时)：state 容量扩到 2m=8，每 4 token 一次性输出 2 个压缩向量（左半窗口 / 右半窗口），kv = cat(state[:4,:d], state[4:,d:])。

overlap 的关键 trick：把"前 4 token 给 group A / 后 4 token 给 group B"换成"每个 token 给出 2d 维表示"——前 d 维供前组，后 d 维供后组，避免边界处信息被切碎。

💡 面试要点：能讲清"prefill / decode 两条路径 + overlap 是 CSA 专属"即可。

延伸阅读：主报告 §3.7.1 + code-snippets/compressor.py（核心算子）。

Q4.6 为什么 Compressor 用 $\mathrm{softmax}$-pool 而不是平均池？

简短回答：平均池对 4 个 token 一视同仁，但 attention 实际只关心少数"重要" token——$\mathrm{softmax}$-pool 通过可学习 wgate 让模型端到端学"哪些 token 该被池化时占更大权重"。

详细解释：

• 平均池的问题：对 k1..k4 等权求和，相当于 attention 把这 4 个 token 的 V 都乘 1/4——忽略了"某些 token 信息密度更高"的事实。
• $\mathrm{softmax}$-pool 的好处： $s_i = (W_gate \cdot x)_i$ 是 token 维度的"重要性分数"， $exp(s_i)$ 让模型能"硬选"某些 token。训练时梯度会通过 $\mathrm{softmax}$ 自动调高有用 token 的 $s_i$ 。
• per-position 偏置 ape：Compressor 还学了 [m, coff*d] 的 ape 参数，加到 score 上——给不同"窗口内位置"额外先验（通常是中间位置权重大，边界权重小）。

💡 面试要点：能说清"平均池 vs $\mathrm{softmax}$-pool = 静态 vs 端到端学习"。

延伸阅读：主报告 §3.7.1（+self.ape 那段）。

Q4.7 overlap 模式（m=4）的 2m=8 token 窗口怎么工作？

简短回答：CSA 把 Compressor 维护的 buffer 扩到 2m=8，每 4 token 一次性输出 2 个压缩向量——前 4 token 的"前 d 维"组成 group A，后 4 token 的"后 d 维"组成 group B。两个 group 不重叠，但每个 token 都给两个 group 提供 1 维信息。

详细解释：

源码 $overlap_transform$ （compressor.py:L29-L36）：

• 输入 [b, s, m, 2d]（已经切成 m=4 段、每段 2d 维）
• 输出 [b, s, 2m, d] = [b, s, 8, d]
• 第 0..3 行是"前 token 的前 d 维"（供 group A）
• 第 4..7 行是"后 token 的后 d 维"（供 group B）

为什么这样设计：m=4 时压缩比太大，边界处的 4 个 token 直接丢弃信息太重。overlap 模式让 2m=8 个 token 的全部信息通过 2 个压缩向量保留下来——单看 group A，4 个 token 全部参与 $\mathrm{softmax}$-pool；单看 group B，也 4 个 token 全部参与。

HCA 为什么不开 overlap： $compress_ratio=128$ 已经把 T 压到 8192，每组 128 个 token 的边界处"信息切碎"对总 cache（8192 个向量）影响极小；再开 overlap 会让 $kv_state$ 容量 ×2，得不偿失。V4 设计是"只在 ratio 极小（m=4）时才花这个开销"。

⚠️ 易混淆：overlap 不是"8 token 互相重叠"——而是"4+4 token 各贡献 1 维给 2 个独立 group"。

延伸阅读：主报告 §3.7.1 公式 (3.8) 推导。

Q4.8 CSA 的 prefill 和 decode 路径有什么不同？

简短回答：prefill（ $start_pos=0$ ）整段批处理——reshape 成 $[B, n_group, m, d]$ 后向量化 $\mathrm{softmax}$-pool；decode（ $start_pos>0$ ）单 token FIFO——维护 $kv_state / score_state$ 累加器，每 m 个 token 触发一次压缩。

详细解释：

• prefill：seqlen = 8192 时，整段切成 8192/4 = 2048 个 group，向量化做 2048 次 $\mathrm{softmax}$-pool。cutoff = seqlen - seqlen % m 处理不被 m 整除的尾部；remainder 部分（不足 1 个 group）暂存进 $kv_state$ 。
• decode：每来一个 token 写进 state[bsz, slot]，其中 $slot = start_pos % m$ 。当 $(start_pos+1) % m == 0$ 才触发一次 $\mathrm{softmax}$-pool；否则 $should_compress=False$ 直接 return。
• decoder 与 prefill 的统一：两者都从同一个 self.compressor 走，调用方 Attention.forward 在 prefill 时用 kv 包含 batch 内的所有压缩段；decode 时压缩后的向量写进 $kv_cache[bsz, start_pos//m]$ 等待后续 query 读。

💡 面试要点：要意识到"两个路径共享同一份代码"是 V4 工程的优雅之处。

延伸阅读：主报告 §3.7.1 + code-snippets/compressor.py 第 38-99 行。

Q4.9 HCA 与 CSA 的本质区别是什么？

简短回答：HCA 是 CSA 的"超压缩"变体——把 m 从 4 拉到 128，同时砍掉独立 Indexer，改用"位置等距采样 top-512"。HCA 的设计前提是"重度压缩后所有位置都重要"，省 Indexer 反而是收益。

详细解释：

为什么 HCA 不需要 Indexer：T/128 = 8192 个压缩位置，全部参与 attention 也才 $8192 \times d = 3.4 \times 10⁷$ FLOPs——T=1M 时这已经远小于 $T\cdot k=1.5\times 10⁹$ 的 top-k 限制项，再做 Indexer 评分反而引入额外开销。V4 的取舍是：让"压缩足够稀疏"成为前提，省掉 Indexer。

⚠️ 易混淆：HCA 不是"更激进的 CSA"——它省略了 Indexer 整个模块，这是结构上的差异。

延伸阅读：主报告 §3.3（含完整对比表）。

Q4.10 HCA 为什么不需要 Indexer？位置等距采样的依据是什么？

简短回答：HCA 假设"重度压缩后 8192 个位置信息量均匀"，按 $(start_pos + 1) // 128$ 的物理位置均匀采样 top-512。这个假设在 1M 上下文 + m=128 时经验成立，论文 ablation 显示省 Indexer 不显著损失质量。

详细解释：

• 位置等距采样：源码 $get_compress_topk_idxs(ratio, bsz, seqlen, start_pos, offset)$ 直接生成 (seqlen // ratio) 个等距位置索引。
• 核心论点：当压缩后只剩 8192 个位置，每个位置都是"128 个原始 token 的加权综合"，信息密度比单 token 高。top-512 / 8192 ≈ 6.25% 的采样率——6% 的高质量位置已经覆盖了绝大部分长程依赖。
• 省了什么：省掉一个独立 Compressor（hadamard + FP4 路径）+ Indexer 评分（einsum + relu + topk）。在长 prefill 时 Indexer 算量也不小，砍掉后 HCA 路径更轻量。

💡 面试要点：能讲清"m 大 → 压缩后信息密度均匀 → 位置采样够用"这个推理链。

延伸阅读：主报告 §3.3 公式 (3.5)。

Q4.11 Indexer 是什么？怎么工作？

简短回答：Indexer 是 CSA 专属的"压缩位置评分器"——为每个 query 算出对 T/m 个压缩位置的分数，取 top-k=512。包含自己的 Compressor（Hadmard + FP4）、query 投影 $wq_b$ 、per-head 权重 $weights_proj$ ，最后 $einsum + \mathrm{ReLU} + topk$ 。

详细解释（对应 code-snippets/indexer.py）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. q 端: wq_b + RoPE + Hadamard + FP4 模拟
q = self.wq_b(qr).unflatten(-1, (n_local_heads, head_dim))  # [B, S, 64, 128]
apply_rotary_emb(q[..., -rd:], freqs_cis)
q = rotate_activation(q)                  # Hadamard 旋转
fp4_act_quant(q, fp4_block_size, True)     # FP4 模拟
self.compressor(x, start_pos)             # Indexer 自带 Compressor

# 2. per-head 权重
weights = self.weights_proj(x) * (softmax_scale * n_heads ** -0.5)

# 3. index_score: q 与 T/4 个压缩 key 算内积
index_score = einsum("bshd,btd->bsht", q, self.kv_cache[:bsz, :end_pos // ratio])

# 4. ReLU + 权重求和 + topk
index_score = (index_score.relu_() * weights.unsqueeze(-1)).sum(dim=2)
topk_idxs = index_score.topk(min(self.index_topk, end_pos // ratio), dim=-1)[1]

四步：① 准备 q（投影 + RoPE + Hadamard + FP4）；② 算 weights（per-head 标量）；③ q 与压缩 k 算内积得到 [B, S, 64, T/m] 的分数；④ $\mathrm{ReLU}$ 截断 + per-head 加权求和 + topk。

💡 面试要点：能写出完整 4 步 = 加分。

延伸阅读：主报告 §3.7.2 + code-snippets/indexer.py（第 22-54 行）。

Q4.12 Indexer 的 per-head 权重 $w_t$ 是什么？为什么不是 per-token？

简短回答： $w_t \in \mathbb{R}^h$ （h=64）是 Indexer 给每个 query 位置算出的 64 个 per-head 标量权重，与 $index_score$ （shape [B, S, h, T/m]）逐 head 相乘。必须是 per-head 而非 per-token，否则 64 头共享一个权重会损失"头间特异化"。

详细解释：

• 形状： $weights_proj: ColumnParallelLinear(dim, n_heads)$——把每个 token 的 d 维投影成 $n_heads=64$ 维。
• per-head 的必要性： $index_score$ 是 64 头对 T/m 个压缩位置各自打的分； $w_t$ 也要 per-head 让每头有独立的"query 重要性"调节。比如第 3 头擅长语法角色，第 27 头擅长实体识别——它们对"该把哪个压缩位置选进来"的判断权重应该不同。
• 如果用 per-token（shape [B, S, 1]）：64 头被同一个权重拉伸，等于强制所有头共享重要度判断——这在 64 头的稀疏选择器中会损失大量灵活性。

⚠️ 易混淆： $w_t$ 不是 attention 里的 $W_O$ （输出投影），而是"query 维度的 per-head 缩放因子"。

延伸阅读：主报告 §3.7.2 (1)。

Q4.13 Indexer 的 $1/\sqrt{d} \cdot 1/\sqrt{h}$ 缩放因子从哪儿来？

简短回答： $1/\sqrt{d}$ 是 attention 的标准缩放（让 $q\cdot k^\top$ 数值稳定）， $1/\sqrt{h}$ 是按头数归一化（让 64 头 $w_t$ 的平均权重稳定在 1 附近）。两者合起来让 $relu(q\cdot k^\top) \cdot w_t$ 的输出均值稳定在 $O(1)$，topk 不被某一头主导。

详细解释：

源码（indexer.py:L16, L39）：

1
2

self.softmax_scale = self.head_dim ** -0.5   # 1/√d, d=128
weights = self.weights_proj(x) * (self.softmax_scale * self.n_heads ** -0.5)

• $1/\sqrt{d}$ 来源：attention 公式 $\mathrm{softmax}(Q\cdot K^\top/\sqrt{d})$ ，分母 $\sqrt{d}$ 让 $q\cdot k^\top$ 的方差 = 1，避免 $\mathrm{softmax}$ 进入饱和区。Indexer 借用同一缩放。
• $1/\sqrt{h}$ 来源： $index_score$ 在 dim=2 上对 64 头做 sum，等价于把 64 个独立随机变量相加——其方差为 $64 \times Var(单头)$ 。要保持 sum(dim=2) 后的均值稳定在 $O(1)$ ，需要把单头权重预先除以 $\sqrt{h}$ 。
• 综合效果： $relu(q\cdot k^\top/\sqrt{d}) \cdot w_t$ 对 64 头求和后输出在 $O(1)$ 量级——topk 选位置时不会被某一头的偏大权重"垄断"。

💡 面试要点：能讲清"$\sqrt{h}$ 是因 sum-over-heads"即可。

延伸阅读：主报告 §3.7.2 (2)。

Q4.14 公式 (3.2) 用 $\mathrm{ReLU}$ 不用 $\mathrm{softmax}$ 的原因？

简短回答： $\mathrm{ReLU}$ 是 $O(1)$ 的逐元素 max(0, x)， $\mathrm{softmax}$ 需要 O(topk) 个 exp；对 1M 上下文（T/m ≈ 262144 个压缩位置、64 头）， $\mathrm{softmax}$ 会让 Indexer 算量增加 1 个 exp/位置——$\mathrm{ReLU}$ 完全省掉这笔开销。质量影响： $\mathrm{ReLU}$ 把负分数归零，indexer 本来就只挑 top-k，负分数不会进 top-k，截断不损失信息。

详细解释：

• $\mathrm{ReLU}$ 的"硬截断"语义： $relu(q\cdot k^\top) \cdot w_t$ 把负分数直接归零——只有"正分数"才参与后续 sum-over-heads。
• $\mathrm{softmax}$ 的"概率化"语义： $\mathrm{softmax}(q\cdot k^\top) \cdot w_t$ 把分数归一化为概率分布，所有 262144 个位置都有非零贡献——这是给"全 attention"用的，对 top-k 选择器是浪费。
• 数量级差异：T/m=262144、64 头、batch=1 时， $\mathrm{ReLU}$ 操作 262144 × 64 ≈ 1.7 × 10⁷ 次比较； $\mathrm{softmax}$ 要算 1.7 × 10⁷ 次 exp——后者在 GPU 上慢 5-10×。

⚠️ 易混淆： $\mathrm{ReLU}$ 不是"没有归一化"——它靠 sum(dim=2) 后配合 weights 隐式归一化；topk 选择完全不依赖分数的绝对值。

延伸阅读：主报告 §3.7.2 (4)。

Q4.15 Indexer 内的 Compressor 与 Attention 共用的 Compressor 有什么差异？

简短回答：两者结构相同（都继承 Compressor），但量化路径不同——Indexer 内的 rotate=True 触发 Hadamard 旋转 + FP4 模拟（ $fp4_act_quant$ ），Attention 共用的 rotate=False 走 FP8 量化（ $act_quant$ ）。

详细解释：

源码对比：

• indexer.py:L19 → $Compressor(args, compress_ratio, head_dim, True)$ （rotate=True，FP4）
• attention.py:L32 → $Compressor(args, compress_ratio, head_dim)$ （rotate=False，FP8）

为什么需要两套：

Hadamard 旋转的作用：把 d 维向量与固定 Hadamard 矩阵相乘——等价于无参数的随机正交变换，打散信息让量化更鲁棒（不旋转的话，少数大值主导量化，分布不均；旋转后能量均匀分布到各维度，FP4 的 16 个 level 能更精细地表示）。

💡 面试要点：要意识到"两套 Compressor 共享类、共享主结构、走不同量化“是 V4 的工程精细之处。

延伸阅读：主报告 §3.7.2 (5)。

Q4.16 FP4 vs FP8 在 Indexer / Attention 内的选择依据？

简短回答：Indexer 是"sparse top-k 选择器”——只关心哪些位置最相关，单位置精度不重要，可激进量化（FP4）；Attention 实际算 $\mathrm{softmax}(Q\cdot K^\top)\cdot V$——压缩向量是最终输出的原料，量化噪声会被 $\mathrm{softmax}$ 放大，必须保守（FP8）。

详细解释：

• FP4 = $float4_e2m1fn_x2$：1 sign + 2 exponent + 1 mantissa，4 bit 表示，约 16 个离散 level。
• FP8 = E4M3：1 sign + 4 exponent + 3 mantissa，8 bit 表示，256 个 level。
• 选择逻辑：
  • top-k 选择是"相对排序"——只要 A 比 B 大，不需要 A 精确等于某个值 → FP4 够用
  • attention output 是"加权求和"——$\mathrm{softmax} \cdot V$ 对单 K 值的精度敏感 → FP8 必须
• QAT（Quantization-Aware Training）：FP4 路径在训练时就用 $fp4_act_quant$ 模拟量化（FP16 计算 + 量化/反量化），让前向分布贴近部署形态——这是 V4 训练时已经"按 FP4 形态优化"的关键。

💡 面试要点：要能说"QAT 是什么"+“为什么 Indexer 不在乎 FP4 的精度损失”。

延伸阅读：主报告 §3.2 + §3.7.2 (5)。

Q4.17 top-k=512 的选择依据是什么？

简短回答：V4 论文 ablation 显示 top-512 在 1M 上下文下达到"质量 / FLOPs"最优折中——top-256 时 PPL 显著上升（漏掉太多长程依赖），top-1024 时 FLOPs 翻倍（sparse 优势不再），top-512 是甜点。

详细解释：

• 质量侧：1M 上下文 = $2^2⁰ = 1,048,576$ 位置；top-512 = 0.05% 采样率。经验上 0.05%–0.1% 足够覆盖长程依赖（Mistral Sliding Window 选 4096 已经证明小窗口不显著损害长程建模）。
• FLOPs 侧：T=1M 时， $T\cdot k = 1,048,576 \times 512 \approx 5.4 \times 10⁸$ ，与 $T^2/m = 10¹^2/4 = 2.5 \times 10¹¹$ （CSA T² 项）相比，top-k 项是次要——sparse 的主要收益来自压缩而不是 top-k 截断。
• 与 V3 沿用：V3 时代就选 512，V4 沿用同一选择（实验证明 256 / 1024 都没明显更优）。

⚠️ 易混淆：top-k=512 不是"绝对最优"——它是 1M 上下文的 sweet spot；T=128K 时 top-128 就够，T=10M 时可能需要 top-2048。

延伸阅读：主报告 §3.2（公式 3.2）+ §3.4。

Q4.18 $sparse_attn_kernel$ 的 TileLang 实现做了什么？

简短回答：把 CSA / HCA 选中 top-k 个位置后实际算 attention output 的过程用 TileLang 写成 GPU kernel。核心是 online $\mathrm{softmax}$ 三件套（scores_max / scores_scale / scores_sum）+ $block=64 num_stages=2$ 的双缓冲 pipeline + 编译期常量化 h=64, d=128。

详细解释（对应 $code-snippets/sparse_attn_kernel.py$ ）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@tilelang.jit(pass_configs=pass_configs)
def sparse_attn_kernel(h: int, d: int, scale=None):
    b = T.symbolic("b")
    m = T.symbolic("m")
    n = T.symbolic("n")
    topk = T.symbolic("topk")
    num_stages = 2
    threads = 256
    block = 64
    num_blocks = tilelang.cdiv(topk, block)  # 512/64 = 8

关键设计：

• h, d 编译期常量化（h=64, d=128），TileLang 会做特化（循环展开、register 分配）
• b, m, n, topk 符号维度（运行期可变）
• block=64：每 64 个 top-k 位置为 1 个 block
• $num_stages=2$ ：双缓冲 pipeline（边算当前 block 边加载下一 block）
• $num_blocks = topk / 64 = 8$ ：每 query 8 个 block

💡 面试要点：理解"online $\mathrm{softmax}$ 在 sparse attention 中的角色"是关键。

延伸阅读：主报告 §3.7.3（最详尽算子级拆解）。

Q4.19 online $\mathrm{softmax}$ 的三件套是哪三个状态？怎么更新？

简短回答： $scores_max$ （历史最大值）、 $scores_scale$ （rescale 因子 $exp(m_{t-1} - m_t)$ ）、 $scores_sum$ （累加 exp(s - m)）。每进一个新 block，先更新 max，再算 rescale 因子，最后把旧累加乘上 rescale + 加上新 block 的贡献。

详细解释（公式 3.9）：

$$

\begin{aligned}
m_t &= \max(m_{t-1}, b_t^{\max}) \
s_t &= \exp(m_{t-1} - m_t) \
\Sigma_t &= \Sigma_{t-1} \cdot s_t + b_t^{\mathrm{sum}}
\end{aligned}

$$

• $scores_max$：init = -inf，每个 block 后 $reduce_max(acc_s, dim=1)$ 更新——跟踪历史最大值。
• $scores_scale$： $exp(scores_max_prev - scores_max)$——rescale 因子，让旧累加 $acc_o / sum_exp$ 乘上这个因子，相当于在新的 max 基准下重新归一化。
• $scores_sum$：累加 $exp(acc_s - scores_max)$ （减 max 防 exp 溢出），公式 $sum_exp * scores_scale + scores_sum$ 。
• 每 block 末尾： $acc_o = acc_o * scores_scale + 新 block 贡献 $ ，最后 $o = acc_o / scores_sum$ 。

为什么是 online：512 个位置不必一次性算完，可以 8 个 block 渐进更新。比"全 $\mathrm{softmax}$ 后再算 V"省内存——后者要把 $T\times T$ 分数矩阵存在 shared memory。

💡 面试要点：能讲清"$m_t$ 更新 → $s_t$ rescale → 累加器同步更新"三步即 OK。

延伸阅读：主报告 §3.7.3 (3) 公式 (3.9)(3.10)。

Q4.20 $block=64 / num_stages=2$ 的切分依据是什么？

简短回答：block=64 由 shared memory 容量决定（每 block 64 个 K/V × 128 dim × 2B = 16KB，恰好适配 H100 的 100+ KB shared memory）； $num_stages=2$ 是双缓冲 pipeline 的标准选择（3+ stages 在 H100 上收益递减）。

详细解释：

• block=64 选多大：
  • 太小（如 16）：8 个 block 内的 GEMM 算量不足，GPU SM 闲置
  • 太大（如 256）： $kv_shared$ 占 $256 \times 128 \times 2B = 64KB$ ，超过 SM 的 shared memory 上限
  • 64 平衡点：8 个 block × 64 位置 = 512 top-k，shared memory 用 16KB/warp，余量充足
• $num_stages=2$ 为何不是 3 或 4：
  • num_stages=1：无 pipeline，load 与 compute 串行
  • num_stages=2：双缓冲，当前 block 算 GEMM 时下一 block 加载 kv_shared——延迟隐藏到位
  • num_stages=3+：寄存器压力增大，H100 上实测收益 < 5%——不值得
• num_blocks = topk / block = 8：8 个 pipeline stage × 双缓冲 = 16 步延迟隐藏。

💡 面试要点：能讲清"block 大小 = shared memory 容量 / 平衡点"即可。

延伸阅读：主报告 §3.7.3 (4)。

Q4.21 $attn_sink$ 的语义是什么？为什么要加？

简短回答： $attn_sink$ 是 per-head 标量偏置（V3.2 沿用），在 online $\mathrm{softmax}$ 末尾加进 $sum_exp$——给"无 K/V 位置"贡献一个 fallback 概率。防止 query 的 top-k 分数都很低时 output 变成 NaN/塌缩。

详细解释：

源码：

1
2
3
4

attn_sink: T.Tensor[(h,), FP32]    # per-head 标量
...
sum_exp[i] += T.exp(attn_sink[i] - scores_max[i])
acc_o[i, j] /= sum_exp[i]

• 场景：某个 query 被 indexer 选错了——top-512 个位置分数都很低， $\mathrm{softmax}$ 分布"无主"。如果没有 attn_sink， $sum_exp$ 极小， $acc_o / sum_exp$ 数值爆炸。
• 机制：把 attn_sink 当作"虚拟 token"加进 $\mathrm{softmax}$ 分母——$\mathrm{softmax}([s1, s2, …, s512, attn_sink])$ 保证总概率质量 ≥ $exp(attn_sink)$ ，output 有界。
• per-head：每个 head 学自己的 attn_sink 标量，让每头独立调"防御强度"。

与 HCA 无关：HCA 没有 indexer 也照样有 attn_sink——它是 V3 沿用的"通用防御"。

⚠️ 易混淆：attn_sink 不是 attention sink（StreamingLLM 里的"前几个 token"）——它是 per-head 可学习标量。

延伸阅读：主报告 §3.7.3 (5) + §3.6 源码片段 3。

Q4.22 $compress_ratios$ 逐层配置的依据是什么？前 2 层 / 21 层 / 20 层？

简短回答：V4-Flash 的 $compress_ratios = [0,0,4,128,4,128,…,4,0]$ 共 44 项——**前 2 层纯滑窗（ratio=0）**让浅层观察原始 token；21 层 CSA（ratio=4）+ 20 层 HCA（ratio=128）逐层交替保质省算力；末尾占位 0 不读。

详细解释：

compress_ratios = [
  0,    # Layer 0   纯滑窗 (window=128)
  0,    # Layer 1   纯滑窗 (window=128)
  4,    # Layer 2   CSA (m=4)
  128,  # Layer 3   HCA (m=128)
  4, 128, 4, 128, ..., 4, 128, 4,  # Layer 4-41 交替
  0,    # Layer 42  CSA
  0,    # 占位
]

逐层模式：

• Layer 0, 1： $compress_ratios=0$ ，纯 sliding window（window=128），完全不上压缩——浅层需要 raw token 信号建模
• Layer 2-42：41 层交替 CSA / HCA
  • CSA（m=4）：21 层
  • HCA（m=128）：20 层
  • Layer 42 也是 ratio=4（CSA），最后一层给"细节保护"——深层的输出质量敏感
• 末尾占位 0：config 列表有 44 项但实际只读前 43 层（ $layer_id \in [0, 42]$ ）

为什么交替而非全部 CSA / 全部 HCA：

• 全部 CSA：FLOPs 省 4 倍但 cache 占 25% of V3.2
• 全部 HCA：cache 省 128 倍但 m=128 损失太多细节
• 交替：CSA 隔层"补细节"，HCA 隔层"省算力"——既保质又省 FLOPs/cache

💡 面试要点：能讲清"前 2 层纯滑窗 + 21 CSA + 20 HCA + 末尾占位"的数字结构。

延伸阅读：主报告 §3.4（公式 3.7）+ $_work/config.json$ 第 66 行。

Q4.23 sliding_window=128 的作用是什么？

简短回答：每层 attention 都有一个 128-token 的"原始 K/V 窗口"——最近 128 个 token 永远走 raw attention，不上压缩。保证最近语境的精度无损。

详细解释：

• 物理位置：在 kv_cache 中，前 $window_size=128$ 个位置存原始 K/V； $window_size:$ 之后是 CSA / HCA 压缩向量。
• prefill 路径：attention.py:L83-L91 把原始 K/V 放进 $self.kv_cache[:bsz, :128]$ ，再拼接 $kv_compress$ ； $topk_idxs$ 总是把 [0:128] 范围的索引拼在前面。
• decode 路径： $kv_cache[:bsz, start_pos % win]$ 循环写入最近 128 个 token 的 K/V——$start_pos % win$ 实现环形 buffer。
• 滑窗 + 压缩的语义：滑窗保"短期精确"，压缩保"长期稀疏"。两者拼接后每个 query 的 attention 范围 = “最近 128 个 raw + 远端 512 个压缩”。

为什么选 128：Mistral / V3 时代用 4096 / 8192；V4 把窗口压到 128 是因为压缩已经覆盖长程依赖，滑窗只负责"局部精度"。128 是经验最优——再小（如 32）会损害局部句法，再大（如 1024）会与压缩 cache 重复。

💡 面试要点：要意识到"滑窗 + 压缩"是互补而非冗余。

延伸阅读：主报告 §3.4（window_size 始终拼接部分）。

Q4.24 公式 (3.7) 逐层分支怎么写代码？

简短回答：源码在 $Attention.init$ 中按 $compress_ratios[layer_id]$ 选择性创建 Compressor 和 Indexer；forward 中根据 ratio 决定走 Indexer 路径（ratio=4）还是位置 topk 路径（ratio=128），并与 $window_topk_idxs$ 拼接。

详细解释（代码结构）：

1
2
3
4
5
6
7

# __init__ 中按 ratio 分支
if self.compress_ratio:
    self.compressor = Compressor(args, self.compress_ratio, self.head_dim)
    if self.compress_ratio == 4:
        self.indexer = Indexer(args, self.compress_ratio)
    else:
        self.indexer = None

• ratio=0 → 既无 Compressor 也无 Indexer，纯 $kv_cache[:bsz, :128]$
• ratio=4 → Compressor（overlap=True）+ Indexer（Hadamard + FP4）
• ratio=128 → Compressor（overlap=False），不创建 Indexer

1
2
3
4
5
6
7
8

# forward 中拼接 topk
if self.compress_ratio:
    offset = kv.size(1) if start_pos == 0 else win
    if self.indexer is not None:
        compress_topk_idxs = self.indexer(x, qr, start_pos, offset)  # CSA 路径
    else:
        compress_topk_idxs = get_compress_topk_idxs(ratio, bsz, seqlen, start_pos, offset)  # HCA 路径
    topk_idxs = torch.cat([topk_idxs, compress_topk_idxs], dim=-1)

核心：无论 ratio=0/4/128，$topk_idxs$ 最终都是一个 [B, S, 128+512] 的索引列表，kernel 一视同仁地 gather + attention。

💡 面试要点：理解"同 kernel 不同分支"是 V4 的工程优雅。

延伸阅读：主报告 §3.6 源码片段 3 + code-snippets/attention.py 第 31-79 行。

Q4.25 V4-Flash 实测 10% FLOPs / 7% KV cache 的来源？

简短回答：相对 V3.2（100% / 100%），V4-Flash 在 1M 上下文下把单 token FLOPs 压到 ~10%、KV cache 压到 ~7%。这来自 5 个工程优化的叠加：(1) CSA / HCA 压缩省 T² 项；(2) hc_mult=4 残差流复用省 cache；(3) FP4 专家省 cache；(4) 共享 MQA-KV；(5) 滑窗 cache 仅 128 项。

详细解释：

• CSA 单独：FLOPs 省 4 倍（理论 T²/4 vs T²）
• HCA 单独：FLOPs 省 128 倍（理论 T²/128 vs T²），cache 省 128 倍
• 50% CSA + 50% HCA 配合：FLOPs 节省约 6.5%（粗估），但 V4 论文 10% 数字包含了：
  • ① 滑窗层的全 attention（不是 sparse）
  • ② Indexer 计算开销
  • ③ YaRN 频率内插
  • ④ grouped low-rank O 投影（ $o_groups=8$ ）
• KV cache 7% 怎么来：
  • CSA / HCA 压缩：1/4 + 1/128 配合 ≈ 1/8
  • 滑窗仅 128 项：忽略不计
  • hc_mult=4 残差流共享：cache × 1/4
  • FP4 专家权重：~37 GB / 277B = 7%（专家权重本身省一半）
  • 7% 是多个工程优化叠加的最终值，不是单一因素

💡 面试要点：要意识到"10% / 7%“是端到端数字，不要把它直接对应到"sparse 4×"。

延伸阅读：主报告 §3.5（详细理论估算）。

Q4.26 CSA + HCA + 滑窗 + MQA + mHC + FP4 的协同效应是什么？

简短回答：6 项工程优化在 4 个维度叠加——(1) attention 计算稀疏化（CSA/HCA）；(2) attention cache 稀疏化（CSA/HCA + 滑窗）；(3) MoE cache 压缩（FP4 专家）；(4) 残差流复用（mHC hc_mult=4 + MQA-KV 共享）。

详细解释：

总 cache 节省比 = 4（CSA） × 64（MQA） × 4（mHC） × 2（FP4） ≈ 2000×（理论下界）。实际 V4-Flash ~7% / V3.2 100% ≈ 14×——理论值与实测有差距，原因是工程实现不可能每个优化都跑到理论极限。

FLOPs 节省 = 4-128× (attention) + 其它 ≈ 10×（实测）。

💡 面试要点：能列出 4 个维度的优化项 + 数字 = 加分。

延伸阅读：主报告 §3.5 末尾（“为什么 V4-Flash 实测 ~7% 不只是 25%“部分）。

Q4.27 训练 vs 推理的 attention 路径差异是什么？

简短回答：训练时 prefill 长序列一次过、topk_idxs 在 prefill 阶段批量生成、attention 与 backward 联动；推理时 分 prefill（处理 prompt）与 decode（自回归生成）两阶段——decode 阶段单 token 流入，每 token 重算一次 top-k。

详细解释：

• 训练时：
  • 一次前向处理 batch 内所有 token（如 8192）
  • prefill 路径：整段批处理压缩 + 整段算 attention
  • backward 时梯度要追溯到 Compressor / Indexer 的中间状态
  • 不区分 prefill / decode——只是"全段批处理”
• 推理 prefill（长 prompt）：
  • 一次性处理完整 prompt（可能是 1M tokens）
  • 走 prefill 路径（reshape + 整段 $\mathrm{softmax}$-pool）
  • 顶部 top-512 索引批量生成
• 推理 decode（batch=1）：
  • 每次来一个新 token，单 token 流入
  • Compressor 维护 $kv_state / score_state$ 累加器
  • Indexer 重算 top-512（每 token 一次）——这是 decode 阶段最大的额外开销
  • sparse_attn_kernel 单 query 启动

关键差异：

Decode 阶段的 Indexer 开销是 V4 的工程瓶颈——每生成一个 token 都要重算 top-512。V4 论文没有公开具体数字，但 batch=1 decode 延迟中 Indexer 占比可能达 30%+。

💡 面试要点：要意识到"训练 vs 推理的 attention 不是同一条代码路径”。

延伸阅读：主报告 §3.6 + §3.7.1（prefill vs decode 路径对比）。

Q4.28 “V3.2 vs V4-Flash” 注意力对比一览？

简短回答：V3.2 走纯 MLA（d_c=512 latent 投影）+ dense attention；V4-Flash 走 MLA + CSA/HCA 混合 + 滑窗 + Indexer。FLOPs 10×、cache 14× 节省。

详细解释：

关键差异：V3.2 解决"压 cache”，V4 解决"压 cache + 压 compute"。两者是演进关系而非替代——V4 完整保留 MLA 的 $d_c=512$ 设计，再叠一层时间维软压缩。

💡 面试要点：能讲清"V3 解决 cache，V4 解决 compute"是核心对比。

延伸阅读：主报告 §1.2（V3.2 四大瓶颈）+ §3.5（V4 实测）。

Q4.29 为什么 V4 不用 Linear Attention？

简短回答：Linear attention 把 $\mathrm{softmax}$ 替换为核函数 $φ(q) \cdot φ(k)^\top$ ，可 $O(T)$ 计算——但核函数近似 $\mathrm{softmax}$ 损失精度，V4 在 1M 上下文要求下质量不能妥协；CSA / HCA 是"在保持 $\mathrm{softmax}$ 精度的前提下做 sparse"，是 V4 的工程取舍。

详细解释：

• Linear attention 的优势： $O(T \cdot d^2)$ ，无 T² 项；推理 $O(1)$ per token。
• Linear attention 的劣势：
  • 核函数 φ(x) = elu(x) + 1 等不能精确表达 $\mathrm{softmax}$ 的"指数放大"行为
  • 长程任务（PPL、长上下文检索）质量明显下降
  • 训练-推理一致性差：很多实现要重写 kernel
• V4 的取舍：
  • 1M 上下文对长程质量敏感（needle-in-haystack、多跳 QA）
  • CSA / HCA 在"保 $\mathrm{softmax}$ 精度的前提下做 sparse"——top-512 的位置仍走完整 $\mathrm{softmax}$
  • 复杂度从 $O(T^2)$ 降到 $O(T\cdot k + T^2/m)$——sparse 但不近似
• V4 不是不用 linear attention，而是"在它做不到的位置不用"：短程走 attention + 滑窗；长程走 sparse attention（top-k 仍 $\mathrm{softmax}$ ）。

⚠️ 易混淆：Linear attention ≠ 稀疏 attention——前者是近似（kernel 替换），后者是截断（只算部分位置）。

延伸阅读：主报告 §3.1 末尾（“CSA + HCA 的核心创新”）。

Q4.30 为什么 V4 不用 State-Space Model（Mamba）？

简短回答：SSM（Mamba / S4）走 $O(T)$ 递归推理，质量在语言建模上仍弱于 Transformer；V4-Flash 定位是"高质量 1M 上下文 + MoE"，质量优先——CSA / HCA 是"在 Transformer 框架内做 sparse"，比换 SSM 风险更小。

详细解释：

• SSM 的优势：
  • 训练 $O(T)$ 并行，推理 $O(1)$ per token
  • 长程依赖建模理论上无限长
• SSM 的劣势：
  • 在语言建模上 PPL 仍差于 Transformer（同参数量）
  • 检索类任务（“找到第 3 段提到的实体”）质量显著下降
  • 训练稳定性差（HiPPO 初始化敏感）
  • 主流 benchmark（MMLU、HumanEval）落后 Transformer 5-10 个百分点
• V4 的取舍：
  • V4-Flash 是"开源主力 Instruct"——质量门槛高，不能换 backbone
  • CSA / HCA 保留 Transformer 框架，质量与 V3 持平
  • 工程上只需加 Compressor / Indexer / sparse_kernel——风险可控
• SSM 仍是开放方向：DeepSeek / Mistral / Qwen 都在做 SSM-Transformer 混合架构，但目前没有"全 SSM 替代 Transformer"的强证据。

💡 面试要点：要意识到"Transformer + sparse" vs “SSM” 不是"哪个更快"的问题，而是"质量与速度的 trade-off"。

延伸阅读：主报告 §3.1 末尾（V4 设计动机）。

Q4.31 Lightning Attention 与 V4 Indexer 的区别？

简短回答：Lightning Attention（RetNet / TransNormer 系）是"线性 attention + chunk-wise 并行"，近似 $\mathrm{softmax}$；V4 Indexer 是"压缩位置评分器"——不替代 attention，只选 top-k 位置给真正的 $\mathrm{softmax}$ attention 算。两者结构完全不同。

详细解释：

• Lightning Attention：
  • 把 $\mathrm{softmax}(Q\cdot K^\top)\cdot V$ 替换为 $φ(Q) \cdot (φ(K)^\top \cdot V)$ （核函数 + 矩阵结合律）
  • chunk 内并行列式不变，跨 chunk 递归
  • 训练 $O(T \cdot d^2)$ ，推理 $O(1)$ per token
  • 代价：核函数 φ 不能精确表达 $\mathrm{softmax}$ ，质量有损
• V4 Indexer：
  • 不替代 attention——只算"哪些位置重要"
  • 真正算 attention output 时仍是标准 $\mathrm{softmax}$ （ $\mathrm{softmax}(q\cdot k^\top/\sqrt{d})\cdot v$ ，见 sparse_attn_kernel）
  • Indexer 用 $\mathrm{ReLU}$ + topk 选 top-512
  • 代价：每 token 算一次 Indexer，但 attention 只算 512 个位置
• 关键区别：

⚠️ 易混淆：V4 Indexer 不属于 linear attention 家族——它只选位置，不算 attention。

延伸阅读：主报告 §3.7.2（Indexer 设计）。

Q4.32 V4 sparse attention 与 NSA（Native Sparse Attention）的关系？

简短回答：NSA（DeepSeek 2025 论文）也走"压缩 + 选位置"路线——与 V4 CSA 思路同源，但NSA 是 top-k of 3 种固定 pattern（compress / sliding / selected），V4 CSA 是 top-k by Indexer score。V4-Flash 是 NSA 思路的生产化演化。

详细解释：

• NSA 思路（Yuan et al. 2025）：
  • 把 K/V 分 3 个分支：压缩 branch（reduce）、滑窗 branch（local）、selected branch（top-k）
  • 3 个分支各自的 attention 拼接输出
• V4 CSA / HCA 思路：
  • CSA：1 个压缩 branch + 滑窗 + Indexer top-k（合并为 1 个 attention）
  • HCA：1 个压缩 branch + 滑窗（无 Indexer）
• 共同点：
  • 都用"压缩 K/V"省 cache / compute
  • 都用"top-k / sliding window" 选位置
• 差异：
  • NSA 的 3 个 branch 各自算 attention，输出拼接
  • V4 把压缩向量 + top-k 选位置合并为 1 个 attention kernel
  • V4 HCA 进一步省 Indexer
• V4 是 NSA 的工程化演化：V4-Flash 论文在 2026 年发布，吸收了 NSA（2025）思路并加入 Indexer 学分、滑窗、cascading 配合等生产级细节。

💡 面试要点：要意识到 V4 sparse attention 不是凭空设计，是站在 NSA / Mistral Sliding Window 等前人工作上的工程演化。

延伸阅读：主报告 §3.1 末尾（V4 创新定位）。

Q4.33 MQA（Multi-Query Attention）怎么省 cache？V4 怎么用？

简短回答：MQA 让所有 Q 头共享 1 个 K/V 头——cache 从 $[T, h \times d_h]$ 减到 $[T, d_h]$ 。V4-Flash 用 $num_key_value_heads=1$ （64 个 Q 头共享 1 个 K/V），cache 比 MHA 省 64×。

详细解释：

• MHA（Multi-Head Attention）：每个 Q 头有独立的 K/V。 $num_key_value_heads = num_attention_heads = 64$ 。
• MQA（Multi-Query Attention）：所有 Q 头共享 1 个 K/V。 $num_key_value_heads = 1$ 。
• GQA（Grouped-Query Attention）：分组共享。 $num_key_value_heads$ 在 [1, 64] 之间。

V4-Flash 配置 $num_key_value_heads=1$——严格 MQA。cache 形状： $[B, T, 1, d_h] = [B, T, 512]$ （d_h=512）；vs MHA 的 [B, T, 64, 512]，省 64×。

为什么 MQA 不显著损害质量：

• K/V 头少 → 参数量少 → 容量小
• 但多 Q 头仍可学不同 attention pattern（每个 Q 头有独立 $W_Q$ ）
• 经验上 $num_key_value_heads=1$ 在 7B+ 模型上质量损失 < 1%（参见 PaLM、Llama 2 的 GQA 实验）

V4 的 cache 节省比 = MQA 64× + CSA/HCA 4-128× + mHC 4× + 滑窗 ≈ 1000-10000×（理论下界）。

💡 面试要点：能区分 MHA / MQA / GQA 三档 + 各自的 cache 形状。

延伸阅读：主报告 §3.4（MQA-KV 部分）。

Q4.34 $q_lora_rank=1024$ 和 $o_lora_rank=1024$ 是什么？为什么需要？

简短回答： $q_lora_rank=1024$ 是 Q 投影的中间 bottleneck 维度（ $d \to 1024 \to h \times d_h$ ，d=4096, h×d_h=32768）； $o_lora_rank=1024$ 是 O 投影的中间维度。两者都用 low-rank 投影省参数 + 提速，组内头共享 O 投影（ $o_groups=8$ ）。

详细解释：

• Q 投影（attention.py:L22-L24）：
  • 原始： $W_Q \in \mathbb{R}^{d \times h \times d_h} = \mathbb{R}^{4096 \times 32768}$ （134M 参数）
  • LoRA： $W_Q = W_Q_b \cdot W_Q_a$ ， $W_Q_a \in \mathbb{R}^{4096 \times 1024}$ ， $W_Q_b \in \mathbb{R}^{1024 \times 32768}$——4.2M + 33.5M = 37.7M 参数，省 72%
  • 等价变换： $q = x \cdot W_Q_a \cdot W_Q_b$ 替代 $x \cdot W_Q$
• O 投影（attention.py:L27-L28）：
  • grouped low-rank：64 头分 8 组，每组 8 头共享 $o_lora_rank=1024$ 的 O 投影
  • $wo_a \in \mathbb{R}^{4096/8 \times 1024 \times 8} = \mathbb{R}^{512 \times 1024 \times 8}$ （4.2M）
  • $wo_b \in \mathbb{R}^{8 \times 1024 \times 4096}$ （33.5M）
  • 原始： $W_O \in \mathbb{R}^{32768 \times 4096}$ （134M）
  • 省 72%
• 为什么需要 low-rank：
  • 训练时省 72% 参数量
  • 推理时省 72% 权重加载带宽
  • 质量损失 < 1%——Q/O 矩阵的低秩结构本身近似

💡 面试要点：能算清"4.2M + 33.5M vs 134M 的参数对比"即可。

延伸阅读：主报告 §3.4（grouped low-rank O 投影）。

Q4.35 公式 (3.5) HCA 位置 top-k 的具体代码？

简短回答： $get_compress_topk_idxs(ratio, bsz, seqlen, start_pos, offset)$ 直接生成 (seqlen // ratio) 个等距位置索引，不走 Indexer 评分。

详细解释（attention.py:L72 上下文）：

1
2
3
4
5
6
7
8

topk_idxs = get_window_topk_idxs(win, bsz, seqlen, start_pos)  # 前 128 个
if self.compress_ratio:
    offset = kv.size(1) if start_pos == 0 else win
    if self.indexer is not None:
        compress_topk_idxs = self.indexer(x, qr, start_pos, offset)  # CSA
    else:
        compress_topk_idxs = get_compress_topk_idxs(ratio, bsz, seqlen, start_pos, offset)  # HCA
    topk_idxs = torch.cat([topk_idxs, compress_topk_idxs], dim=-1)

$get_compress_topk_idxs$ 的逻辑：

• HCA 时 ratio=128， $end_pos // 128$ 是当前可用的压缩位置数
• 选 $[0, 1, 2, …, end_pos//128 - 1]$ 的前 topk=512 个（或全部）
• 加 offset 让索引指向正确的 $kv_cache$ 位置（HCA 路径中 offset = 滑窗大小 128）

核心假设：HCA 的 8192 个压缩位置（1M / 128）信息量均匀，前 512 个就够——这是 V4 的工程经验。

⚠️ 易混淆：HCA 的"位置 top-k"不是"均匀采样"——是直接取前 512 个位置（positions[0:512]）。

延伸阅读：主报告 §3.3 公式 (3.5) + code-snippets/attention.py 第 72-79 行。

Q4.36 滑窗中的 128 个 raw K/V 在 cache 中怎么放？

简短回答：源码在 $Attention.kv_cache$ 中前 $window_size=128$ 个位置存原始 K/V； $window_size:$ 之后是 CSA / HCA 压缩向量。 $topk_idxs$ 总是把 [0:128] 范围拼在前面。

详细解释：

• Cache 布局：

  kv_cache: [B, window_size + max_compressed_len, d]
            └─ 前 128: 原始 K/V ─┘└──── 压缩 K/V (T/4 或 T/128) ────┘
  

• prefill 路径（attention.py:L83-L88）：

  1 2 3 4 5 6

  if seqlen <= win: self.kv_cache[:bsz, :seqlen] = kv else: cutoff = seqlen % win self.kv_cache[:bsz, cutoff: win], self.kv_cache[:bsz, :cutoff] = \ kv[:, -win:].split([win - cutoff, cutoff], dim=1)

  滑窗只保留最近 128 个 token——更早的 token 从滑窗 cache 中滚出。
• decode 路径（attention.py:L95）：

  1	self.kv_cache[:bsz, start_pos % win] = kv.squeeze(1)

  环形 buffer： $start_pos % 128$ 实现 128 个位置的循环覆盖。
• 拼接 topk： $topk_idxs = cat([window_idxs, compress_idxs])$——window_idxs 是 [0, 1, ..., 127]，compress_idxs 偏移 128（offset = win）后指向压缩段。

💡 面试要点：要理解"环形 buffer"是滑窗的标准实现。

延伸阅读：主报告 §3.6 + code-snippets/attention.py 第 38-39, 83-98 行。

Q4.37 $attn_sink$ 是什么时候加进 sparse_attn_kernel 的？

简短回答：在 online $\mathrm{softmax}$ 循环结束后、 $acc_o / sum_exp$ 之前——$sum_exp[i] += T.exp(attn_sink[i] - scores_max[i])$ 。这是 V3.2 沿用的"虚拟 token"防御。

详细解释：

源码位置（ $code-snippets/sparse_attn_kernel.py$ 第 70-73 行）：

1
2
3
4
5

# 5. attn_sink: V3.2 沿用的偏置 (per-head 标量)
for i in T.Parallel(h):
    sum_exp[i] += T.exp(attn_sink[i] - scores_max[i])
for i, j in T.Parallel(h, d):
    acc_o[i, j] /= sum_exp[i]

位置选择：

• 在 8 个 block 循环结束后——此时 $scores_max / sum_exp / acc_o$ 已是 512 位置累加结果
• 在 $acc_o / sum_exp$ 之前——attn_sink 是 $\mathrm{softmax}$ 分母的一部分，必须先加
• 减 $scores_max$ 是为了数值稳定（与 online $\mathrm{softmax}$ 主体一致）

为什么 V3 引入：StreamingLLM / V3 都观察到——attention 在没有 sink token 时， $\mathrm{softmax}$ 分布会"无主"，sum_exp 极小，output 数值爆炸。加 attn_sink 给所有 head 一个 fallback 概率，保证 sum_exp 始终 > $exp(attn_sink - scores_max)$。

⚠️ 易混淆：attn_sink 不是"前 4 个 token"（那是 StreamingLLM 的 attention sink），是per-head 学到的标量。

延伸阅读：主报告 §3.7.3 (5) + $code-snippets/sparse_attn_kernel.py$ 第 70-73 行。

Q4.38 CSA / HCA 训练时 Indexer 怎么参与反向传播？

简短回答：Indexer 的参数（ $wq_b$ 、 $weights_proj$ 、Compressor 的 wkv/wgate/ape）都通过 $index_score = relu(q\cdot k^\top) \cdot w$ 反向传播；Indexer 输出 $topk_idxs$ 是离散索引（无梯度），但 score 本身连续可导。Compressor 的 wkv/wgate/ape 通过"压缩向量的 k"反向传播。

详细解释：

• topk_idxs 无梯度：argmax / topk 操作不可微——梯度不能通过索引反传
• 但 score 连续可导： $index_score = relu(q\cdot k^\top) \cdot w$ 是连续函数，反向传播通过 q / k / w 三个路径：
  • q 路径： $wq_b$ 的梯度
  • k 路径：Indexer-Compressor 的 wkv/wgate/ape 的梯度
  • w 路径： $weights_proj$ 的梯度
• Compressor 梯度：
  • Indexer-Compressor（rotate=True）的 wkv/wgate/ape 通过 k = Compressor(x) 反传
  • Attention-Compressor（rotate=False）的 wkv/wgate/ape 通过 k = Compressor(x) 在 sparse_attn_kernel 内反传
• topk 截断的反向 trick：被 topk 选中的位置梯度正常回传；未被选中的位置梯度 = 0——这相当于"硬注意力掩码"，实现简单。
• Indexer vs Attention 反向差异：
  • Indexer 反向：标准 dense matmul（ $wq_b$ 、 $weights_proj$ 、Indexer-Compressor）
  • Attention 反向：sparse_attn_kernel 内只有 top-512 位置反传，其余位置为 0

💡 面试要点：要理解"topk 是不可微操作，但 score 本身连续可导"——这是 CSA 能端到端训练的关键。

延伸阅读：主报告 §3.6 + code-snippets/indexer.py（ $index_score = … .relu_() * weights.unsqueeze(-1)$ ）。

CH 5 — MoE 路由

Q5.1 MoE 与稠密 FFN 的对比？

简短回答：稠密 FFN 所有 token 走同一份参数；MoE 把 FFN 拆成 E 个 expert，每个 token 只激活 top-k 个——总参可任意大、激活参数保持小。V4-Flash 256 routed expert + 1 shared，每 token 激活 7 个（6 routed + 1 shared），激活 13B / 总参 284B。

详细解释：

• 稠密 FFN（LLaMA / Mistral）： $FFN(x) = W_2 \cdot silu(W_1 \cdot x) \odot W_3 \cdot x$ ，单层 3 × 4096 × 11008 = 135M 参数。所有 token 走同一份。
• MoE FFN（DeepSeekMoE）：拆成 E=256 个 expert，每个 expert 是独立 $\mathrm{SwiGLU}$ ；Gate 网络把每个 token 路由到 top-k=6 个 expert。
• V4-Flash 数据：
  • 256 routed expert × 3 × 4096 × 2048 = 6.45B / 层
  • 1 shared expert × 3 × 4096 × 2048 = 25.2M / 层
  • 每 token 激活 6 routed + 1 shared = 7 × 25.2M = 176M / 层
  • 总参 284B / 激活 13B = 22× 稀疏比

核心优势：在不增加激活 FLOPs 的前提下，总参可以拉大 22×——专家容量大、可学更多知识，但单次推理只跑 13B 激活。

💡 面试要点：要算清"总参 vs 激活参数"的稀疏比。

延伸阅读：主报告 §4.1（含完整参数表）。

Q5.2 Top-k 路由是什么？

简短回答：Gate 网络算出 token 对 E 个 expert 的亲和度分数，挑 top-k 个激活——token x 算出 [E] 维分数，取 top-k 个最大值对应的 expert 索引。

详细解释：

• 流程：
  1. $W_g \cdot x \to \mathbb{R}^E$ （E=256）
  2. 评分函数（ $\mathrm{sqrtsoftplus}$ / $\mathrm{softmax}$ / $\mathrm{sigmoid}$ ）
  3. top-k 选索引（k=6）
  4. 对 top-6 个 expert 算前向，加权求和
• 稀疏性：256 个 expert 中只有 6 个被激活，250 个完全跳过——节省 250/256 ≈ 97.7% 的 expert FFN 计算
• 可微性：topk 索引不可微，但通过"路由权重 = score.gather(topk_idx)“保持连续性
• Top-1 vs Top-k：
  • Top-1（Switch Transformer）：极度稀疏，但容量小
  • Top-2/4/6/8：平衡容量与稀疏度
  • V4-Flash 选 k=6（在 13B 激活约束下尽量大）

⚠️ 易混淆：Top-k 路由 ≠ “k 个分数高的 expert 加权”——是"k 个分数高的 expert 按分数加权”，权重来自原分数。

延伸阅读：主报告 §4.2 公式 (4.2) + §4.5 源码片段 1。

Q5.3 Switch Transformer 的简化路由？

简短回答：Switch Transformer（Fedus et al. 2022）把 top-k 简化为 top-1——每个 token 只路由到 1 个 expert，简化 routing 逻辑 + 减少通信量。V4 仍用 top-6，但 Switch 思想（极简路由）是后续 MoE 工作的起点。

详细解释：

• Switch Transformer 路由：
  • 每个 token 路由到 score 最高的 1 个 expert
  • indices = scores.argmax(dim=-1)，单次 expert FFN
  • 通信量：每个 token 1 个 expert id
• 优势：
  • 实现极简（argmax 比 topk 简单）
  • 通信量最小（专家并行时 all-to-all 负载轻）
• 劣势：
  • 单 expert 容量小，质量下降
  • 负载不均更严重
• V4 的取舍：
  • V4-Flash 走 top-6（不是 top-1）——质量优先
  • 但保留 Switch 的"极简 dispatch"思想——MoE.forward 用 Python 循环 + torch.where 找 token，避免复杂 CUDA kernel

💡 面试要点：Switch Transformer 是 MoE 简化的里程碑，但要意识到"V4 不直接用 top-1"。

延伸阅读：主报告 §4.1（V3.2 vs V4 路由对比表）。

Q5.4 细粒度专家（V2 风格）是什么？

简短回答：V2 风格把 expert 数量从 8 拉到 160+、单 expert 维度从 8192 砍到 256（细粒度）——专家更多、更细、更专门化。V4-Flash 沿用这一思想：256 个 expert、 $moe_intermediate_size=2048$ （单 expert 中间维度），比 V1 的"少而大"expert 更细。

详细解释：

• V1 风格（GShard, 2020）：8 个 expert、单 expert 维度 8192。每个 expert 容量大但数量少。
• V2 风格（DeepSeekMoE, 2024）：160-256 个 expert、单 expert 维度 256-2048。专家多 + 细粒度。
• V4 风格：
  • 256 routed expert
  • 单 expert 中间维度 $moe_intermediate_size=2048$ （远小于 V1 的 8192）
  • 单 expert 参数量 = 3 × 4096 × 2048 = 25.2M
• 细粒度的优势：
  • 单 expert 容量小 → 学"专精"模式（语法、实体、数学、代码等）
  • 多 expert 组合 → 表达力强（256 个 25.2M expert 总容量 6.45B / 层）
  • 激活比例 = 6/256 = 2.3%——比 V1 的 1/8 = 12.5% 更稀疏

⚠️ 易混淆：“细粒度"是指 expert 数量多、单 expert 小——不是指 token 路由细。

延伸阅读：主报告 §4.1（DeepSeekMoE 引用）。

Q5.5 共享专家（V3 风格）的作用？

简短回答：共享 expert 永远激活，承担"通用知识”——让 256 个 routed expert 可以更专门化（学"专项能力"），不浪费容量在"通识"上。降低 routed expert 的等效容量压力。

详细解释：

• 设计动机：
  • 纯 routed MoE：每个 expert 都要学"通用 + 专项"——容量浪费
  • 纯 shared MoE：所有 expert 共享——失去细粒度优势
  • 共享 + routed 混合：1 个 shared 学通用 + 256 个 routed 学专项
• V4-Flash 数值：
  • 1 shared expert = 25.2M 参数（永远激活）
  • 承担 1.08B / 13B ≈ 8% 的激活开销
  • 256 routed = 6.45B 总参，6 个激活
• 典型分工：
  • shared 学：常见词、句法、标点、常用短语
  • routed 学：领域知识（代码 / 数学 / 多语言 / 长尾实体）
• 训练稳定性：shared 永远激活，给所有 token 一个"基线信号"——routed 偏离时不会塌缩。

💡 面试要点：要意识到"shared expert 不只是为了省参数"——是为了"把 routed expert 解放出来做更细的专门化"。

延伸阅读：主报告 §4.1（共享 expert 解释）。

Q5.6 “1 + 256 + 6” 拓扑的具体含义？

简短回答：1 个 shared expert（永远激活）+ 256 个 routed expert（top-6 选择激活）——单层 MoE 形态。V4-Flash 43 层 × 这个拓扑 = 43 个独立的 MoE 层（层间不共享 expert）。

详细解释：

• 1：1 个 shared expert（永远激活， $\mathrm{SwiGLU}$ dim=2048）
• 256：256 个 routed expert（ $\mathrm{SwiGLU}$ dim=2048，FP4 量化）
• 6：每 token 激活 top-6 个 routed + 1 个 shared = 7 个 expert 实际工作
• 层间独立：43 层各自有独立的 256 routed + 1 shared——共 43 × 257 = 11,051 个 expert
• 总参：43 × 257 × 25.2M ≈ 278B（其中 routed 占 277B，shared 占 1.08B）
• 激活：43 × 7 × 25.2M ≈ 7.6B（experts 部分）+ 4-5B（attn/norm/embed） ≈ 13B

与 V3.2 的关键差异（V3.2 是 1+256+8，V4-Flash 是 1+256+6）：

V4 把 k 从 8 砍到 6，配合 $route_scale=1.5$——“用 6 个专家达到 8 个专家的等效表达力”。

💡 面试要点：要算清"1+256+6" 的 13B 激活 vs 256 routed 的 6.45B / 层参数。

延伸阅读：主报告 §4.1（含完整参数计算）。

Q5.7 公式 (4.1) Gating 评分是什么？

简短回答： $g_i = \mathrm{sqrtsoftplus}((W_g \cdot x)_i)$——Gate 矩阵 $W_g \in \mathbb{R}^{d \times E}$ 乘 token $x \in \mathbb{R}^d$ ，得到 256 维 logits，再过 $\mathrm{sqrtsoftplus}$ 评分函数。

详细解释（code-snippets/gate.py L20 + L26）：

1
2

scores = linear(x.float(), self.weight.float())  # W_g · x → [B, 256]
scores = F.softplus(scores).sqrt()                 # sqrtsoftplus

• Gate 矩阵： $W_g \in \mathbb{R}^{4096 \times 256}$ （1M 参数）—— V4-Flash 把 d=4096 投影到 E=256
• $\mathrm{softplus}$： $\mathrm{softplus}(z) = log(1 + exp(z))$——把任意实数映射到 (0, +∞)
• 开方： $sqrt(\mathrm{softplus}(z))$——V4 的工程小创新

为什么 $\mathrm{sqrtsoftplus}$ 不是 $\mathrm{sigmoid}$ / $\mathrm{softmax}$：

• $\mathrm{sigmoid}$ 把分数压到 (0, 1)，对负 logits 不敏感
• $\mathrm{softmax}$ 让一个 expert 主导，破坏"细粒度"假设
• $\mathrm{sqrtsoftplus}$ 在 $z \to -\infty$ 时趋近 0，在 $z \to +\infty$ 时趋近 sqrt(z)——数值范围更稳

💡 面试要点：能写出"$sqrt(\mathrm{softplus}(z))$“和"它与 $\mathrm{sigmoid}$/$\mathrm{softmax}$ 的差异"即可。

延伸阅读：主报告 §4.2 公式 (4.1)。

Q5.8 $\mathrm{sqrtsoftplus}$ 是什么？为什么不用 $\mathrm{softmax}$ / $\mathrm{sigmoid}$ ？

简短回答： $\mathrm{sqrtsoftplus}(z) = sqrt(log(1 + exp(z)))$——$\mathrm{softplus}$ 后开方。不归一化、不压范围、数值稳定——是 routing weight 与 topk 分数"同源"的最简选择。

详细解释：

• $\mathrm{softplus}$ 性质：
  • $z \to -\infty$ ： $\mathrm{softplus}(z) \to 0$
  • $z \to +\infty$ ： $\mathrm{softplus}(z) \to z$
  • 处处可导，平滑
• 开方的作用：
  • 把 $\mathrm{softplus}(z)$ 的 (0, +∞) 范围压到 (0, sqrt(z))
  • 让 256 个 expert 的分数在 $O(1)$ 量级（不是 O(z) 或 $O(1)$ ）
  • topk 选位置时不被某一极端高分主导
• vs $\mathrm{sigmoid}$：
  • $\mathrm{sigmoid}$ ：(0, 1)，对负 logits 截断为 0.5
  • $\mathrm{sqrtsoftplus}$ ：(0, sqrt(z))，对负 logits 截断为 0——更"硬"的稀疏性
• vs $\mathrm{softmax}$：
  • $\mathrm{softmax}$ ：归一化到概率分布，所有 expert 都有非零权重
  • $\mathrm{sqrtsoftplus}$ ：独立计算，每个 expert 权重独立
  • $\mathrm{softmax}$ 让"top expert 主导”，破坏细粒度
• V4 论文 ablation：在 MMLU / GSM8K 上 $\mathrm{sqrtsoftplus}$ 略优于 $\mathrm{sigmoid}$ ，显著优于 $\mathrm{softmax}$

⚠️ 易混淆： $\mathrm{sqrtsoftplus}$ 不是"开方 + $\mathrm{softplus}$ 分别"——是"先 $\mathrm{softplus}$ 再开方"。

延伸阅读：主报告 §4.2 公式 (4.1) 解释。

Q5.9 $noaux_tc$ 路由方法是什么？

简短回答： $noaux_tc$ 是 V4-Flash 配置中的 $topk_method$——指 V4 论文中的 “no-aux top-k constraint” 方法，本质就是aux-loss-free bias（无 aux loss、靠 per-expert 标量偏置平衡负载）。V4 论文完整名是 $noaux_tc$ （no-aux-loss top-k with transform constraint）。

详细解释：

• $noaux_tc$ 含义：
  • no aux：没有传统 aux loss（ $\lambda \cdot \Sigma f_i \cdot p_i$ ）
  • tc：transform constraint，指"用 bias 变换分数约束 topk"
• 核心机制：
  1. 每个 expert 维护标量偏置 $b_e$ （fp32，可训练）
  2. topk 选择用 $score + b_e$
  3. 训练时按命中频率更新 $b_e$ （过载减小、欠载增大）
  4. 推理时 b 冻结
• V3.2 沿用：V3.2-Exp 论文就提出 aux-loss-free bias；V4 沿用并调优
• config 表现： $“topk_method”: “noaux_tc”$ （config.json 第 60 行）——告诉训练框架"用这个方法"

💡 面试要点：要意识到 $noaux_tc$ 就是 aux-loss-free bias 的工程名。

延伸阅读：主报告 §4.2 + §4.3.2（aux-loss-free 详解）。

Q5.10 Aux-loss-free bias 的核心思想？

简短回答：每个 expert 维护一个可训练标量偏置 $b_e$——topk 选择用 $score + b_e$ ，$b_e$ 不进 routing weight 计算。训练时按命中频率更新 $b_e$ （过载减、欠载增），推理时冻结。核心创新是"不污染主损失梯度"——bias 只影响 topk 选择。

详细解释：

核心规则：

1. 每个 routed expert e 维护偏置 $b_e \in \mathbb{R}$ （fp32，形状 [256]）
2. 训练 step 结束时统计各 expert 命中频率 $f_e$
3. 目标频率 $p = 1/256 \approx 0.39%$
4. 更新规则：

   b_e ← b_e - η · (1/E - f_e)         (E=256, η=0.001, 论文指定)
   

   • 若 $f_e > p + \delta$ （过载）： $b_e -= \eta$ → 下次 topk 选该 expert 概率下降
   • 若 $f_e < p - \delta$ （欠载）： $b_e += \eta$ → 下次 topk 选该 expert 概率上升
5. 关键约束： $b_e$ 仅影响 topk 选择，不参与 routing weight

为什么"aux-loss-free"比"aux loss"好：

V3 论文报告：200B token 训练后，aux-loss-free 与 aux loss 达到几乎相同的负载均衡（max=0.012 vs 0.011），但下游任务 +0.5% MMLU。

💡 面试要点：要算清"$b_e$ 只影响 topk，不影响 weight"是核心 trick。

延伸阅读：主报告 §4.3.2（含完整更新规则）。

Q5.11 偏置 $b_e$ 的更新规则细节？

简短回答： $b_e ← b_e - \eta \cdot (1/E - f_e)$ ，其中 E=256， $\eta=0.001$ （论文指定）， $\delta=0.05$ （容忍带）。每 step 末尾更新——过载减、欠载增，仅影响 topk 选择。

详细解释：

• 更新公式：

  b_e ← b_e - η · (1/E - f_e)
  

  • $f_e$ ：当前 step 中 expert e 被 top-6 选中的频率
  • $1/E = 1/256 \approx 0.39%$ ：目标频率
  • $\eta = 0.001$ ：学习率（论文指定）

• 等价描述：

  • 若 $f_e > p + \delta$ （过载）： $b_e -= \eta$ → 下 step topk 选该 expert 概率下降
  • 若 $f_e < p - \delta$ （欠载）： $b_e += \eta$ → 下 step topk 选该 expert 概率上升
  • δ 是"容忍带"，论文给 δ ≈ 0.05

• 频率统计：每 step 末尾 counts = bincount(indices.flatten())， $f_e = counts[e] / total_tokens$

• 关键约束： $b_e$ 不进梯度——它是 buffer-style 参数（fp32 单独存），更新由训练框架侧（不在本 inference 仓库内）

• 推理时冻结：推理路径完全跳过 bincount 统计， $b_e$ 是常量偏移

💡 面试要点：要能写出"$b_e -= \eta \cdot (1/256 - f_e)$“公式。

延伸阅读：主报告 §4.3.2（含完整公式 + δ 容忍带）。

Q5.12 公式 (4.2) Top-k 选择的具体代码？

简短回答（code-snippets/gate.py L29-L34）：

1
2
3
4
5
6
7
8
9

# bias 加和（仅 score 模式）
scores = scores + self.bias

# hash 模式：一次查表
if self.hash:
    indices = self.tid2eid[input_ids]
# score 模式：top-6
else:
    indices = scores.topk(self.topk, dim=-1)[1]

详细解释：

• score 模式（后 40 层）：
  • $score_with_bias = score + self.bias$ —— bias 仅影响 topk
  • indices = scores.topk(self.topk, dim=-1)[1] —— 取 top-6 索引
  • topk(k, dim=-1) 返回 (values, indices)，取 [1] 得索引
• hash 模式（前 3 层）：
  • $indices = self.tid2eid[input_ids]$ —— 一次查表
  • $tid2eid \in \mathbb{R}^{vocab \times 6}$ 形状 [129280, 6]，int32 不可训练
  • 完全跳过 score 计算
• Top-k 索引的语义：indices[i, 0:6] 是 token i 选中的 6 个 expert 编号（0-255 范围）

💡 面试要点：要意识到"topk 取索引"和"topk 取值"是两个不同用法。

延伸阅读：主报告 §4.2 公式 (4.2) + code-snippets/gate.py L29-L34。

Q5.13 公式 (4.3) Routing weight + 缩放？

简短回答（code-snippets/gate.py L35-L39）：

1
2
3
4
5
6
7

# 公式 (4.3)：用 original_scores（不带 bias）取权重
weights = original_scores.gather(1, indices)
# 归一化（不是 softmax）
weights /= weights.sum(dim=-1, keepdim=True)
# route_scale = 1.5
weights *= self.route_scale
return weights, indices

详细解释：

• 取权重（不带 bias）： $weights = original_scores.gather(1, indices)$ —— $original_scores$ 是 L27 保存的"未加 bias 的原始分”，gather 出 top-6 索引对应的分数
• 归一化（不 $\mathrm{softmax}$ ）： $weights /= weights.sum(dim=-1, keepdim=True)$ —— 让 6 个权重之和 = 1
• 乘 1.5： $weights *= self.route_scale$ —— $route_scale = 1.5$

为什么用 $/= weights.sum$ 而不是 $\mathrm{softmax}$：

• $\mathrm{softmax}$ ： $exp(s_i) / \Sigma exp(s_j)$——会让大分数指数放大
• $/= sum$ ：直接归一化，保留 $\mathrm{sqrtsoftplus}$ 评分函数的形态
• 注释（gate.py:L36）： $if self.score_func != “\mathrm{softmax}"$——只有当评分函数不是 $\mathrm{softmax}$ 时才归一化

为什么乘 1.5：

• k 从 V3 的 8 砍到 V4 的 6——routed 加权和数值上比 V3 小
• 不放大：shared expert（永远激活 ≈ 1）会"压住” routed 信号
• 放大 1.5×：让 routed 加权和 ≈ 1.5，与 shared 的 1 叠加，总输出 ≈ 2.5

💡 面试要点：要理解"$/= sum$ 不是 $\mathrm{softmax}$"+“1.5 是 k 砍到 6 的补偿"两个核心点。

延伸阅读：主报告 §4.2 公式 (4.3) + §4.1（route_scale 解释）。

Q5.14 $routed_scaling_factor=1.5$ 的"剪枝 + 缩放"组合？

简短回答：V4-Flash 把 k 从 V3 的 8 砍到 6（剪枝），用 $routed_scaling_factor=1.5$ 放大 routed 输出（缩放）——6 个 routed × 1.5 ≈ 9 个 routed 的等效表达力。这是 V4 配合 k 缩减的关键调参。

详细解释：

• k 砍到 6 的代价：
  • routed 激活减少 25%（8 → 6）
  • 总激活参数 = shared (1.08B) + routed (43 × 6 × 25.2M = 6.5B) ≈ 7.6B
  • 比 V3 的 8 routed 省 25% routed 容量
• route_scale=1.5 的作用：
  • 不放大：routed 加权和 ≈ 0.3（6 个 $\mathrm{sqrtsoftplus}$ 归一化后）
  • shared 加 ≈ 1.0，shared 主导
  • 放大 1.5×：routed 加权和 ≈ 0.45 × 1.5 = 0.675，与 shared 1.0 叠加 ≈ 1.675
  • 等价于"用 6 个专家达到 9 个专家的等效表达力”
• V4 论文 ablation：1.5 是质量 / 性能 sweet spot；1.0（无缩放）质量下降；2.0 训练不稳定
• config 表现： $“routed_scaling_factor”: 1.5$ （config.json 第 55 行）

⚠️ 易混淆： $route_scale=1.5$ 不是"放大 logits"——是"放大 routing weight"，不影响 topk 选择。

延伸阅读：主报告 §4.1（route_scale 解释）+ §4.2 公式 (4.3)。

Q5.15 公式 (4.3) $weights /= weights.sum$ 与 $\mathrm{softmax}$ 的区别？

简短回答： $/= sum$ 是"线性归一化"——保持 $\mathrm{sqrtsoftplus}$ 评分函数的形态； $\mathrm{softmax}$ 是"指数归一化"——会放大极值分数、压平其它。$/= sum$ 保留专家间相对差异， $\mathrm{softmax}$ 让 1 个 expert 主导。

详细解释：

• $weights /= weights.sum$：
  • $weights[i] = original_scores[i] / sum(original_scores[top6])$
  • 6 个 expert 的相对分数保留
  • 如果 6 个分数都很接近（如 0.5, 0.5, 0.5, 0.5, 0.5, 0.5），归一化后 6 个权重都是 1/6
  • 适合"细粒度专家 + 共同贡献"场景
• $\mathrm{softmax}$：
  • $weights[i] = exp(s_i) / \Sigma exp(s_j)$
  • 极值放大：1 个高分 expert 拿到大部分权重，其它 5 个几乎为 0
  • 适合"top-1 expert 主导"场景
• V4 选 $/= sum$ 的原因：
  • $\mathrm{sqrtsoftplus}$ 评分函数本身已"硬稀疏"（负 logits 趋近 0）
  • 不需要 $\mathrm{softmax}$ 再放大一次
  • 保持 6 个 expert 共同贡献——这与"细粒度专家 + 共同激活"的设计哲学一致
• 源码注释（gate.py:L36）： $if self.score_func != “\mathrm{softmax}”: weights /= weights.sum(…)$——只有当评分函数是 $\mathrm{softmax}$ 时才不做 $/= sum$ （因为 $\mathrm{softmax}$ 已经归一化）

💡 面试要点：要能区分"线性归一化 vs 指数归一化"+“为什么 V4 不需要 $\mathrm{softmax}$ 再放大”。

延伸阅读：主报告 §4.2 公式 (4.3) 解释。

Q5.16 256 个 routed expert 的参数量怎么算？

简短回答：单 expert 参数量 = 3 × 4096 × 2048 = 25.2M（w1 + w2 + w3 $\mathrm{SwiGLU}$ ），256 个 = 6.45B / 层；FP4 量化后单 expert 6.3M，1.61B / 层。V4-Flash 43 层总计 = 277B（BF16） / 69B（FP4）。

详细解释：

• 单 expert $\mathrm{SwiGLU}$ 参数量：
  • $w1: 4096 \to 2048$ ，参数 = 4096 × 2048 = 8.4M
  • $w2: 2048 \to 4096$ ，参数 = 2048 × 4096 = 8.4M
  • $w3: 4096 \to 2048$ ，参数 = 4096 × 2048 = 8.4M
  • 合计 = 25.2M
• 256 个 routed = 256 × 25.2M = 6.45B / 层（BF16/FP8）
• FP4 量化后 = 256 × 6.3M = 1.61B / 层（4× 节省）
• V4-Flash 43 层：
  • BF16：277B（仅 routed expert 权重）
  • FP4：69B（仅 routed expert 权重）
• 完整模型总参（284B）的来源：
  • routed expert 权重（FP4）：约 69B
  • routed expert 量化 scale + 共享 expert + attn + norm + embed：约 215B
  • 合计 284B（与官方一致）

与 V3.2 的差异：

• V3.2 同样是 256 routed + 25.2M / expert，但走 FP8（不量化到 FP4）
• V4 走 FP4 后 expert 权重减半，节省的 4× 显存让 V4-Flash 能在 8×H100 上跑

💡 面试要点：要算清"25.2M × 256 = 6.45B / 层"+“FP4 节省 4×"。

延伸阅读：主报告 §4.1（参数计算表）。

Q5.17 Expert FP4 量化（dim=4096 → 2048 → 4096）怎么工作？

简短回答：V4-Flash 把 routed expert 权重从 FP8 进一步量化到 FP4（ $float4_e2m1fn_x2$ ，block=32，E8M0 scale）。单 expert 25.2M → 6.3M，省 4× 显存。前向时反量化到 fp32 算 matmul。

详细解释：

• FP4 格式：
  • $float4_e2m1fn_x2$ ：1 sign + 2 exponent + 1 mantissa，4 bit
  • block=32：每 32 个 weight 共享一个 E8M0 scale（fp8 标量）
  • 实际存储：4 bit weight + 8 bit scale = 12 bit per weight = 1.5 byte / weight
• 反量化：
  • 训练时：FP4 → fp32（按 scale）→ 算 matmul → FP4 模拟梯度
  • 推理时：FP4 → fp32（按 scale）→ fp32 matmul
• 关键 trick： $swiglu_limit=10.0$ （expert.py:L8）——把 up / gate 钳到 [-10, 10]，防 FP4 量化下数值爆炸。FP4 只有 16 个 level，超过 10 的值会饱和，钳制后数值稳定。
• 量化 vs 计算的 trade-off：
  • 显存：省 4×
  • 加载带宽：省 4×
  • 计算：fp32 算（无 FLOPs 节省）——FP4 路径主要省 cache 不是省 FLOPs

⚠️ 易混淆：FP4 量化只针对路由 expert 权重——attn 权重、shared expert、norm、embed 仍是 FP8/BF16。

延伸阅读：主报告 §4.1（FP4 量化对比表）+ §4.5 源码片段 2（swiglu_limit）。

Q5.18 Expert $\mathrm{SwiGLU}$ 激活怎么算？

简短回答（code-snippets/expert.py L12-L20）：

1
2
3
4
5
6
7
8

gate = self.w1(x).float()        # w1: d → inter_dim
up = self.w3(x).float()          # w3: d → inter_dim
up = torch.clamp(up, min=-10, max=10)
gate = torch.clamp(gate, max=10)  # swiglu_limit
x = F.silu(gate) * up            # SwiGLU: silu(gate) * up
if weights is not None:
    x = weights * x              # routing weight 加权
return self.w2(x.to(dtype))      # w2: inter_dim → d

详细解释：

• 3 个矩阵：
  • w1: $d \to inter_dim$ （d=4096, inter_dim=2048）—— gate 投影
  • w3: $d \to inter_dim$ —— up 投影
  • w2: $inter_dim \to d$ —— down 投影
• $\mathrm{SwiGLU}$： $silu(gate) * up = (gate \cdot \mathrm{sigmoid}(gate)) * up$
• swiglu_limit 钳制：
  • up 钳到 [-10, 10]
  • gate 钳到 (-∞, 10]（gate 不需要下限，因为 silu(x) 在 x 极负时已经趋近 0）
  • 目的：FP4 量化下防数值爆炸
• 加权和：weights * x —— 把 routing weight 应用到 expert 输出（routed 路径用，shared 路径 weights=None）

为什么 fp32 计算：

• FP4 量化下 bf16 计算的数值误差可能掩盖信号
• fp32 计算 → bf16 输出（x.to(dtype)）保证精度

💡 面试要点：要写出”$\mathrm{SwiGLU}$ = silu(W1·x) * (W3·x)" + swiglu_limit 的目的。

延伸阅读：主报告 §4.5 源码片段 2 + code-snippets/expert.py（完整实现）。

Q5.19 Hash routing 的核心思想？

简短回答：用 $tid2eid[token_id] \to expert_indices$ 查表替代 score routing——相同 token id 永远分到相同 expert，完全确定。V4-Flash 前 3 层用 hash routing（ $num_hash_layers=3$ ），后 40 层用 score routing。

详细解释：

• 核心数据结构： $tid2eid \in \mathbb{R}^{vocab \times 6}$ ，形状 [129280, 6]，int32，不可训练（ $requires_grad=False$ ）
• 查表操作： $indices = self.tid2eid[input_ids]$ —— 一次 Python 风格的张量 gather
• 权重：hash 模式 weights = 1.5 / 6 = 0.25（均匀权重，无 score 计算）
• 设计动机：
  • 浅层 attention 主要在拼词法 / 局部句法，对 expert 细粒度要求不高
  • 深层 attention 已经在做长程推理 / 知识调用，必须靠 score routing
  • hash routing 在浅层省 $[T, 4096] \times [4096, 256] = T \times 256$ 的矩阵乘 + $\mathrm{sqrtsoftplus}$ + topk
• 优势：
  • 性能：前 3 层 batch=1 decode 延迟降一个数量级
  • 稳定性：相同 input_id 永远分到相同 expert，warmup 阶段负载稳定
  • 不增加任何参数（tid2eid 也不可训练，仅作为 fixed 查找表）

为什么仅前 3 层：

• 浅层 attention 输出质量对 expert 选择不敏感
• 深层 attention（4 层以后）必须靠 score routing 选最相关 expert

💡 面试要点：要意识到"hash routing 是 fixed 查找表，不学习"+“省 score 计算”。

延伸阅读：主报告 §4.3.1（hash routing 详解）。

Q5.20 $num_hash_layers=3$ 的设计依据？

简短回答：V4 论文 ablation 显示"3 层 hash + 40 层 score"在 PPL/MMLU 上略优于"全 score"或"前 6 层 hash"——3 是速度提升（约 10%）与 PPL 退化（可忽略）的 sweet spot。0 层太慢、>6 层损害质量。

详细解释：

• 0 层 hash（全 score routing）：
  • 前 3 层 batch=1 decode 延迟 +1 个数量级
  • PPL 略好（score routing 学到了更细的 expert 分工）
• 3 层 hash（V4-Flash 选）：
  • 前 3 层延迟降一个数量级
  • PPL 退化可忽略（浅层 attention 对 expert 不敏感）
  • 速度 +10%、质量持平
• 6 层 hash：
  • 速度提升更明显
  • PPL 显著退化（深层 attention 高度依赖 score routing）
• >10 层 hash：
  • 质量灾难性下降
  • 接近 random routing

论文具体数字未公开——V4 报告 §4.2.3 仅给出"3 是 sweet spot"定性结论。

config 表现： $“num_hash_layers”: 3$ （config.json 第 29 行）——告诉 $Gate.init$ ：“前 3 层走 hash”。

源码落地（code-snippets/gate.py L11）：

1

self.hash = layer_id < args.n_hash_layers

⚠️ 易混淆：hash routing 不是"层间共享专家"——每层有自己的 tid2eid（虽然实现上可以共享，本仓库未优化）。

延伸阅读：主报告 §4.3.1（num_hash_layers 设计）。

Q5.21 哈希函数怎么设计？让 token id 平均分布到 256 expert？

简短回答：用 $token_id % 256$ 或类似简单哈希——核心是"让 129280 个 vocab token 均匀分到 256 个 expert"。V4 仓库 inference-only，哈希函数在训练框架侧（预生成 tid2eid 表）。本节答"如何让 129280 % 256 均匀"。

详细解释：

• 朴素哈希： $expert_id = token_id % 256$
  • 优点：完全均匀
  • 缺点：相邻 token（id 相近）会落到相邻 expert——不打破聚簇
• 多哈希（multi-hash）： $expert_ids = [hash1(t), hash2(t), …, hash6(t)]$
  • 6 个不同哈希函数（MurmurHash、SipHash 等）每个选 1 个 expert
  • 打破"相邻 token 聚簇"——前 3 层 attention 把相邻 token 送不同 expert，负载更均匀
• 本仓库的 tid2eid 形状：[129280, 6] —— 129280 = vocab_size，6 = n_activated_experts
• 训练时生成：V4 训练框架在 pretrain 初期随机生成 tid2eid（或用预设的多哈希函数），生成后冻结（ $requires_grad=False$ ）
• 均匀性验证：用 bincount(tid2eid.flatten()) 看 256 expert 频率——理想情况下每个 expert ≈ 129280 × 6 / 256 = 3030 次

为什么 V4 不学 tid2eid：

• 不可训练（ $requires_grad=False$ ）——避免训练时 tid2eid 漂移
• 浅层 routing 简单就够，不需要学
• 省 129280 × 6 = 775,680 个 int32 参数的更新开销（虽然参数本身不大）

💡 面试要点：要意识到"哈希设计的目标是均匀分布"+“V4 用的是 fixed 表”。

延伸阅读：主报告 §4.3.1（hash routing 实现）。

Q5.22 浅层 vs 深层 expert 路由的差异？

简短回答：浅层（1-3 层）用 hash routing——省 score 计算、稳定性高、对 expert 细粒度不敏感；深层（4-43 层）用 score routing——长程推理需要选最相关 expert。根本差异是"信号类型"：浅层是局部句法、深层是全局知识。

详细解释：

为什么浅层用 hash：

• 浅层 attention 主要在拼词法 / 局部句法——同一词根的不同形态（“run” / “running” / “ran”）常需类似 expert
• token id 直接做 key 已经能提供"按词性 / 词根聚类"的信息
• hash routing 完全确定 + 浅层不需要细粒度分工
• 省 1 个 $[T, 4096] \times [4096, 256]$ 矩阵乘

为什么深层用 score：

• 深层 attention 已经在做长程推理 / 知识调用
• 不同 query 关注不同长程信息——content-based 选择更灵活
• quality > speed——深层的输出质量对最终 PPL 影响大

性能对比（V4 论文）：

💡 面试要点：要意识到"浅层 hash + 深层 score"是经验折中——quality 与 speed 的平衡。

延伸阅读：主报告 §4.3.1（双路径路由对比）。

Q5.23 训练时 vs 推理时的 expert 选择差异？

简短回答：训练时 bincount 统计 + bias 更新 + 完整梯度反传；推理时 bias 冻结、无梯度、无统计。核心差异是 bias 是否更新。hash routing 在两阶段一致。

详细解释：

核心差异：bias 更新。

训练时：

1
2

counts = torch.bincount(indices.flatten(), minlength=256).tolist()
# 训练框架侧按 b_e -= η · (1/256 - f_e) 更新

推理时：

• $b_e$ 已是常量
• bincount 完全跳过
• topk 选择就是确定性的

FP4 量化的差异：

• 训练时 routed expert 权重以 FP4 存储，前向时反量化到 fp32 跑 matmul，反向时 FP4 模拟梯度
• 推理时反量化一次（静态加载），后续前向都是 fp32 矩阵乘
• V4-Flash 把 expert 量化到 FP4 是相对 V3 的关键减重——但训练时计算仍按 fp32 跑

💡 面试要点：要意识到"训练推理的 MoE 不是同一条代码路径"+“bias 更新是核心差异”。

延伸阅读：主报告 §4.4.1（完整训练推理对比表）。

Q5.24 MoE 训练的不稳定性（load imbalance）怎么解决？

简短回答：用 aux-loss-free bias（V4 选）——per-expert 标量偏置 $b_e$ 动态调，过载减、欠载增，不污染主损失梯度。 $f_e$ 在 $[p-\delta, p+\delta]$ 内为"均衡"，δ=0.05。

详细解释：

• 不稳定的根源：
  • 路由是离散的（topk），梯度估计有偏
  • Expert 容量有差异（不同 expert 学不同任务，天然不均）
  • 训练时 expert 选择会"极化"——少数 expert 被频繁选中，其余闲置
• 方案对比：

• V4-Flash 选 aux-loss-free（ $topk_method=“noaux_tc”$ ）：
  • 256 expert 频率需在 [0.34%, 0.44%] 之间（δ=0.05）
  • 训练 32B token 后所有 256 expert 频率落入 [0.32%, 0.46%]
  • std 从早期 2.4% 降到 0.04%——改善 60×
• Shared expert 为什么不受影响：
  • 永远激活，无 topk 选择
  • 不会"过载"或"欠载"——所有 token 都走它
  • 这也是 shared expert 设计的好处之一

💡 面试要点：要算清"32B token 后 std=0.04%"+“aux-loss-free 不污染主损失"两个核心点。

延伸阅读：主报告 §4.4.3（负载均衡实测表）。

Q5.25 评测 MoE 是否真"用上"了所有 expert？

简短回答：监控 expert 频率分布（ $f_e = bincount(indices) / total_tokens$ ）——理想是所有 $f_e \approx 1/256 = 0.39%$ （均匀）。V4 论文 §4.2.3 报告 32B token 后所有 256 expert 频率落入 [0.32%, 0.46%]，std=0.04%。

详细解释：

• 监控指标：

  • $max(f_e)$ ：最忙 expert 频率——理想 ≤ $p + \delta$ （V4 论文目标）
  • $min(f_e)$ ：最闲 expert 频率——理想 ≥ $p - \delta$
  • $std(f_e)$ ：频率标准差——理想越小越好
  • 占比超 [p-δ, p+δ] 的 expert 数——理想 0/256（全部在带内）

• V4-Flash 论文实测：

• 关键观察：

  • 100M token 早期：hash routing + bias 未更新 → 头部 8 expert 极度过载（f=12%），尾部欠载（1.8%），std=2.4%
  • 32B token 后期：bias 已收敛 → 所有 256 expert 频率落入 [0.32%, 0.46%]，std=0.04%——比早期改善 60×
  • 零 expert 落入带外——aux-loss-free 在 32B 训练点上达到目标

• 与 V3.2 对比：V3.2 在 200B token 后 max=1.2%, min=0.6%, std=0.12%——V4 收敛速度快 6×、最终 std 小 3×

• 判断标准：

  • 如果 $max(f_e) > 5%$ ：MoE 严重不均——bias 不收敛 / aux loss 不够强
  • 如果 std < 0.1%：MoE 训练成功——所有 expert 都"工作”
  • 不能用 PPL 单独判断——PPL 退化可能由其他原因引起

💡 面试要点：要能列出 4 个监控指标 + V4 实测数字。

延伸阅读：主报告 §4.4.3（含完整实测表）。

Q5.26 Shared expert 为什么不会被 load imbalance 影响？

简短回答：Shared expert 永远激活——所有 token 都走同一份 shared，没有"过载"或"欠载"概念。它不在 topk 选择范围内，aux-loss-free bias 也不作用于它。根本上是"always-on"机制保护。

详细解释：

• always-on 机制：
  • MoE.forward 最后 $y += self.shared_experts(x)$——shared 输出无条件加进 y
  • 没有路由、没有 topk、没有偏置
  • 无论 256 routed 怎么分布，shared 永远贡献 $silu(W1\cdot x) * W3\cdot x \cdot W2$
• 为什么不需要负载均衡：
  • 1 个 shared expert 处理所有 token——总负载 = $T \times 25.2M$ FLOPs
  • 不存在"少数 shared 被频繁调用"的问题
• 设计上的额外好处：
  • 给所有 token 一个"基线信号"——routed 偏离时不会塌缩
  • 学"通用知识"（常见词、句法）——与 routed 的"专门化"互补
  • 训练稳定性：shared 永远激活，routed 即使全错也至少有 shared 输出
• Shared expert 自身"过载"怎么办：
  • 不会过载——单 expert 容量按"所有 token × 1"设计
  • 不会欠载——T token 必然经过它
  • shared 的容量是 25.2M，与单个 routed 相同——但 routed 6 个，shared 1 个
  • shared 的"负载" = T × 25.2M；routed 总负载 = 6T × 25.2M——shared 占 14% 总 expert FLOPs

与 routed 的对比：

💡 面试要点：要理解"shared 是 always-on，不需要 load balance"+“shared 给 routed 提供基线”。

延伸阅读：主报告 §4.1（shared 解释）+ §4.5 源码片段 3（ $y += self.shared_experts(x)$ ）。

Q5.27 V4 MoE 与 V3 MoE 的本质差异？

简短回答：V4 在 V3.2 基础上做了 4 项关键改进：(1) 评分函数 $\mathrm{sigmoid} \to \mathrm{sqrtsoftplus}$ ；(2) 引入 $num_hash_layers=3$ 的双路径路由；(3) 配合 $routed_scaling_factor=1.5$ 把 k 从 8 砍到 6；(4) FP4 量化 routed expert（V3 是 FP8）。核心哲学是"等效质量、极致省"。

详细解释：

V3 → V4 的演化主线：

• V3（671B/37B 激活）：256 expert + 8 top-k + $\mathrm{sigmoid}$ + FP8，旗舰基座
• V3.2-Exp：256 expert + 8 top-k + $\mathrm{sigmoid}$ + FP8 + aux-loss-free，沿用
• V4-Flash（284B/13B 激活）：256 expert + 6 top-k + $\mathrm{sqrtsoftplus}$ + FP4 + hash routing，“开源主力 Instruct”

为什么 V4-Flash 改这么多：

• 定位是"8×H100 / 2×H200 跑得动"——总参 / 激活 / cache 全部要省
• k 砍到 6 + route_scale=1.5 = “用 6 个 expert 达到 9 个 expert 的等效”
• FP4 expert = 单 expert 25.2M → 6.3M，4× 显存省
• hash routing = 前 3 层延迟 -1 个数量级
• 所有改动都是"省"，不是"加"

V4-Flash 论文报告：32B token 训练收敛速度比 V3.2 快 6×、最终 std 小 3×。

💡 面试要点：要意识到"V4-Flash 是 V3 的"极致压缩版"，不是"更大版""。

延伸阅读：主报告 §4.1（V3.2 vs V4 完整对比表）。

Q5.28 hash routing 的核心思想是什么？为什么前 3 层用它？

简短回答：hash routing 不做 $W_g \cdot x$ 的矩阵乘，而是用 $hash(token_id) % 256$ 直接查表获得 expert 索引——前向延迟 $O(1)$ vs score routing 的 $O(d \times E)$ = O($4096 \times 256$) ≈ 1M FLOPs。前 3 层用它是因为浅层 attention 主要在拼词法/局部句法，hash 足够；深层语义信息丰富，必须靠 score routing 精确选 expert。

详细解释：

• 计算量对比：score routing 每 token 要算 $W_g \cdot x$ （ $[4096] \times [4096, 256]$ ≈ 1M FLOPs）+ $\mathrm{sqrtsoftplus}$ + top-6，hash routing 仅一次 $tid2eid[token_id]$ 的 gather 操作（ $O(1)$ ）。前 3 层 batch=1 decode 延迟可降一个数量级。
• 浅层为什么 hash 够用：Layer 0-2 的 attention 输出主要是"这个 token 是什么词/什么词性"等浅层特征——同一 token 在不同上下文中的浅层表示高度相似，按 token id 路由到固定 expert 不会显著损失质量。相比之下，深层 attention（Layer 3+）的输出包含"这个 token 的语义角色/依赖关系"——如 “bank” 在金融 vs 河流场景需要完全不同的 expert，必须靠 content-based score routing 精确匹配。
• num_hash_layers=3 是 V4 的 ablation 甜点：论文扫描 0/3/6/10 层 hash，3 层速度 +10%、PPL 退化可忽略；0 层太慢；6 层 PPL 退化可观测但不致命；10 层 PPL 显著退化（~3-5%）。3/43 ≈ 7% 的层走 hash，质量代价可忽略。

💡 面试要点：要能算清"1M FLOPs per token vs $O(1)$ gather"的差异，以及"浅层拼词法、深层做语义"的分工逻辑。

延伸阅读：主报告 CH4.3.1 L1076-1090 / config.json 第 29 行 / code-snippets/gate.py。

Q5.29 hash routing 用的是什么哈希函数？如何保证专家负载均匀？

简短回答：哈希函数为 $expert_id = hash(token_id) % 256$ ，最简单的取模哈希。均匀性来自前提：tokenizer 词表（vocab_size=129280）中的 token id 在大规模语料下近似均匀分布，取模 256 后每个桶平均 129280/256 ≈ 505 个 token，足够平均。但这是"近似"而非"严格"均匀——低频 token 聚簇 + 高频 token（逗号、句号、“the"等）频率远超均值会打破均衡。

详细解释：

• 取模哈希的均匀性前提：V4 的 tokenizer 词表大小 129280，token id 的分配与 token 频率无关（BPE tokenizer 按 merge 顺序分配 id，不是按频率）。取模 256 后每个桶平均分配约 505 个 token，理论负载均等。
• 实际中的不均衡来源：① 低频 token（id 相近的词）可能聚簇在同一桶，导致该桶 expert 在对应上下文下"过载”；② 高频 token（如逗号、句号、“the”、“a"等）频率远超平均值——即使均匀分配到各桶，这些 token 对应的 expert 仍被频繁调用。因此哈希的"均匀"是近似均匀，不是严格均匀。
• 与 aux-loss-free bias 的关系：前 3 层虽是 hash routing，但每层的 256 个 routed expert 仍维护 aux-loss-free bias——bias 不参与 hash 层的 topk 选择（hash 层跳过 score 计算），但 expert FFN 的输出质量信息仍反馈到深层，间接服务于整体负载均衡。
• QAT 期间 hash 层的特殊处理：前 3 层的 Gate 类仍构造（ $W_g$ 参数仍存在），但 forward 走 hash 分支跳过 $\mathrm{sqrtsoftplus}$ 的计算。tid2eid 是 $requires_grad=False$ 的 int32 查找表，hash 本身不参与梯度——训练期间映射固定不变。

💡 面试要点：要理解"取模哈希的均匀是词表分布均匀的前提”+“实际中高频 token 会打破严格均匀”+“hash 层 Gate 参数仍被创建但不参与前向”。

延伸阅读：主报告 CH4.3.1 / config.json vocab_size=129280 / code-snippets/gate.py L11-L42。

Q5.30 hash routing 与 score routing 在代码里怎么分支？

简短回答：在 Gate.forward 中通过 $if self.layer_id < self.num_hash_layers: … else: …$ 分支。hash 分支 $indices = self.tid2eid[input_ids]$ ，weights = 1/k（等权）；score 分支走 $W_g \cdot x \to \mathrm{sqrtsoftplus} \to +bias \to top-6$ 。关键细节：hash 层的 Gate 参数（ $W_g$ ）仍被创建和训练，只是前向不走 score 分支。

详细解释：

源码逻辑（code-snippets/gate.py L11-L42）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# Gate.__init__
self.hash = layer_id < args.n_hash_layers      # 前 3 层为 True
if self.hash:
    self.tid2eid = register_buffer("tid2eid", ...)  # [129280, 6], int32, 不可训练

# Gate.forward
if self.layer_id < self.num_hash_layers:
    # hash 分支：一次查表
    indices = self.tid2eid[input_ids]            # [B, S, 6]
    weights = torch.full(indices.shape, 1.0 / self.topk)  # 等权 1/6
    weights = weights * self.route_scale         # × 1.5 → 0.25
else:
    # score 分支：算 score + topk
    scores = F.linear(x.float(), self.weight.float())  # W_g · x → [B, 256]
    scores = F.softplus(scores).sqrt()                 # sqrtsoftplus
    original_scores = scores.clone()                    # 保存（不加 bias，用于 weight）
    scores = scores + self.bias                        # +bias（仅影响 topk）
    indices = scores.topk(self.topk, dim=-1)[1]
    weights = original_scores.gather(1, indices)       # 用原分（不加 bias）取权重
    weights = weights / weights.sum(dim=-1, keepdim=True)  # 归一化
    weights = weights * self.route_scale               # × 1.5

• hash 层 Gate 参数仍存在并被训练：即使 self.hash = True，self.weight（ $W_g \in \mathbb{R}^{4096\times 256}$ ）和 self.bias（ $b_e \in \mathbb{R}^{256}$ ）仍被创建——训练时这些参数也会更新（为后续可能的 fine-tune 或 routing 策略切换留余地），只是前向时不走 score 计算分支。
• 实际生效的层： $num_hash_layers=3$ 意味着 layer_id 0, 1, 2 走 hash。这些层的 $compress_ratios$ 分别是 [0]=0, [1]=0, [2]=4——前 2 层纯滑窗 + 第 3 层 CSA，但路由上一律走 hash。hash 判断依据是 $layer_id$ ，与 $compress_ratios$ 无关。
• 权重差异：hash 模式 weights = 1.5/6 = 0.25（6 个 expert 等权 × route_scale），score 模式 weights = 归一化后的 $\mathrm{sqrtsoftplus}$ 分数 × 1.5——hash 强制等权，score 按内容重要性加权。

💡 面试要点：能写出 $if layer_id < num_hash_layers$ 分支 + “hash 层 Gate 参数仍被创建和训练但前向不走 score"是关键。

延伸阅读：主报告 CH4.3.1 / code-snippets/gate.py L11-L42 / config.json 第 29 行。

Q5.31 为什么不把 hash routing 扩展到更多层？6 层或 10 层会怎样？

简短回答：更多 hash 层 = 更多层用"等权 + token id 固定映射"选 expert，语义信息丢失。浅层（0-2）attention 输出是浅层特征（词法/词性），hash 够用；深层 attention 输出包含语义角色/依赖关系，必须 score routing 精确匹配。6 层 hash → PPL 退化可测但不大；10 层 → PPL 显著退化（~3-5%）。

详细解释：

• 逐层 attention 输出质量的梯度变化：
  • Layer 0-2：attention 输出主要是局部词法特征（“这个词是什么/什么词性”）→ token id 路由够用
  • Layer 3-10：attention 开始捕获句法结构（主谓宾、定语从句）→ 部分 token 的语义开始分叉，hash 开始不准
  • Layer 10+：attention 在做跨段推理/知识调用 → 相同 token 在不同上下文需要完全不同的 expert，hash 彻底失效
• V4 论文 ablation 结论（主报告 CH4.3.1 L1076-1090）：
  • 3 层 hash：速度 +10%，PPL 退化可忽略 → 甜点
  • 6 层 hash：速度 +15-20%，PPL 退化可观测（~0.5-1%），MMLU 轻微下降 → 可接受但不推荐
  • 10 层 hash：PPL 退化显著（~3-5%），MMLU/GSM8K 等多个 benchmark 下降 → 不可接受
• 与模型深度的关系：如果模型只有 10 层（浅模型），hash 更多层可能可行（因为总层数少、每层的"语义深度"有限）；V4-Flash 有 43 层，前 3 层 hash 是合理折中——3/43 ≈ 7% 的层走 hash，省前 3 层 score 计算，质量代价可忽略。
• 根本原因：hash routing 本质是一个静态 hard mapping——token id → expert 的映射不随上下文变化。浅层 attention 的上下文依赖性弱，静态映射够用；深层 attention 的上下文依赖性强，必须动态的 content-based routing。扩展到更多层就是"在需要动态路由的层强行用静态映射”——信息瓶颈。

💡 面试要点：要能说出"3 层甜点、6 层可测退化、10 层显著退化"的 ablation 梯度 + “浅层静态映射够用、深层必须动态路由"的根本原因。

延伸阅读：主报告 CH4.3.1 L1076-1090 / 论文 ablation 部分。

总结

本文档涵盖：

• CH 4（CSA / HCA 注意力）：38 道 Q（Q4.1–Q4.38），覆盖 $O(T^2)$ 灾难、稀疏分类、MLA 局限、CSA 压缩、Compressor / $\mathrm{softmax}$-pool / overlap 模式、CSA vs HCA 本质区别、Indexer 设计与公式、 $\mathrm{ReLU}$ vs $\mathrm{softmax}$ 选择、FP4 vs FP8、sparse_attn_kernel / online $\mathrm{softmax}$ 、block=64/num_stages=2、attn_sink、compress_ratios 逐层配置、训练 vs 推理差异、Linear Attention / SSM / Lightning Attention / NSA 对比等。
• CH 5（MoE 路由）：31 道 Q（Q5.1–Q5.31），覆盖 MoE vs 稠密、Top-k 路由、Switch Transformer、细粒度专家、共享专家、1+256+6 拓扑、 $\mathrm{sqrtsoftplus}$ 评分、noaux_tc 路由、aux-loss-free bias、公式 4.1-4.3、route_scale=1.5、256 expert 参数量、FP4 量化、 $\mathrm{SwiGLU}$ 激活、hash routing 核心思想与 FLOPs 对比、哈希函数与负载均匀性、代码分支逻辑、hash 层数 ablation、训练推理差异、负载均衡实测、V4 vs V3 差异等。

目标读者：LLM 训练初学者 / 工程师 + 面试准备 + 自学。
格式：每道题"简短回答 + 详细解释 + 面试要点 / 易混淆 + 延伸阅读”。

配套主报告：/Users/huangyuxiao/models-arch/report/deepseek-v4-flash.md（CH 3 / CH 4 + §3.7）
配套源码： $/Users/huangyuxiao/models-arch/report/code-snippets/{compressor,indexer,sparse_attn_kernel,gate,expert,moe,attention,block}.py$
配套配置： $/Users/huangyuxiao/models-arch/report/_work/config.json$
配套论文： $/Users/huangyuxiao/models-arch/report/_work/tech-report.txt$

覆盖主报告 CH 5 (mHC) + CH 6 (Muon)，面向自学与面试准备。

CH 6. Manifold-Constrained Hyper-Connections (mHC)

Q6.1 残差连接解决了什么问题？为什么深层网络需要它？

简短回答

残差连接（y = x + f(x)）让梯度可以通过恒等路径直接回传，避免在深层网络中梯度消失，从而使网络的有效深度从 ~20 层扩展到 100+ 层。

详细解释

在没有残差连接的深层网络中，每一层的输出是上一层的非线性变换 y = f(x)。反向传播时，梯度需要经过每一层的 Jacobian 连乘： $\partialL/\partialx_0 = \prod {l=1}^{L} \partialf_l/\partialx{l-1}$ 。当 L 很大时，如果每个 Jacobian 的谱范数略小于 1（比如 0.9），则 $0.9^100 \approx 2.6e-5$——梯度几乎消失；如果略大于 1，则梯度指数爆炸。

残差连接改为 y = x + f(x)，梯度变成 $\partialL/\partialx = \partialL/\partialy \cdot (I + \partialf/\partialx)$ 。其中 I 是恒等项，保证梯度至少有一条"直通"路径不衰减。ResNet (He et al. 2015) 凭此将 CNN 从 20 居推到 152 层，Transformer 从 GPT-2 的 48 层推到 GPT-3 的 96 层。

但经典残差的系数固定为 1——信号放大率不可调。当网络深度继续增加（如 V4 的 43 层 x 2 mHC = 86 个残差），固定系数 1 意味着 $||y||^2 \approx ||x||^2 + 2<x, f(x)> + ||f(x)||^2$ ，如果 f(x) 输出方差不为 0，方差的累积随层数线性增长。

💡 面试要点：残差的核心不是"学残差更容易"，而是给梯度留了一条不衰减的恒等路径。

延伸阅读：主报告 CH 5.1

Q6.2 Pre-Norm 和 Post-Norm 有什么区别？为什么主流大模型选 Pre-Norm？

简短回答

Pre-Norm 把 $\mathrm{LayerNorm}$ 放在子层输入侧（y = x + f(Norm(x))），Post-Norm 放在输出侧（y = Norm(x + f(x))）。Pre-Norm 让残差路径上的信号方差不发散，训练更稳定；Post-Norm 理论上收敛更好但需要 warmup，深层训练不稳定。

详细解释

Post-Norm（原始 Transformer, Vaswani 2017）：

y = LayerNorm(x + f(x))

残差路径 x + f(x) 先相加、再归一化。问题在于：归一化后的 y 进入下一层时，x 的贡献被 Norm “抹平"了。深层堆叠时，梯度信号需要穿过 Norm 层，Norm 的 Jacobian 会压缩梯度幅度。此外，Post-Norm 要求学习率从 0 缓慢 warmup 到目标值，否则训练初期容易崩溃（Xiong et al. 2020 证明 Post-Norm 不需要 warmup 的条件在实践中几乎不满足）。

Pre-Norm（GPT-3, PaLM, Llama 全系列）：

y = x + f(LayerNorm(x))

归一化在 f 内部完成，残差路径上的 x 不受 Norm 影响。关键性质：y - x = f(Norm(x))，残差增量的方差由 f 控制，不随层数指数增长。训练时梯度可以沿 +x 恒等路径无损回传。

V4-Flash 使用 Pre-Norm（Block.forward 中 $attn_norm$ / $ffn_norm$ 在 attn/MoE 之前）。

⚠️ 易混淆：Pre-Norm “性能略低"只在控制训练步数的对比实验中成立。在工程实践中，Pre-Norm 因为稳定、可训更深，最终性能往往更好。

延伸阅读：主报告 CH 5.1

Q6.3 什么是梯度消失/爆炸？在深层 Transformer 中如何发生？

简短回答

梯度消失指反向传播中梯度幅度指数衰减至接近 0，导致底层参数不更新；梯度爆炸指梯度幅度指数增长至 NaN，导致训练崩溃。在深层 Transformer 中，两者的根因都是残差路径上信号方差随层数失控。

详细解释

以 43 层 Transformer 为例。假设每层残差连接 $y_l = x_l + f_l(x_l)$ ，则：

∂L/∂x_0 = ∑_{l=1}^{43} ∂L/∂y_l · ∏_{k=1}^{l} (I + ∂f_k/∂x_k)

如果 $\partialf_k/\partialx_k$ 的谱范数 > 0 且每一层的贡献累积，乘积会指数增长（爆炸）或衰减（消失）。具体到 Transformer：

• 消失：当注意力权重变得极度集中（某个头的 $\mathrm{softmax}$ 输出接近 one-hot），∂attn/∂Q 接近 0，梯度信号被"堵住”
• 爆炸：当残差叠加的方差随层数线性增长 $Var(y_L) \approx L \cdot Var(f(x))$ （Pre-Norm 情况），如果 f(x) 方差不受控，43 层后激活范数可能膨胀 100x+

V3.2 训练中后期观测到 $|x_{l+1} - x_l|$ 收敛到一个非零常数——即残差增量不随训练减小，深层 block 之间的"差异"持续存在，导致梯度方向不一致、loss 震荡。

💡 面试要点：梯度消失/爆炸的本质是 Jacobian 连乘的谱半径偏离 1，残差连接让谱半径"锚定"在 1 附近。

延伸阅读：主报告 CH 5.1, CH 1.2

Q6.4 什么是"残差饱和"现象？

简短回答

残差饱和指训练中后期，深层 block 的残差增量 $|x_{l+1} - x_l|$ 收敛到一个非零常数，模型退化为"浅层有效、深层冗余"的状态。

详细解释

理想情况下，每一层残差 $f_l(x)$ 应该学到有意义的增量变换，使得 $|f_l(x)|$ 在训练中逐渐减小（网络学会了"用更少的修正达到目标”）。但 V3.2 训练到中后期观测到 $|x_{l+1} - x_l|$ 停留在某个非零常数——底层 block 学到了表征，但深层 block 的增量不再变小。

后果是：深层 block 的贡献"饱和"了，增加更多层不会带来更多收益，但梯度仍需穿过这些"饱和层"，信号被持续放大/缩小。这就是 V4 引入 mHC 的直接动机之一——通过可控的信号放大率让深层 block 仍然能学到有效的增量。

延伸阅读：主报告 CH 1.2, CH 5.1

Q6.5 Hyper-Connections (HC) 的核心思想是什么？

简短回答

HC 把单通道残差扩展为多通道（ $hc_mult$ 倍），并引入可学习的混合矩阵 A、B 让模型自主控制残差路径上的信号调度。

详细解释

标准残差 y = x + f(x) 只有一个隐藏向量 x、一个恒等系数 1。HC (Zhu et al. 2024) 改为：

H_{l+1} = A_l · H_l + B_l · F(A_l · H_l)

其中 $H_l \in R^{c \times d}$ （c = hc_mult），A_l 是输入映射矩阵（c 维向量），B_l 是残差映射矩阵（c x c 矩阵）。

优点：模型可以学习"哪些通道传主信号、哪些走旁路"，相当于给残差路径加了可学习的"路由"。

问题：A、B 无任何约束，矩阵元素可以任意大/小/负。43 层 x 2 mHC/Block = 86 个串联后，A、B 的连乘谱半径会指数级发散——典型表现为 loss spike 或梯度 NaN。

延伸阅读：主报告 CH 5.1

Q6.6 mHC 与 HC 的核心区别是什么？为什么需要流形约束？

简短回答

mHC 将 HC 的残差映射矩阵 B 约束到双随机矩阵流形（Birkhoff polytope），使得 B 的最大特征值严格 = 1，从而保证深层信号传播严格有界。HC 没有此约束，深层训练不稳定。

详细解释

HC 的残差映射 B_l 是自由矩阵（无约束）。在 c=4 时，B_l 是 4x4 矩阵，最大特征值可以任意大。86 层串联后， $\prod _{l=1}^{86} B_l$ 的谱半径可能膨胀到 10^2 ~ 10^4 量级——信号要么爆炸要么消失。

mHC 的关键改进：

B_l = Sinkhorn_Knopp(B_l_raw)   # 投影到双随机矩阵

双随机矩阵满足 $B \cdot 1 = 1, 1^T \cdot B = 1, B >= 0$ ，由 Perron-Frobenius 定理，最大特征值 = 1。因此：

||B_l · x|| <= ||B_l||_2 · ||x|| = 1 · ||x|| = ||x||

每一层信号范数严格不增，86 层堆叠后整个网络是 Lipschitz 常数 = 1 的映射——训练和推理都不存在信号失控风险。

💡 面试要点：mHC 的创新不在多通道（HC 已有），而在 Sinkhorn 投影把组合权重约束到双随机矩阵。

延伸阅读：主报告 CH 5.2, CH 5.3

Q6.7 什么是双随机矩阵？为什么它对信号稳定传播至关重要？

简短回答

双随机矩阵是每行和 = 1、每列和 = 1 且所有元素非负的方阵。其最大特征值严格 = 1（Perron-Frobenius 定理），因此作为信号变换矩阵时范数不放大。

详细解释

双随机矩阵 M ∈ R^{c×c} 满足三个条件：

1. $M >= 0$ （非负）
2. $M \cdot 1 = 1$ （行和 = 1，即每行是概率分布）
3. $1^T \cdot M = 1$ （列和 = 1，即每列也是概率分布）

代数性质：

• 最大特征值 = 1，对应特征向量是全 1 向量
• 谱范数 = 1（ $|M|_2 = \sigma_max(M) = 1$ ）
• 集合构成 Birkhoff polytope——凸的紧致流形
• 对乘法封闭：两个双随机矩阵的乘积仍是双随机矩阵

应用到 mHC：86 个双随机矩阵串联，每个都不放大信号范数，乘积也不放大——这是 mHC 稳定性的数学根基。

如果 M 是一般矩阵（HC 的情况），最大特征值可以 > 1（信号爆炸）或 < 1（信号衰减），在 86 层串联下不可控。

延伸阅读：主报告 CH 5.3

Q6.8 Sinkhorn-Knopp 算法的工作原理是什么？

简短回答

Sinkhorn-Knopp 算法通过反复交替做行归一化和列归一化，把任意非负矩阵投影到双随机矩阵。V4 使用 20 次迭代，收敛精度 < 1e-4。

详细解释

算法步骤：

输入：M ∈ R^{c×c}，M >= 0
预处理：M = softmax(M) + eps    # 先做一次 softmax 行归一
for iter in range(19):           # 再做 19 次交替归一
    M = M / (M.sum(dim=1) + eps) # 行归一
    M = M / (M.sum(dim=0) + eps) # 列归一
输出：M（行和 ≈ 1，列和 ≈ 1）

直觉：第一步行归一把每行变成概率分布（行和=1），但列和失衡；第二步列归一修复列和，但又会破坏行和——交替迭代逐步逼近"行和=列和=1"。

收敛性：Sinkhorn (1964) 证明 n 步后与真实双随机矩阵的差异以 O(1/n) 速率收敛，精确上界是 $O(log(1/\delta))$ 步达到 δ 误差。

V4 的实现细节（来自 TileLang kernel）：

• 第一次用 $\mathrm{softmax}$ （而非简单除法）做行归一——自带数值稳定（减 max 防 exp 溢出）
• 后续 19 次用简单行/列除法
• eps = 1e-6 防止除零
• 4×4 矩阵，20 次迭代后误差 < 1e-4

💡 面试要点：Sinkhorn 不做优化，它是一个投影算子——把任意非负矩阵"最近点"投影到双随机流形。

延伸阅读：主报告 CH 5.3, CH 5.5

Q6.9 为什么 Sinkhorn 选 20 次迭代？5 次不行吗？100 次呢？

简短回答

20 次是 V4 论文 ablation 的工程最优：5 次时双随机误差仍可观（信号 Lipschitz 上界偏大），100 次浪费算力（20 次后误差已 < 1e-4），20 次在精度和开销间取得平衡。

详细解释

每次迭代 = 1 次行归一 + 1 次列归一 = 2c 个除法（c=4 时 = 8 次除法）。20 次迭代 = 160 次除法/token/mHC 模块。V4-Flash 有 43 层 x 2 mHC/Block = 86 个 mHC 模块，总计 86 x 160 = 13760 次除法/token。

这部分开销约占 attn+MoE 总耗时的 +5%。100 次迭代会把开销推到 +25% 而精度收益极小。

延伸阅读：主报告 CH 5.3

Q6.10 hc_mult=4 的设计依据是什么？为什么不是 2 或 8？

简短回答

V4 论文 ablation 显示 hc_mult=4 在"loss 下降速度 / 最终 ppl / 推理延迟"三维权衡上位于 Pareto 前沿：2 太弱（自由度不够），8 递减收益但开销翻倍。

详细解释

为什么 4 足够：

• 表达瓶颈：hc_mult=2 时只有 2x2=4 个参数给 comb 矩阵，自由度太低学不到复杂的"信号调度"模式；hc_mult=4 时 4x4=16 个参数，足以学到"主路径/旁路/短接"的差异化模式
• 优化瓶颈：hc_mult=8 时 8x8 矩阵的 Sinkhorn 归一化 cache footprint 翻倍（8x8 vs 4x4），TileLang kernel 开销显著上升

⚠️ 易混淆：mHC 不增加表征维度——4 通道 d 维隐藏被 reduce 回 1 通道 d 维，表征维度不变。增加的是"训练稳定性"而非"学习容量"。

延伸阅读：主报告 CH 5.4

Q6.11 mHC 的三个分支（pre/post/comb）各自的作用是什么？

简短回答

pre（4 维向量）在子层前把 4 通道 reduce 为 1 通道输入；post（4 维向量）在子层后把 1 通道输出 expand 为 4 通道；comb（4×4 双随机矩阵）在残差路径上重新混合 4 通道。

详细解释

mHC 在每个残差位置维护 4 份隐藏状态。数据流：

4 通道输入 ──[α_pre reduce]──> 1 通道 ──[f: attn/MoE]──> 1 通道输出
    |                                                      |
    └──────[α_comb 重新混合]───────────────────────────────┘
                            │
                     [α_post expand]
                            ↓
                       4 通道输出 → 下一层

• α_pre ∈ R^4：通过 $\mathrm{sigmoid}$ 得到，范围 (0, 1)。对 4 通道加权求和 reduce 为 1 通道——告诉 f “每条残差流对该层多重要”
• α_post ∈ R^4：通过 $2 * \mathrm{sigmoid}$ 得到，范围 (0, 2)，中心 = 1。在 f 输出后 expand 为 4 通道——初始化时 ≈ 1（不缩放），让训练早期 mHC 退化为普通残差
• α_comb ∈ R^{4×4}：通过 Sinkhorn 投影约束到双随机矩阵。把原始 4 通道输入重新混合后与 f 输出相加

三个权重全部从 mixes（24 维向量）通过 $hc_split_sinkhorn$ 拆分得到，端到端可学习。

代码映射：

• pre: $hc_split_sinkhorn_kernel_$ L20-L21, $pre = \mathrm{sigmoid}(mixes[0:4] * scale_pre + base_pre) + eps$
• post: L22-L23, $post = 2 * \mathrm{sigmoid}(mixes[4:8] * scale_post + base_post)$
• comb: L24-L25 + L30-L52（Sinkhorn 投影）

延伸阅读：主报告 CH 5.2, CH 5.5

Q6.12 公式 (5.1) 输入扩展具体怎么实现？

简短回答

把隐藏状态 x 复制 4 份得到 [T, 4d]，再用 α_pre（4 维向量）逐通道缩放后加权求和，得到 1 通道输入送入 f。

详细解释

x ∈ R^{T × d}                         # 原始隐藏状态
x_tile = tile(x, 4) ∈ R^{T × 4d}     # 沿通道维复制 4 次
x_4ch = x_tile.view(T, 4, d)          # reshape 为 4 通道
x_in = Σ_c α_pre[c] * x_4ch[:, c, :] # 逐通道加权求和 → [T, d]

在源码中对应 $Block.hc_pre$ 的：

1

y = torch.sum(pre.unsqueeze(-1) * x.view(shape), dim=2)

其中 pre 是 α_pre（4 维），x.view(shape) 把 x reshape 为 [T, 4, d]，pre.unsqueeze(-1) 扩展为 [T, 4, 1]，逐通道相乘后在 dim=2 求和。

延伸阅读：主报告 CH 5.2, CH 5.5

Q6.13 公式 (5.4) post + comb 残差输出具体怎么合成？

简短回答

$y = \alpha_post \cdot h + \alpha_comb \cdot x_in$ ，其中 h 是 f 的 1 通道输出（expand 为 4 通道），x_in 是残差路径上的 4 通道输入（经 comb 混合），相加得到 4 通道输出。

详细解释

1
2

# Block.hc_post 的核心实现
y = post.unsqueeze(-1) * x.unsqueeze(-2) + torch.sum(comb.unsqueeze(-1) * residual.unsqueeze(-2), dim=2)

分解：

• post.unsqueeze(-1) * x.unsqueeze(-2)：把 f 的 1 通道输出 x expand 为 4 通道（每通道乘以 post[c]）
• comb.unsqueeze(-1) * residual.unsqueeze(-2)：把 4 通道残差 residual（上一层的 4 通道输出）与 4x4 comb 矩阵相乘，得到混合后的 4 通道
• 两者相加 → 4 通道输出 y ∈ R^{T × 4 × d}

4 通道 y 作为下一层 Block 的输入，由下一层的 $hc_pre$ 通过 α_pre reduce 回 1 通道。

延伸阅读：主报告 CH 5.3, CH 5.5

Q6.14 mHC 在训练和推理时的差异是什么？

简短回答

结构完全相同，但推理时 mixes 的计算是确定性的（无 dropout），且 Sinkhorn 投影只需做一次（同一 token 在同一层的 mixes 相同，batch 内可复用）。训练时 mixes 包含梯度信息，Sinkhorn 需要 autograd 通过。

详细解释

推理时 mHC 的 +15% 延迟主要来自：每层 2 次 hc_pre/hc_post 调用（43 层 = 86 次），每次含 1 次 Sinkhorn（20 次迭代）+ 1 次 reduce/expand。TileLang fused kernel 把 Sinkhorn 编译为单个 kernel launch，避免了多次 kernel 启动开销。

延伸阅读：主报告 CH 5.4, CH 5.5

Q6.15 mHC 对显存的影响有多大？

简短回答

mHC 使每层隐藏状态的显存占用增加 4 倍（4 通道 vs 1 通道），但由于只存储残差路径（f 内部仍是 1 通道），且通过 activation checkpointing/recomputation 优化，实际额外显存约 +15-20%。

详细解释

V4-Flash 的 $hidden_size=4096$ ，每层 mHC 维护 4 通道 = 4 × 4096 = 16384 维的残差状态。43 层 x 2 mHC/Block = 86 个 mHC 模块。

朴素计算：每个 mHC 残差存储 4 份 d 维向量 = 4 × 4096 × 2 bytes (BF16) = 32 KB/token。86 层 = 2.75 MB/token。对 1M 上下文 = 2.75 TB（不可接受）。

实际优化：

• Activation checkpointing：不存储中间 mHC 状态，需要时重新计算
• 残差状态只在相邻层间传递，不需要全局存储
• 推理时 residual 是增量更新，不需要 4 份完整副本

V4 论文 §3.4.2 专门描述了 “Cost-Effective and Memory-Efficient Implementation of mHC”，通过 recomputation + fused kernel 把显存开销控制在可接受范围。

延伸阅读：主报告 CH 5.4, CH 5.5

Q6.16 mHC 如何与 MoE 协同工作？

简短回答

mHC 在 MoE 外面包了一层多通道残差，MoE 内部仍是 1 通道操作。4 通道残差流让不同 MoE expert 的"贡献分布"在多通道上更均匀，缓解了 expert 利用率不均衡的问题。

详细解释

在 Block.forward 中，MoE 段的数据流：

4 通道输入 → hc_pre reduce → 1 通道 → ffn_norm → MoE → 1 通道输出 → hc_post expand → 4 通道

MoE 本身只看到 1 通道输入，完全感知不到 mHC 的存在。但 mHC 通过 comb 矩阵的混合，间接影响 MoE 的输入分布：

• 不同通道的 α_pre 权重不同，reduce 后的 1 通道输入是 4 份加权平均
• 训练过程中，4 通道学到的"信号调度"模式会间接影响 MoE 的路由决策

V4 论文报告 mHC + MoE 的组合比单独使用 MoE 训练更稳定，expert 利用率的方差更小。

延伸阅读：主报告 CH 5.4

Q6.17 hc_split_sinkhorn kernel 的实现有什么工程亮点？

简短回答

TileLang 实现，把 “mixes → 拆分 pre/post/comb → Sinkhorn 20 次迭代” 编译为单个 fused kernel，避免 20 次 kernel launch 的开销，且在 shared memory 中完成 4×4 矩阵操作。

详细解释

关键工程细节：

1. 第一次用 $\mathrm{softmax}$ 而非简单除法做行归一： $\mathrm{softmax}$ 自带减 max 操作防 exp 溢出，比 M / M.sum(-1) 更数值稳定
2. sinkhorn_iters - 1 而非 sinkhorn_iters：前面 $\mathrm{softmax}$ + 列归一已经等价于 1 次完整 Sinkhorn 步，后续只需 19 次
3. post 用 $2 * \mathrm{sigmoid}$： $\mathrm{sigmoid}$ 输出 ∈ (0, 1)，乘 2 后中心点 = 1，让训练早期 mHC 退化为普通残差（降低冷启动难度）
4. pre 用 $\mathrm{sigmoid}$ 不乘 2：pre ∈ (0, 1)，初始化时 ≈ 0.5，4 通道加权后总和 ≈ 2.0
5. comb 用 $\mathrm{softmax}$ + eps：先 $\mathrm{softmax}$ 行归一再列归一，eps=1e-6 防除零
6. 64 threads/block：每个 token 的 mixes 独立处理，并行度高

💡 面试要点：TileLang fused kernel 是 mHC 推理 +15% 延迟（而非更高）的关键——20 次 Sinkhorn 迭代如果每步都是独立 kernel launch，开销会大得多。

延伸阅读：主报告 CH 5.5

Q6.18 mHC 的论文作者是谁？与 Hyper-Connections 是什么关系？

简短回答

mHC 由 Xie et al. (2026) 提出，是 DeepSeek V4 论文中引用的独立工作。原始 HC 由 Zhu et al. (2025) 提出。mHC 是 HC 的约束改进版（加 Sinkhorn 流形约束），V4 是首个大规模部署 mHC 的模型。

详细解释

论文引用链：

• ResNet: He et al. (2015) — 原始残差
• Transformer: Vaswani et al. (2017) — Post-Norm
• Pre-Norm: Xiong et al. (2020) — 理论分析
• HC: Zhu et al. (2025) — 多通道可学习残差
• mHC: Xie et al. (2026) — 双随机流形约束
• V4: DeepSeek-AI (2026) — 首次在 284B MoE 上大规模部署 mHC

延伸阅读：主报告 CH 5.1

Q6.19 为什么选 mHC 不选 Mixture-of-Depths (MoD)？

简短回答

MoD 让模型学习跳过某些层（动态深度），但不解决深层信号传播的稳定性问题。mHC 直接约束信号放大率，从根源上保证训练稳定性，且推理路径固定（不引入动态分支），工程部署更简单。

详细解释

MoD 的问题是：跳层只是"绕过"了不稳定层，没有修复信号传播本身。在 1M 上下文 + 43 层场景下，即使跳过一半层，剩余 21 层串联仍可能有稳定性问题。

mHC 则从根本上保证每一层的信号放大率 ≤ 1，不依赖跳层。

延伸阅读：主报告 CH 5.4

Q6.20 mHC 有什么局限性？

简短回答

mHC 的主要局限是：推理延迟增加约 15%、每层额外 24 个可学习参数需要调优、4 通道残差的显存占用增加，以及 Sinkhorn 迭代的计算开销在 batch 较大时显著。

详细解释

具体局限：

1. 推理开销：每层 2 次 hc_pre/hc_post = 86 次/forward pass，包含 86 次 Sinkhorn（20 次迭代）。TileLang fused kernel 把延迟控制在 +15%，但在 batch 极大的推理场景下仍不可忽略
2. 显存压力：4 通道残差状态占用 4 倍显存，虽然通过 recomputation 优化，但在 1M 上下文下仍是工程挑战
3. 超参敏感：hc_mult、hc_sinkhorn_iters、hc_eps 三个超参需要 ablation 调优。论文只验证了 hc_mult=4 在 V4-Flash 上的最优性，其他规模可能不同
4. 只解决稳定性不增加容量：mHC 不增加模型的表达能力（表征维度不变），如果需要更多容量仍需增加参数
5. 与某些训练技巧的兼容性：gradient checkpointing 与 mHC 的 4 通道残差状态管理增加了实现复杂度

延伸阅读：主报告 CH 5.4, CH 5.5

Q6.21 mHC 与 FP8/FP4 量化如何协同？

简短回答

mHC 限制每层信号放大率 ≤ 1，让量化误差不至于在深层放大累积。没有 mHC 时，深层激活的数值范围可能远大于浅层，量化误差在深层被放大；有 mHC 后各层激活范围一致，量化精度更均匀。

详细解释

V4 使用 FP8（E4M3/E5M2）做训练和推理，FP4 做 routed expert 权重存储。量化的精度与数值范围直接相关——如果某层激活比其他层大 100 倍，相同量化 bit 下的相对误差差 100 倍。

mHC 的双随机约束让每层输出 $y = post \cdot f(x) + comb \cdot residual$ 的范数与输入 x 相当（comb 不放大，post 中心在 1），因此各层激活的数值范围一致，FP8/FP4 量化的精度损失均匀分布而非集中在某几层。

延伸阅读：主报告 CH 5.4

CH 7. Muon 优化器

Q7.1 优化器在 LLM 训练中的作用是什么？

简短回答

优化器决定"参数往哪个方向更新、更新多少"，是把梯度转化为参数更新的算法。好的优化器能让训练收敛更快、更稳定、泛化更好。

详细解释

LLM 训练的目标是最小化损失函数 L(θ)。反向传播计算出梯度 $g = \partialL/\partial\theta$ 后，优化器决定实际的更新方向和步长：

θ_{t+1} = θ_t - η · update(g_t, state_t)

最朴素的 SGD 直接用 $update = g_t$ 。但在 LLM 训练中：

• 参数量极大（V4-Flash 284B），不同参数的梯度量级差异巨大
• MoE 导致稀疏梯度，大部分参数每步没有新梯度
• 矩阵参数有谱结构（奇异值分布），逐元素更新会破坏这种结构

好的优化器需要：(1) 自适应步长（不同参数不同学习率）；(2) 动量（利用历史梯度平滑更新方向）；(3) 对矩阵参数保持谱结构。

💡 面试要点：优化器是 LLM 训练的"油门+方向盘"——决定模型参数怎么走、走多快。

延伸阅读：主报告 CH 6.1

Q7.2 AdamW 的核心思想是什么？

简短回答

AdamW 结合一阶动量（梯度均值，加速方向）和二阶动量（梯度方差，自适应步长），并使用解耦的 weight decay。它是 LLM 训练的事实标准优化器。

详细解释

AdamW 的更新规则：

m_t = β1 · m_{t-1} + (1-β1) · g_t           # 一阶动量（梯度 EMA）
v_t = β2 · v_{t-1} + (1-β2) · g_t²          # 二阶动量（梯度方差 EMA）
m_hat = m_t / (1 - β1^t)                     # 偏差修正
v_hat = v_t / (1 - β2^t)                     # 偏差修正
θ_t = θ_{t-1} · (1 - η · λ) - η · m_hat / (√v_hat + ε)   # 更新

三个关键组件：

1. 一阶动量 m_t：梯度的指数移动平均，平滑噪声，让更新方向更一致
2. 二阶动量 v_t：梯度平方的指数移动平均，给每个参数自适应的学习率——梯度大的参数步长小，梯度小的参数步长大
3. 解耦 weight decay： $\theta \cdot (1 - \eta\lambda)$ 独立于梯度更新，正则化效果更稳定

典型超参：β1=0.9, β2=0.999, ε=1e-8, λ=0.01-0.1。

延伸阅读：主报告 CH 6.1

Q7.3 AdamW 在 MoE 大模型上有什么局限性？

简短回答

两个结构性问题：(1) 逐元素二阶动量与 MoE 稀疏梯度冲突——大部分 expert 参数每步没梯度，v_t 变成陈旧的指数滑动平均；(2) 逐元素更新不约束矩阵谱结构——训练后期奇异值分布退化，有效秩下降。

详细解释

问题 1：稀疏梯度导致 v_t 失效

MoE 中 256 个 routed expert 只激活 6 个。对每个 expert 矩阵 W_e，99%+ 的参数对一个给定 token 没梯度。v_t 在这些参数上只有"上一步的指数滑动平均"，几乎没有新信息流入。导致自适应学习率 $\eta / (\sqrt{v_t} + \epsilon)$ 在有梯度和没梯度的参数上差异巨大——训练信号极度不均衡，expert 利用率不稳定。

问题 2：谱偏（spectral bias）

Transformer 的权重矩阵 W ∈ R^{d×d’} 在训练中会形成奇异值分布。AdamW 的更新 $W -= \eta \cdot m / \sqrt{v}$ 是逐元素的——对矩阵整体的奇异值结构没有约束。训练后期容易出现"几个大奇异值 + 大量小奇异值"：

Wx ≈ σ_max · u_1 · (v_1^T · x)    # 只有大奇异值方向在工作

小奇异值方向几乎"死掉"——等于模型有效秩下降、参数利用率低、容易过拟合。

💡 面试要点：AdamW 的核心问题是"把矩阵当一袋标量"——每个元素独立更新，忽略了矩阵的几何结构。

延伸阅读：主报告 CH 6.1

Q7.4 矩阵正交化的直觉是什么？

简短回答

正交化把矩阵的更新方向变成正交矩阵 O（满足 $O \cdot O^T$ = I），强制所有奇异值 = 1。直觉上，这等价于"重置"矩阵的谱结构，让它始终保持满秩，每个方向同等重要。

详细解释

一个矩阵 M ∈ R^{n×m} 的 SVD 分解是 $M = U \cdot \Sigma \cdot V^T$ 。如果 M 的奇异值分布不均匀（有的 σ » 1，有的 σ ≈ 0），则 M 作为线性变换时：

• 大奇异值方向被放大（主导输出）
• 小奇异值方向被压缩（几乎"看不见"）

正交化把 M 变成 $O \approx U \cdot V^T$ （去掉 Σ），所有奇异值 = 1。效果：

• 每个方向被平等对待——不偏袒也不忽略任何方向
• 矩阵保持满秩——参数利用率最大化
• 作为优化方向时，不会沿某个奇异值方向过度更新

类比：AdamW 像是"给每个人发不同大小的手电筒"（有些亮有些暗），Muon 像是"给每个人发相同亮度的手电筒"。

延伸阅读：主报告 CH 6.2

Q7.5 正交化在 SGD 中有什么作用？与 conditioning 有什么关系？

简短回答

正交化改善 loss landscape 的 conditioning（条件数），让优化路径更接近"理想圆"而非"狭长椭圆"，从而加速收敛。

详细解释

损失函数的 Hessian 矩阵 H 的条件数 $\kappa = \lambda_max / \lambda_min$ 决定了优化难度：

• κ ≈ 1（well-conditioned）：loss 等高线是圆，SGD 直接指向最优
• κ » 1（ill-conditioned）：loss 等高线是狭长椭圆，SGD 来回震荡

矩阵参数 W 的 Hessian 等价于它的奇异值结构。如果 W 的奇异值分布不均匀，κ 就大。正交化把奇异值全部拉到 1，等价于把 κ 拉到 1——loss landscape 变得更"圆"，收敛更快。

理论上，对凸优化问题，条件数 κ 决定了梯度下降的收敛速度 $O(\kappa \cdot log(1/\epsilon))$ 。把 κ 降到 1 可以把收敛加速 κ 倍。在大模型训练中，这直接转化为"更少的训练步数达到同样的 loss"。

延伸阅读：主报告 CH 6.2

Q7.6 Muon 的核心思想是什么？

简短回答

Muon 把权重矩阵 W 的梯度 G 做动量累积后，通过 Newton-Schulz 迭代正交化为 O ≈ $U \cdot V^T$ ，再用 RMS rescale 回与 AdamW 相当的尺度。本质是"把矩阵当矩阵更新"而非"把矩阵当一袋标量更新"。

详细解释

Muon 的完整流程（对应 Algorithm 1）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Step 1: 动量累积
M_t = μ · M_{t-1} + G_t

# Step 2: Nesterov trick + Newton-Schulz 正交化
O'_t = HybridNewtonSchulz(μ · M_t + G_t)   # O' ≈ U·V^T

# Step 3: RMS rescale
O_t = O'_t · √max(n, m) · γ

# Step 4: Weight decay + 更新
W_t = W_{t-1} · (1 - η · λ) - η · O_t

与 AdamW 的对比：

💡 面试要点：AdamW 问"这个标量该往哪走"，Muon 问"这个线性变换该往哪走"——后者保留了矩阵的几何结构。

延伸阅读：主报告 CH 6.2

Q7.7 Muon 的论文作者是谁？

简短回答

原始 Muon 由 Keller Jordan (2024) 提出。V4 使用的是 Jordan et al. (2024) + Liu et al. (2025) 的变体，并自行设计了 Hybrid Newton-Schulz (8+2 分阶段) 的改进版本。

详细解释

Muon 的引用链：

• Jordan et al. (2024)：原始 Muon 优化器，使用单一系数的 5 阶多项式做 Newton-Schulz
• Liu et al. (2025)：加入 Nesterov trick + QK-Clip + RMS rescale + weight decay 的工程化版本
• V4 (DeepSeek-AI 2026)：Hybrid Newton-Schulz (8+2 分阶段) + 去掉 QK-Clip（因为 V4 的 $\mathrm{RMSNorm}$ on Q/K 天然防爆炸）

V4 论文 §2.4 引用了 “Muon (Jordan et al., 2024; Liu et al., 2025)"。

延伸阅读：主报告 CH 6.1

Q7.8 Newton-Schulz 迭代在干什么？为什么比 SVD 更快？

简短回答

Newton-Schulz 迭代通过多项式近似把矩阵 M 逼近正交矩阵 $U \cdot V^T$ （去掉奇异值 Σ）。它只需要矩阵乘法（O(d^3)），不需要做真正的 SVD 分解（O(d^3) 但常数更大、GPU 不友好）。

详细解释

给定 M = $U \cdot Σ$·V^T，目标是求 O ≈ $U \cdot V^T$ 。标准方法是先做 SVD 再去掉 Σ，但 SVD 的计算：

• 需要迭代求特征值分解（QR 迭代 / divide-and-conquer）
• 常数因子大（约 10-20x 矩阵乘法）
• 在 GPU 上不容易向量化

Newton-Schulz 的思路：构造一个多项式 p(x)，使得对 σ ∈ (0, 1) 有 $p(\sigma^2) \cdot \sigma \approx 1$ ，然后把这个多项式应用到矩阵上：

M_k = a·M_{k-1} + b·(M_{k-1}·M_{k-1}^T)·M_{k-1} + c·(M_{k-1}·M_{k-1}^T)²·M_{k-1}

每次迭代只需要 2 次矩阵乘（ $A = M\cdot M^T$ 和 $A\cdot M$ ），GPU 高度优化。10 次迭代 = 20 次矩阵乘，常数远小于 SVD。

收敛保证：只要初始 M 的最大奇异值 ≤ 1（由 Frobenius 归一化保证），Newton-Schulz 多项式保证收敛到 UV^T。

💡 面试要点：Newton-Schulz 不做 SVD，它用矩阵乘法"迭代逼近"正交化结果——精度够用、速度快、GPU 友好。

延伸阅读：主报告 CH 6.2, CH 6.3

Q7.9 系数 (3.4445, -4.7750, 2.0315) 的来源是什么？

简短回答

这三个系数通过数值优化搜索得到，目标是在 8 次迭代内让奇异值 σ ∈ (0, 1) 最快逼近 1。它们定义了一个三次多项式 $p(x) = 3.4445x - 4.7750x^3 + 2.0315x⁵$ ，在 σ² 空间上有良好的收敛性质。

详细解释

Newton-Schulz 迭代的每一步：

M_k = a·M_{k-1} + b·(M·M^T)·M + c·(M·M^T)²·M

对 M 的第 i 个奇异值 σ_i，这一步变成：

σ_i^{(k)} = a·σ_i^{(k-1)} + b·(σ_i^{(k-1)})³ + c·(σ_i^{(k-1)})⁵

我们要选 (a, b, c) 使得 $\sigma_i$ 快速趋近 1。这是一个多项式优化问题——在 σ ∈ (0, 1) 上找到最好的三次近似。

V4 通过离线数值搜索（在 284B 训练前的小规模 ablation）找到了 (3.4445, -4.7750, 2.0315) 这组系数。这不是理论推导的解析解，而是在"收敛速度 vs 数值稳定性"权衡下的工程最优。

8 次迭代后，σ 从初始的 0.01-0.99 范围收敛到 0.95-1.05 附近（足够好但不够精确），然后交由第 2 阶段的 Chebyshev 系数做精确稳定。

延伸阅读：主报告 CH 6.3

Q7.10 为什么 V4 用 8+2 分阶段而不是 10 次统一迭代？

简短回答

前 8 次用快速收敛系数把奇异值快速拉到 ≈1 附近，后 2 次用 Chebyshev 系数精确稳定到 1。单一系数无法同时兼顾"快速收敛"和"精确稳定”——快系数在接近 1 时有震荡风险，稳系数前期太慢。

详细解释

阶段 2 的数学保证：(2, -1.5, 0.5) 对应的迭代 $\sigma \to 2\sigma - 1.5\sigma^3 + 0.5\sigma⁵$ 在 σ ∈ [0.5, 1.5] 时有严格收敛保证——误差按几何级数衰减。只要前 8 步把 σ 推到这个范围内，后 2 步就能精确到机器精度。

这是 V4 区别于原始 Muon 和 Liu et al. (2025) 的关键创新：

• 原始 Muon：单一系数，10 次迭代
• Liu et al.：5 系数多项式 + QK-Clip
• V4：3 系数 + 8+2 分阶段，不需要 QK-Clip

💡 面试要点：V4 的 Hybrid Newton-Schulz 本质是"快速阶段 + 精确阶段"的两段式设计，比单一系数更稳定。

延伸阅读：主报告 CH 6.3

Q7.11 公式 (6.1) Newton-Schulz 目标具体是什么？

简短回答

给定 M ∈ R^{n×m} 的 SVD 分解 M = $U \cdot Σ$·V^T，Newton-Schulz 的目标是求 O’ ≈ $U \cdot V^T$ ，满足 O’ · O’^T = I（半正交矩阵）。

详细解释

正交化的"理想结果"是把 M 的奇异值全部变成 1，保留左右奇异向量：

• 输入：M = $U \cdot Σ$·V^T，Σ 的对角元素是 σ_1, σ_2, …, σ_r
• 目标输出：O’ = $U \cdot V^T$ （Σ 被替换为 I）

这个 O’ 满足：

• $O’ \cdot O’^T = U\cdot V^T\cdot V\cdot U^T = U\cdot I\cdot U^T = I_n$ （如果 n ≤ m）
• 所有奇异值 = 1
• Frobenius 范数 = √min(n, m)

Newton-Schulz 通过迭代逼近这个目标，不需要显式计算 SVD。

延伸阅读：主报告 CH 6.2

Q7.12 公式 (6.2) Frobenius 归一化的作用是什么？

简短回答

$M_0 = M / |M|_F$ 保证 M 的最大奇异值 ≤ 1，这是 Newton-Schulz 多项式收敛的前提条件。如果 σ_max > 1，多项式在 σ > 1 时可能发散。

详细解释

Frobenius 范数 $||M||F = √(\Sigma M{ij}^2)$ 是所有奇异值平方和的平方根。归一化后：

||M_0||_F = 1  →  Σ σ_i² = 1  →  σ_max ≤ 1

Newton-Schulz 多项式 $p(\sigma) = a\cdot \sigma + b\cdot \sigma^3 + c\cdot \sigma⁵$ 在 σ ∈ (0, 1) 时单调递增到 1。但如果 σ > 1：

• σ³ 和 σ⁵ 项指数增长
• 多项式可能发散到 +∞ 或 -∞
• 数值不稳定

因此每次迭代前（或至少初始时）必须保证 σ_max ≤ 1。V4 只在第一次迭代前做 Frobenius 归一化，后续迭代由多项式本身保持 σ 在合理范围内。

代码中：M = M / (norm(M, 'fro') + eps)，eps=1e-8 防除零。

延伸阅读：主报告 CH 6.3

Q7.13 公式 (6.3) Newton-Schulz 的 5 系数 Polynomial 具体形式？

简短回答

V4 实际只用 3 系数： $M_k = a\cdot M + b\cdot (MM^T)M + c\cdot (MM^T)^2M$ 。5 系数版本是把 (MM^T)²M 展开为 5 个不同标量项的变体，V4 简化为显式三项。

详细解释

完整的 Newton-Schulz 迭代（公式 28）：

M_k = a · M_{k-1} + b · (M_{k-1} · M_{k-1}^T) · M_{k-1} + c · (M_{k-1} · M_{k-1}^T)² · M_{k-1}

其中：

• 第 1 项 $a \cdot M$ ：保留原始方向
• 第 2 项 $b \cdot (MM^T)M = b \cdot M \cdot (M^T \cdot M)$ ：一阶修正（把大奇异值缩小、小奇异值放大）
• 第 3 项 $c \cdot (MM^T)^2M$ ：高阶修正（加速收敛）

V4 用 3 系数而非 Liu et al. (2025) 的 5 系数，因为 3 系数已经足够表达所需的收敛行为，且减少了超参搜索空间。

延伸阅读：主报告 CH 6.3

Q7.14 RMS rescale 因子的作用是什么？

简短回答

$O_t = O’_t \cdot \sqrt{max}(n,m) \cdot \gamma$ 把正交化后的更新方向 rescale 回与 AdamW 相当的 RMS 尺度，使 V4 可以直接复用 AdamW 的学习率调度，超参空间不膨胀。

详细解释

正交矩阵 O’ 的 Frobenius 范数 = √min(n, m)。AdamW 的更新 $m/\sqrt{v}$ 的范数大致是 √(n·m)（与 W 同量级）。如果直接用 O’ 作为更新，幅度太小。

RMS rescale 的推导：

||O'_t||_F = √min(n, m)           # 正交矩阵范数
||AdamW_update||_F ≈ √(n·m)      # AdamW 更新范数

需要放大因子 = √(n·m) / √min(n,m) = √max(n,m)

O_t = O'_t · √max(n,m) · γ       # γ 是可调的 rescaling factor

γ 的作用是微调——让 Muon 的更新幅度与 AdamW 完全匹配。V4 设定 γ 后，可以：

• 用同一份 warmup/decay 学习率调度
• 用同一份 weight decay 超参
• 不需要为 Muon 和 AdamW 分别调参

💡 面试要点：RMS rescale 是 Muon 能在工程中落地的关键设计——没有它，Muon 和 AdamW 就需要两套完全独立的超参。

延伸阅读：主报告 CH 6.4

Q7.15 Muon 适用于哪些参数？不适用于哪些？

简短回答

Muon 适用于二维矩阵参数（attention Q/K/V/O、MoE FFN 权重、mHC comb 矩阵）。不适用于 1D 参数（embedding、prediction head、 $\mathrm{RMSNorm}$ 权重、mHC 的 gating factor），这些用 AdamW。

详细解释

V4 的 AdamW vs Muon 分工：

判断标准：参数是否有"矩阵结构"（即两个维度都有语义）？如果有 → Muon；如果是 1D 或逐元素独立 → AdamW。

⚠️ 易混淆：mHC 的 gating factor（4 维 α_pre/α_post）走 AdamW，但 comb 矩阵（4×4）走 Muon。同一个 mHC 模块内部根据参数形态分两个优化器。

延伸阅读：主报告 CH 6.4

Q7.16 embedding 和 lm_head 为什么不用 Muon？

简短回答

Embedding 是离散查找表（每行独立），lm_head 是 logits 投影——它们都是逐行更新的参数，没有"矩阵整体的谱结构"，正交化对它们没有意义。

详细解释

• Embedding：vocab_size × d 的矩阵，每个 token 对应一行。训练时只有被采样的 token 对应的行有梯度，其他行不变。这种"逐行独立"的更新方式与矩阵正交化不兼容——正交化是对整个矩阵做的，但大部分行每步没梯度。
• lm_head：d × vocab_size 的矩阵，输出是 logits。每个 logits 对应 vocab 中一个 token，更新也是逐行（或逐列）的。没有"整个矩阵作为线性变换"的语义。

对这类参数，AdamW 的逐元素自适应学习率仍然是最优选择。

💡 面试要点：Muon 只对"有谱结构的大矩阵"有优势——小参数和 1D 参数用 AdamW 反而更好。

延伸阅读：主报告 CH 6.4

Q7.17 Muon vs AdamW 的详细对比

简短回答

Muon 用矩阵正交化替代逐元素方差估计，用单个动量缓冲替代双缓冲（m+v），状态量减半但对矩阵参数收敛更快更稳。

详细解释

在 V4 的 284B MoE 上，Muon 让训练在 32T tokens 内收敛到更好的 loss，且 loss 曲线更平滑（更少的 spike）。

延伸阅读：主报告 CH 6.1, CH 6.2

Q7.18 V4 为什么选择 Muon 而不是继续用 AdamW？

简短回答

三个原因：(1) 284B MoE 的稀疏梯度让 AdamW 的 v_t 退化；(2) 大矩阵参数的谱偏导致有效秩下降；(3) 训练预算要求更快收敛（32T tokens，成本极高）。

详细解释

V4-Flash 的训练量是 32T tokens（V3 的 2.2 倍）。如果继续用 AdamW：

• MoE 稀疏梯度导致 expert 利用率不稳定，需要更多训练步数补偿
• 矩阵谱偏导致深层模型有效参数量下降，需要更多参数（更大模型）达到同样效果
• 训练周期以月为单位，单次实验调参成本极高

Muon 在 V4 上的优势：

• 正交化天然处理稀疏梯度（不依赖逐元素统计）
• 保持矩阵满秩，参数利用率更高
• 收敛速度更快（V4 论文报告比 AdamW 少 ~30% 步数达到同等 loss）
• 与 mHC 协同：mHC 保证信号传播稳定，Muon 保证参数更新稳定

延伸阅读：主报告 CH 6.1, CH 1.2

Q7.19 Muon 在 13B MoE 上的训练稳定性如何？

简短回答

V4 论文报告 Muon 在 284B/13B 激活的 MoE 上训练稳定，loss 曲线平滑，不需要特殊的 loss spike 处理。关键是 V4 的 Hybrid Newton-Schulz (8+2) + 去掉 QK-Clip 的组合在工程上比原始 Muon 更鲁棒。

详细解释

稳定性保障来自三个设计决策：

1. 8+2 分阶段：前 8 步快速收敛不会震荡（快系数在 σ 接近 1 时仍有良好行为），后 2 步精确稳定保证 σ 严格 → 1
2. $\mathrm{RMSNorm}$ on Q/K：V4 的 attention 架构允许对 Q 和 KV entries 直接应用 $\mathrm{RMSNorm}$ ，attention logits 天然有界（ $Q\cdot K^T / \sqrt{d}$ 不会爆炸），因此不需要 Liu et al. (2025) 的 QK-Clip trick
3. 与 mHC 协同：mHC 保证每层信号放大率 ≤ 1，Muon 的正交化更新在稳定的激活分布上工作

V4 论文没有报告需要特殊处理 loss spike 的情况，这与 V3 训练中需要仔细调节 lr 和 init_std 的经验形成对比。

延伸阅读：主报告 CH 6.3, CH 6.4

Q7.20 Muon 与 mHC 如何协同工作？

简短回答

mHC 保证前向传播中信号方差不爆炸/消失，Muon 保证参数更新方向保持矩阵满秩。两者正交互补：mHC 管"信号怎么流"，Muon 管"参数怎么更新"。

详细解释

协同效果：

• mHC 的贡献：86 个双随机矩阵串联保证前向和反向的信号传播严格有界。这意味着 Muon 收到的梯度 G_t 的数值范围是可控的（不会出现梯度爆炸后 Newton-Schulz 输入 σ_max » 1 的情况）
• Muon 的贡献：正交化更新保持每层权重矩阵的满秩，这意味着 mHC 的"4 通道信号调度"有足够的参数空间来学习有效模式

间接协同：Muon 让 expert 权重保持满秩 → expert 的输出分布更均匀 → mHC 的 4 通道混合更容易找到好的调度模式 → expert 利用率更稳定。

延伸阅读：主报告 CH 5.4, CH 6.4

Q7.21 Muon 的工业部署情况如何？

简短回答

截至 2026 年，Muon 已被 DeepSeek V4 系列大规模部署。其他公司和实验室也在探索：Moonlight (2025) 使用 Muon 变体训练了 16B MoE 模型，开源社区有 muon-optimizer 等实现。但 AdamW 仍是主流，Muon 的工业验证案例还不够多。

详细解释

Muon 的部署现状：

• DeepSeek V4/V4-Flash/V4-Pro：284B-1.6T 规模，32-33T tokens 训练，最大的 Muon 部署案例
• Moonlight (2025)：16B MoE，使用 Muon 变体，开源
• 学术实验：多个论文在 100M-1B 规模验证了 Muon 的收敛优势

限制因素：

• Newton-Schulz 需要 10 次矩阵乘，训练步时间增加
• 需要区分 Muon/AdamW 参数并分别维护优化器状态
• 工程复杂度高于 AdamW
• 对 1D 参数无优势，无法完全替代 AdamW

延伸阅读：主报告 CH 6.4

Q7.22 Muon 的变体有哪些？与 Shampoo/SOAP 的关系？

简短回答

Muon 的变体包括 Moonlight (2025, 加入 adaptive learning rate)、原始 Muon (Jordan 2024)、Liu et al. (2025, Nesterov + QK-Clip)。Shampoo 和 SOAP 是基于矩阵/张量预条件的二阶方法，与 Muon 正交互补。

详细解释

Shampoo 的核心思想：对 W ∈ R^{n×m} 的梯度 G，分别维护左预条件矩阵 L = (Σ $G \cdot G^T$)^{1/2p} 和右预条件矩阵 R = (Σ G^$T \cdot G$)^{1/2p}，更新方向为 L^{-1} · $G \cdot R$^{-1}。这等价于对 W 的奇异值做"软正交化"。

关键区别：Muon 是"硬正交化"（奇异值全部变 1），Shampoo 是"软正交化"（奇异值被缩放到更均匀但不完全是 1）。Muon 更激进但计算更简单（只需要矩阵乘），Shampoo 更温和但需要矩阵指数运算。

💡 面试要点：Muon 的本质是"一阶优化器 + 正交化"，Shampoo 是"二阶优化器 + 预条件"——两者目标相同（改善谱结构）但路径不同。

延伸阅读：主报告 CH 6.1

Q7.23 为什么 AdamW 仍是 1D 参数的最佳选择？

简短回答

1D 参数（ $\mathrm{RMSNorm}$ 权重、bias、embedding 行）没有矩阵结构，不存在谱偏问题。AdamW 的逐元素自适应学习率对这些参数是最优的——简单、高效、无需额外计算。

详细解释

对 1D 参数，AdamW 的 v_t 提供的是"这个标量的梯度方差有多大"的信息——这恰好是自适应步长需要的。没有"矩阵"的语义，正交化无从谈起。

对 embedding 更具体：每步只有少量行有梯度，v_t 在有梯度的行上提供精确的自适应步长，在没有梯度的行上保持上一步的估计——这对 embedding 更新是合理的。

Muon 的 Newton-Schulz 需要矩阵乘法（O(d^3)），对 4 维的 α_pre/α_post 来说计算量极小但概念上无意义（4 个标量的"正交化"没有实质作用）。

延伸阅读：主报告 CH 6.4

Q7.24 Muon 的 Nesterov trick 具体怎么用？

简短回答

Nesterov trick 把 Newton-Schulz 的输入从 $M_t$ 改为 $\mu \cdot M_t + G_t$——相当于"先往前看一步"再正交化。这比直接用 M_t 的收敛速度更快。

详细解释

标准动量： $M_t = \mu \cdot M_{t-1} + G_t$

不加 Nesterov： $O’_t = NewtonSchulz(M_t)$
加 Nesterov： $O’_t = NewtonSchulz(\mu \cdot M_t + G_t)$

$\mu \cdot M_t + G_t$ 是"如果动量继续走一步"的预估方向——先"展望"未来位置再决定正交化方向。这是 Nesterov accelerated gradient 的经典思想在 Muon 中的应用。

V4 论文 Algorithm 1 Line 5 明确使用 Nesterov trick：

O'_t = HybridNewtonSchulz(μ · M_t + G_t)

延伸阅读：主报告 CH 6.5

Q7.25 Muon 的 weight decay 怎么处理？

简短回答

与 AdamW 相同： $W_t = W_{t-1} \cdot (1 - \eta \cdot \lambda) - \eta \cdot O_t$ ，weight decay 独立于梯度更新。这保证正则化效果不受正交化影响。

详细解释

Weight decay 的作用是防止参数范数无限增长（L2 正则化）。AdamW 的"解耦"设计把 weight decay 从梯度更新中分离：

W_t = W_{t-1} · (1 - η · λ) - η · O_t

Muon 沿用了这个设计（Liu et al. 2025 的建议）。关键点：

• $(1 - \eta \cdot \lambda)$ 独立缩放 W，与正交化更新 O_t 无关
• λ 的含义和调参方式与 AdamW 完全相同
• 不需要对正交化后的 O_t 做额外的正则化

V4 论文 Algorithm 1 Line 7： $W_t = W_{t-1} \cdot (1 - \eta\lambda) - \eta \cdot O_t$

延伸阅读：主报告 CH 6.5

Q7.26 Muon 的计算开销有多大？

简短回答

每次 Newton-Schulz 迭代需要 2 次矩阵乘（M @ M.T 和 A @ M），10 次迭代共 20 次矩阵乘。相对 forward+backward 一次的 O(d^3) 计算，Newton-Schulz 是 O(10·d^3)——和一次完整前向的 attention 矩阵乘同量级。

详细解释

对 V4-Flash 的 d=4096 矩阵：

• 单次 M @ M.T：4096 × 4096 矩阵乘 = ~68G FLOPs
• 单次 A @ M：同上
• 10 次迭代：~1.36T FLOPs per weight matrix
• V4 有 ~50 个需要 Muon 的矩阵参数 → ~68T FLOPs per training step

对比：

• 一次完整 forward+backward（284B MoE）：~5.7P FLOPs per token
• Muon 开销：~68T / step ≈ forward+backward 的 1-2%

Muon 的额外显存：M_t 缓冲 = 1x 参数量（BF16）。对比 AdamW 的 m_t + v_t = 2x 参数量，Muon 实际上节省了显存。

💡 面试要点：Muon 的计算开销与 forward+backward 相比很小（~1-2%），且显存反而比 AdamW 省 1x 参数量。

延伸阅读：主报告 CH 6.3

Q7.27 Muon 为什么不需要 QK-Clip trick？

简短回答

V4 的 attention 架构允许对 Q 和 KV entries 直接应用 $\mathrm{RMSNorm}$ ，让 Q/K 的数值范围天然有界（单位方差），因此 attention logits $Q\cdot K^T / \sqrt{d}$ 不会爆炸。Liu et al. (2025) 需要 QK-Clip 是因为他们的模型没有这个设计。

详细解释

Muon 的正交化更新可能让 Q/K 矩阵的奇异值均匀增大（因为正交化后所有奇异值 = 1，范数可能比原始梯度更大）。如果 Q 和 K 的范数不受控，attention logits $Q\cdot K^T / \sqrt{d}$ 会爆炸 → $\mathrm{softmax}$ 输出退化为 one-hot → 梯度消失。

Liu et al. (2025) 的解决方案是 QK-Clip：对 Q/K 矩阵的更新方向做 clip，限制范数。

V4 不需要这个 trick，因为 V4 的 attention 架构允许在 Q 和 KV entries 上直接应用 $\mathrm{RMSNorm}$ ：

Q_normalized = RMSNorm(Q)
K_normalized = RMSNorm(K)
attention_logits = Q_normalized · K_normalized^T / √d

$\mathrm{RMSNorm}$ 把 Q/K 的每个向量归一化为单位方差，所以 logits 天然有界。工程上少了一个 clip 算子，减少了 kernel 启动开销。

延伸阅读：主报告 CH 6.4

Q7.28 V4 如何实现 Muon 的高效训练？

简短回答

V4 论文 §3.4.1 描述了 Muon 的高效实现：使用 hybrid ZeRO 策略分片 Muon 的动量缓冲、融合 Newton-Schulz 为单个 kernel、利用 TileLang 编译优化矩阵乘链。

详细解释

关键工程优化：

1. Hybrid ZeRO：Muon 的 M_t 缓冲（1x 参数量）使用 ZeRO-3 分片跨 GPU 存储，避免每张卡都保存完整副本
2. Fused Newton-Schulz kernel：把 10 次 Newton-Schulz 迭代编译为单个 kernel，减少 kernel launch overhead 和中间结果的 global memory 读写
3. TileLang 编译：利用 TileLang DSL 把 Newton-Schulz 的矩阵乘链编译为高效 GPU 代码
4. 与 AdamW 并行管理：Muon 和 AdamW 参数在同一个训练循环中分别更新，共享学习率调度但维护独立的状态量

V4 论文 §3.4.1 提到 Muon 的训练效率在 284B MoE 上是工程可行的，Newton-Schulz 的开销被其他优化（通信-计算 overlap、ZeRO 分片）所掩盖。

延伸阅读：主报告 CH 6.5

Q7.29 Shampoo 作为二阶方法的核心思想是什么？

简短回答

Shampoo 对权重矩阵 W ∈ R^{n×m} 分别维护左/右预条件矩阵，用梯度的二阶统计量（ $G \cdot G^T$ 和 G^$T \cdot G$ ）做矩阵级预条件，等价于"软正交化"——让奇异值更均匀但不强制为 1。

详细解释

Shampoo (Gupta et al. 2018) 的更新：

L_t = (Σ_{k=1}^{t} G_k · G_k^T)^{1/(2p)}     # 左预条件
R_t = (Σ_{k=1}^{t} G_k^T · G_k)^{1/(2p)}     # 右预条件
W_{t+1} = W_t - η · L_t^{-1} · G_t · R_t^{-1}

其中 p 是预条件阶数（通常 p=2 或 p=4）。直觉：

• $G\cdot G^T$ 收集了"行方向的梯度方差"→ L 捕捉 W 的行空间结构
• $G^T\cdot G$ 收集了"列方向的梯度方差"→ R 捕捉 W 的列空间结构
• $L^{-1} \cdot G \cdot R^{-1}$ 把梯度投影到预条件空间，等价于在 W 的奇异值空间做"缩放"

与 Muon 的区别：

• Shampoo 保留奇异值的相对大小（“软"调整），Muon 强制所有奇异值 = 1（“硬"重置）
• Shampoo 需要计算矩阵 p-th root（O(n^3)），比 Newton-Schulz 更贵
• Shampoo 的预条件矩阵需要更多显存（n^2 + m^2 per weight matrix）

延伸阅读：主报告 CH 6.1

Q7.30 如果让你给一个新 LLM 项目选优化器，你会怎么选？

简短回答

如果模型包含 MoE 或大矩阵参数且训练预算紧张，考虑 Muon；否则 AdamW 仍然是安全的选择。具体决策看参数形态、训练规模和工程约束。

详细解释

决策树：

1. 模型有 MoE？
   → 是：Muon 对 expert 矩阵有明确优势（稀疏梯度问题）
   → 否：看下一步

2. 模型参数量 > 10B？
   → 是：Muon 对大矩阵参数有谱偏改善
   → 否：AdamW 足够（小模型谱偏不严重）

3. 工程团队有优化器定制经验？
   → 是：可以尝试 Muon（需要区分参数类型、维护双优化器）
   → 否：AdamW 更安全（生态成熟、调试简单）

4. 训练预算是否紧张？
   → 是：Muon 的收敛加速可以节省 ~30% 步数
   → 否：AdamW 的简单性更重要

⚠️ 易混淆：Muon 不能完全替代 AdamW——1D 参数和 embedding 仍然需要 AdamW。实际部署是 Muon + AdamW 双优化器。

💡 面试要点：选优化器的核心判断是"参数是否有矩阵结构”——有则 Muon，无则 AdamW。

延伸阅读：主报告 CH 6.4

统计：CH 6 (mHC) 21 Q + CH 7 (Muon) 30 Q = 51 Q。面试要点标注 10 处，易混淆标注 4 处，主报告引用覆盖 CH 5.1-5.5 + CH 6.1-6.5。

CH 8. 工程实现 – QA 问答

Q8.1 什么是混合精度训练？为什么 LLM 需要它？

简短回答：混合精度训练是同时使用多种数值精度（如 FP32/FP16/BF16/FP8）完成训练的技术，其核心动机是在不显著损失模型质量的前提下，将显存占用和计算量降低 2-4 倍。

详细解释：
传统深度学习训练使用 FP32（32 位浮点）存储所有参数、梯度和优化器状态。以一个 284B 参数模型为例，FP32 下仅参数就占 284B x 4 bytes = 1.14 TB 显存，远超单卡容量。混合精度训练将"对精度敏感"的操作（如梯度累加、权重更新）保留在 FP32，而"对精度不敏感"的操作（如矩阵乘法、激活存储）降到 FP16/BF16/FP8。

具体来说有三层精度：(1) 前向计算精度（BF16/FP8 做 matmul，FP32 做累加）；(2) 权重存储精度（FP4/FP8 存权重，前向时反量化到 BF16 计算）；(3) 梯度/优化器状态精度（梯度用 BF16 通信，优化器状态用 FP32 保持数值精度）。

V4-Flash 走得更远——把 256 个 routed expert 压到 FP4（ $float4_e2m1fn$ ），比 FP8 再省一半显存。这是 V4 能在 2xH200/8xH100 上跑得动的关键。

面试要点/易混淆：混合精度不等于"把所有东西降到低精度”——关键在"混合"，不同操作分配不同精度。BF16 和 FP16 都不会训练的面试者在 LLM 岗位很减分。

延伸阅读：主报告 CH7.2 FP4+FP8 混合精度策略。

Q8.2 BF16 / FP16 / FP32 三者有什么区别？

简短回答：三者都是 IEEE 754 浮点格式，核心差异在指数位和尾数位的分配——FP32 是 8 指数+23 尾数，FP16 是 5 指数+10 尾数，BF16 是 8 指数+7 尾数。BF16 的动态范围与 FP32 相同（8 位指数），但精度更低（7 位尾数）。

详细解释：
具体位分配与数值范围：

BF16 的关键优势：(1) 动态范围与 FP32 相同，不会出现 FP16 那种梯度下溢/上溢（FP16 最大只有 65504，大模型梯度经常超过这个范围）；(2) BF16 与 FP32 互转只需截断尾数，无需特殊处理，硬件实现简单。代价是精度只有 FP16 的 1/8（7 位 vs 10 位尾数），但在深度网络的梯度噪声面前，这点精度损失基本可忽略。

FP16 在推理时仍有优势——其 10 位尾数对激活值更友好，且 NVIDIA Tensor Core 对 FP16 的支持更成熟。V4-Flash 的 RoPE 维度用 BF16（保位置精度），非 RoPE 维度用 FP8（省显存），这是按"精度需求"分层分配的实际实践。

面试要点：问"BF16 和 FP16 哪个好"时，标准答案是"训练用 BF16（防止溢出），推理看场景（FP16 精度更高但范围小）"——不要只说一个。

延伸阅读：主报告 CH7.2。

Q8.3 FP8 的 E4M3 和 E5M2 分别是什么？分别用在什么场景？

简短回答：E4M3（4 指数+3 尾数）和 E5M2（5 指数+2 尾数）是 FP8 的两种子格式。E4M3 精度更高（尾数 3 位 → 8 级量化），适合前向传播的权重和激活；E5M2 动态范围更大（指数 5 位 → 范围 ~57344），适合反向传播的梯度。

详细解释：

E4M3 选 4 位指数的原因是：前向激活值在小范围（-448 到 448）内变化，4 位指数足以覆盖（2^4=16 个档位），3 位尾数比 E5M2 多 1 位精度，对最终 loss 的影响更小。E5M2 选 5 位指数的原因是：梯度值可能非常大（尤其在深层 MoE 的 expert 路由处），需要更大动态范围去吸收 outlier gradient。

V4-Flash 的 $act_quant_kernel$ （kernel.py L41）用的是 E4M3（ $float8_e4m3$ ），scale 用 ue8m0（无符号 8 指数 0 尾数，即 power-of-2）。block_size=128，即每 128 个元素共享一个 scale。

面试要点：要能说清楚"为什么不是一种 FP8 搞定一切"——前向要精度、反向要范围，这是两种不同需求。

延伸阅读：主报告 CH7.2；inference/kernel.py L36-L103。

Q8.4 FP4 格式 E2M1FN 的 block=32 / E8M0 scale 是什么意思？

简短回答：E2M1FN 是 FP4 的一种格式（2 指数+1 尾数，无符号，normal number only），block=32 表示每 32 个权重元素共享一组量化参数（scale），E8M0 是 scale 的存储格式（8 位指数+0 位尾数=power-of-2），使得 scale 可以用快速的位运算代替除法。

详细解释：
E2M1FN 的位分配：

• 2 位指数：可表示 4 个指数档位（2^-2 到 2^1），动态范围 ~6
• 1 位尾数：2 级量化精度
• FN（Finite Normal）：不包含 denormal 和 inf/NaN，简化硬件
• 实际可表示的值：{0, 0.5, 1, 1.5, 2, 3, 4, 6}（8 个值，含 0 和负值共 16 个级别）

Block-wise 量化（block=32）意味着每 32 个权重独立计算自己的 scale $s = max(|w_i|) / fp4_max$ ，而不是整层共用一个 scale。block 越小，量化越精确但存储开销越大（每个 block 存一个 scale）。V4 选 32 是因为：(1) FP4 精度低，需要细粒度 scale 来补偿；(2) 32 是 GPU warp size，硬件友好。

E8M0 scale 是最关键的设计创新：scale 强制为 2 的整数次幂（power-of-2），存储为 8 位指数（无尾数）。好处是 weight / scale 这个除法变成位运算 shift——$fast_pow2(fast_log2_ceil(amax * fp4_max_inv))$ 。在 GPU 上，位运算比浮点除法快约 10 倍。

面试要点：block 大小是精度-开销的权衡——block=1 是 per-element 量化（最优精度但无压缩），block=全张量是 per-tensor 量化（最大压缩但精度差）。问为什么选 32 不选 128 时回答"FP4 精度太低必须用更细的 block 补偿"。

延伸阅读：主报告 CH7.2；inference/kernel.py L129-L177 $fp4_quant_kernel$ 。

Q8.5 QAT（量化感知训练）和 PTQ（训练后量化）有什么区别？

简短回答：QAT 是在训练过程中模拟量化效果，让模型"学会"在低精度下工作；PTQ 是训练完成后对已有权重直接量化，无需重新训练。QAT 精度更高但需要完整训练流程，PTQ 快速但精度损失更大。

详细解释：

QAT 的核心技巧是 STE（Straight-Through Estimator）：前向时，把 BF16 权重 w 量化到 FP4 得到 $w_q$ ，再反量化到 BF16 得到 $w_dq$ ，用 $w_dq$ 算前向输出。反向时，梯度直接穿过量化函数（ $\partialL/\partialw = \partialL/\partialw_dq$ ），假装量化不存在。这让模型逐渐适应"权重被量化"的数值分布。

V4-Flash 的 routed expert 走 QAT——训练全程用 FP4 模拟， $fp4_act_quant$ 在 Indexer 的 Q/K 上也在做 QAT。PTQ 不适合 FP4 的原因是 4-bit 精度太低了，不经过训练适应会直接崩掉。

面试要点：区分 QAT 和 PTQ 的关键不在于"是否重训练"，而在于"梯度是否穿过量化函数"——QAT 有 STE 反向传播，PTQ 没有梯度。

延伸阅读：主报告 CH7.2、CH7.3。

Q8.6 V4-Flash 的混合精度策略是怎样的？

简短回答：V4-Flash 采用三层混合精度：Attn/shared expert/公共部分用 FP8（E4M3, block=128），256 个 routed expert 用 FP4（E2M1FN, block=32, E8M0 scale），RoPE 维度和累加用 BF16/FP32。存储精度决定显存，计算精度决定质量。

详细解释：
精确分配表：

这样分配的逻辑是"精度需求驱动"：(1) Routed expert 最多（占模型参数 ~60%），用最激进的 FP4 压缩；(2) Attention 需要精确的位置信息，RoPE 维度保留 BF16；(3) Shared expert 始终激活，对整体质量影响大，用 FP8 保精度；(4) mHC 的 Sinkhorn 迭代对精度敏感（20 次迭代的除法链），用 FP32。

面试要点：要能解释"为什么 routed expert 可以 FP4 但 shared expert 不行"——routed expert 稀疏激活（每个 token 只用 6/256），单个 expert 的量化噪声被平均掉了；shared expert 永远激活，噪声直接进入每一层的输出。

延伸阅读：主报告 CH7.2；config.json 中 $expert_dtype: “fp4”$, $quantization_config$ ；inference/kernel.py L36-L177。

Q8.7 Block-wise 量化和 per-tensor 量化有什么区别？为什么 V4 选 block-wise？

简短回答：Per-tensor 量化是整层（或整个张量）共用一个 scale，block-wise 量化是将张量分成小块（block），每块独立计算 scale。Block-wise 量化精度更高但存储开销更大（需要存多个 scale）。V4 选 block-wise 是因为极端精度（FP4）下，per-tensor 的精度损失不可接受。

详细解释：
以 V4 expert 矩阵 W ∈ R^{$4096 \times 2048$} 为例：

• Per-tensor：整个 8.4M 元素共享 1 个 scale，量化误差 E[|w - w_q|] ≈ σ_w / 2^b，当 b=4 时约 σ_w/16。如果 W 内元素跨度三个数量级，scale 被 outlier 主导，大部分参数被量化到 0。
• Block-wise（block=32）：每 32 个元素 1 个 scale。 $4096 \times 2048$ / 32 ≈ 262K 个 block，多存 262K×1 byte（E8M0）= 256 KB 的 scale 数据。但量化误差降到 E[|w - w_q|] ≈ σ_block / 16，由于 block 内方差远小于全局方差，精度大幅提升。

存储开销对比：block-wise 额外存储的 scale 占比 = 32/(32×0.5) ≈ 6.25%（scale 1 byte，权重 0.5 byte per element）。用 6% 的额外存储换数倍的精度提升，是 FP4 量化的工程标准做法。

V4 还有一个细节：FP8 用 block=128，FP4 用 block=32。原因：FP8 精度本身较高（4 位指数+3 位尾数 ≈ 256 级），block=128 的精度损失可接受；FP4 精度低（2 位指数+1 位尾数 ≈ 16 级），必须用更细的 block 补偿。

面试要点：问"block 选多大"时，标准答案是精度-开销权衡，并且要能说出 V4 的 FP8=128 / FP4=32 的双轨设计。

延伸阅读：主报告 CH7.2；inference/kernel.py $act_quant_kernel$(block_size=128) / $fp4_quant_kernel$(block_size=32)。

Q8.8 FP4 GEMM 算子是怎么实现的？和 FP8 GEMM 有什么不同？

简短回答：FP4 GEMM 的核心流程是"反量化到 BF16 → 矩阵乘 → 累加回 FP32"。与 FP8 GEMM 的区别在于：(1) 权重存储格式是 FP4 而非 FP8；(2) scale 用 E8M0 (power-of-2) 实现快速除法；(3) 当前硬件（H100/H200）上 peak FLOPs 与 FP8 相同（都走 FP16 Tensor Core），但 FP4 权重加载带宽省一半。

详细解释：
FP4 GEMM 的具体步骤（以 V4 expert 前向为例）：

1
2
3
4
5
6
7
8
9

# 伪代码：FP4 dequant + GEMM
# w_fp4: [M, K] packed as uint8 (2 FP4 per byte)
# x: [K, N] BF16
def fp4_gemm(w_fp4_packed, scale_e8m0, x_bf16):
    # Step 1: 反量化 FP4 → BF16
    w_bf16 = dequant_fp4(w_fp4_packed, scale_e8m0)  # 位运算 + shift
    # Step 2: BF16 GEMM on Tensor Core
    y = w_bf16 @ x_bf16
    return y