MoE (Mixture-of-Experts) 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 核心思想：把单个 FFN 换成 $N$ 个 expert + 一个 router，每个 token 只走 $k \ll N$ 个 expert，总参数 ↑、激活参数不变（sparse activation）。计算量约等于 $k/N$ × dense，但内存 / 显存按总参数计。
2. 路由公式（Token-Choice top-k）：$g_i(x) = \text{softmax}(W_g x)_i$，选 $\mathcal{T}_k(x) = \text{TopK}_i\, g_i(x)$，输出 $y = \sum_{i \in \mathcal{T}_k(x)} g_i(x) \cdot E_i(x)$。Gate 概率作为 soft 权重乘到 expert 输出上，反传时让 router 可微。
3. 历史脉络（必背 5 篇）：Shazeer 2017（首个深度学习里可工作的 MoE 层）→ GShard 2020（top-2 + capacity factor + all-to-all）→ Switch Transformer 2021（top-1 极简，aux loss + load balance）→ Mixtral 8x7B/8x22B 2024（首个开源主流 MoE，top-2）→ DeepSeek-V3 2024（671B/37B，aux-loss-free，fine-grained + 1 shared）。
4. DeepSeek 路线（2026 面试热点）：DeepSeekMoE 2024 提出 fine-grained experts（拆细，$mN$ 个小 expert 选 $mK$ 个）+ shared experts（少数 expert 给所有 token，吸收通用知识）。V2 用 MLA + DeepSeekMoE，V3 把路由专家做到 256 + 1 shared，取消 aux loss，改用 expert bias 在线更新。
5. Aux-loss-free balance：在 router score 上加每 expert 的偏置 $b_i$，只用于 top-k 选择，不进梯度（也不进最终 gate 权重）；每个 step 按"实际 load - 期望 load"反向更新 $b_i$（多负载 expert 减偏置）。不破坏 sparse gradient，不引入干扰梯度。
6. 容量与丢 token：每个 expert 的容量 $C = \lceil \alpha \cdot T \cdot k / N \rceil$（$\alpha$ 是 capacity factor，常用 1.0-1.25）。超过容量的 token 走 residual bypass（直接跳过 expert，原始残差通过），或被 drop。Switch Transformer 论文里这是核心工程细节。
7. 并行：MoE 几乎必须用 Expert Parallelism (EP)——把不同 expert 放到不同 GPU，token 路由后做 all-to-all（dispatch）→ expert 算 → all-to-all（combine）。DeepEP 与 DualPipe 是 DeepSeek-V3 在 H800 上把 EP 通信和计算 overlap 的两大工程武器。
8. 常见 bug：①routing collapse（某些 expert 被全部 token 选、其他 expert 饿死）；②fp16 下 router logit overflow；③推理时 all experts 必须全部加载到显存——只是激活参数少，显存依然按总参数算；④小 batch 时 EP 通信占满，吞吐反而比 dense 差。

§1 直觉：稀疏激活 = 用"参数容量"换"计算量"

Dense FFN 长这样：每个 token 都过同一个 $D \times 4D \to 4D \times D$ 大矩阵，参数全部参与计算。

MoE 把 FFN 换成 $N$ 个独立 expert（每个本质仍是 FFN），但每个 token 由 router 决定只走 $k$ 个：

                    Token x  [B, L, D]
                          │
                          ↓
                  Router W_g ∈ R^{D × N}        (gate)
                          │
                          ↓
                  scores  g(x) ∈ R^N
                          │
                  TopK + softmax-renormalize
                          │
              ┌─────┬─────┼─────┬─────┐
              ↓     ↓     ↓     ↓     ↓
            E_1   E_2   ...   E_{N-1}  E_N    (每个 expert = FFN)
              │     │           │     │
              └─ × g_1 ─ ... ─ × g_N ─┘        (只有 k 个 g_i ≠ 0)
                          │
                          ↓
                  Sum → output y [B, L, D]

为什么这是好主意？三个层次的回答：

• 容量论：模型容量主要来自参数量，泛化主要来自数据 × 容量。Sparse activation 允许把总参数推到上千 B，而每 token 计算仍像 30B dense——参数容量 ≫ 计算量。
• 专精论：不同 expert 在训练中天然分工——code / math / 多语言 / 通用语义。Switch Transformer 给过 t-SNE 可视化，DeepSeekMoE 用 fine-grained 进一步加剧这种专精。
• 推理效率：固定 active 参数 $\approx$ 固定 FLOPs，可与 dense 同台比，但参数容量大很多——这是 Mixtral 8x7B 用 13B active 干过 LLaMA-2 70B 的根本原因。

§2 路由：从 Top-k Token-Choice 到 Expert Choice 到 Loss-Free

