---
tags: [AI, LLM, MoE, 稀疏激活]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[Transformer架构详解]], [[分布式训练与部署]], [[GPT系列架构]]"
---

# 专家混合MoE

## 定义

**专家混合**（mixture of experts，MoE）是一种条件计算结构：把一个前馈子层的参数划分为 $N$ 个**专家**（expert），由一个**门控网络**（gating network，也称 router）对每个 token 输出 $N$ 个权重，只对权重最大的 $k$ 个专家执行前向计算，再按权重求和作为该子层的输出。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $T$ | 一个批次内的 token 总数，也是本层输入的行数 |
| $d$ | 模型维度，即每个 token 表示的维度 |
| $d_{ff}$ | 单个专家内部前馈层的隐藏维度 |
| $N$ | 专家数量 |
| $k$ | 每个 token 激活的专家数量，$1\le k\le N$ |
| $\mathbf{x}_t\in\mathbb{R}^{d}$ | 第 $t$ 个 token 进入 MoE 层的表示 |
| $\mathbf{W}_g\in\mathbb{R}^{N\times d}$ | 门控矩阵，第 $i$ 行为专家 $i$ 的打分向量 |
| $\mathbf{z}_t=\mathbf{W}_g\mathbf{x}_t\in\mathbb{R}^{N}$ | 第 $t$ 个 token 的门控 logits |
| $\mathbf{p}_t=\mathrm{softmax}(\mathbf{z}_t)\in\mathbb{R}^{N}$ | 路由概率，$\sum_i p_{t,i}=1$ |
| $\mathcal{T}_t$ | 被选中的专家下标集合，$|\mathcal{T}_t|=k$ |
| $E_i(\cdot)$ | 第 $i$ 个专家的前馈函数 $\mathbb{R}^{d}\to\mathbb{R}^{d}$ |
| $\tilde p_{t,i}$ | 在 $\mathcal{T}_t$ 上重新归一化后的门控权重 |
| $C$ | 每个专家在本次前向中可接收的 token 上限，即容量 |
| $\gamma$ | 容量因子（capacity factor） |
| $f_i$ | 首选项为专家 $i$ 的 token 占比，用于负载均衡损失 |
| $P_i$ | 专家 $i$ 的平均路由概率，用于负载均衡损失 |
| $\alpha$ | 负载均衡损失在总损失中的系数 |
| $P_{\text{tot}},P_{\text{act}}$ | 总参数量与每 token 激活参数量 |
| $b$ | 浮点数位宽，单位为字节（bf16 为 2） |
| $L$ | Transformer 层数 |
| $D$ | 专家并行组的设备数 |
| $\sigma$ | logistic 函数 $\sigma(x)=1/(1+e^{-x})$ |
| $\mathbb{1}[\cdot]$ | 指示函数，条件成立取 1、否则取 0 |

术语定义：

- **专家**（expert）：一层独立参数的子网络。主流实现中每个专家是一个两层前馈网络 $E_i(\mathbf{x})=\mathbf{W}_2^{(i)}\,\sigma(\mathbf{W}_1^{(i)}\mathbf{x})$，$\sigma$ 为激活函数。
- **门控网络**（gating network）：只含一个线性层与一次 softmax 的小网络，参数量为 $N d$，相对于专家参数可忽略。
- **top-k 路由**（top-k routing）：每个 token 独立选择分数最高的 $k$ 个专家，不同 token 的选择可以不同。
- **稀疏激活**（sparse activation）：前向时每个 token 只执行 $k$ 个专家而非全部 $N$ 个，故单 token 的计算量只与 $k$ 有关。
- **激活参数量**（active parameter count）：一次前向中实际参与某个 token 计算的参数个数，包含共享的注意力层与归一化层。
- **容量因子**（capacity factor）：每个专家缓冲容量的放大系数，用来给负载波动留余量。
- **token 丢弃**（token dropping）：超过容量的路由分配被直接丢弃，该 token 少收到一个专家的贡献。
- **负载均衡损失**（load balancing loss，也称辅助损失 auxiliary loss）：加到训练目标上的正则项，惩罚专家负载的不均匀。
- **路由坍缩**（routing collapse）：路由概率向少数专家集中，其余专家长期收不到 token 而无法获得有效梯度。
- **专家并行**（expert parallelism，EP）：把不同专家放在不同设备上，token 通过 all-to-all 通信被送往专家所在设备。
- **all-to-all**：集合通信原语，每台设备向组内所有设备发送互不相同的分片，是所有设备间的全交换。

## 为什么重要

稠密 Transformer 的每 token 计算量与参数量成正比。设一层的前馈子层为 $d\to d_{ff}\to d$，其参数为 $2dd_{ff}$，每 token 的乘加次数为 $2dd_{ff}$；取 $d_{ff}=4d$ 得每层前馈 $8d^2$ 个参数、$8d^2$ 次乘加。再加上注意力投影的 $4d^2$ 个参数，整层参数量与每 token 乘加次数同阶。由于一次乘加计 2 次浮点运算，稠密模型的经验关系是

$$
\text{FLOPs per token}\approx 2P,
$$

其中 $P$ 为总参数量。70B 稠密模型每 token 约需 $1.4\times10^{11}$ 次浮点运算，405B 模型约需 $8.1\times10^{11}$ 次。

模型质量随参数与数据规模提升，但若参数量与每 token 计算量被上式绑定，提升容量就必须同比提升训练与推理成本。MoE 打破这一绑定：总参数 $P_{\text{tot}}$ 决定模型容量与显存占用，激活参数 $P_{\text{act}}$ 决定每 token 的计算量，二者之比即稀疏激活比。Mixtral 8x7B 的总参数为 46.7B、激活参数 12.9B，每 token 计算量与 13B 稠密模型相当，容量接近 47B 稠密模型；DeepSeek-V3 的总参数为 671B、激活 37B，稀疏激活比约 5.5%。

没有 MoE 时只有两种选择：按稠密方式扩展，每 token 计算量随参数线性上升；或维持计算量而限制参数量。前者使推理成本不可承受，后者使容量不足。MoE 提供第三条路径，代价是把成本从"计算"转移到"显存与通信"：全部专家必须常驻显存，token 需要跨设备传输，路由本身引入离散决策与训练不稳定。

