把一座美食广场看作一个大模型：几十个摊位各怀绝技——川菜摊位会做辣，面食摊位会扯面，甜品摊位会拉丝。顾客（token）走进广场，不可能把每个摊位的菜都尝一遍，也不能全都扔给同一个大师傅；这时候门口那位手持排号机的经理（Router）就派上了用场。他飞快扫一眼顾客的需求，从几十个摊位里挑出最拿手的两位，把单子派过去，同时还得看着哪家排队太长、哪家闲着没事，偶尔故意给冷门摊位塞几单。这套“点餐调度”系统，就是MoE（混合专家）里的专家路由机制。 本文会用这个美食广场的比喻，讲透MoE路由的完整链路：为什么需要混合专家、路由器如何打分、Top-k怎么选人、训练时为什么加噪声、负载均衡损失怎么算、容量因子怎么设。读完你不仅知道每个旋钮拧向哪里，还能理解它们为什么存在。

岗位关联

对AI从业者而言，如果把MoE看作大模型的“降本增效神器”，路由就是它的方向盘。掌握路由机制和调参手感，是设计与优化大规模稀疏模型的核心竞争力。

目录
  1. 可视化演示
  2. 背景与动机
  3. 路由器设计
  4. Top-k路由
  5. 噪声路由
  6. 负载均衡损失
  7. 容量因子与丢弃
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

背景与动机

单个饭店再厉害，也不可能把川、鲁、粤、淮扬菜全都做到极致。一个主厨的精力、灶台数量、备菜空间都有限。现实中的解法，是开一个美食广场，让不同摊位各专精一域；模型世界也一样——把超大规模神经网络拆成一个“总店长加多个专家”的结构，这就是混合专家（MoE）的由来。

假设我们只有一个稠密模型，把所有知识都塞进同一组参数。每来一个token，它都要激活全部神经元，计算量随参数规模线性膨胀，训不动也跑不起。MoE的想法很直接：准备 $N$ 个专家网络，每个专家只负责一种“菜系”；输入一个token时，由路由器选择其中少数几个专家参与计算，其余专家什么都不用做。这样单个token的计算量大大下降，但模型总参数量还可以继续扩——这就是“稀疏激活”的秘密。

回到美食广场的比喻：过去一位大厨累死累活做满汉全席；现在改成几十个专业摊位，顾客只挑两三家。MoE 用架构上的“分工”，换来了大模型训练和推理上的“减负”。

y=∑i=1Ngi(x)⋅ei(x)\displaystyle y=\sum_{i=1}^{N} g_{i}(x)\cdot e_{i}(x)
这个公式是说：token x 的最终输出，是 N 个专家各自输出的加权和。但大多数权重 g_i(x) 是0，只有少数专家真正参与了计算。
  1. 专家输出 $e_i(x)$第 i 个专家网络对输入 x 的变换结果，相当于某个摊位做出来的菜。
    ei(x)=FFNi(x)\displaystyle e_{i}(x)=\mathrm{FFN}_{i}(x)
  2. 路由权重 $g_i(x)$路由器给第 i 个专家分配的权重，决定这道菜按多大比例算进最终结果。
    gi(x)∈[0,1],∑i=1Ngi(x)=1\displaystyle g_{i}(x)\in[0,1],\quad \sum_{i=1}^{N}g_{i}(x)=1
  3. 加权求和 $\sum$把所有被选中的专家输出累加起来，得到当前 token 的最终输出。
    y=∑i∈激活集合gi(x)⋅ei(x)\displaystyle y=\sum_{i\in \text{激活集合}}g_{i}(x)\cdot e_{i}(x)

路由器设计

美食广场的经理要派单，得先判断顾客的需求：顾客说“想吃辣”，他脑子里立刻给川菜馆打9分、湘菜馆打8分、甜品店打1分；顾客说“想吃甜的”，分数又反过来。路由器就是模型里的这位经理，它对每个 token 打一套分数，分数越高，代表这个专家越适合处理该 token。