2.1　Token-Choice Top-k（GShard / Switch / Mixtral / DeepSeek）

最经典也最常考。Gate 计算每个 (token, expert) 对的 affinity，token 选 top-k expert：

$$\boxed{\;s(x) = W_g x \in \mathbb{R}^N, \quad g(x) = \text{softmax}(s(x)), \quad \mathcal{T}_k(x) = \text{TopK}_i\, g_i(x)\;}$$

输出（routing weight 重新归一化版本，Mixtral / DeepSeek 默认这种）：

$$y = \sum_{i \in \mathcal{T}_k(x)} \tilde{g}_i(x) \cdot E_i(x), \quad \tilde{g}_i(x) = \frac{g_i(x)}{\sum_{j \in \mathcal{T}_k(x)} g_j(x)}$$

几个变体的 $k$：

2.2　Auxiliary Load Balancing Loss（Switch 公式，必背）

问题：纯 top-k 没有任何机制让 router 均衡使用所有 expert——很容易 collapse 成"只用 1-2 个 expert"。

Switch Transformer 引入 differentiable load balancing loss：

$$\boxed{\;\mathcal{L}_\text{aux} = \alpha \cdot N \sum_{i=1}^{N} f_i \cdot P_i\;}$$

其中

• $f_i = \dfrac{1}{T} \sum_{t=1}^{T} \mathbb{1}\{\arg\max_j s_j(x_t) = i\}$ ——分配给 expert $i$ 的 token 比例（不可微，sample-level 估计）
• $P_i = \dfrac{1}{T} \sum_{t=1}^{T} g_i(x_t)$ ——expert $i$ 的平均 gate 概率（可微，softmax 输出）
• $\alpha$ 是 loss 权重（常用 $10^{-2}$）
• $N$ 是 expert 数量；$T$ 是 batch 中 token 数

关键点 / 易混淆：

1. $f_i$ 给"实际频率"，$P_i$ 给"梯度通路"。乘起来 $\sum_i f_i P_i$ 当两者都集中在同一组 expert 时最大；均匀分布时最小（$= 1/N$，乘以 $N$ 后 = 1）。
2. 这是 encourage 均匀分布，不是硬约束。极端 collapse 会被惩罚，但日常小幅不均不会被强力惩罚。
3. Switch top-1 公式直接如此；top-k 时把 $f_i$ 改成"top-k 命中频率"（更准确写法见 GShard 论文）。
4. $\alpha$ 太大会干扰主任务梯度——这是 DeepSeek 改 aux-loss-free 的根本动机。

2.3　Expert Choice Routing（Zhou et al. 2022，NeurIPS）

反向思维：不让 token 挑 expert，让 expert 挑 token。每个 expert 根据 capacity 选 top-$M$ 个 token，$M = (T \cdot k) / N$（每个 expert 平均分到 token 数）。

$$s(x) \in \mathbb{R}^{T \times N}, \quad \mathcal{T}_M^{(i)} = \text{TopM}_{t}\, s_{t,i}, \quad y_t = \sum_{i: t \in \mathcal{T}_M^{(i)}} g_{t,i} \cdot E_i(x_t)$$

优点：

• 天然平衡：每个 expert 严格选 $M$ 个 token，不需要 aux loss
• 不丢 token：理论上不会有"溢出"（capacity 是 hard 给定）

缺点 / 限制：

• 不是 causal：第 $t$ 个 token 的归属依赖 $T$ 个 token 全部的 score——decoder 推理时无法 token-by-token 生成，需要 batch-level 全局视角（autoregressive 不友好）
• 每个 token 实际激活的 expert 数 不固定（可能没被选 / 被多个选）
• 主要在 encoder（如 T5、BERT-style）或 vision 用

2.4　Auxiliary-Loss-Free Balance（DeepSeek-V3 招牌，必考）

DeepSeek（Wang et al., arXiv 2408.15664, 2024）提出的方案，被 V3 全面采纳。核心一句话：给每个 expert 加一个偏置项 $b_i$，只用于 top-k 选择，不进梯度。

具体地，原 score 是 $s_i(x)$，做 top-k 选择时用 biased score：

$$\tilde{s}_i(x) = s_i(x) + b_i$$

$$\mathcal{T}_k(x) = \text{TopK}_i\, \tilde{s}_i(x)$$

但最终 gating weight 仍用原始 $s_i$ 的 softmax（或 sigmoid 后 renormalize，DeepSeek-V3 用 sigmoid）：

$$g_i(x) = \frac{\sigma(s_i(x))}{\sum_{j \in \mathcal{T}_k(x)} \sigma(s_j(x))}, \quad i \in \mathcal{T}_k(x)$$

$b_i$ 的更新规则（每 step 一次，out-of-graph，非梯度更新）：