在本库中的位置如下。[[Transformer架构详解]] 给出前馈子层的形状与残差结构，本篇替换的正是该子层。[[GPT系列架构]] 是稠密扩展的对照：参数、层数、每 token FLOPs 同步增长。[[分布式训练与部署]] 展开专家并行与 all-to-all 在 4D 并行中的位置。[[模型推理优化]] 讨论 MoE 推理受显存带宽约束的成因。对应学习目标中的"懂原理"与"会评估"：能写出路由三式、核算任意 MoE 模型的激活参数量、判断给定部署条件下 MoE 是否划算。

## 原理与推导

### 1 稠密扩展的成本结构

设一层内注意力与前馈的参数分别为 $4d^2$ 与 $8d^2$（$d_{ff}=4d$），序列长度为 $T$。每 token 每层的浮点运算次数为

$$
\underbrace{8Td^2}_{\text{QKV 与输出投影}}+\underbrace{4T^2d}_{\text{打分与加权}}+\underbrace{16Td^2}_{\text{前馈}} ,
$$

除以 $T$ 得每 token 的 $24d^2+4Td$。当 $T\ll d$ 时前馈占主导，当 $T\gg d$ 时注意力占主导。参数量为每层 $12d^2$ 乘以层数 $L$，与 $T$ 无关。

因此稠密模型的两条约束同时成立：参数量决定显存与容量，每 token 计算量由参数量决定。若把 $P$ 提升 4 倍，每 token 的运算量也提升约 4 倍，训练与推理的算力开销同比上升，这是稠密扩展无法回避的线性关系。

### 2 MoE 层的结构

MoE 层用 $N$ 个专家替换单个前馈子层。对第 $t$ 个 token，门控先给出 $N$ 个 logits 与概率：

$$
\mathbf{z}_t=\mathbf{W}_g\mathbf{x}_t,\qquad
\mathbf{p}_t=\mathrm{softmax}(\mathbf{z}_t),\qquad
p_{t,i}=\frac{\exp(z_{t,i})}{\sum_{j=1}^{N}\exp(z_{t,j})}.
$$

softmax 沿专家维进行，即固定 $t$，对 $i=1,\dots,N$ 归一化。随后选出概率最大的 $k$ 个专家：

$$
\mathcal{T}_t=\mathrm{TopK}(\mathbf{p}_t,k).
$$

输出为选中专家输出的加权和，权重在选中集合内重新归一化：

$$
\mathbf{y}_t=\sum_{i\in\mathcal{T}_t}\tilde p_{t,i}\,E_i(\mathbf{x}_t),
\qquad
\tilde p_{t,i}=\frac{p_{t,i}}{\sum_{j\in\mathcal{T}_t}p_{t,j}}.
$$

三个式子的形状依次为：$\mathbf{z}_t\in\mathbb{R}^{N}$，$\mathcal{T}_t$ 含 $k$ 个互不相同的下标，$\mathbf{y}_t\in\mathbb{R}^{d}$。每个专家 $E_i$ 的输出维度必须与 $\mathbf{x}_t$ 相同，才能与残差相加。

写成矩阵形式更容易看清计算量。构造稀疏矩阵 $\mathbf{S}\in\mathbb{R}^{T\times N}$，每行只有 $k$ 个非零元，第 $t$ 行为 $\tilde p_{t,i}\mathbb{1}[i\in\mathcal{T}_t]$，则

$$
\mathbf{Y}=\mathbf{S}\,\mathbf{E}(\mathbf{X}),
$$

其中 $\mathbf{E}(\mathbf{X})\in\mathbb{R}^{N\times T\times d}$ 表示对每个专家分别作用于分配到它的 token 子集。实际实现不构造该三维张量，而是按专家分组后做 $N$ 次小批量矩阵乘法。每 token 的前馈乘加次数由稠密情形的一个 $d\,d_{ff}$ 变为 $k$ 个，即

$$
\text{MACs}_{\text{MoE}}=k\cdot 2dd_{ff},\qquad \text{MACs}_{\text{dense}}=2dd_{ff}.
$$

门控本身只增加 $Nd$ 次乘加，占每 token 计算的比例为 $Nd/(2kdd_{ff})=N/(2kd_{ff})$，在 $d_{ff}\gg N$ 时可忽略。

### 3 稀疏激活比

**稀疏激活比**定义为每 token 激活参数量与总参数量之比：

$$
r=\frac{P_{\text{act}}}{P_{\text{tot}}},\qquad
P_{\text{act}}=P_{\text{shared}}+\frac{k}{N}P_{\text{expert}},
$$

其中 $P_{\text{shared}}$ 为所有 token 都经过的参数（嵌入、注意力、归一化、门控），$P_{\text{expert}}$ 为全部专家的参数之和。当专家参数占绝对多数时 $r\approx k/N$。Switch Transformer 的 top-1 取 $k=1$，$r\approx 1/N$；Mixtral 取 $N=8,k=2$，$r\approx 1/4$；DeepSeek-V3 取 $N=256,k=8$，$r\approx 1/32$。

| 模型 | $P_{\text{tot}}$ | $P_{\text{act}}$ | $r$ | 每 token FLOPs |
|---|---|---|---|---|
| Llama-2 70B（稠密） | 70B | 70B | 1.00 | $1.4\times10^{11}$ |
| Mixtral 8x7B | 46.7B | 12.9B | 0.28 | $2.6\times10^{10}$ |
| DeepSeek-V3 | 671B | 37B | 0.055 | $7.4\times10^{10}$ |

$r$ 只描述计算，不描述显存。全部专家参数仍要驻留显存，因此 MoE 的显存占用由 $P_{\text{tot}}$ 决定，与稠密模型按同一公式计算：bf16 下 46.7B 参数需 $46.7\times10^{9}\times2\approx93$ GB，超过单张 80 GB 加速卡的容量，必须跨设备切分。

### 4 容量因子、溢出与丢弃

若按路由结果动态分配显存，每个专家收到的 token 数随批次波动，无法预先确定张量形状，在专家并行下还会造成设备间等待。工程上的做法是给每个专家固定容量，超出部分丢弃。

设每个 token 有 $k$ 个选择，则全部专家收到的分配总数为 $kT$，平均每个专家 $kT/N$。容量取

$$
C=\left\lceil \gamma\cdot\frac{kT}{N}\right\rceil ,
$$