路由器本质上是一个可学习的门控网络。它先把 token 的表征向量 x 分别与每个专家的权重向量做内积，得到“匹配分”，再套一层 softmax，把所有分数压成总和为1的概率分布。这样既保留了“谁更合适”的排序信息，又方便后续做加权组合和均衡损失计算。

经理不会因为“觉得川菜好”就直接拍板，他要看具体顾客；路由器也要通过训练，学会把不同的 token 映射到不同的专家集合。这个打分器，是整个路由机制的心脏。

gi(x)=softmax(Wi⊤x+b)\displaystyle g_{i}(x)=\mathrm{softmax}\left(W_{i}^{\top}x+b\right)
每个专家对应一个打分器：内积衡量 x 与专家“口味”的匹配度，加偏置相当于经理的个人偏好，softmax 把一组原始分变成像“支持率”一样的概率值。
  1. 线性打分 $W_i^{\top}x$token 向量 x 与第 i 个专家的权重向量做内积，得到相似度分数。
    scorei=Wi⊤x\displaystyle \text{score}_{i}=W_{i}^{\top}x
  2. 加偏置 $+b$为第 i 个专家加一个可学习偏置，相当于经理对某些摊位有基础偏爱。
    zi=Wi⊤x+bi\displaystyle z_{i}=W_{i}^{\top}x+b_{i}
  3. Softmax 归一把 N 个分数转成和为1的概率，便于解释成“分给各摊位的订单比例”。
    gi(x)=ezi∑j=1Nezj\displaystyle g_{i}(x)=\frac{e^{z_{i}}}{\sum_{j=1}^{N}e^{z_{j}}}

Top-k路由

如果经理把订单平均发给所有摊位，每家做一口，顾客什么都吃不到；如果把订单只发给最对口的一家，万一这家手艺波动或者宕机，顾客就得饿着。所以经理通常选择“Top-2”：把单子给得分最高的两三家摊，其他摊位就当没这回事，也别来问。

Top-k 路由的思想完全一致：路由器照样给 N 个专家都算出分数，但最终只保留分数最高的 k 个专家，其余专家的门控权重直接置零。这样模型进入“稀疏”状态——大部分专家对这个 token 完全不参与计算，只有被选中的少数专家才真正跑前向和反向。

为什么大家偏爱 Top-2 而不是 Top-1？因为 Top-2 相当于让两个专家“打配合”：一个主打、一个兜底，模型训练时梯度信息也更丰富；Top-1 计算量最小，但容易把“宝”押错，训练也不稳。美食广场经理的智慧，就是永远留一个备胎摊位。