$$b_i \leftarrow b_i + u \cdot \text{sign}(\bar{c}_i - c_i)$$

• $c_i$ = 本 step 中 expert $i$ 实际接到的 token 数
• $\bar{c}_i = T k / N$ = 均匀分布下每个 expert 应接到的期望 token 数
• 若 $c_i > \bar{c}_i$（过载）→ $b_i$ 减小 → 下次更难被选
• 若 $c_i < \bar{c}_i$（欠载）→ $b_i$ 增大 → 下次更易被选
• $u$ 是固定步长（V3 报告里很小，量级 $10^{-3}$）

2.5　Noisy Top-k（Shazeer 2017 原始方案，已较少用）

Shazeer 等 2017 论文里在 score 上加可学习的 Gaussian noise：

$$s_i(x) = (W_g x)_i + \text{StandardNormal}() \cdot \text{Softplus}((W_\text{noise} x)_i)$$

噪声为了让 top-k 选择"软化"、避免 collapse。后被 GShard / Switch 用更明确的 load balance loss 取代——但概念（"top-k 不可微 → 需要某种 stochastic 软化"）仍有教学价值。

§3 实现细节：核心 60 行 PyTorch

最小可跑实现：token-choice top-k MoE 层 + Switch aux loss。不考虑 EP，单 GPU 教学用。

import torch
import torch.nn as nn
import torch.nn.functional as F

class Expert(nn.Module):
    """每个 expert 就是一个标准 FFN（SwiGLU 风格也可，这里用 GELU 简化）"""
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.w1 = nn.Linear(d_model, d_ff, bias=False)
        self.w2 = nn.Linear(d_ff, d_model, bias=False)
    def forward(self, x):
        return self.w2(F.gelu(self.w1(x)))

class MoELayer(nn.Module):
    """
    Token-choice top-k MoE layer.
    输入 x: [B, L, D]
    输出 y: [B, L, D], aux_loss: scalar (Switch load-balance loss)
    """
    def __init__(self, d_model, d_ff, num_experts, top_k=2, capacity_factor=1.25, aux_loss_coef=0.01):
        super().__init__()
        assert top_k <= num_experts
        self.d_model = d_model
        self.num_experts = num_experts
        self.top_k = top_k
        self.capacity_factor = capacity_factor
        self.aux_loss_coef = aux_loss_coef

        # Router: D -> N, no bias (Switch / Mixtral 都不用 bias)
        self.router = nn.Linear(d_model, num_experts, bias=False)
        # N 个 expert
        self.experts = nn.ModuleList([Expert(d_model, d_ff) for _ in range(num_experts)])

    def forward(self, x):
        B, L, D = x.shape
        T = B * L
        x_flat = x.view(T, D)                              # [T, D]

        # ----- 1. Router 计算 score + top-k -----
        logits = self.router(x_flat)                       # [T, N]
        probs = F.softmax(logits, dim=-1)                  # [T, N]
        top_probs, top_idx = probs.topk(self.top_k, dim=-1)  # [T, k], [T, k]
        # Mixtral / DeepSeek 风格：在 top-k 上重归一
        top_probs = top_probs / (top_probs.sum(dim=-1, keepdim=True) + 1e-9)  # [T, k]

        # ----- 2. Aux load-balance loss (Switch 公式) -----
        # f_i = 分给 expert i 的 token 比例 (每 token 算 top_k 次命中, 与 top_k 一致)
        with torch.no_grad():
            one_hot = F.one_hot(top_idx, num_classes=self.num_experts).float()  # [T, k, N]
            f = one_hot.sum(dim=(0, 1)) / (T * self.top_k)                       # [N]
        P = probs.mean(dim=0)                                                    # [N], 可微
        aux_loss = self.aux_loss_coef * self.num_experts * (f * P).sum()

        # ----- 3. Capacity 计算 + token dispatch -----
        # 与正文公式一致：ceil(capacity_factor * T * top_k / N_E)，避免小 batch 截断为 0
        import math as _math
        capacity = max(1, _math.ceil(self.capacity_factor * T * self.top_k / self.num_experts))
        # 把 [T, k] 展开成 [T*k] 的 (token_idx, expert_idx) pair
        flat_expert = top_idx.view(-1)                     # [T*k]
        flat_weight = top_probs.view(-1)                   # [T*k]
        flat_token = torch.arange(T, device=x.device).repeat_interleave(self.top_k)  # [T*k]

        # ----- 4. Expert forward (capacity-aware) -----
        y_flat = torch.zeros_like(x_flat)                  # [T, D]
        for e in range(self.num_experts):
            mask_e = (flat_expert == e)                    # [T*k]
            if mask_e.sum() == 0:
                continue
            tok_e = flat_token[mask_e]                     # 要给 expert e 处理的 token 全局 idx
            w_e   = flat_weight[mask_e]                    # 对应 gate weight
            # 容量截断：超过 capacity 的 token drop (Switch residual bypass)
            if tok_e.numel() > capacity:
                tok_e = tok_e[:capacity]
                w_e   = w_e[:capacity]
            inp_e = x_flat[tok_e]                          # [≤cap, D]
            out_e = self.experts[e](inp_e)                 # [≤cap, D]
            # 按 token idx scatter-add (一个 token 可能被多个 expert 命中,所以是 add)
            y_flat.index_add_(0, tok_e, out_e * w_e.unsqueeze(-1))

        return y_flat.view(B, L, D), aux_loss