其中 $\gamma$ 为容量因子。Switch Transformer 的 top-1 使用 $C=\lceil\gamma T/N\rceil$，$\gamma$ 取 $1.0$ 至 $1.25$；GShard 的 top-2 使用 $C=\lceil 2T/N\rceil$，相当于 $k=2$ 时 $\gamma=1$。两种写法口径不同：前者以 $T/N$ 为基准，后者已把 $k$ 乘进基准。若统一按 $kT/N$ 表述，Switch 的 $\gamma$ 就是实际余量，而 GShard 在 top-2 下的余量为 1，没有额外缓冲。

容量不足时按到达顺序保留前 $C$ 个分配，其余丢弃。所谓顺序有两种实现：按 token 在批次中的位置（position priority），或在训练时随机打乱（random priority）。丢弃只影响该 token 在对应专家上的贡献，残差通路与注意力通路仍然保留；若一个 token 的 $k$ 个分配全部被丢弃，则它在本层的输出为零向量。

$\gamma=1$ 时的丢弃量可以估算。设路由近似独立均匀，单个专家收到的 token 数服从二项分布 $\mathrm{Bin}(T,k/N)$，其均值为 $kT/N=C$，标准差为

$$
\sigma=\sqrt{T\cdot\frac{k}{N}\left(1-\frac{k}{N}\right)} .
$$

超出容量的期望量约为 $\sigma\phi(0)=\sigma/\sqrt{2\pi}$，其中 $\phi$ 为标准正态密度。取 $T=8192$、$N=8$、$k=2$，则 $\sigma=\sqrt{8192\times0.25\times0.75}\approx39.2$，每个专家平均丢弃约 $15.6$ 个分配，八个专家合计约 125 个，占全部分配 $kT=16384$ 的 0.8%。把 $\gamma$ 提到 1.25 后容量为 $1.25\times2048=2560$，距均值 13 个标准差，丢弃可忽略。这解释了为何 $\gamma$ 通常取略大于 1 的小值：容量按最坏情况设置会浪费显存，按均值设置会稳定丢弃。

### 5 负载均衡损失

容量只限制后果，不改变路由。若门控把所有 token 都送给同一个专家，其余专家的参数永远不更新。为此在训练目标上加一个正则项，使分配尽量均匀。

Switch Transformer 采用的形式为

$$
L_{\text{aux}}=\alpha\,N\sum_{i=1}^{N}f_iP_i,
\qquad
f_i=\frac{1}{T}\sum_{t=1}^{T}\mathbb{1}\!\left[i=\arg\max_j p_{t,j}\right],
\qquad
P_i=\frac{1}{T}\sum_{t=1}^{T}p_{t,i},
$$

其中 $f_i$ 是首选项为专家 $i$ 的 token 占比，$P_i$ 是专家 $i$ 的平均路由概率，$\alpha$ 通常取 $10^{-2}$。$f_i$ 由硬计数得到，不含梯度；$P_i$ 由 softmax 输出得到，含梯度。该项在 $f$ 与 $P$ 都为均匀分布时取值

$$
N\sum_{i=1}^{N}\frac{1}{N}\cdot\frac{1}{N}=1,
$$

即均匀分配时该损失取值为 1（而不是 0）。若 $f$ 与 $P$ 反相关，其值可以小于 1，因此只能比较相对变化，不能把绝对值当作不平衡度。

对 logits 求梯度可以看出它如何起作用。记 $\mathbf{z}_t$ 为第 $t$ 个 token 的 logits，$p_{t,j}$ 为其 softmax 分量，则

$$
\frac{\partial P_i}{\partial z_{t,j}}=\frac{1}{T}\,p_{t,i}\left(\delta_{ij}-p_{t,j}\right),
$$

其中 $\delta_{ij}$ 在 $i=j$ 时为 1、否则为 0。代入得

$$
\frac{\partial L_{\text{aux}}}{\partial z_{t,j}}
=\alpha N\sum_{i=1}^{N}f_i\,\frac{\partial P_i}{\partial z_{t,j}}
=\frac{\alpha N}{T}\,p_{t,j}\left(f_j-\sum_{i=1}^{N}f_ip_{t,i}\right).
$$

括号内是"专家 $j$ 的实际负载占比"减去"按路由概率加权的平均负载占比"。当专家 $j$ 的负载高于这一加权平均时括号为正，梯度下降把 $z_{t,j}$ 压低，减少后续分配；反之抬高。梯度幅度与 $p_{t,j}$ 成正比，因此已经被压得很低的专家获得的修正量也小，这是该损失无法单独阻止坍缩的原因之一。

GShard 使用的是同一思想的另一种归一化：

$$
L_{\text{aux}}=\frac{1}{N}\sum_{i=1}^{N}\frac{c_i}{S}\,m_i,
$$

其中 $c_i$ 为分配给专家 $i$ 的 token 数，$S$ 为 token 总数，$m_i$ 为专家 $i$ 收到的平均门控值。两式的求和项相同，缩放因子相差 $N^2$（不含各自的系数），因此系数不能跨实现直接照搬：把 Switch 的 $\alpha=10^{-2}$ 直接用于 GShard 形式，等效强度会相差 $N^2$ 倍。

早期工作（Shazeer 等，2017）使用变异系数平方的形式：

$$
L_{\text{importance}}=w_{\text{imp}}\left(\frac{\mathrm{std}(\mathbf{Imp})}{\mathrm{mean}(\mathbf{Imp})}\right)^{2},
\qquad
\mathrm{Imp}_i=\sum_{t=1}^{T}p_{t,i},
$$

$$
L_{\text{load}}=w_{\text{load}}\left(\frac{\mathrm{std}(\mathbf{Load})}{\mathrm{mean}(\mathbf{Load})}\right)^{2},
\qquad
\mathrm{Load}_i=\sum_{t=1}^{T}\mathbb{1}\left[i\in\mathcal{T}_t\right].
$$

重要性项对概率可导，直接约束各专家的总路由质量；负载项基于硬计数，没有梯度路径，主要作为监控量并配合带噪声的门控使用。Switch 的 $f_iP_i$ 形式可以看作把两者合并成一项：$f_i$ 提供目标分布，$P_i$ 提供梯度。

