w wyl123ly 的博客
MD

专家混合MoE

41 KB 2026.10.18 原文件

专家混合MoE

定义

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

本篇符号约定如下。

符号含义
一个批次内的 token 总数,也是本层输入的行数
模型维度,即每个 token 表示的维度
单个专家内部前馈层的隐藏维度
专家数量
每个 token 激活的专家数量,
第 个 token 进入 MoE 层的表示
门控矩阵,第 行为专家 的打分向量
第 个 token 的门控 logits
路由概率,
被选中的专家下标集合,
第 个专家的前馈函数
在 上重新归一化后的门控权重
每个专家在本次前向中可接收的 token 上限,即容量
容量因子(capacity factor)
首选项为专家 的 token 占比,用于负载均衡损失
专家 的平均路由概率,用于负载均衡损失
负载均衡损失在总损失中的系数
总参数量与每 token 激活参数量
浮点数位宽,单位为字节(bf16 为 2)
Transformer 层数
专家并行组的设备数
logistic 函数
指示函数,条件成立取 1、否则取 0

术语定义:

  • 专家(expert):一层独立参数的子网络。主流实现中每个专家是一个两层前馈网络 , 为激活函数。
  • 门控网络(gating network):只含一个线性层与一次 softmax 的小网络,参数量为 ,相对于专家参数可忽略。
  • top-k 路由(top-k routing):每个 token 独立选择分数最高的 个专家,不同 token 的选择可以不同。
  • 稀疏激活(sparse activation):前向时每个 token 只执行 个专家而非全部 个,故单 token 的计算量只与 有关。
  • 激活参数量(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 计算量与参数量成正比。设一层的前馈子层为 ,其参数为 ,每 token 的乘加次数为 ;取 得每层前馈 个参数、 次乘加。再加上注意力投影的 个参数,整层参数量与每 token 乘加次数同阶。由于一次乘加计 2 次浮点运算,稠密模型的经验关系是

其中 为总参数量。70B 稠密模型每 token 约需 次浮点运算,405B 模型约需 次。

模型质量随参数与数据规模提升,但若参数量与每 token 计算量被上式绑定,提升容量就必须同比提升训练与推理成本。MoE 打破这一绑定:总参数 决定模型容量与显存占用,激活参数 决定每 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 稠密扩展的成本结构

设一层内注意力与前馈的参数分别为 与 (),序列长度为 。每 token 每层的浮点运算次数为

除以 得每 token 的 。当 时前馈占主导,当 时注意力占主导。参数量为每层 乘以层数 ,与 无关。

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

2 MoE 层的结构

MoE 层用 个专家替换单个前馈子层。对第 个 token,门控先给出 个 logits 与概率:

softmax 沿专家维进行,即固定 ,对 归一化。随后选出概率最大的 个专家:

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

三个式子的形状依次为:, 含 个互不相同的下标,。每个专家 的输出维度必须与 相同,才能与残差相加。

写成矩阵形式更容易看清计算量。构造稀疏矩阵 ,每行只有 个非零元,第 行为 ,则

其中 表示对每个专家分别作用于分配到它的 token 子集。实际实现不构造该三维张量,而是按专家分组后做 次小批量矩阵乘法。每 token 的前馈乘加次数由稠密情形的一个 变为 个,即

门控本身只增加 次乘加,占每 token 计算的比例为 ,在 时可忽略。

3 稀疏激活比

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

其中 为所有 token 都经过的参数(嵌入、注意力、归一化、门控), 为全部专家的参数之和。当专家参数占绝对多数时 。Switch Transformer 的 top-1 取 ,;Mixtral 取 ,;DeepSeek-V3 取 ,。

模型每 token FLOPs
Llama-2 70B(稠密)70B70B1.00
Mixtral 8x7B46.7B12.9B0.28
DeepSeek-V3671B37B0.055

只描述计算,不描述显存。全部专家参数仍要驻留显存,因此 MoE 的显存占用由 决定,与稠密模型按同一公式计算:bf16 下 46.7B 参数需 GB,超过单张 80 GB 加速卡的容量,必须跨设备切分。

4 容量因子、溢出与丢弃

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

设每个 token 有 个选择,则全部专家收到的分配总数为 ,平均每个专家 。容量取

其中 为容量因子。Switch Transformer 的 top-1 使用 , 取 至 ;GShard 的 top-2 使用 ,相当于 时 。两种写法口径不同:前者以 为基准,后者已把 乘进基准。若统一按 表述,Switch 的 就是实际余量,而 GShard 在 top-2 下的余量为 1,没有额外缓冲。

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

时的丢弃量可以估算。设路由近似独立均匀,单个专家收到的 token 数服从二项分布 ,其均值为 ,标准差为

超出容量的期望量约为 ,其中 为标准正态密度。取 、、,则 ,每个专家平均丢弃约 个分配,八个专家合计约 125 个,占全部分配 的 0.8%。把 提到 1.25 后容量为 ,距均值 13 个标准差,丢弃可忽略。这解释了为何 通常取略大于 1 的小值:容量按最坏情况设置会浪费显存,按均值设置会稳定丢弃。

5 负载均衡损失

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

Switch Transformer 采用的形式为

其中 是首选项为专家 的 token 占比, 是专家 的平均路由概率, 通常取 。 由硬计数得到,不含梯度; 由 softmax 输出得到,含梯度。该项在 与 都为均匀分布时取值

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

对 logits 求梯度可以看出它如何起作用。记 为第 个 token 的 logits, 为其 softmax 分量,则

其中 在 时为 1、否则为 0。代入得

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

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

其中 为分配给专家 的 token 数, 为 token 总数, 为专家 收到的平均门控值。两式的求和项相同,缩放因子相差 (不含各自的系数),因此系数不能跨实现直接照搬:把 Switch 的 直接用于 GShard 形式,等效强度会相差 倍。

早期工作(Shazeer 等,2017)使用变异系数平方的形式:

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

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

6 路由坍缩

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

用两个专家的情形说明该反馈为何稳定。设专家 1、2 的 logits 差为 ,则 ,。若数据分布使 增大能降低语言建模损失,则梯度会持续推高 ;均衡损失能提供的修正量只有 量级,且随 一同缩小。当 较大时 ,softmax 饱和,两个方向的梯度都趋于零,系统停在被锁定的分配上。这正是辅助损失系数、路由精度与初始化会显著影响结果的原因。

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

7 Switch Transformer:top-1 与工程改进

Switch Transformer 把路由简化为 :

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

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

  • 容量因子取 至 ,在负载波动与显存之间折中。
  • 辅助损失系数 ,与上文公式配套。
  • 选择性精度(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 由两个专家共同处理,权重为对应的门控值。其容量取 ,即按平均负载设置、不留额外余量。训练在 600B 参数、 的规模上进行,配合专家并行与组级调度: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 层,,8 个专家,,专家内部隐藏维 ,采用 SwiGLU 门控前馈(三个矩阵),注意力为 32 个查询头、8 个 KV 头的分组查询注意力,词表 32000,上下文长度 32768。

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

八个专家合计 。注意力部分:查询与输出投影各 ,键与值投影各 (8 个 KV 头,每头 128 维),合计

于是每层参数约 ,32 层为 ,加上词嵌入与输出头 与各层路由矩阵,总量约 ,与论文给出的 46.7B 一致。

激活参数按每 token 经过 2 个专家计算:每层 ,32 层为 ,加词嵌入与输出头约 ,与论文的 12.9B 一致(差额来自路由与归一化参数)。

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

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

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

10 专家并行与 all-to-all

当 超过单设备容量时,最直接的切分方式是把专家分散到不同设备,即专家并行。设 EP 组有 个设备,每个设备持有 个专家。一次 MoE 前向包含两次 all-to-all:

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

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

取 Mixtral 的 、、、每批 个 token,则每层通信量约为 字节即 256 MiB,32 层合计约 8 GiB。同期每层专家计算的浮点运算量为 ,在 300 TFLOPS 的有效吞吐下约需 19 ms,而 256 MiB 在 100 GB/s 的互联上约需 2.7 ms。通信占比约一成,但这一比例对 、互联带宽与并行度高度敏感: 越小,通信的相对开销越大,因此 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,是针对性修复:门控的参数量只有 ,用 fp32 计算它的代价可以忽略,而专家的大矩阵乘仍用 bf16。

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

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

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

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

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

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

关键直觉

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

例子与代码

例 1 手算一个 top-2 MoE 层

取 个 token、 个专家、、。门控 logits 给定为

先按行做 softmax。第一行分母 ,得 。四行结果为

取每行最大的两个分量,并在两者上重新归一化。第一行选专家 0 与 1,,另一个为 。四行的路由结果为

token选中专家归一化权重
00, 10.7311, 0.2689
11, 20.8808, 0.1192
20, 20.5498, 0.4502
32, 00.8176, 0.1824

容量为 。按 token 顺序分配:专家 0 收到 token 0、2、3 的三个分配,只保留前两个,token 3 的 0.1824 被丢弃;专家 1 收到 token 0、1 两个,全部保留;专家 2 收到 token 1、2、3 三个,只保留前两个,token 3 的 0.8176 被丢弃。于是

token 3 的两个分配都被丢弃,它在本层的输出为零向量。若把 提到 1.0,容量变为 ,三个专家都容得下全部分配,丢弃数为 0。

负载均衡损失按首选项统计:专家 0 被 token 0、2 首选,专家 1 被 token 1 首选,专家 2 被 token 3 首选,故 ;平均概率 ;于是

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

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

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

# 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())}")

预期输出(权重固定,两次运行结果一致):

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

输出解读如下。

第一行给出容量。,即每个专家最多接收 4 个分配。

t6 行是两个关键现象的交汇点。它的首选项是专家 0(权重 0.512),次选项是专家 1(0.488)。专家 0 按 token 顺序收到 t0、t1、t4、t5、t6 五个分配,容量为 4,于是 t6 的首选项被丢弃,kept=1。此时该 token 在本层只收到 ,权重和为 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,原因是 集中在专家 0,而 相对平坦, 与 的乘积被推高。注意 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,路由分布被 缩放, 与 的含义同时失效。

易错点

以下六条均可在代码或推导中直接检验。

1. softmax 维度取错。 中 softmax 沿专家维进行,即对形状 的张量取 dim=-1。写成 dim=0 或 dim=-2 时形状仍然合法,但归一化发生在 token 之间:每个专家的概率和为 1,单个 token 的概率和变为 量级, 与 的尺度同时错掉,辅助损失不再有均衡作用。

2. top-k 权重未归一化。 时若直接使用 ,选中权重之和小于 1 且随 token 波动,输出幅度不可控。GShard 直接使用门控值,Mixtral 在选中集合上重新归一化,两种约定不能混用;混用时同一模型内的输出尺度不一致。

3. 容量口径与取整。容量必须用 向上取整,用整除或向下取整会低估容量并在边界处多丢分配。口径上要区分 (Switch,top-1)与 (统一按分配总数归一):top-2 时用前者的公式等于把容量减半。此外容量计算必须在整个批次上做,不能按单条序列做,否则容量随序列长度变化。

4. 辅助损失系数与归一化。Switch 的 已含因子 ,再乘一次 会把均衡强度放大 倍;GShard 的 与它相差 ,系数不能跨实现照搬。 必须视作常数(stop-gradient),否则梯度会尝试修改计数而不是概率。该损失在均匀分布时取 1,不以 0 为下界,不能用"损失接近 0"判断均衡。

5. 专家并行的 all-to-all 与容量截断不一致。分发与合并两次通信依赖同一份路由结果,截断决策必须在所有 rank 上一致:若各设备按本地随机数或本地顺序截断,同一个 token 在分发与合并时的分配集合不同,合并阶段索引错位或权重相加错误。分发前还需按专家排序并记录逆排列,否则合并无法还原 token 顺序。

6. 用低精度计算门控并直接 argmax。bf16 的 8 位尾数使接近的 logits 在舍入后交换次序,路由在训练中出现不可复现的跳变,损失随之出现尖峰。门控的参数只有 ,应在 fp32 下计算 softmax 与路由,再把概率转回 bf16 参与加权。

关联笔记

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

达标检测

  • [ ] 写出 、 与 三式,标注每一步的张量形状,并说明为何 softmax 必须沿专家维进行。
  • [ ] 由 的形状 推导门控的每 token 乘加次数,并证明它占 MoE 层计算的比例为 量级。
  • [ ] 独立核算 Mixtral 8x7B 的每层专家参数量、总参数与激活参数,说明 46.7B 与 12.9B 分别由哪些部分组成。
  • [ ] 给定 、、、,计算容量,并用二项分布近似估算总丢弃分配数;再说明 时该估计为何降到可忽略。
  • [ ] 推导 ,解释括号两项的含义,并说明梯度幅度正比于 为何会削弱对已坍缩专家的修正。
  • [ ] 运行例 2 的代码,解释 t6 的 kept=1 与权重和 0.4875 的来源;把 capacity_factor 改为 0.5 后说明 zero_tokens 从 0 变为 4 的原因。
  • [ ] 估算 Mixtral 在 EP=8、、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 节的 辅助损失、第 7 节的 top-1 路由与选择性精度等工程改进。
  • Lepikhin et al., "GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding", arXiv:2006.16668, 2020 —— 对应第 8 节的 top-2 路由、容量 、组级调度与 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 节前馈子层的形状约定与残差连接位置,用于对照专家网络与稠密前馈的结构关系。