3.1　Aux-Loss-Free Bias Update（DeepSeek-V3 风格）

把上面 §3 中的 aux loss 删掉，改用 expert bias 更新：

class MoEAuxFree(nn.Module):
    def __init__(self, d_model, d_ff, num_experts, top_k=2, bias_step=1e-3):
        super().__init__()
        self.num_experts = num_experts
        self.top_k = top_k
        self.bias_step = bias_step
        self.router = nn.Linear(d_model, num_experts, bias=False)
        # b_i: 非参数, 不进梯度图 (buffer)
        self.register_buffer('expert_bias', torch.zeros(num_experts))
        self.experts = nn.ModuleList([Expert(d_model, d_ff) for _ in range(num_experts)])

    def forward(self, x):
        B, L, D = x.shape
        T = B * L
        x_flat = x.view(T, D)

        # Router score (V3 用 sigmoid 不是 softmax, 但 top-k 逻辑一样)
        logits = self.router(x_flat)                       # [T, N]
        # ★ Top-k 用 biased score, 但 gating weight 用原始 score
        biased_logits = logits + self.expert_bias.unsqueeze(0)
        _, top_idx = biased_logits.topk(self.top_k, dim=-1)         # [T, k]
        # 取出原始 score 对应位置, sigmoid 后 renormalize
        gate_raw = torch.sigmoid(logits).gather(-1, top_idx)        # [T, k]
        top_weights = gate_raw / (gate_raw.sum(dim=-1, keepdim=True) + 1e-9)

        # ----- 在线更新 expert_bias (无梯度, 论文 sign 更新) -----
        if self.training:
            with torch.no_grad():
                one_hot = F.one_hot(top_idx, num_classes=self.num_experts).float()  # [T, k, N]
                c = one_hot.sum(dim=(0, 1))                          # [N], 实际 load
                c_bar = T * self.top_k / self.num_experts            # 期望 load (scalar)
                # 过载 -> 减偏置; 欠载 -> 加偏置
                self.expert_bias -= self.bias_step * torch.sign(c - c_bar)

        # Dispatch + expert forward (与 §3 同, 这里省略)
        y_flat = torch.zeros_like(x_flat)
        flat_expert = top_idx.view(-1)
        flat_weight = top_weights.view(-1)
        flat_token  = torch.arange(T, device=x.device).repeat_interleave(self.top_k)
        for e in range(self.num_experts):
            mask = (flat_expert == e)
            if mask.sum() == 0: continue
            tok_e = flat_token[mask]
            w_e   = flat_weight[mask]
            out_e = self.experts[e](x_flat[tok_e]) * w_e.unsqueeze(-1)
            y_flat.index_add_(0, tok_e, out_e)
        return y_flat.view(B, L, D)

注意：

1. expert_bias 是 buffer 不是 parameter，不进梯度图、不被 optimizer step——只被 §forward 末尾的"sign 更新"修改。
2. biased_logits 只用于选 top-k，gating weight 来自原始 logits（这是 V3 论文反复强调的点）。如果连 gating weight 都用 biased，相当于把控制信号污染到主梯度路径，aux-loss-free 的好处就丢了。
3. V3 实际是 sigmoid + 256 experts + 9 选（8 routed + 1 shared 在 §6 讲），这里简化成 softmax + top-k 演示原理。

3.2　Fine-Grained + Shared Expert Layer（DeepSeekMoE 风格）