DeepSeek-V3 采用另一条路线：不用辅助损失，改为给每个专家维护一个偏置 $b_i$，路由打分用 $\sigma(\mathbf{u}_t^{\top}\mathbf{e}_i)+b_i$ 选择 top-k，但加权仍用未加偏置的 $\sigma(\mathbf{u}_t^{\top}\mathbf{e}_i)$，其中 $\mathbf{u}_t$ 是该 token 的路由表示、$\mathbf{e}_i$ 是专家 $i$ 的路由向量。训练中按负载误差调整 $b_i$：过载的专家减小偏置，欠载的专家增大偏置；推理时偏置固定。这样负载均衡不进入梯度，避免辅助损失与语言建模目标相互干扰。该报告同时保留一个权重很小（$10^{-4}$ 量级）的序列级均衡损失作为补充。

### 6 路由坍缩

路由坍缩指 $\mathbf{p}_t$ 在训练中逐渐集中到少数专家，其余专家的 $f_i$ 与 $P_i$ 同时趋近 0。其机制是正反馈：收到更多 token 的专家获得更多梯度、更快拟合数据，其 logits 随之增大，又收到更多 token。极端情况下 $N$ 个专家中只有 $k$ 个被使用，稀疏激活退化为固定子网络，容量优势消失。

用两个专家的情形说明该反馈为何稳定。设专家 1、2 的 logits 差为 $\Delta=z_1-z_2$，则 $p_1=\sigma(\Delta)$，$p_2=1-\sigma(\Delta)$。若数据分布使 $\Delta$ 增大能降低语言建模损失，则梯度会持续推高 $\Delta$；均衡损失能提供的修正量只有 $\frac{\alpha N}{T}p_{t,j}\left(f_j-\sum_i f_ip_{t,i}\right)$ 量级，且随 $p_{t,j}$ 一同缩小。当 $\Delta$ 较大时 $\sigma'(\Delta)\to0$，softmax 饱和，两个方向的梯度都趋于零，系统停在被锁定的分配上。这正是辅助损失系数、路由精度与初始化会显著影响结果的原因。

可用的缓解手段有：提高门控 logits 的数值精度、使用较小的初始化、在门控输入上加噪声、使用 top-2 而非 top-1（多一个专家可获得梯度）、以及在训练早期使用较大的均衡系数后逐步衰减。

### 7 Switch Transformer：top-1 与工程改进

Switch Transformer 把路由简化为 $k=1$：

$$
\mathbf{y}_t=p_{t,i^\star}E_{i^\star}(\mathbf{x}_t),
\qquad
i^\star=\arg\max_i p_{t,i}.
$$

由于只选一个专家，不存在"选中集合内归一化"的问题，权重直接取 $p_{t,i^\star}$，取值范围为 $(0,1)$，输出幅度随之缩放。相比 top-2，top-1 把专家计算量与专家间通信量都减半，代价是每个 token 只接收一个专家的变换。

该工作给出的工程改进直接针对 MoE 的不稳定与通信开销：

- 容量因子取 $1.0$ 至 $1.25$，在负载波动与显存之间折中。
- 辅助损失系数 $\alpha=10^{-2}$，与上文公式配套。
- **选择性精度**（selective precision）：门控的矩阵乘与 softmax 在 fp32 下计算，得到概率后再转回 bf16。路由的 argmax 对舍入敏感，这一步把路由决策与低精度计算解耦。
- 参数初始化缩小 10 倍，降低训练早期的 logits 方差。
- 微调阶段对专家使用 0.1 的 dropout，缓解过拟合与路由震荡。
- 提供把稀疏模型蒸馏回稠密模型的做法，便于部署。

在相同每 token 计算量下，Switch 报告的预训练加速最高约 7 倍，并训练了参数量达 1.6T 的 Switch-C。加速来自总参数增加带来的容量，而非每 token 计算量增加。

### 8 GShard：top-2 与容量 2T/N

GShard 使用 top-2 路由，每个 token 由两个专家共同处理，权重为对应的门控值。其容量取 $C=\lceil 2T/N\rceil$，即按平均负载设置、不留额外余量。训练在 600B 参数、$N=1000$ 的规模上进行，配合专家并行与组级调度：token 先在组内重排，再做 all-to-all，减少跨组通信。

top-2 相对 top-1 的收益在于每个 token 获得两条不同的变换路径，路由的表达能力更强，第二个槽位也让 token 有机会落到负载较低的专家上。代价是每 token 的专家计算与通信都翻倍。Mixtral 沿用 top-2，Switch 之后的多数大规模 MoE 也在 top-1 与 top-2 之间按算力预算选择。

### 9 Mixtral 8x7B 的配置与参数核算

Mixtral 8x7B 的结构参数为：32 层，$d=4096$，8 个专家，$k=2$，专家内部隐藏维 $d_{ff}=14336$，采用 SwiGLU 门控前馈（三个矩阵），注意力为 32 个查询头、8 个 KV 头的分组查询注意力，词表 32000，上下文长度 32768。

逐层核算参数量。单个专家的前馈含三个矩阵：

$$
3\times d\times d_{ff}=3\times4096\times14336\approx1.762\times10^{8}.
$$

八个专家合计 $1.409\times10^{9}$。注意力部分：查询与输出投影各 $4096\times4096$，键与值投影各 $4096\times1024$（8 个 KV 头，每头 128 维），合计

$$
2\times4096^2+2\times4096\times1024\approx4.194\times10^{7}.
$$

于是每层参数约 $1.451\times10^{9}$，32 层为 $4.64\times10^{10}$，加上词嵌入与输出头 $2\times32000\times4096\approx2.62\times10^{8}$ 与各层路由矩阵，总量约 $4.67\times10^{10}$，与论文给出的 46.7B 一致。

激活参数按每 token 经过 2 个专家计算：每层 $2\times1.762\times10^{8}+4.194\times10^{7}\approx3.943\times10^{8}$，32 层为 $1.262\times10^{10}$，加词嵌入与输出头约 $1.29\times10^{10}$，与论文的 12.9B 一致（差额来自路由与归一化参数）。

名称"8x7B"容易读作 8 个 7B 专家、合计 56B。实际总参数是 46.7B，原因是注意力层、嵌入层与归一化层在所有专家间共享，而单个专家只有约 0.176B。这说明 MoE 的参数量必须按结构逐层计数，不能由名称推断。

显存方面，bf16 下 46.7B 参数需约 93 GB。若用 EP=8 部署，注意力、嵌入与输出头的 $1.60\times10^{9}$ 个参数在每个设备上复制一份，专家参数 $4.51\times10^{10}$ 分为 8 份、每份约 $5.64\times10^{9}$，单设备约 $7.2\times10^{9}$ 个参数，即约 14.5 GB，此外还需 KV Cache 与激活值。

