16. 前沿架构:MoE 混合专家 —— Router 与 top-k 手搓¶
大模型要更大但推理要更快?MoE(Mixture of Experts):把 FFN 换成 N 个专家(每个都是独立小 FFN), 一个 Router(门控) 给每个 token 选 top-k 个专家,稀疏激活:总参数量大、每次只算一部分。
- 密集模型:每个 token 过全部 FFN(计算量 = 参数量)
- MoE:总参数 3-8 倍大,但每个 token 只过 k 个专家 → 同样算力,容量大几倍
本讲按 minLLM model_minimind.py 的 MOEFeedForward(第 148-181 行)逐行手搓,并数值验证。
核心概念¶
(a) 🗂️ MoE:用 Router 让模型更大却算得更少¶
把 FFN 换成 N 个专家,Router 用门控分数取 top-k 稀疏路由——每个 token 只算 k 个专家,再用辅助损失防 Router 偏心,并对照 DeepSeek-V3 与 minLLM 的工程实现。
flowchart TB
A["💡 MoE 动机<br/>更大但推理更快"] --> B["🚪 Router 门控<br/>softmax(x·Wg)"]
B --> C["🎯 Top-k 稀疏路由<br/>每 token 只选 k 个"]
C --> D["🧠 专家 FFN<br/>N 个独立小网络"]
D --> E["⚖️ 输出加权<br/>Σ ĝᵢ·Eᵢ(x) 归一化"]
E --> F["📊 负载均衡<br/>aux loss 防偏心"]
F --> G["🏭 工程对照<br/>DeepSeek-V3/minLLM"]
- 💡 MoE 动机:模型要更大但推理要更快,用稀疏激活打破「参数全都要算」。
- 🚪 Router 门控:x 经线性层 + softmax 得到 N 个专家的门控分数。
- 🎯 Top-k 稀疏路由:每个 token 只选分数最高的 k 个专家参与计算。
- 🧠 专家 FFN:N 个独立的小 FFN,各自擅长不同类型的输入。
- ⚖️ 输出加权:选中专家的输出按归一化门控权重加权求和。
- 📊 负载均衡:aux_loss = α·N·Σ fᵢ·Pᵢ 惩罚 Router 偏心,保证专家利用率。
- 🏭 工程对照:对照 DeepSeek-V3 与 minLLM MOEFeedForward(L148-181)的「router + top-k」实现。
🕸️ 网络配图(Wikimedia Commons)
📷 来源:Wikimedia Commons · <a href="//commons.wikimedia.org/w/index.php?title=User:Nocodeing&ac…
1. MoE 数学¶
对输入 $x$,router 输出门控分数,softmax 后取 top-$k$:
$$g(x)=\mathrm{softmax}(xW_g)\in\mathbb{R}^{N}\ (N=\text{专家数}),\qquad y=\sum_{i\in \mathrm{topk}(g)}\frac{g_i}{\sum_{j\in \mathrm{topk}}g_j}\,E_i(x)$$
(top-k 权重归一化:norm_topk_prob,minLLM L161-166;k=1 时用 straight-through 技巧让门控仍可学。)
负载均衡辅助损失(minLLM L176-178,防止所有 token 都挤同一个专家):
$$\mathcal{L}_{aux}=\alpha\cdot N\cdot\sum_{i=1}^{N} f_i\,P_i,\qquad f_i=\frac{1}{T}\sum_t \mathbb 1[i\in \mathrm{topk}(g(x_t))]\ (\text{被选频率}),\quad P_i=\frac{1}{T}\sum_t g_i(x_t)\ (\text{平均门控})$$
✍️ §1.1 手算 MoE top-2 路由:3 个专家,两个被选中、权重归一化¶
MoE 输出 $y=\sum_{i\in\text{top-}k} g_i E_i(x)$——3 个专家算一遍 top-2,把"稀疏路由 + 权重归一化"变成数字。
设定:router 输出 logits $[1.0,\ 2.0,\ 0.5]$(对应专家 1/2/3),$k=2$。
第 1 步:softmax 门控分数($e^1=2.718,\ e^2=7.389,\ e^{0.5}=1.649$)
$$p=\left[\frac{2.718}{11.756},\ \frac{7.389}{11.756},\ \frac{1.649}{11.756}\right]=[0.231,\ 0.629,\ 0.140]$$
第 2 步:取 top-2 → 专家 2(0.629)与专家 1(0.231),专家 3(0.140)被丢弃。
第 3 步:top-2 权重归一化(让权重和为 1)
$$g_2=\frac{0.629}{0.629+0.231}=0.731,\qquad g_1=\frac{0.231}{0.629+0.231}=0.269$$
第 4 步:输出(专家 2 输出 1.5、专家 1 输出 0.8)
$$y=0.731\times1.5+0.269\times0.8=1.097+0.215=1.312$$
手算收获:
- 稀疏激活:3 个专家只有 2 个参与计算($k=2$),专家 3 的 FFN 完全不 forward——这就是"模型更大、算得更少"的来源
- 归一化必要:top-2 权重不归一化则输出尺度随 router 分数漂移;除以 top-2 分数和保证 $y$ 是凸组合(权重和为 1)
- top-2 相比 top-1 更平滑(两个专家取平均,路由错误影响减半)——DeepSeek-MoE 用 top-2 的原因
- 若 router 分数接近(如 [1.0,1.1,0.9]),softmax 权重接近 1/3——"专家偏心"就发生在分数差很大时(§2 负载均衡的 aux loss 就为此)
下面 numpy 复算。
# ---- §1.1 验证:numpy 复算 MoE top-2 路由 ----
import numpy as np
logits = np.array([1.0, 2.0, 0.5])
e = np.exp(logits)
p = e / e.sum()
print(f'softmax 门控 = {np.round(p, 4)}(手算 [0.231 0.629 0.140])')
assert np.allclose(p, [0.2312, 0.6285, 0.1402], atol=1e-3)
top_idx = np.argsort(p)[::-1][:2]
print(f'top-2 专家 = 专家{top_idx + 1}(索引 {top_idx})')
assert list(top_idx) == [1, 0]
g = p[top_idx]
g_norm = g / g.sum()
print(f'top-2 权重 = {np.round(g, 4)},归一化 = {np.round(g_norm, 4)}')
assert np.allclose(g_norm, [0.7311, 0.2689], atol=1e-3)
E = np.array([0.8, 1.5, 0.3])
y = (g_norm * E[top_idx]).sum()
print(f'y = {y:.4f}(手算 1.312)')
assert abs(y - 1.3117) < 1e-3
print('\n✓ 与手算一致:top-2 稀疏路由 + 权重归一化')
# ---- matplotlib 中文字体(防图内中文乱码)----
import matplotlib
matplotlib.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'Songti SC', 'Arial Unicode MS', 'DejaVu Sans']
matplotlib.rcParams['axes.unicode_minus'] = False
# -------------------------------------------
import numpy as np
import math
# ---- 手搓 MoE:4 个专家(小 FFN),top-k 路由 ----
d, N, k = 8, 4, 2 # 输入 8 维,4 个专家,每 token 选 2 个
rng = np.random.default_rng(0)
# 专家:每个是 2 层线性 + ReLU(8 -> 16 -> 8)
def make_expert():
return (rng.standard_normal((d, 16)) * 0.1, rng.standard_normal((16, d)) * 0.1)
experts = [make_expert() for _ in range(N)]
def expert_ffn(ex, x):
"""第 ex 个专家前向:ReLU(x W1) W2"""
W1, W2 = experts[ex]
return np.maximum(0, x @ W1) @ W2
def router_gate(x, Wg):
"""门控:softmax(x Wg) -> [T, N]"""
s = x @ Wg
s = s - np.max(s, -1, keepdims=True)
e = np.exp(s)
return e / e.sum(-1, keepdims=True)
# ---- 与 minLLM MOEFeedForward.forward 同构的前向 ----
def moe_forward(x, Wg, k):
"""x: [T,d] -> y: [T,d](每 token 只过 top-k 专家,权重归一化)"""
scores = router_gate(x, Wg) # [T,N] 门控分数
idx = np.argsort(-scores, axis=1)[:, :k] # top-k 专家索引 [T,k]
w = scores[np.arange(len(x))[:, None], idx] # top-k 权重 [T,k]
w = w / (w.sum(-1, keepdims=True) + 1e-20) # norm_topk_prob:权重归一化
y = np.zeros_like(x)
for i in range(N): # 每个专家处理被选中的 token
mask = (idx == i).any(-1)
if mask.any():
w_i = w[mask] * (idx[mask] == i) # 只保留选择专家 i 的权重列
y[mask] += expert_ffn(i, x[mask]) * w_i.sum(-1, keepdims=True)
return y, scores
# ---- 与"全专家加权"对照:手选专家 = 显式逐专家计算 ----
def moe_manual(x, Wg, k):
"""对照实现:等价于 MoE 前向,用于数值验证。"""
scores = router_gate(x, Wg)
idx = np.argsort(-scores, axis=1)[:, :k]
w = scores[np.arange(len(x))[:, None], idx]
w = w / (w.sum(-1, keepdims=True) + 1e-20)
y = np.zeros_like(x)
for t in range(len(x)):
y[t] = sum(w[t, j] * expert_ffn(i, x[t:t+1])[0] for j, i in enumerate(idx[t]))
return y
Wg = rng.standard_normal((d, N)) * 0.2 # router 权重 [8,4]
X = rng.standard_normal((6, d)) # 6 个 token
y_moe, scores = moe_forward(X, Wg, k)
y_manual = moe_manual(X, Wg, k)
err = float(np.abs(y_moe - y_manual).max())
print(f'MoE 前向 vs 手动逐专家加权:最大差 = {err:.2e}')
assert err < 1e-10
print('一致 -> PASS(每个 token 确实只由 top-2 专家加权输出)')
MoE 前向 vs 手动逐专家加权:最大差 = 2.78e-17 一致 -> PASS(每个 token 确实只由 top-2 专家加权输出)
2. 负载均衡:router 会不会"偏心"?¶
def aux_loss(idx, scores, N, alpha=0.01):
"""minLLM L176-178:aux_loss = alpha * N * sum(f_i * P_i)
f_i = 被选中频率(one_hot 平均),P_i = 平均门控分数。"""
T = len(idx)
load = np.zeros(N)
for i in range(N):
load[i] = (idx == i).sum() / T # 被选频率 f_i
P = scores.mean(0) # 平均门控 P_i
return alpha * N * float((load * P).sum()), load
def router_gate_bias(x, Wg, b):
"""门控(带专家偏置 b,方便演示确定性偏心):softmax(x Wg + b) -> [T, N]"""
s = x @ Wg + b
s = s - np.max(s, -1, keepdims=True)
e = np.exp(s)
return e / e.sum(-1, keepdims=True)
# 三种 router:均匀 / 偏心(每 token 固定偏爱专家 0)/ 随机
Wg_u = rng.standard_normal((d, N)) * 0.01; b_u = np.zeros(N)
Wg_b = rng.standard_normal((d, N)) * 0.1; b_b = np.array([0.6, 0.0, 0.0, 0.0])
Wg_r = rng.standard_normal((d, N)) * 0.3; b_r = np.zeros(N)
XB = rng.standard_normal((200, d)) # 200 个 token(样本量够,结果稳定)
print('router 选择分布(200 token,top-2):')
losses = {}
for name, Wg_, b_ in [('均匀', Wg_u, b_u), ('偏心(偏爱专家0)', Wg_b, b_b), ('随机', Wg_r, b_r)]:
s = router_gate_bias(XB, Wg_, b_)
idx = np.argsort(-s, axis=1)[:, :2]
loss, load = aux_loss(idx, s, N)
losses[name] = loss
use = 100 * load / load.sum()
print(f' {name:14s} 专家使用率 {[f"{u:.0f}%" for u in use]} aux_loss = {loss:.5f}')
assert losses['均匀'] < losses['偏心(偏爱专家0)'] and abs(losses['均匀'] - 0.02) < 1e-3
print('均匀 router 的 aux_loss ≈ 理论下界 0.02,偏心 router 更高 -> PASS(负载均衡损失惩罚“偏心”)')
router 选择分布(200 token,top-2): 均匀 专家使用率 ['24%', '25%', '27%', '24%'] aux_loss = 0.02000 偏心(偏爱专家0) 专家使用率 ['50%', '19%', '18%', '12%'] aux_loss = 0.02347 随机 专家使用率 ['24%', '27%', '22%', '28%'] aux_loss = 0.02013 均匀 router 的 aux_loss ≈ 理论下界 0.02,偏心 router 更高 -> PASS(负载均衡损失惩罚“偏心”)
%matplotlib inline
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False
# 图1:3 个 router 的专家使用率(均衡度对比)
fig, ax = plt.subplots(figsize=(8, 4.4))
names = ['均匀', '偏心\n(偏爱专家0)', '随机']
usages = []
for name, Wg_, b_ in [('均匀', Wg_u, b_u), ('偏心', Wg_b, b_b), ('随机', Wg_r, b_r)]:
s = router_gate_bias(XB, Wg_, b_)
idx = np.argsort(-s, axis=1)[:, :2]
load = np.array([(idx == i).sum() for i in range(N)])
usages.append(100 * load / load.sum())
xx = np.arange(N); w = 0.25
colors = ['#4C72B0', '#C44E52', '#55A868']
for j, (name, u) in enumerate(zip(names, usages)):
ax.bar(xx + (j - 1) * w, u, w, label=name, color=colors[j])
ax.set_xticks(xx); ax.set_xticklabels([f'专家 {i}' for i in range(N)])
ax.set_ylabel('被选中频率 (%)'); ax.legend(fontsize=9)
ax.set_title('top-2 路由下的专家使用率(理想:每专家 ~50%)', fontsize=12)
ax.axhline(50, color='k', ls='--', lw=1, alpha=0.5)
plt.tight_layout(); plt.show()
3. 真实工程对照(minLLM + DeepSeek)¶
| 环节 | 本讲 | minLLM MOEFeedForward(L148-181) |
生产(DeepSeek-V3) |
|---|---|---|---|
| 路由 | 手搓 softmax + topk | gate = Linear(hidden, num_experts) + F.topk(k) |
细粒度专家 + 共享专家 |
| 归一化 | top-k 权重归一化 | norm_topk_prob(k>1 归一化;k=1 straight-through) |
同 |
| 聚合 | 逐专家 index_add | y.index_add_(0, token_idx, expert(x)*weight) |
同(GPU 高效实现) |
| 负载均衡 | 手搓 aux_loss | aux_loss = (load*scores.mean(0)).sum()*N*coef |
同 + 专家级平衡 |
| 容量 | 4 专家 top-2 | num_experts / num_experts_per_tok 配置 |
256 专家 top-8 |
MoE 的代价:显存随专家数线性涨(全部专家都要驻留),推理用 expert parallelism;路由不平衡会浪费专家容量——所以 aux_loss 是标配。MiniMind 提供 use_moe 开关:同一个模型可以一键切成 MoE 版本(隐藏 FFN,加路由)。
总结¶
- MoE = N 个专家 + Router 稀疏路由:$y=\sum_{i\in\mathrm{topk}} \hat g_i E_i(x)$,每个 token 只算 top-k。
- 数值验证:MoE 前向与手动逐专家加权完全一致(<1e-10)。
- 负载均衡 aux_loss 惩罚偏心的 router(实验:均匀 router aux_loss 最低),防止专家浪费。
- minLLM 的
MOEFeedForward与本讲逐行对应;DeepSeek-V3 用 256 专家 + 细粒度/共享专家。