class DeepSeekMoELayer(nn.Module):
    """
    Fine-grained + shared expert: 
      - 总共 N 个 routed expert (拆细, 每个比标准 expert 小 m 倍)
      - 加 N_shared 个 shared expert (所有 token 都走)
      - 每个 token 路由到 K 个 routed expert (K = m × baseline_top_k)
    论文 (Dai et al. 2024, arXiv 2401.06066): 把 N 个原始 expert 拆成 mN 个,
    每个 expert 的 d_ff 缩到 d_ff/m, 路由数从 K 提到 mK, 总计算 / 参数量不变,
    但组合数 C(mN, mK) >> C(N, K) -> 专业化粒度提升.
    """
    def __init__(self, d_model, d_ff_per_expert, num_routed_experts, num_shared_experts, top_k):
        super().__init__()
        self.num_routed = num_routed_experts
        self.num_shared = num_shared_experts
        self.top_k = top_k
        self.router = nn.Linear(d_model, num_routed_experts, bias=False)
        # 拆细后的 routed experts (每个比 baseline 小 m 倍)
        self.routed_experts = nn.ModuleList(
            [Expert(d_model, d_ff_per_expert) for _ in range(num_routed_experts)]
        )
        # Shared experts: 永远激活, 不进 router
        self.shared_experts = nn.ModuleList(
            [Expert(d_model, d_ff_per_expert) for _ in range(num_shared_experts)]
        )

    def forward(self, x):
        # 1. Shared expert: 直接累加, 不路由
        shared_out = sum(e(x) for e in self.shared_experts)

        # 2. Routed top-k (这里简化省略 aux loss / capacity)
        B, L, D = x.shape
        T = B * L
        x_flat = x.view(T, D)
        logits = self.router(x_flat)
        probs = F.softmax(logits, dim=-1)
        top_p, top_i = probs.topk(self.top_k, dim=-1)
        top_p = top_p / (top_p.sum(dim=-1, keepdim=True) + 1e-9)

        routed_out = torch.zeros_like(x_flat)
        flat_e = top_i.view(-1)
        flat_w = top_p.view(-1)
        flat_t = torch.arange(T, device=x.device).repeat_interleave(self.top_k)
        for e in range(self.num_routed):
            mask = (flat_e == e)
            if mask.sum() == 0: continue
            tok = flat_t[mask]
            w   = flat_w[mask]
            routed_out.index_add_(0, tok, self.routed_experts[e](x_flat[tok]) * w.unsqueeze(-1))

        return shared_out + routed_out.view(B, L, D)

§4 容量、Token Dropping、Routing Collapse

4.1　Capacity Factor（必背工程细节）

每个 expert 不可能接受任意多 token——GPU memory + EP 通信都需要静态 buffer。所以预先给每个 expert 设容量 $C$：

$$\boxed{\;C = \left\lceil \alpha \cdot \frac{T \cdot k}{N} \right\rceil\;}$$

• $T$：batch 中 token 总数
• $k$：每 token 走的 expert 数
• $N$：expert 总数
• $\alpha$：capacity factor（常用 1.0、1.25、2.0）

$\alpha = 1$：均匀分布下刚好够用，但稍微不均就 drop；$\alpha = 1.25$（Switch / GShard 默认）：留 25% 余量缓冲不均匀；$\alpha > 2$：基本不 drop 但浪费显存。

4.2　Token Dropping vs Residual Bypass

当某 expert 已收满 $C$ 个 token，新来的 token 怎么办？两条路线：

Residual bypass 的好处：被 drop 的 token 不是变 0——它在残差通路上仍然带着自己的表示，只是这层"没被任何 expert 加工"，相当于退化成 identity layer。整个网络仍然能学到东西。

4.3　Routing Collapse（💣 经典 bug）

如果 router 没有 balance 机制，训练初期某些 expert 偶然被多选 → 它们参数被更新更多 → 下次更可能被选 → 强者愈强 → 少数 expert 通吃，多数饿死。这就是 routing collapse。

诊断信号：

• 监控 expert load（每 step 每 expert 接到的 token 数）→ 极不均
• 监控 aux loss → 大或在涨
• Validation loss 平台期早出现

修复手段：

1. Aux loss（Switch 公式，§2.2）
2. Expert dropout / Z-loss（对 router logits 加 entropy regularizer）
3. Expert Choice（§2.3，硬约束每 expert 选固定数 token）
4. Aux-loss-free bias（§2.4，DeepSeek-V3）
5. Capacity factor 适度调大（让 collapse 触发 drop，间接惩罚集中）

4.4　Top-k 的"硬"选择如何反传梯度？

经典问题：$\text{TopK}$ 是不可微的离散操作。

答案：top-k 只决定走哪条路径（discrete），不参与梯度；softmax 权重 $g_i(x)$ 进入最终输出 $y = \sum_i g_i E_i(x)$，对 $g_i$ 求导是连续的（standard softmax 链式法则）。所以 router 的 $W_g$ 是可微的（注意 softmax / renorm 的耦合带来 完整 Jacobian，不只是对角项）：

记 $s = W_g x$（logits），$p = \text{softmax}(s)$，top-k 选 $\mathcal{T}_k(x)$ 后做 renormalize $g_i = p_i / Z$（$Z = \sum_{j \in \mathcal{T}_k} p_j$）：