论文报告该模型在多数基准上达到或超过 Llama 2 70B，而每 token 激活参数只有 13B。这一对比是 MoE 成本-质量论证的常用证据：质量接近 70B 稠密模型，单 token 计算量约为其 $1/5.4$；但显存占用（约 93 GB）比 13B 稠密模型高一个数量级，与 70B 稠密模型（约 140 GB）同属必须多卡部署的量级。

### 10 专家并行与 all-to-all

当 $P_{\text{tot}}$ 超过单设备容量时，最直接的切分方式是把专家分散到不同设备，即专家并行。设 EP 组有 $D$ 个设备，每个设备持有 $N/D$ 个专家。一次 MoE 前向包含两次 all-to-all：

1. 分发（dispatch）：每个设备把自己批次中属于其他设备专家的 token 发送出去，接收本设备专家应处理的 token。
2. 计算：各设备对自己持有的专家执行前馈，容量决定本地缓冲的形状。
3. 合并（combine）：把专家输出发回 token 原来的设备，按门控权重求和。

设隐藏维为 $d$、浮点宽度为 $b$ 字节，一次前向的分发量与合并量各为 $kTdb$，合计

$$
V_{\text{layer}}=2\,k\,T\,d\,b\ \text{字节}.
$$

取 Mixtral 的 $d=4096$、$k=2$、$b=2$、每批 $T=8192$ 个 token，则每层通信量约为 $2.68\times10^{8}$ 字节即 256 MiB，32 层合计约 8 GiB。同期每层专家计算的浮点运算量为 $2\times T\times k\times3dd_{ff}\approx5.8\times10^{12}$，在 300 TFLOPS 的有效吞吐下约需 19 ms，而 256 MiB 在 100 GB/s 的互联上约需 2.7 ms。通信占比约一成，但这一比例对 $T$、互联带宽与并行度高度敏感：$T$ 越小，通信的相对开销越大，因此 MoE 推理需要较大的批。

EP 还带来两个实现约束。其一是负载不均导致的等待：即使有容量截断，各设备实际处理的 token 数仍有差异，同步点上的最慢设备决定整层耗时，因此容量因子也起到限制最长等待的作用。其二是通信拓扑：跨节点 all-to-all 的带宽远低于节点内 NVLink，DeepSeek-V3 采用节点受限路由，规定每个 token 最多被送到 4 个节点，把跨节点流量限制在可控范围。

在 4D 并行中，EP 与数据并行、张量并行、流水线并行正交组合。EP 组越大，单设备专家数越少、显存越省，但 all-to-all 的参与方越多、单次通信越小、效率越低。实际配置需要在显存、带宽与批大小之间求平衡。

### 11 训练不稳定与数值精度

MoE 的训练不稳定有四个来源。

第一，路由是离散决策。argmax 不可导，梯度只经概率项回传，未被选中的专家在该 token 上梯度为零。top-1 时每个 token 只有一条专家路径，梯度方差显著高于稠密前馈。

第二，低精度下的路由跳变。bf16 只有 8 位尾数，两个接近的 logits 在舍入后可能交换大小，同一个 token 在不同步被送往不同专家，损失出现尖峰。Switch 的选择性精度把门控计算放在 fp32，是针对性修复：门控的参数量只有 $Nd$，用 fp32 计算它的代价可以忽略，而专家的大矩阵乘仍用 bf16。

第三，softmax 饱和。logits 幅度增大后概率接近 0 或 1，梯度趋近于零，负载均衡项的修正也随之失效。缩小初始化、限制 logits 幅度、使用较高的门控精度都能缓解。

第四，专家负载的批间波动使有效学习率不稳定。同一专家在一步内看到大量 token、下一步看到很少，梯度尺度随之变化。容量截断与均衡损失压缩了这种波动，但不能消除。

工程上的做法是组合使用：门控 fp32、专家 bf16、较小的初始化、容量因子略大于 1、均衡损失系数在训练后期衰减、梯度裁剪，以及微调阶段降低学习率。

### 12 与稠密模型的成本-质量对比

| 维度 | 稠密模型 | MoE |
|---|---|---|
| 每 token 计算量 | $\approx 2P_{\text{tot}}$ | $\approx 2P_{\text{act}}$ |
| 显存占用 | $\propto P_{\text{tot}}$ | $\propto P_{\text{tot}}$，不减少 |
| 通信 | 张量并行/流水线并行的固定通信 | 额外两次 all-to-all |
| 训练稳定性 | 较稳定 | 路由坍缩、精度敏感、损失尖峰 |
| 批量要求 | 中等 | 大（通信与专家利用率） |
| 同等计算下的质量 | 基线 | 通常更高，规模越大优势越明显 |

MoE 的收益来自"用显存换计算"。当显存充足而算力受限时，MoE 在同等每 token 计算量下提供更大的参数容量；当显存紧张、批量很小或互联带宽不足时，全部专家常驻与 all-to-all 的开销可能抵消收益。推理阶段还有一层约束：单 token 解码时每步只用到 $k$ 个专家，但需要从显存读取这些专家的全部权重，算术强度低，性能受显存带宽限制；增大批可以提高专家权重的复用率，这也是 MoE 服务通常要求较大批的原因。

## 关键直觉

> [!tip] MoE 可以视为按输入选择参数子集的条件计算：门控给出 $N$ 个权重的分布，前向只对权重最大的 $k$ 个专家执行矩阵乘法，其余专家的参数不参与该 token 的计算。它与稠密前馈的差别不在单个专家的函数形式（每个专家仍是两层前馈网络），而在"哪些参数对哪个 token 生效"由输入决定。严格定义中 $\mathrm{TopK}$ 是这一条件的离散化，$\tilde p_{t,i}$ 是条件权重的连续部分；容量因子把"每个专家能接收多少 token"从数据依赖变为固定形状，代价是丢弃超出部分；负载均衡损失则是对离散选择分布的连续松弛约束，用来防止条件计算退化为固定子网络。

## 例子与代码

### 例 1 手算一个 top-2 MoE 层

取 $T=4$ 个 token、$N=3$ 个专家、$k=2$、$\gamma=0.5$。门控 logits 给定为