gi(x)={gi(x),i∈TopK({gj(x)}j=1N)0,其他\displaystyle g_{i}(x)=\begin{cases} g_{i}(x), & i\in\mathrm{TopK}(\{g_{j}(x)\}_{j=1}^{N})\\ 0, & \text{其他}\end{cases}
Top-k 像一个硬性选举规则：票数最高的前 k 个专家当选，其他人哪怕得了第二名也落选。当选后权重才会保留，落选者权重直接清零，不参与计算。
  1. TopK 集合对所有专家的概率排序，取前 k 个下标构成集合。
    TopK(⋅)=arg max⁡i∈{1,…,N}gi(x) 取前 k 个\displaystyle \mathrm{TopK}(\cdot)=\operatorname{arg\,max}_{i\in\{1,\dots,N\}}g_{i}(x)\ \text{取前 }k\ \text{个}
  2. 条件保留i 在集合内就保留原权重，不在就置0。
    gi(x)←gi(x)⋅1(i∈TopK)\displaystyle g_{i}(x)\leftarrow g_{i}(x)\cdot \mathbf{1}(i\in\mathrm{TopK})
  3. 重新归一有的实现还会把保留的 k 个权重再归一化一次，保证和为1。
    g~i(x)=gi(x)∑j∈TopKgj(x)\displaystyle \tilde{g}_{i}(x)=\frac{g_{i}(x)}{\sum_{j\in\mathrm{TopK}}g_{j}(x)}

噪声路由

如果经理永远只把单子派给网红摊位，冷门摊位就会永远没客，慢慢倒闭，而网红摊位排队过长，体验也变差。为了探索，经理偶尔会故意把几张单子派给冷门摊位试试看——说不定那家手艺人其实很厉害，只是没人发现。

MoE 训练中也怕这种“马太效应”：路由器刚学会偏爱某几个专家，就把所有 token 都往那儿塞，导致其他专家梯度不足、永远学不好。解决办法，是在训练时的门控分数上加高斯噪声：让分数带有随机性，原本排名靠后的专家也有机会被选进 Top-k，从而获得训练信号。推理时再关掉噪声，用真实分数做派单。

噪声路由是训练期的“探索策略”。它让冷门专家也能分到订单、学到本事，避免专家退化。等模型训练完，经理已经掌握了各摊位的真实水平，再把随机扰动全关掉，安安稳稳地凭实力派单。

g^i(x)=gi(x)+εi,εi∼N(0,σi)\displaystyle \hat{g}_{i}(x)=g_{i}(x)+\varepsilon_{i},\qquad \varepsilon_{i}\sim\mathcal{N}(0,\sigma_{i})
这相当于给每个专家的得分加一个微量的随机扰动。得分差一点儿的专家，偶尔会被“推”进前 k 名；噪声的幅度 σ_i 由模型自己学习，太大会破坏判断，太小则探索不足。
  1. 原始得分 $g_{i}(x)$无噪声时的门控概率，代表模型当前的判断。
    gi(x)=softmax(Wi⊤x+b)\displaystyle g_{i}(x)=\mathrm{softmax}\left(W_{i}^{\top}x+b\right)
  2. 噪声项 $\varepsilon_{i}$从均值为0、方差为 σ_i 的高斯分布中采样一个随机值。
    εi∼N(0,σi)\displaystyle \varepsilon_{i}\sim\mathcal{N}(0,\sigma_{i})
  3. 加噪后的结果把噪声叠加到原始得分上，再进行 Top-k 和归一化。
    g^i(x)=softmax(Wi⊤x+b+εi)\displaystyle \hat{g}_{i}(x)=\mathrm{softmax}\left(W_{i}^{\top}x+b+\varepsilon_{i}\right)

负载均衡损失

美食广场最怕的就是：某家店排队100米，隔壁却空无一人。顾客饿着肚子等，摊位老板也亏租金。经理必须用一盘棋的眼光，时刻盯住各家订单比例，必要时主动把单子拨给空闲摊位，哪怕它做菜不是最顶尖的。

MoE 模型也一样：如果没有约束，路由器很容易把大多数 token 都派到同一个专家，造成专家崩溃。训练时这些热门专家过载，冷门专家学不到任何东西。为了解决这个问题，论文中提出负载均衡损失（Auxiliary Loss），它是主损失之外的一个辅助惩罚项，衡量“各专家接单是否均匀”。专家接单占比 f_i 与路由器平均概率 p_i 的乘积越小，分配越均匀。

回到比喻：负载均衡损失就是经理的“绩效指标”。他不只看顾客满不满意，还要看每个摊位的利用率。既要保证网红大厨不累死，也要让家常菜师傅有活干，整个广场才能长久运转。

Laux=α⋅N⋅∑i=1Nfi⋅pi\displaystyle \mathcal{L}_{\text{aux}}=\alpha\cdot N\cdot\sum_{i=1}^{N}f_{i}\cdot p_{i}
这个损失像一张“排班表检查单”：f_i 是第 i 个专家实际接了多少单的比例，p_i 是路由器给它的平均派单概率。两者乘积越大，分配越不均，模型就越要受罚。
  1. 频率 $f_{i}$本批次中，被路由到专家 i 的 token 数占 batch 总 token 数的比例。
    fi=分给专家 i 的 token 数batch 的总 token 数\displaystyle f_{i}=\frac{\text{分给专家 }i\text{ 的 token 数}}{\text{batch 的总 token 数}}
  2. 概率 $p_{i}$路由器对专家 i 的所有门控权重的平均值。
    pi=1T∑x∈batchgi(x)\displaystyle p_{i}=\frac{1}{T}\sum_{x\in \text{batch}}g_{i}(x)
  3. 惩罚求和 $\sum f_i p_i$均匀时 f_i 和 p_i 都接近 1/N，乘积最小；越不均匀，乘积越大。
    ∑i=1Nfipi≥1N\displaystyle \sum_{i=1}^{N}f_{i}p_{i}\ge \frac{1}{N}
  4. 系数 α控制均衡惩罚的分量，太小不管用，太大反而让每个 token 都平均分配到所有专家。
    α∈(0.001,0.01)\displaystyle \alpha\in(0.001,0.01)

容量因子与丢弃

每个摊位灶台有限，同一时间只能炒固定数量的菜。假设一分钟只能做三道菜，经理硬派五单，后两单就只能干等，前面的菜也凉了。为了避免这种情况，经理会给每个摊位设定“容量上限”，并且按经验把上限定得比理论平均值高一些——这就是容量因子。

在 MoE 中，一个专家在同一批次里能处理的 token 数量是有上限的。如果超过上限，超出的 token 就无法由该专家计算，只能被丢弃，或者在实现中选择落回其他专家。容量上限的公式如下：

容量因子调参的直觉：CF 设小，计算效率高，但溢出 token 多，信息丢失严重；CF 设大，几乎没有溢出，但每个专家都要处理更多 token，训练速度变慢。实际工程中，通常看“丢弃率”这个指标——如果丢弃率太高，就适当调大 CF；如果计算资源吃紧，就调小 CF。经理在“翻台率”和“顾客体验”之间找到一个平衡点。

C=⌈TN×CF⌉\displaystyle C=\left\lceil\frac{T}{N}\times \mathrm{CF}\right\rceil
其中 T 是 batch 内的 token 总数，N 是专家数，CF 是容量因子。如果把 T/N 看成“每个专家的平均接待量”，CF 就是经理给摊位预留的缓冲余量。
  1. 平均负载 $T/N$理想情况下，每个专家平均应该处理的 token 数。
    avg=TN\displaystyle \text{avg}=\frac{T}{N}
  2. 乘容量因子 $\times \mathrm{CF}$CF=1 时上限刚好等于平均值，任何不均衡都会导致溢出；CF>1 时留出缓冲，如 CF=1.25 意味着上限比平均值多25%。
    Craw=TN×CF\displaystyle C_{\text{raw}}=\frac{T}{N}\times \mathrm{CF}
  3. 向上取整 $\lceil\cdot\rceil$容量必须是整数，向上取整后得到实际容量上限。
    C=⌈TN×CF⌉\displaystyle C=\left\lceil\frac{T}{N}\times \mathrm{CF}\right\rceil

AI 应用场景

大模型推理服务的路由与吞吐调优

阶段：推理部署与性能优化

解决的问题：MoE 大模型（如 Mixtral 8×7B）虽然单个 token 只激活部分专家，但全部专家参数仍占满 GPU 显存。推理时如果路由不均，某些专家会成为热点，导致批处理排队，整体吞吐不稳定。传统稠密模型没有“容量”概念，直接把 MoE 当成稠密模型部署会遇到 OOM 和超时。

具体案例：在一个对话式 AI 产品的推理集群上，工程师监控每个专家被调用的次数，发现头两个专家承担了 60% 的流量。于是他们调大容量因子到 1.25，并对负载均衡损失加了更高的 α，重新微调路由，最终把 P99 延迟下降了 18%，专家利用率也更均匀。

推荐系统中的多专家路由模型

阶段：模型训练与特征建模

解决的问题：推荐场景中用户行为差异极大，用一个网络建模“逛、买、刷”三种行为，效果互相干扰。用 MoE 的思路，把不同的行为预测任务分给不同专家，由路由器根据用户当前行为特征自动派单。

具体案例：某电商推荐团队参考 MMoE 结构，设置 4 个专家网络和 1 个带噪声的 Top-2 路由器。训练中加负载均衡损失后，原本“什么任务都接”的万能专家承担的流量明显下降，长尾商品的曝光多样性提升了 12%。

分布式训练中的专家负载监控

阶段：分布式训练与调试

解决的问题：在大规模 MoE 训练中，专家通常被切分到不同 GPU 上。路由不均会导致跨卡通信量爆炸——所有 token 都涌向同一张卡，其他卡闲得发慌。靠人工看日志定位“哪张卡过载”效率极低。

具体案例：训练一个 MoE 语言模型时，训练框架每 100 步记录一次每个专家的 f_i 和丢弃率。发现某专家被丢弃 30% 的 token 后，工程师将容量因子从 1.0 提到 1.2，同时把 α 从 0.001 提到 0.005，训练损失重新稳定下降。

Python 演示

python70 行
import mathimport random def softmax(scores):    max_s = max(scores)    exps = [math.exp(s - max_s) for s in scores]    total = sum(exps)    return [e / total for e in exps] def top_k(probs, k=2):    # 返回概率最高的 k 个专家下标，生成 0/1 掩码    sorted_idx = sorted(range(len(probs)), key=lambda i: probs[i], reverse=True)    top = set(sorted_idx[:k])    return [1.0 if i in top else 0.0 for i in range(len(probs))] def route(input_vec, router_weights, k=2):    scores = []    for weights in router_weights:        # 线性打分：输入向量与专家权重做内积        s = sum(x * w for x, w in zip(input_vec, weights))        scores.append(s)    probs = softmax(scores)    mask = top_k(probs, k)    # 门控权重：概率乘掩码，落选专家直接为 0    return [p * m for p, m in zip(probs, mask)] def load_balance_loss(counts, avg_probs, alpha=0.01):    total = sum(counts)    n = len(counts)    loss = 0.0    for i in range(n):        f_i = counts[i] / total          # 专家 i 服务的 token 占比        p_i = avg_probs[i] / total       # 专家 i 的平均门控概率        loss += f_i * p_i    return alpha * n * loss def main():    random.seed(42)    # 3 个专家，每个专家的权重向量维度为 2    router_weights = [        [1.0, 0.1],        [0.1, 1.0],        [0.6, 0.6]    ]    tokens = [        [0.9, 0.1],   # token 1：偏“专家 1”口味        [0.2, 0.8],   # token 2：偏“专家 2”口味        [0.4, 0.6],   # token 3：中规中矩        [0.8, 0.3],   # token 4：偏“专家 1/3”口味        [0.3, 0.7]    # token 5：偏“专家 2/3”口味    ]     counts = [0] * len(router_weights)    avg_probs = [0.0] * len(router_weights)     print("token -> 路由权重 (Top-2)")    for vec in tokens:        g = route(vec, router_weights, k=2)        chosen = max(range(len(g)), key=lambda i: g[i])        counts[chosen] += 1        for i in range(len(g)):            avg_probs[i] += g[i]        print(vec, "->", ["%.2f" % v for v in g], "主专家:", chosen + 1)     loss = load_balance_loss(counts, avg_probs)    print("负载均衡损失:", round(loss, 4))    print("各专家接单数:", counts) if __name__ == "__main__":    main()
目的：演示一个迷你 MoE 路由器的完整流程——为每个 token 打分、softmax 归一化、Top-2 选择、统计专家负载并计算负载均衡损失。
  1. softmax(scores)把原始分数转成概率分布，方便比较和加权。
  2. top_k(probs, k)生成掩码，只保留得分最高的 k 个专家。
  3. route(input_vec, router_weights, k)完整的路由逻辑，返回每个专家的门控权重。
  4. load_balance_loss(counts, avg_probs)用 f_i×p_i 的乘积之和计算不均衡程度。
  5. chosen = max(...)模拟选择“主专家”做最终归类，方便统计负载。
  6. alpha * n * loss负载均衡损失最终要乘以系数和专家数，控制惩罚力度。

常见误区

误区以为路由器像人一样读懂了“猫”“狗”的含义，再决定把它们分给哪个专家。甚至有人觉得路由器内部一定有一份“专家特长对照表”。

正解路由器只是一组可学习的线性打分器。它不知道“喵星人”是什么，只知道这个 token 的表征向量和专家 3 的内积更大。它学到的“偏好”是嵌入空间里的相似性，不是人类的语义理解。就像美食广场经理看到“辣”字就派给川菜摊，他并不懂烹饪原理，只是经验让他知道这样配对通常不错。

为何常见：因为路由结果看起来很有“智能感”，人们习惯性地把语义理解能力投射到任何产生合理分配的系统上。

误区Top-1 只激活一个专家，计算量最小，所以应该是最优选择。Top-2 多算一个专家，纯属浪费。

正解Top-1 的数学期望虽然便宜，但训练噪音大、容错率低。一旦路由器打错分，token 就被“塞”给完全不适合的专家，梯度也缺少其他专家的“纠偏”。Top-2 的额外计算量通常可以让训练更稳定，模型质量也更好。这就像经理只派一个摊位，万一这家今天发挥失常，顾客就只能饿肚子。

为何常见：很多人只看到 Top-2 多了一次前向计算，没看到它换来的训练稳定性和最终效果提升。

误区容量因子 set 到 2.0 甚至更高，让每个专家都能容纳很多 token，这样几乎不会有溢出，信息不会丢，肯定比 CF=1 好。

正解容量因子越大，专家处理 token 的批长度就越长，padding 和排队等待的时间也越多。模型虽然没丢信息，但训练速度大幅下降，带来隐性成本。实际调参要看“丢弃率”——如果丢弃率很低，就没有必要继续增大 CF。经理可以把备用灶台全租下来，但租金和浪费也是成本。

为何常见：容量因子的作用非常直观（越大越不丢数据），让人忽略了它对计算效率和显存占用的反向影响。

误区把 α 调得很大，让负载均衡损失趋近于 0，让每个专家都平均接单，这样就完美解决了专家崩溃问题。

正解负载均衡损失只是辅助正则项，不是训练目标本身。强行把它压到极低，会迫使路由器无视 token 的真实倾向，把单子平均分给所有专家，导致每个专家都变成“半吊子”，模型整体效果大跌。理想状态是“必要的不均衡”——高手多干活，庸手有活干。

为何常见：看到损失函数的曲线下降，容易默认“越低越好”，忽略了辅助损失与主损失之间的对抗关系。

误区既然噪声让训练效果更好，那推理时也保留噪声，模型会不会更鲁棒？

正解推理时加噪声会让路由结果随机抖动，同一个 token 两次可能被分给不同的专家，输出不稳定，推理性能也无法保证。噪声只是训练期的探索机制，推理时必须关闭，保证“按真实实力派单”。

为何常见：把训练的探索策略误解为推理的增强策略，忽略了训练与推理的一致性原则。

面试题

Q1. MoE 路由器最终输出的是什么？

单选题 · easy

  • A.经过 Softmax 的专家概率分布← 正确答案
  • B.未经归一化的原始匹配分数
  • C.随机抽取一个专家的 ID
  • D.所有专家输出的直接相加

答案：A。路由器先对各专家打分，再用 Softmax 把分数归一化为总和为 1 的概率分布，后续的 Top-k 和加权求和都依赖这个分布。B 缺了归一化，C 是随机策略，D 是稠密模型的加法，均不符合路由器设计。

Q2. MoE 中最常用的 Top-k 路由策略，k 值通常是？

单选题 · easy

  • A.k=1，只让一个专家处理
  • B.k=2，让两个专家协同处理← 正确答案
  • C.k=全部专家数，计算更充分
  • D.k=0，不做路由选择

答案：B。Top-2 是实践中最常用的配置，既保证稀疏性，又比 Top-1 更稳定。C 等于稠密模型，失去了稀疏激活的意义；D 完全没有专家被选中，无法工作。

Q3. 负载均衡损失公式中，N 表示什么？

单选题 · easy

  • A.专家总数← 正确答案
  • B.token 总数
  • C.训练步数
  • D.批次大小

答案：A。负载均衡损失对 N 个专家逐个统计 f_i 和 p_i，再求和后乘 N，因此 N 是专家总数。token 总数通常记为 T，批次大小与 N 无关，训练步数完全不参与该公式。

Q4. 下列哪些方法可以缓解 MoE 中的“专家崩溃”问题？

多选题 · mid

  • A.增加负载均衡损失← 正确答案
  • B.训练阶段加入噪声路由← 正确答案
  • C.无限增大容量因子
  • D.把 Top-k 改成 Top-全部，让所有专家都参与运算

答案：AB。负载均衡损失直接惩罚不均衡分配，噪声路由让冷门专家得到探索机会，两者都能缓解专家崩溃。增大容量因子只改变专家处理上限，并不能让冷门专家获得梯度；Top-全部等于稠密模型，既失去稀疏性，也没有解决“热门专家学得太快、冷门学不到”的问题。

Q5. 噪声路由中的高斯噪声应该在什么时候关闭？

单选题 · mid

  • A.训练阶段
  • B.验证阶段
  • C.推理阶段← 正确答案
  • D.数据预处理阶段

答案：C。噪声的目的是在训练中增加探索，让非 Top 专家有机会获得更新。训练结束后，模型已经学好了路由策略，推理时必须关闭噪声以保证输出稳定。验证阶段通常也应该关闭噪声，以获得可复现的评估指标。

Q6. 负载均衡损失中的 f_i 表示什么？

单选题 · mid

  • A.专家 i 被分配到的 token 占比← 正确答案
  • B.专家 i 的输出特征维度
  • C.专家 i 的总参数量
  • D.专家 i 的单个输出得分

答案：A。f_i 是频率项，等于分给专家 i 的 token 数除以 batch 总 token 数。输出维度、参数量、输出得分都与负载均衡损失无直接关系。f_i 与 p_i 的乘积之和反映了派单是否均匀。

Q7. 容量因子 CF 的主要作用是？

单选题 · mid

  • A.控制每个专家能处理的 token 上限← 正确答案
  • B.提高路由器的打分精度
  • C.增大模型的参数量
  • D.改变输入 token 的维度

答案：A。容量因子通过公式 C = ceil(T/N × CF) 决定专家容量上限。CF 越大，每个专家能容纳的 token 越多，溢出越少。它不参与路由打分，不改变参数量，也不影响 token 维度。

Q8. batch 中 token 总数为 1024，专家数为 8，CF=1.25，每个专家的容量上限是？

单选题 · hard

  • A.128
  • B.160← 正确答案
  • C.200
  • D.132

答案：B。先算平均负载 1024/8=128，再乘 CF=1.25 得 160，向上取整后仍是 160。128 是没有乘 CF 的基础值，200 是错误放大，132 是误加了 CF。容量上限直接决定了该专家最多能承接多少 token。

Q9. 下列对 MoE “稀疏激活”的描述，正确的有哪些？

多选题 · hard

  • A.单个 token 只激活部分专家，计算量减小← 正确答案
  • B.所有专家参数仍需要载入内存← 正确答案
  • C.所有专家参数都不占内存
  • D.稀疏激活后训练时间一定缩短

答案：AB。稀疏激活减少的是单 token 的 FLOPs，A 正确；但 MoE 的参数量分散在所有专家中，部署时仍要把全部参数载入内存，B 正确、C 错误。计算量降低不等于训练时间一定缩短，因为路由开销、通信开销和负载不均衡都可能拖慢训练，D 过于绝对。

Q10. 某专家已被分配到容量上限的 token，此时又有新 token 被路由到它，通常如何处理？

单选题 · hard

  • A.强行插入并把旧 token 挤出
  • B.溢出 token 丢弃或走备用路由← 正确答案
  • C.清零该专家所有参数
  • D.自动降低该专家的容量上限

答案：B。当专家容量已满，新到达的 token 无法进入计算，通常被丢弃，或实现中退回给路由器再走其他专家。A 会破坏已排队的 token，C 是自毁，D 会加剧溢出。工程上就是通过丢弃率指标来监测容量是否合理。