$$\frac{\partial g_i}{\partial s_l} = \mathbf{1}[i \in \mathcal{T}_k]\cdot\left(\frac{\partial p_i / \partial s_l}{Z} - \frac{p_i}{Z^2}\cdot \mathbf{1}[l \in \mathcal{T}_k] \cdot \frac{\partial Z}{\partial s_l}\right)$$

其中 $\partial p_i/\partial s_l = p_i(\delta_{il} - p_l)$ 是 softmax Jacobian（含交叉项 $-p_i p_l$，不只是对角 $p_i(1-p_i)$）。汇总：

$$\frac{\partial \mathcal{L}}{\partial W_g} = \sum_{i \in \mathcal{T}_k(x)}\sum_{l} \frac{\partial \mathcal{L}}{\partial g_i} \cdot \frac{\partial g_i}{\partial s_l} \cdot \frac{\partial s_l}{\partial W_g}$$

对 $l \notin \mathcal{T}_k$（被 top-k 排除），$\partial g_i/\partial s_l$ 通过 $p_l$ 仍非零（softmax 的全局耦合），但这一项在 forward 不影响输出、在 backward 的贡献仅经 $\partial p_i / \partial s_l = -p_i p_l$ 间接进入。实操上，只有 top-k 内的 expert 才能拿到主导梯度信号；top-k 外的 expert 长期得不到 "我应该被选" 的训练 push——这是 chicken-and-egg：不被选 → 不更新 → 永远不被选。Aux loss / bias 就是为了打破这个循环。

§5 经典模型谱系：从 Shazeer 到 DeepSeek-V3

按时间和"工程门槛"排成 7 行（必背年表 + 关键贡献）：

5.1　主流开源 MoE 横向对比（2026 面试常考）

§6 DeepSeek-V3 全景（必背重点）

DeepSeek-V3（DeepSeek-AI, arXiv 2412.19437, 2024.12）是 2026 面试季最高频的 MoE 系统。把它的设计点拆开：

6.1　架构层面

                  DeepSeek-V3 MoE Layer
                 ────────────────────────
       x  [B, L, D=7168]
         │
         ├──────► Shared Expert (1 个, d_ff ≈ 2048)   →  shared_out
         │         (永远激活, 不进 router)
         │
         └──────► Router (D → 256)
                   │
                   ├ score s_i(x) + b_i  (bias 仅用于 top-k 选择)
                   │
                   ↓
                Top-8 (256 选 8)
                   │
                   │  实际 gating weight: sigmoid(s_i) / Σ sigmoid(s_j)
                   ↓
        ┌────────┬────────┬────────┬────────┐
        ↓        ↓        ↓        ↓        ↓
      E_a      E_b      E_c     ...      E_h         (8 个 routed expert)
        │        │        │        │        │
        └─ × g ─┴─ × g ─┴─ × g ─┴─ × g ─┘
                          │
                          ↓
                routed_out  +  shared_out  →  y

关键数字：

• Total 671B parameters
• Active per token 37B parameters
• MoE layer：256 routed experts + 1 shared，每 token 选 9 个 expert（8 routed + 1 shared）
• Attention 用 MLA（Multi-head Latent Attention），把 KV 压缩到低秩 latent → KV cache 降 ~93%
• MTP（Multi-Token Prediction）作为辅助 objective，inference 时可做 speculative decode

6.2　Auxiliary-Loss-Free Balance（详见 §2.4）

V3 论文里写了两件事的组合：

1. Per-expert bias $b_i$（核心）—— §2.4 描述
2. Sequence-wise auxiliary loss（兜底）—— 极小权重的辅助 loss，用于防止单条序列内部极端不均（不是跨 batch 的传统 aux loss）

第二点经常被忽略：V3 不是"完全无 aux loss"，而是主要靠 bias 做平衡，留一个 sequence-level 的极小 aux 兜底。面试时如果说"V3 完全没有 aux loss"是不准确的。

6.3　Node-Limited Routing

V3 训练时跑 64-way EP 跨 8 个 node。Naïve top-8 routing 可能让一个 token 的 8 个 expert 散布到所有 8 个 node → 严重 all-to-all 通信。V3 加了硬约束：每个 token 最多路由到 4 个 node，且每 node 最多选 3 个 expert。这是 algorithm × system 联合优化。

6.4　System：DualPipe + DeepEP

• DualPipe（github: deepseek-ai/DualPipe）：双向 pipeline parallelism，把 forward 和 backward 的 compute / comm 重叠到几乎 0 bubble。
• DeepEP（github: deepseek-ai/DeepEP）：专门为 MoE all-to-all 优化的通信库，支持 FP8 dispatch + asymmetric inter/intra-node bandwidth。