$$
\mathbf{Z}=
\begin{bmatrix}
2.0 & 1.0 & 0.0\\
0.0 & 3.0 & 1.0\\
1.0 & 0.0 & 0.8\\
0.5 & 0.4 & 2.0
\end{bmatrix}.
$$

先按行做 softmax。第一行分母 $e^{2}+e^{1}+e^{0}=7.389+2.718+1=11.107$，得 $\mathbf{p}_0=(0.6652,0.2447,0.0900)$。四行结果为

$$
\mathbf{P}=
\begin{bmatrix}
0.6652 & 0.2447 & 0.0900\\
0.0420 & 0.8438 & 0.1142\\
0.4573 & 0.1682 & 0.3744\\
0.1566 & 0.1417 & 0.7017
\end{bmatrix}.
$$

取每行最大的两个分量，并在两者上重新归一化。第一行选专家 0 与 1，$0.6652/(0.6652+0.2447)=0.7311$，另一个为 $0.2689$。四行的路由结果为

| token | 选中专家 | 归一化权重 |
|---|---|---|
| 0 | 0, 1 | 0.7311, 0.2689 |
| 1 | 1, 2 | 0.8808, 0.1192 |
| 2 | 0, 2 | 0.5498, 0.4502 |
| 3 | 2, 0 | 0.8176, 0.1824 |

容量为 $C=\lceil0.5\times2\times4/3\rceil=\lceil1.333\rceil=2$。按 token 顺序分配：专家 0 收到 token 0、2、3 的三个分配，只保留前两个，token 3 的 0.1824 被丢弃；专家 1 收到 token 0、1 两个，全部保留；专家 2 收到 token 1、2、3 三个，只保留前两个，token 3 的 0.8176 被丢弃。于是

$$
\mathbf{Load}=(2,2,2),\qquad \text{丢弃分配数}=2,\qquad \text{零输出 token 数}=1 .
$$

token 3 的两个分配都被丢弃，它在本层的输出为零向量。若把 $\gamma$ 提到 1.0，容量变为 $\lceil2.667\rceil=3$，三个专家都容得下全部分配，丢弃数为 0。

负载均衡损失按首选项统计：专家 0 被 token 0、2 首选，专家 1 被 token 1 首选，专家 2 被 token 3 首选，故 $f=(0.5,0.25,0.25)$；平均概率 $P=(0.3303,0.3496,0.3201)$；于是

$$
L_{\text{aux}}=3\left(0.5\times0.3303+0.25\times0.3496+0.25\times0.3201\right)\approx0.9977 .
$$

该值略小于 1，原因是 $f$ 与 $P$ 轻微反相关：负载最重的专家 0 的平均概率低于专家 1。

### 例 2 PyTorch 实现一个 top-2 MoE 层

下面的实现包含门控、专家、容量截断与辅助损失，权重固定写入以便复现输出。PyTorch 2.x，CPU 可运行。

```python
# moe_top2.py  PyTorch 2.x，CPU 可运行
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


class Expert(nn.Module):
    """单个专家：d -> d_ff -> d 的两层前馈网络，无偏置。"""

    def __init__(self, d: int, d_ff: int):
        super().__init__()
        self.w1 = nn.Linear(d, d_ff, bias=False)   # 权重形状 (d_ff, d)
        self.w2 = nn.Linear(d_ff, d, bias=False)   # 权重形状 (d, d_ff)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.w2(F.gelu(self.w1(x), approximate="tanh"))


class Top2MoE(nn.Module):
    """top-k 稀疏 MoE 层：门控、容量截断、Switch 式负载均衡损失。"""

    def __init__(self, d=6, d_ff=8, n_experts=4, k=2, capacity_factor=1.0):
        super().__init__()
        self.k = k
        self.n_experts = n_experts
        self.capacity_factor = capacity_factor
        self.gate = nn.Linear(d, n_experts, bias=False)          # 形状 (N, d)
        self.experts = nn.ModuleList(Expert(d, d_ff) for _ in range(n_experts))
        self._fix_weights(d, d_ff)

    @torch.no_grad()
    def _fix_weights(self, d, d_ff):
        """写入固定权重使示例可复现；训练时应改为随机初始化。"""
        g = torch.tensor([
            [1.0, 0.0, 0.0, 0.0],
            [0.0, 0.5, 0.0, 0.0],
            [0.3, 0.0, 0.9, 0.0],
            [0.0, 0.0, 0.5, 0.5],
            [1.0, 0.0, -0.5, 0.0],
            [0.0, 0.6, 0.0, 0.4],
        ])                                                      # (d, N)，第 j 列为专家 j
        self.gate.weight.copy_(g.t())
        r = torch.arange(d, dtype=torch.float32).view(1, -1)      # (1, d)
        c = torch.arange(d_ff, dtype=torch.float32).view(-1, 1)   # (d_ff, 1)
        for i, e in enumerate(self.experts):
            e.w1.weight.copy_(0.10 * torch.cos(0.7 * (c + 1.5 * r + 2.0 * i)))
            e.w2.weight.copy_(0.10 * torch.cos(0.5 * (c.t() + r.t() + 1.0 * i)))

    def forward(self, x: torch.Tensor) -> dict:
        T = x.shape[0]
        logits = self.gate(x)                                  # (T, N)
        probs = F.softmax(logits, dim=-1)                      # 沿专家维归一化
        top_p, top_i = probs.topk(self.k, dim=-1)              # (T, k)
        gates = top_p / top_p.sum(dim=-1, keepdim=True)        # 选中集合内重新归一化

        cap = math.ceil(self.capacity_factor * self.k * T / self.n_experts)
        y = torch.zeros_like(x)
        load = torch.zeros(self.n_experts, dtype=torch.long)
        assigned = torch.zeros((T, self.k), dtype=torch.bool)
        for e in range(self.n_experts):
            tok, slot = (top_i == e).nonzero(as_tuple=True)     # 按 token 序号升序
            tok, slot = tok[:cap], slot[:cap]                   # 超出容量即丢弃
            if tok.numel() == 0:
                continue
            load[e] = tok.numel()
            assigned[tok, slot] = True
            w = gates[tok, slot].unsqueeze(-1)                  # (n, 1)
            y.index_add_(0, tok, w * self.experts[e](x[tok]))

        f = torch.bincount(top_i[:, 0], minlength=self.n_experts).float() / T
        P = probs.mean(dim=0)                                   # (N,)
        aux = self.n_experts * (f * P).sum()                    # Switch 辅助损失
        return {"y": y, "expert_idx": top_i, "gates": gates, "load": load,
                "assigned": assigned, "f": f, "P": P, "aux": aux, "capacity": cap}


if __name__ == "__main__":
    X = torch.tensor([
        [1.0, 0.0, -1.0, 0.5, 0.0, 0.0],
        [0.0, 1.2, 0.0, -0.5, 0.5, 0.0],
        [-1.0, 0.0, 1.0, 0.0, 0.0, 0.5],
        [0.5, 0.5, 0.0, 1.0, -1.0, 0.0],
        [0.0, -1.0, 0.5, 0.0, 1.0, 0.5],
        [1.0, -0.5, 0.0, 0.5, 0.0, -1.0],
        [0.5, 0.0, 0.5, -1.0, 0.0, 1.0],
        [-0.5, 1.0, 0.0, 0.0, -0.5, 0.5],
    ])

    moe = Top2MoE()
    T = X.shape[0]
    out = moe(X)
    print(f"cap={out['capacity']}  cf={moe.capacity_factor}  k={moe.k}  T={T}  E={moe.n_experts}")
    for t in range(T):
        route = "  ".join(f"e{int(i)}:{float(g):.3f}"
                          for i, g in zip(out["expert_idx"][t], out["gates"][t]))
        yv = ", ".join(f"{v:+.3f}" for v in out["y"][t, :3].tolist())
        print(f"t{t}  {route}  kept={int(out['assigned'][t].sum())}  y[:3]=[{yv}]")
    print(f"load={out['load'].tolist()}  "
          f"dropped={moe.k * T - int(out['assigned'].sum())}  "
          f"zero_tokens={int((out['assigned'].sum(dim=1) == 0).sum())}")
    print(f"f={[round(float(v), 3) for v in out['f'].tolist()]}  "
          f"P={', '.join(f'{v:.3f}' for v in out['P'].tolist())}  "
          f"aux={float(out['aux']):.4f}")

    moe.capacity_factor = 0.5
    out = moe(X)
    print(f"cf=0.5 -> cap={out['capacity']}  load={out['load'].tolist()}  "
          f"dropped={moe.k * T - int(out['assigned'].sum())}  "
          f"zero_tokens={int((out['assigned'].sum(dim=1) == 0).sum())}")
```

预期输出（权重固定，两次运行结果一致）：

```text
cap=4  cf=1.0  k=2  T=8  E=4
t0  e0:0.611  e3:0.389  kept=2  y[:3]=[+0.011, +0.011, +0.008]
t1  e1:0.525  e0:0.475  kept=2  y[:3]=[-0.007, +0.001, +0.009]
t2  e2:0.646  e1:0.354  kept=2  y[:3]=[+0.007, -0.005, -0.016]
t3  e2:0.622  e3:0.378  kept=2  y[:3]=[-0.008, -0.018, -0.022]
t4  e0:0.721  e3:0.279  kept=2  y[:3]=[+0.009, +0.003, -0.003]
t5  e0:0.679  e2:0.321  kept=2  y[:3]=[-0.007, -0.007, -0.005]
t6  e0:0.512  e1:0.488  kept=1  y[:3]=[-0.001, +0.005, +0.010]
t7  e1:0.634  e2:0.366  kept=2  y[:3]=[-0.017, -0.013, -0.005]
load=[4, 4, 4, 3]  dropped=1  zero_tokens=0
f=[0.5, 0.25, 0.25, 0.0]  P=0.298, 0.251, 0.241, 0.209  aux=1.0890
cf=0.5 -> cap=2  load=[2, 2, 2, 2]  dropped=8  zero_tokens=4
```

输出解读如下。

第一行给出容量。$C=\lceil1.0\times2\times8/4\rceil=4$，即每个专家最多接收 4 个分配。

`t6` 行是两个关键现象的交汇点。它的首选项是专家 0（权重 0.512），次选项是专家 1（0.488）。专家 0 按 token 顺序收到 t0、t1、t4、t5、t6 五个分配，容量为 4，于是 t6 的首选项被丢弃，`kept=1`。此时该 token 在本层只收到 $0.488\times E_1(\mathbf{x}_6)$，权重和为 0.488 而非 1，输出幅度约为正常情况的一半。这正是"丢弃后未重新归一化"的直接后果：门控的归一化发生在容量截断之前，截断之后没有第二次归一化。

`load=[4, 4, 4, 3]` 说明分配并不均匀：专家 0 达到容量上限，专家 3 只收到 3 个。`dropped=1` 与上文的 `t6` 对应。`zero_tokens=0` 表示没有 token 的两个分配同时被丢弃。

`f=[0.5, 0.25, 0.25, 0.0]` 是首选项占比，专家 3 从未被首选；`P` 是平均路由概率；`aux=1.0890` 大于 1，原因是 $f$ 集中在专家 0，而 $P$ 相对平坦，$f$ 与 $P$ 的乘积被推高。注意 `aux` 只依赖路由概率，不依赖容量：把 `cf` 改为 0.5 后 `aux` 仍为 1.0890，说明辅助损失看不到丢弃。

把 `capacity_factor` 改为 0.5 后容量降为 2，每个专家都只保留前两个分配，丢弃 8 个分配，t4 至 t7 四个 token 的两个分配全部被丢弃，输出为零向量。`zero_tokens=4`。这一组输出说明容量因子直接控制"多少 token 完全失去前馈变换"。

去掉 `gates` 的重新归一化（直接使用 `top_p`）时，正常 token 的权重和小于 1，输出幅度整体缩小，且缩小比例随 token 变化，等效于对每个 token 施加了与路由置信度相关的缩放；去掉容量截断（`tok[:cap]` 改为 `tok`）时，专家 0 会处理 5 个 token，容量因子失去作用，在专家并行下本地缓冲形状随批次变化；把 `dim=-1` 改为 `dim=0` 时，softmax 沿 token 维归一化，每个专家的概率和为 1，路由分布被 $T$ 缩放，$P_i$ 与 $f_i$ 的含义同时失效。

## 易错点