这两个开源库是 V3 在 2048 张 H800 上把 MoE 训练 cost 压到 $5.6M USD 的关键工程基础。

§7 复杂度、显存、推理算账

7.1　训练时 FLOPs / 参数对比

设 dense baseline 用 $D$ hidden, $d_\text{ff} = 4D$, 层数 $L$, token 数 $T$。FFN 部分 FLOPs（dense）：

$$\text{FLOPs}_\text{FFN}^\text{dense} \approx 2 \cdot T \cdot L \cdot D \cdot d_\text{ff} \cdot 2 = 16 T L D^2$$

MoE：把 FFN 换成 $N$ expert, 每 expert $d_\text{ff}$, 每 token 走 $k$。计算量只算被激活的 expert：

$$\text{FLOPs}_\text{FFN}^\text{MoE} \approx 16 T L D^2 \cdot \frac{k}{N} \cdot \frac{N \cdot d_\text{ff}^\text{expert}}{4D}$$

如果 $d_\text{ff}^\text{expert} = 4D$（"每个 expert 等于一个完整 FFN"，Mixtral 风格），$\text{FLOPs} \propto k$，与 $N$ 无关（典型 Mixtral 8x7B $k=2$ → 计算 $\approx$ 2 个 FFN）。

参数量则与 $N$ 线性增长：

$$\text{Params}_\text{FFN}^\text{MoE} = N \cdot 8D^2 + D \cdot N \;(\text{router}) \approx 8 N D^2$$

结论：MoE 的"参数容量 $N$ 倍, 计算量 $k$ 倍"——这正是为什么 Mixtral 8x7B 总参 47B / active 13B 比同 active 13B 的 dense 表现强。

7.2　推理显存（必考！）

面试常见陷阱问题：MoE 推理时显存是按"active 参数"还是"总参数"算？

答案：几乎按总参数——所有 expert 必须常驻 GPU，因为下一个 token 可能路由到任何 expert。不能"按需 load 一个 expert"，因为 PCIe / NVLink 加载延迟远高于 expert 计算延迟。

具体地，单 GPU 推理 671B model（FP8 / FP16）：

带宽的好处：每 token 只取 active_param / total_param 比例的权重做 matmul → memory bandwidth bottleneck 缓解（推理多数是 memory-bound）。671B / 37B → 每 token 只读 ~5% 权重——这是 V3 在 H800 上 inference throughput 与 dense 30B 同台的根源。

7.3　KV Cache

MoE 不直接影响 KV cache 大小——KV 与 attention 相关，与 FFN sparsity 无关。但 V2/V3 同时引入 MLA 把 KV 压缩到低秩 latent，所以 V3 的 KV cache 是 LLaMA-3 70B 的 ~5%。面试要区分"MoE 减的是 FFN 显存（FP8 OK），MLA 减的是 KV 显存"——是两条互相独立的优化线。

§8 EP / TP / PP / DP：MoE 并行的 4 维交织

Dense LLM 训练常用 DP + TP + PP（数据 / 张量 / 流水）三维并行。MoE 必须加第 4 维：Expert Parallelism (EP)。

8.1　Expert Parallelism

把 $N$ 个 expert 切到不同 GPU 上（如 64 EP, 每 GPU 4 个 expert）。Forward 流程：

   Step 1.  Token x [local batch] -> Router -> top-k expert IDs
   Step 2.  ★ all-to-all dispatch:
            按 expert ID 把 token 发到对应 GPU
            (每 GPU 收到的 token 数 ≤ capacity)
   Step 3.  本地 expert forward
   Step 4.  ★ all-to-all combine:
            把 expert 输出按原始 token ID 发回起点 GPU
   Step 5.  Gate 加权求和 -> 下一层

两次 all-to-all 是 MoE 的灵魂也是痛点：通信量 $\propto T \cdot k \cdot D$，可以轻易吃掉一半时间。

8.2　EP × DP × TP × PP

实践组合（DeepSeek-V3 训练）：

• 16-way PP × 64-way EP × ZeRO-1 DP
• 单 H800 cluster: 8 GPU per node × 256 nodes = 2048 GPU
• DualPipe 让 PP bubble 接近 0；DeepEP 把 EP all-to-all 与 expert compute overlap

8.3　EP 通信量算账

设每 token 平均 $k$ expert, $D$ hidden, $G$ EP group size, 每 step token 数 $T$：

$$\text{all-to-all volume per layer} \approx 2 \cdot T \cdot k \cdot D \cdot \frac{(G-1)}{G}$$

（$\times 2$ 是 dispatch + combine 各一次。$(G-1)/G$ 是因为 1/G 的 token 本地命中无需通信。）