> [!warning] 以下六条均可在代码或推导中直接检验。
> 1. softmax 维度取错。$\mathbf{p}=\mathrm{softmax}(\mathbf{W}_g\mathbf{x})$ 中 softmax 沿专家维进行，即对形状 $(T,N)$ 的张量取 `dim=-1`。写成 `dim=0` 或 `dim=-2` 时形状仍然合法，但归一化发生在 token 之间：每个专家的概率和为 1，单个 token 的概率和变为 $N/T$ 量级，$f_i$ 与 $P_i$ 的尺度同时错掉，辅助损失不再有均衡作用。
> 2. top-k 权重未归一化。$k>1$ 时若直接使用 $p_{t,i}$，选中权重之和小于 1 且随 token 波动，输出幅度不可控。GShard 直接使用门控值，Mixtral 在选中集合上重新归一化，两种约定不能混用；混用时同一模型内的输出尺度不一致。
> 3. 容量口径与取整。容量必须用 $\lceil\cdot\rceil$ 向上取整，用整除或向下取整会低估容量并在边界处多丢分配。口径上要区分 $C=\gamma T/N$（Switch，top-1）与 $C=\gamma kT/N$（统一按分配总数归一）：top-2 时用前者的公式等于把容量减半。此外容量计算必须在整个批次上做，不能按单条序列做，否则容量随序列长度变化。
> 4. 辅助损失系数与归一化。Switch 的 $\alpha N\sum_i f_iP_i$ 已含因子 $N$，再乘一次 $N$ 会把均衡强度放大 $N$ 倍；GShard 的 $\frac{1}{N}\sum_i\frac{c_i}{S}m_i$ 与它相差 $N^2$，系数不能跨实现照搬。$f_i$ 必须视作常数（stop-gradient），否则梯度会尝试修改计数而不是概率。该损失在均匀分布时取 1，不以 0 为下界，不能用"损失接近 0"判断均衡。
> 5. 专家并行的 all-to-all 与容量截断不一致。分发与合并两次通信依赖同一份路由结果，截断决策必须在所有 rank 上一致：若各设备按本地随机数或本地顺序截断，同一个 token 在分发与合并时的分配集合不同，合并阶段索引错位或权重相加错误。分发前还需按专家排序并记录逆排列，否则合并无法还原 token 顺序。
> 6. 用低精度计算门控并直接 argmax。bf16 的 8 位尾数使接近的 logits 在舍入后交换次序，路由在训练中出现不可复现的跳变，损失随之出现尖峰。门控的参数只有 $Nd$，应在 fp32 下计算 softmax 与路由，再把概率转回 bf16 参与加权。

## 关联笔记

- 前置 [[Transformer架构详解]]：MoE 替换的是该篇中的前馈子层，残差连接、LayerNorm 位置与子层输出维度均沿用其约定。
- 对照 [[GPT系列架构]]：该系列是稠密扩展的典型，参数量与每 token FLOPs 同步增长，可与本篇的稀疏激活比直接比较。
- 后续 [[分布式训练与部署]]：专家并行与 all-to-all 是 4D 并行中的一维，该篇给出 EP 与数据、张量、流水线并行的组合方式。
- 后续 [[模型推理优化]]：MoE 解码阶段受显存带宽约束，该篇讨论批处理、量化与专家放置对吞吐的影响。
- 对照 [[Llama-2架构复盘]]：Llama 2 的 7B/70B 是稠密配置的参照点，可用于核算 Mixtral 在相同质量下的计算量差异。

## 达标检测

- [ ] 写出 $\mathbf{p}_t=\mathrm{softmax}(\mathbf{W}_g\mathbf{x}_t)$、$\mathcal{T}_t=\mathrm{TopK}(\mathbf{p}_t,k)$ 与 $\mathbf{y}_t=\sum_{i\in\mathcal{T}_t}\tilde p_{t,i}E_i(\mathbf{x}_t)$ 三式，标注每一步的张量形状，并说明为何 softmax 必须沿专家维进行。
- [ ] 由 $\mathbf{W}_g$ 的形状 $(N,d)$ 推导门控的每 token 乘加次数，并证明它占 MoE 层计算的比例为 $N/(2kd_{ff})$ 量级。
- [ ] 独立核算 Mixtral 8x7B 的每层专家参数量、总参数与激活参数，说明 46.7B 与 12.9B 分别由哪些部分组成。
- [ ] 给定 $T=8192$、$N=8$、$k=2$、$\gamma=1.0$，计算容量，并用二项分布近似估算总丢弃分配数；再说明 $\gamma=1.25$ 时该估计为何降到可忽略。
- [ ] 推导 $\partial L_{\text{aux}}/\partial z_{t,j}=\frac{\alpha N}{T}p_{t,j}\left(f_j-\sum_i f_ip_{t,i}\right)$，解释括号两项的含义，并说明梯度幅度正比于 $p_{t,j}$ 为何会削弱对已坍缩专家的修正。
- [ ] 运行例 2 的代码，解释 t6 的 `kept=1` 与权重和 0.4875 的来源；把 `capacity_factor` 改为 0.5 后说明 `zero_tokens` 从 0 变为 4 的原因。
- [ ] 估算 Mixtral 在 EP=8、$T=8192$、bf16 下单设备的参数显存与单层 all-to-all 通信量，并说明为何提升批大小能改善通信与计算的比例。

## 参考来源

- Shazeer et al., "Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer", arXiv:1701.06538, 2017 —— 对应本篇第 2 节的稀疏门控结构、第 5 节的重要性与负载损失（变异系数平方形式）、第 6 节的路由坍缩。
- Fedus et al., "Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity", arXiv:2101.03961, 2021 —— 对应第 4 节的容量因子、第 5 节的 $f_iP_i$ 辅助损失、第 7 节的 top-1 路由与选择性精度等工程改进。
- Lepikhin et al., "GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding", arXiv:2006.16668, 2020 —— 对应第 8 节的 top-2 路由、容量 $2T/N$、组级调度与 600B/1000 专家的规模配置。
- Jiang et al., "Mixtral of Experts", arXiv:2401.04088, 2024 —— 对应第 9 节的 8x7B 结构参数、46.7B 总参数与 12.9B 激活参数、以及稀疏激活下的基准对比。
- DeepSeek-AI, "DeepSeek-V3 Technical Report", arXiv:2412.19437, 2024 —— 对应第 3 节的稀疏激活比、第 5 节的无辅助损失负载偏置、第 10 节的节点受限路由与专家并行配置。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 4 章 —— 对应本篇第 2 节前馈子层的形状约定与残差连接位置，用于对照专家网络与稠密前馈的结构关系。