对 V3：$T \sim$ few-M tokens/step, $k=8$, $D=7168$, $G=64$ → 单 layer 通信量 ~ TB 级。这就是为什么 DeepEP / NVLink-aware kernel 这么关键。

§9 与相关方法对比

9.1　MoE vs Dense（同 FLOPs / 同参数）

9.2　MoE vs Mixture-of-Depths (MoD)

MoD（Raposo et al. 2024）思路不同：每层选 top-k 个 token 走完整层，其他 token skip 整层（沿 depth 方向稀疏化）。对比 MoE 沿 width 方向稀疏化（每个 token 选部分 expert）。

不互斥——理论上可以同时用，2025 后的几个工作（如 Llama 4 的细节、Qwen3 的某些实验）开始混用。

9.3　MoE 微调：ESFT 和它的同类

标准 LoRA 在 MoE 上有几个坑：

• LoRA 加到 $W_q/W_k/W_v$ 上是 attention 层级，不动 expert
• 加到每个 expert 上 → $N$ 倍 LoRA 参数，部分 expert 训不到（因为不被路由）

ESFT（Expert-Specialized Fine-Tuning, Wang et al. arXiv 2407.01906）：

• 先用任务数据做 forward，统计 router score
• 找出任务最相关的 top-k expert（per-layer），其余冻结
• 只训这些"任务专家"，显存 ↓ 90%、时间 ↓ 30%、性能 ≈ 全参 fine-tune

9.4　MoE vs MQA/GQA

完全正交：

• MQA/GQA 减 KV cache（attention 端）
• MoE 减 FFN 算力（FFN 端）

可以同时用（V2/V3 = MLA + MoE；LLaMA-3 = GQA + dense；理论上 GQA + MoE 也合法）。

§10 25 高频面试题

按难度分 L1（10 必会）/ L2（10 进阶）/ L3（5 顶级 lab）。每题点开看答案要点 + 易踩坑。

L1必会题（任何 ML 工程岗都会问）

L2进阶题（research-oriented 岗位）

L3顶级 lab / Research 方向

§A 附录：参考文献清单（按时间）

按出现先后整理。注：所有 arXiv ID 已交叉验证。

1. Shazeer, N., Mirhoseini, A., Maziarz, K., Davis, A., Le, Q., Hinton, G., Dean, J. (2017). Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer. ICLR. arXiv:1701.06538.
2. Lepikhin, D., Lee, H., Xu, Y., Chen, D., Firat, O., Huang, Y., Krikun, M., Shazeer, N., Chen, Z. (2020). GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding. arXiv:2006.16668.
3. Fedus, W., Zoph, B., Shazeer, N. (2021). Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity. JMLR. arXiv:2101.03961.
4. Zhou, Y., Lei, T., Liu, H., Du, N., Huang, Y., Zhao, V., Dai, A., Chen, Z., Le, Q., Laudon, J. (2022). Mixture-of-Experts with Expert Choice Routing. NeurIPS. arXiv:2202.09368.
5. Zoph, B., Bello, I., Kumar, S., Du, N., Huang, Y., Dean, J., Shazeer, N., Fedus, W. (2022). ST-MoE: Designing Stable and Transferable Sparse Expert Models. arXiv:2202.08906.（Z-loss 来源）
6. Dai, D., Deng, C., Zhao, C., Xu, R., et al. (2024). DeepSeekMoE: Towards Ultimate Expert Specialization in Mixture-of-Experts Language Models. ACL. arXiv:2401.06066.
7. Jiang, A. Q., Sablayrolles, A., et al. (2024). Mixtral of Experts. arXiv:2401.04088.
8. DeepSeek-AI (2024). DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model. arXiv:2405.04434.
9. Wang, Z., Chen, D., Dai, D., Xu, R., Li, Z., et al. (2024). Let the Expert Stick to His Last: Expert-Specialized Fine-Tuning (ESFT). arXiv:2407.01906.
10. Wang, L., Gao, H., Zhao, C., Sun, X., Dai, D. (2024). Auxiliary-Loss-Free Load Balancing Strategy for Mixture-of-Experts. arXiv:2408.15664.
11. DeepSeek-AI (2024). DeepSeek-V3 Technical Report. arXiv:2412.19437.
12. Raposo, D., Ritter, S., Richards, B., Lillicrap, T., Humphreys, P., Santoro, A. (2024). Mixture-of-Depths: Dynamically Allocating Compute in Transformer-Based Language Models. arXiv:2404.02258.
13. Meta AI (2025). Llama 4: Scout, Maverick, Behemoth (blog announcement, April 5, 2025).
14. Qwen Team (2025). Qwen3 Technical Report. arXiv:2505.09388.
15. DeepSeek-AI / DualPipe / DeepEP (2025). Open-source releases at github.com/deepseek-ai/{DualPipe,DeepEP}.