大模型入门教程6 - 规模扩展、分组查询注意力(GQA)与稀疏混合专家(MoE)

#规模扩展、分组查询注意力(GQA)与稀疏混合专家(MoE)

系列导读:这个系列从 第一篇(从 Bigram 到 GPT-2) 开始,经过 第二篇(钢琴曲生成) 和 第三篇(算子加速与多模态),在 第四篇(分词器与位置编码) 与 第五篇(RMSNorm、SwiGLU 与 KV Cache) 里把单层 Transformer Block 逐步改成了主流开源模型的结构。但第五篇最后跑出来的生成效果依然不好:模型在 0.92M Token 的小语料上反复背书,经常把不同法条拼在一起,或者陷入人名复读。这一篇我们先不改模型代码,把模型和数据规模一起放大,跑出一个 97.54M 参数的新基线(6.1),再在这个基线上依次实验 分组查询注意力(GQA) 和 稀疏混合专家(Sparse MoE)。


#1. 先把基线做大:两次扩规模尝试

回到第五篇结尾的 5.3 模型,当时有两个明显的瓶颈,没法直接拿来试 GQA 和 MoE:

  1. 语料太小,模型在“背书”而不是学语言:训练集只有约 0.92M(918K)个法律文本 Token,跑 2,000 步相当于把同一批文本反复背了近 36 遍,训练 Loss 掉到了 0.899,验证 Loss 却反弹到 4.203,生成文本到处是条文嫁接和复读。如果在这样的数据集上直接上参数量翻几倍的 Sparse MoE,只会过拟合得更厉害。
  2. 模型太袖珍,KV Cache 压力还没显现:12.19M 参数的模型只有 6 层、隐藏层维度 384、窗口 512,单条续写时 KV Cache 只有几 MiB,batch=16 下开启缓存也只提速了 1.66x。在这种体量下把 MHA 改成 GQA,很难直观看到显存和吞吐的变化。

所以在动模型结构之前,我们保持 5.3 的模型实现代码(GPT、Block、CausalSelfAttention、MLP、RMSNorm)一行不改,先把配置放大到接近 GPT-2 Small 的规格:

  • 模型规模:从 6 层、6 头、n_embd = 384、block_size = 512,放大到 12 层、12 头、n_embd = 768、block_size = 1024(SwiGLU 中间维度相应变为 $\frac{2}{3} \times 4 \times 768 = 2048$);
  • 分词器:改为在训练语料子集上(严格剔除验证集文档)训练 16,384(16K)词表的 Byte-Level BPE,总参数量来到 97.54M;
  • 数据集与训练配置:换成开源中文教育语料 opencsg/Fineweb-Edu-Chinese-V2.1 的高分筛选子集(4_5 目录,过滤掉不足 120 字符的短文本,每 20 篇文档留出 1 篇做验证集),开启 bfloat16 混合精度、torch.compile、线性预热加余弦学习率退火(Cosine Decay)以及梯度裁剪(1.0)。

为了跑通这个 97.54M 基线,我们先后试了两次。

#1.1 第一次尝试:Colab L4 + 131.07M Token(不背书了,但欠训练且太慢)

第一次我们在 Google Colab 的 NVIDIA L4(24 GiB 显存)上试跑。考虑到在线下载和单卡训练耗时,当时只拉取了前 51 个分片(87,640 篇文档,共 260.0M 字符),切分编码出 149.04M 训练 Token 和 8.11M 验证 Token。

受限于单卡显存和等待时间,我们设 micro_batch = 32、grad_accum = 2(每步 65,536 个 Token),峰值学习率设为较保守的 6.0e-4(100 步预热,余弦衰减到 6.0e-5),跑了 2,000 步,总训练量 131.07M Token(约为训练集长度的 0.88 倍):

跑完 2,000 步花了 2,991.7s(约 50 分钟,峰值显存 16.59 GiB):

step    1 (  37.2s) | lr=6.00e-06 | batch_loss=9.854 | train=9.794 | val=9.794
step  200 ( 339.1s) | lr=5.96e-04 | batch_loss=6.453 | train=6.470 | val=6.447
step  400 ( 633.9s) | lr=5.67e-04 | batch_loss=5.407 | train=5.463 | val=5.438
step  600 ( 928.9s) | lr=5.13e-04 | batch_loss=4.708 | train=4.808 | val=4.792
step  800 (1224.2s) | lr=4.38e-04 | batch_loss=4.507 | train=4.509 | val=4.509
step 1000 (1519.4s) | lr=3.52e-04 | batch_loss=4.316 | train=4.329 | val=4.341
step 1200 (1814.8s) | lr=2.64e-04 | batch_loss=4.005 | train=4.197 | val=4.219
step 1400 (2109.7s) | lr=1.82e-04 | batch_loss=4.170 | train=4.100 | val=4.133
step 1600 (2405.0s) | lr=1.17e-04 | batch_loss=4.062 | train=4.027 | val=4.070
step 1800 (2698.5s) | lr=7.46e-05 | batch_loss=3.914 | train=3.973 | val=4.028
step 2000 (2991.7s) | lr=6.00e-05 | batch_loss=3.806 | train=3.946 | val=4.004

好消息是没有再像第五篇那样过拟合。虽然 get_batch 是有放回地随机抽样,局部片段仍可能重复,但总训练量还不到训练集长度的一倍(0.88x),实测训练 Loss(3.946)和验证 Loss(4.004)全程贴得很紧。另外,模型变深变宽后,KV Cache 的加速效果也显现出来了:在 L4 上并发续写 512 个 Token(batch=64,缓存占用 1,181.2 MiB),无缓存要跑 76.485s(428.4 tok/s),开启缓存后降到 7.605s(4,309.0 tok/s,提速 10.06x;单条 batch=1 时仍只有 1.01x)。

坏消息是 生成质量依然很差,而且实在太慢了。

看两段第 2,000 步模型的续写就能明白问题出在哪:

输入 光合作用是植物、藻类和某些细菌利用光能:

光合作用是植物、藻类和某些细菌利用光能、光能、光能、光能和其他物质进行光合作用,使植物光合作用和光合作用发生化学反应,产生光合作用。 2、光合作用是植物光合作用的最主要机制 光合作用是植物光合作用的重要功能之一。 光合作用是植物光合作用中的主要形式。 光合作用是植物光合作用的最主要形式。

输入 在计算机科学中,操作系统的主要职责是管理:

在计算机科学中,操作系统的主要职责是管理操作系统中的软件、软件、软件、数据、数据等要素。 3.3 设计软件功能 设计软件功能包括软件的基本功能、软件的功能和应用程序……设计软件功能包括软件设计功能、设计软件设计功能、设计软件设计功能。

模型刚写几个词就开始原地打转(“光能、光能、光能”、“软件、软件、软件”)。算一下数据量就明白了:97.54M 参数的模型只喂了 131.07M Token,平均每个参数才分到 1.34 个 Token。作为对照,Chinchilla 在固定算力预算下给出的稠密模型经验配比大约在 20 Token/参数左右。当前训练量明显不够,再加上 6.0e-4 的学习率偏保守,跑完 2,000 步验证 Loss 还停在 4.004(困惑度 $\text{PPL} = e^{4.004} \approx 54.8$)。

更现实的阻碍是训练时间:在 L4 上跑 131.07M Token 就要 50 分钟;如果把训练预算放大 8 倍到 1B Token 以上,每跑一版模型都要将近 7 个小时,做多组对照实验太折磨了。

#1.2 第二次尝试(正式 6.1 基线):迁移到 B200 + 1.05B Token

为了解决欠训练和速度慢的问题,我们把实验环境迁到了更强大的显卡,并把数据准备与模型训练拆开:

  1. 语料扩大到 1.09B Token:先用便宜的纯 CPU 容器并行拉取前 357 个 Parquet 分片(4_5/000000.parquet .. 4_5/000356.parquet,共 640,070 篇文档、1.90B 字符),按同样的规则切出 608,067 篇训练文档和 32,003 篇验证文档,用 16,384 词表的 BPE 编码成 1,091.01M(约 1.09B)训练 Token 和 57.80M 验证 Token 的二进制文件存入持久化卷,后续 GPU 容器直接通过 np.memmap 挂载。
  2. 训练预算扩大 8 倍到 1,048.58M(约 1.05B)Token:把全局批大小翻倍到 128 × 1024 = 131,072 Token/步,训练步数拉长到 8,000 步,总训练量 1,048.58M Token(约为训练集长度的 0.96 倍,平均每参数约 10.75 个 Token);同时把峰值学习率提高到 1.8e-3(200 步线性预热,余弦衰减到 1.8e-4)。
  3. 模型代码零改动,算力换到 NVIDIA B200(178.3 GiB):单卡直接跑 micro_batch = 128, grad_accum = 1,峰值显存占用 61.03 GiB。

8,000 步(1.05B Token)在 B200 上只用了 1,185.0s 就跑完了:

step    1 (  15.3s) | lr=9.00e-06 | batch_loss=9.854 | train=9.746 | val=9.746
step  800 ( 136.9s) | lr=1.78e-03 | batch_loss=4.135 | train=4.190 | val=4.215
step 1600 ( 253.4s) | lr=1.67e-03 | batch_loss=3.803 | train=3.840 | val=3.875
step 2400 ( 370.0s) | lr=1.50e-03 | batch_loss=3.692 | train=3.687 | val=3.728
step 3200 ( 486.5s) | lr=1.28e-03 | batch_loss=3.566 | train=3.581 | val=3.626
step 4000 ( 603.0s) | lr=1.02e-03 | batch_loss=3.455 | train=3.497 | val=3.546
step 4800 ( 719.4s) | lr=7.65e-04 | batch_loss=3.411 | train=3.426 | val=3.482
step 5600 ( 835.9s) | lr=5.30e-04 | batch_loss=3.412 | train=3.362 | val=3.422
step 6400 ( 952.2s) | lr=3.42e-04 | batch_loss=3.278 | train=3.311 | val=3.375
step 7200 (1068.6s) | lr=2.22e-04 | batch_loss=3.385 | train=3.276 | val=3.342
step 8000 (1185.0s) | lr=1.80e-04 | batch_loss=3.244 | train=3.253 | val=3.324

第 800 步(耗时 136.9s,训练 104.86M Token)时,验证集 Loss(4.215)就已经追上了上一版 L4 跑了半小时(第 1,200 步,4.219)的水平;到第 8,000 步结束时,验证集 Loss 一路降到了 3.324(困惑度从约 54.8 降到约 27.8),train(3.253)与 val(3.324)之间只差 0.071。从 L4 初试到这一版,我们同时放大了语料规模、总训练量(8x)、全局批大小(2x)和峰值学习率(3x),因此 4.004 -> 3.324 是几项改动共同作用的结果。这一版的目的是定下一条新的起跑线,接下来的 6.2 和 6.3 都会固定这套数据、分词器和训练超参。

再看同样的提示词在 6.1 基线下的生成样例:

输入 中国古代造纸术的发明与传播对世界文明:

中国古代造纸术的发明与传播对世界文明进程产生了深远的影响。 造纸术的发明与传播促进了世界各地的交流与融合,促进了人类文明的发展。 造纸术作为一种先进的技术,推动了社会生产力的发展。 中国造纸术的传播离不开中国的文化传统,中国造纸术的发明推动了世界文化的交流,促进了人类文明的发展。 在中国漫长的历史发展过程中,造纸术在传播过程中也曾受到不同文化的冲击……

输入 在计算机科学中,操作系统的主要职责是管理:

在计算机科学中,操作系统的主要职责是管理计算机硬件设备、计算机软件、网络资源等,保证计算机硬件和软件的可靠性和安全性。计算机硬件安全是一个相对的概念,一般包括操作系统安全、硬件安全、操作系统审计、系统硬件安全、操作系统安全审计等。操作系统安全,是指操作系统在实现操作系统功能时,对用户程序和文件系统进行保护,防止或减少安全漏洞和漏洞的危害……

对比刚才 L4 上的结巴输出,现在模型已经能写出语法完整、围绕主题展开的段落了。不过实事求是地看,97.54M 参数配合 1.05B Token 距离“聪明”还差得很远:在整段 200 个 Token 的后半截,模型依然容易绕回相似的句式打转(例如上面最后几句反复解释“操作系统审计”),遇到具体科学常识也会一本正经地胡编(例如输入 地球的大气层从地表向上依次可以分为对流层、,模型续写出了 上升流层、海陆层、季风层 而不是 平流层、中间层)。但作为架构对比的基线,它已经摆脱了前几篇“死记硬背”和“逐词复读”的病态区间。

在跑 6.1 的推理测速时,我们还踩到了一个和硬件后端相关的坑:在 B200(PyTorch cu128)上,F.scaled_dot_product_attention 默认会优先调度 cuDNN 注意力后端。训练阶段每次输入的序列长度固定为 1024,cuDNN 表现很正常;但在自回归解码阶段,KV 序列长度每一步都会加 1(从 13 一直变到 524),cuDNN 后端在遇到每一个新长度时都会触发重复的执行计划编译,第一次跑测速时卡了 15 分钟。在进入推理前显式关掉 cudnn_sdp(torch.backends.cuda.enable_cudnn_sdp(False)),让 PyTorch 回退到 FlashAttention / Memory-Efficient 后端后,整个测速在半分钟内就跑完了:

Max logit abs diff (fp32): 4.94e-03 | 64-token greedy match: True
[batch=  1, new_tokens=512, kv_cache=  18.5 MiB] no_cache:  3.153s (  162.4 tok/s) | kv_cache:  1.263s (  405.5 tok/s) | speedup: 2.50x
[batch= 64, new_tokens=512, kv_cache=1181.2 MiB] no_cache:  6.892s ( 4754.5 tok/s) | kv_cache:  1.797s (18238.8 tok/s) | speedup: 3.84x
[batch=128, new_tokens=512, kv_cache=2362.5 MiB] no_cache: 11.985s ( 5468.2 tok/s) | kv_cache:  2.680s (24457.3 tok/s) | speedup: 4.47x

注:这里 fp32 的最大绝对误差是 4.94e-03,比第五篇 T4 上的 3.81e-06 大不少。主要是因为脚本开启了 torch.set_float32_matmul_precision("high"),允许 Tensor Core 用 TF32 跑 fp32 矩阵乘(乘法输入的尾数缩短到 10 位,累加仍用 FP32),此外模型层数翻倍、显卡和注意力后端也都变了;这里没有单独关掉 "high" 重测误差占比,不过 64 步贪心解码的输出依然逐字一致(True)。

看最后一行 batch=128 的缓存体积:一个 97.54M 的小模型,总序列长度才五百出头(提示词加 512 个新 Token),KV Cache 就占了 2,362.5 MiB(2.31 GiB)显存,超过了模型自身 bfloat16 权重体积(约 186 MiB)的 12 倍。如果上下文窗口拉长到 8K、32K,或者层数与宽度再放大几倍,KV Cache 很快就会把整张显卡塞满,并且每解码一步都要把这么大一块缓存从高带宽显存(HBM)搬进计算单元。这就是下一节 GQA 要解决的问题。


#2. 分组查询注意力(GQA):给 KV Cache 瘦身

在标准的多头注意力(MHA, Multi-Head Attention)里,6.1 模型设有 n_head = 12 个注意力头,每个头维度 head_dim = 64:

  • 12 个头各自拥有独立的查询、键、值投影矩阵(W_Q、W_K、W_V);
  • 推理阶段,每一层每个历史位置都要存下全部 12 个头的 K 和 V 向量。

为了砍掉 KV Cache,早期的 MQA(Multi-Query Attention,Shazeer, 2019) 走了一个极端:保留全部 12 个独立的 Query 头,但让整层 所有 12 个头共用唯一 1 份 K, V(即 n_kv_head = 1)。这样 KV Cache 直接降到原来的 1/12,但把所有头的键值压成单头,在较大模型上往往会带来可见的精度损失。

GQA(Grouped-Query Attention,Ainslie et al., 2023) 取了 MHA 和 MQA 之间的折中,也是如今 Llama 3、Qwen 2.5/3、Mistral 等模型标配的做法:把 n_head 个 Query 头分成 n_kv_head 个组,组内共享同一份 K, V,而每个头的 Query 保持独立。

在 6.2 里,我们保持 n_head = 12 不变,设 n_kv_head = 3(即 4 个 Query 头共用 1 组 KV,4:1 分组):

  1. Query(Q)保持 12 个独立头:投影维度依然是 768 -> 12 × 64 = 768,每个头要查询什么特征互不干扰;
  2. Key / Value(K, V)缩减为 3 组:投影维度变成 768 -> 3 × 64 = 192。计算注意力时,Query 头 0..3 查第 0 组 K/V,头 4..7 查第 1 组 K/V,头 8..11 查第 2 组 K/V;
  3. 输出投影(c_proj)不变:同一组内的 4 个头虽然查的是同一份 K/V,但各自的查询向量不同,算出来的注意力权重和加权结果依然是 4 份不同的 64 维向量;12 个头拼回 768 维后再经过 c_proj(768 -> 768)混合。

除了把推理时的 KV Cache 直接砍到原来的 四分之一(batch=128 下从 2,362.5 MiB 降到 590.6 MiB),GQA 也顺带省下了一截模型参数。对比每一层合并投影层 c_attn 的形状:

架构版本单层 c_attn 投影维度单层 c_attn 参数量12 层累计参数变化全模型总参数量单步 KV Cache 比例
6.1 MHA (12Q : 12KV)768 -> 768 + 2×768 = 23041,769,472基准97.54M100%
6.2 GQA (12Q : 3KV)768 -> 768 + 2×192 = 1152884,736-10.62M (-10,616,832)86.92M25%

把 K 和 V 投影砍掉 75% 后,单层 c_attn 刚好瘦身一半,12 层一共省下了 10.62M 参数(全模型参数减少约 10.9%)。做“等参数量(Iso-parameter)”对比的论文,通常会把省下来的参数补到前馈层宽度上;这里我们保持 MLP(hidden_dim = 2048)不动,只改 CausalSelfAttention,直接看少了 10.62M 参数、KV Cache 缩到四分之一后,同样的 1.05B Token 训练下来验证集 Loss 会差多少。

实现上,早期的写法常在调用前用 k.repeat_interleave(4, dim=1) 把 3 个 KV 头复制成 12 个,白白多出显存读写和拷贝。PyTorch 2.5 起,F.scaled_dot_product_attention 支持传入 enable_gqa=True,代码里直接喂入 (B, 12, T, 64) 的 q 和 (B, 3, S, 64) 的 k, v 即可;底层落到 FlashAttention 等支持 GQA 的融合后端时会直接按组读取 K/V,不再展开(只有退回 math 后端时,内部才会做 repeat_interleave)。

同样在 NVIDIA B200 上以完全一致的超参数(micro_batch = 128, grad_accum = 1,每步 131,072 Token)跑完 8,000 步,总耗时从 6.1 的 1,185.0s 降到了 1,067.3s(快了约 10%),训练峰值显存也从 61.03 GiB 降到了 55.83 GiB(省下 5.20 GiB):

step    1 (  14.9s) | lr=9.00e-06 | batch_loss=9.868 | train=9.763 | val=9.764
step  800 ( 125.3s) | lr=1.78e-03 | batch_loss=4.148 | train=4.201 | val=4.226
step 1600 ( 230.0s) | lr=1.67e-03 | batch_loss=3.816 | train=3.853 | val=3.888
step 2400 ( 334.6s) | lr=1.50e-03 | batch_loss=3.708 | train=3.703 | val=3.743
step 3200 ( 439.3s) | lr=1.28e-03 | batch_loss=3.588 | train=3.599 | val=3.643
step 4000 ( 543.9s) | lr=1.02e-03 | batch_loss=3.473 | train=3.517 | val=3.565
step 4800 ( 648.6s) | lr=7.65e-04 | batch_loss=3.435 | train=3.448 | val=3.503
step 5600 ( 753.4s) | lr=5.30e-04 | batch_loss=3.437 | train=3.385 | val=3.444
step 6400 ( 858.0s) | lr=3.42e-04 | batch_loss=3.297 | train=3.335 | val=3.398
step 7200 ( 962.8s) | lr=2.22e-04 | batch_loss=3.410 | train=3.300 | val=3.365
step 8000 (1067.3s) | lr=1.80e-04 | batch_loss=3.263 | train=3.278 | val=3.347

把 6.1(MHA, 97.54M) 和 6.2(GQA, 86.92M) 的验证集 Loss 放在同一张表里逐段对照:

训练步数累计训练 Token6.1 MHA (97.54M) 验证 Loss6.2 GQA (86.92M) 验证 Loss验证 Loss 差值 (6.2 - 6.1)
800104.86M4.2154.226+0.011
1600209.72M3.8753.888+0.013
3200419.43M3.6263.643+0.017
4800629.15M3.4823.503+0.021
6400838.86M3.3753.398+0.023
80001,048.58M3.3243.347+0.023

两条曲线从头到尾几乎平行往下走:我们没有把省下的 10.62M 参数补回前馈层(总参数少了 10.9%),同时把 KV Cache 压到了原来的四分之一,跑完 1.05B Token 后验证 Loss 只高了 0.023(困惑度从 27.8 升到 28.4)。因为“共享 KV 头”和“少 10.62M 参数”同时发生,而且 c_attn 形状改变后后续层的随机初始化也会跟着变,这 0.023 没法继续拆成单一因素;但整体算账,用 0.023 的验证 Loss 换掉 75% 的 KV Cache,非常划算。

看两段 6.2 的采样生成,表现和局限也与 6.1 基本一致:

输入 在计算机科学中,操作系统的主要职责是管理:

在计算机科学中,操作系统的主要职责是管理计算机硬件设备、计算机软件、网络资源、计算机系统资源和网络服务。 操作系统是计算机系统的重要组成部分,是计算机网络中不可或缺的一部分。随着计算机技术的发展,操作系统也不断出现新功能,主要表现在以下几个方面: · 扩充性:操作系统是计算机硬件设备、软件系统、网络服务中的一部分,主要用于扩充计算机硬件设备、软件系统、网络服务。 · 可扩充性:操作系统在扩充性上具有很大的优势,它可以扩充系统的硬件资源,扩展设备的种类和数量,增加系统的可靠性,提高系统可靠性。 · 可移植性:操作系统可以移植到不同的计算机系统和应用软件中,在移植时可以方便地移植到不同的操作系统上,从而可以解决计算机系统扩充性不足的问题……

输入 中国古代造纸术的发明与传播对世界文明:

中国古代造纸术的发明与传播对世界文明的发展产生了深远的影响。 造纸术的发明与传播促进了世界文明的进步与发展。 造纸术的发明与传播推动了世界文明的发展。 造纸术的发明与传播促进了世界文明的进步与发展……

第一条还能有模有样地分点列举“可扩充性、可移植性”,但第二条在写完三句车轱辘话后就掉进了整句复读循环。在当前约 90M 参数和 1.05B Token 的体量下,是否改用 GQA 并没有改变这类生成层面的通病。

再看同一张 B200 上的 KV Cache 校验与推理测速:

Max logit abs diff (fp32): 5.02e-03 | 64-token greedy match: True
[batch=  1, new_tokens=512, kv_cache=   4.6 MiB] no_cache:  3.323s (  154.1 tok/s) | kv_cache:  1.280s (  399.9 tok/s) | speedup: 2.60x
[batch= 64, new_tokens=512, kv_cache= 295.3 MiB] no_cache:  6.058s ( 5409.3 tok/s) | kv_cache:  1.299s (25231.2 tok/s) | speedup: 4.66x
[batch=128, new_tokens=512, kv_cache= 590.6 MiB] no_cache: 10.414s ( 6292.9 tok/s) | kv_cache:  1.452s (45132.3 tok/s) | speedup: 7.17x

把 6.1(MHA) 和 6.2(GQA) 在 B200 上开启 KV Cache 后的解码表现直接摆在一起:

并发批大小(续写 512 Token)6.1 MHA 缓存占用6.2 GQA 缓存占用6.1 MHA 解码速度6.2 GQA 解码速度GQA 相对 MHA 提速
batch = 118.5 MiB4.6 MiB1.263s (405.5 tok/s)1.280s (399.9 tok/s)0.99x(持平)
batch = 641,181.2 MiB295.3 MiB1.797s (18,238.8 tok/s)1.299s (25,231.2 tok/s)1.38x(+38.3%)
batch = 1282,362.5 MiB590.6 MiB2.680s (24,457.3 tok/s)1.452s (45,132.3 tok/s)1.85x(+84.5%)

对比这三行结果,可以看到两个现象:

  1. 小并发(batch = 1)时没有加速:两边耗时都卡在 1.27s 左右。这是因为不管 18.5 MiB 还是 4.6 MiB,对 B200 的显存带宽来说都微不足道;此时的瓶颈在于未编译的 Python generate 循环要串行跑 512 步、每步逐层启动一堆小 CUDA Kernel。
  2. 大并发(batch = 64 -> 128)时差距迅速拉开:当并发上到 batch = 128 时,6.1 的 KV Cache 膨胀到了 2,362.5 MiB,总解码耗时从单条时的 1.263s 翻倍涨到了 2.680s;而 6.2 的 KV Cache 只有 590.6 MiB,总生成量扩大 128 倍(输出 65,536 个 Token),耗时却只从 1.280s 微涨到 1.452s,吞吐量冲到了 45,132.3 tok/s,比同卡 MHA 快了 84.5%(相对自身无缓存快了 7.17x)。由于我们的 generate 每步都用 torch.cat 动态拼接缓存,KV 头缩到四分之一后,注意力读取历史 KV、torch.cat 拷贝历史张量以及 K/V 线性投影三部分的开销都会跟着减小,1.85x 是这三项叠加的结果。

#3. 稀疏混合专家(Sparse MoE):参数扩容而单步激活不变

解决完数据规模和注意力缓存,接下来看 Mixtral、DeepSeek-V2/V3、Qwen2.5/3-MoE 等模型用来扩大参数容量的结构:稀疏混合专家(Sparse Mixture-of-Experts, MoE)。

在 6.2 的稠密(Dense)模型里,每一层只有一个 SwiGLU 前馈网络(hidden_dim = 2048)。不管输入是标点符号、常见虚词,还是专业术语,每个 Token 都要完整算一遍同一套参数。想把稠密模型的总参数量翻 3 倍,就得加宽隐藏层或增加层数,每个 Token 的训练和推理计算量也会跟着涨大约 3 倍。

Sparse MoE 的思路是把“总参数量”和“单步激活计算量”拆开:把每层单独一个大 MLP 拆成多个独立的小专家(Experts),前面加一个轻量路由器(Router / Gate)。每来一个 Token,路由器只挑得分最高的少数几个专家出来计算,其余专家跳过不算。

为了和 6.2 做单变量对照,6.3 保持注意力层(12Q : 3KV)原封不动,只把每层那个 hidden_dim = 2048 的稠密 MLP,换成 8 个小专家、每次挑 2 个计算(Top-2) 的 MoE 层。

这里有个关键的尺寸设计:如果直接把原来的 2048 宽网络复制 8 份、每次挑 2 个跑,那每个 Token 要算的矩阵宽度就翻倍成了 4096,单步计算量跟着翻倍,没法公平对比。因此我们把每个专家的中间维度砍半设成 1024。改动前后的规模对比如下:

对比维度6.2 稠密版(单个 MLP)6.3 稀疏版(8 专家 Top-2 MoE)变化说明
单层前馈结构1 × SwiGLU(2048)8 × SwiGLU(1024) + 路由层单个专家宽度减半,共 8 个独立专家
单层前馈总参数4.72M18.88M8 个半宽专家合计相当于 8192 宽,前馈容量翻 4 倍
每 Token 激活前馈宽度20482 × 1024 = 2048专家矩阵乘规模持平(仅多出路由打分与加权求和)
全模型总参数 / 激活参数86.92M / 86.92M256.86M / 86.99M全模型总参数涨至约 3 倍,单步激活参数基本不变
KV Cache(batch=128)590.6 MiB590.6 MiB注意力层未改动,缓存大小不变

前向计算时,每个 Token 的 768 维向量 $x$ 按三步走完一层 MoE:

  1. 路由打分:用一个线性层 gate(768 -> 8,仅 6,144 个参数)给 8 个专家打分,过一遍 Softmax 得到 8 个概率 $p_0, p_1, \dots, p_7$;
  2. 挑前两名并重新归一化:选出概率最大的 2 个专家(记编号为 $a$ 和 $b$),把它们俩的概率重新归一化成权重 $w_a$ 和 $w_b$,保证相加仍等于 1;
  3. 只算这 2 个专家并加权相加:其余 6 个专家跳过不算,只把 $x$ 送进第 $a$ 号和第 $b$ 号专家算出 $E_a(x)$ 与 $E_b(x)$,按权重合并输出:

$$w_a = \frac{p_a}{p_a + p_b}, \quad w_b = \frac{p_b}{p_a + p_b}, \quad \text{MoE}(x) = w_a E_a(x) + w_b E_b(x)$$

但直接拿这个式子去训练,很容易撞上 MoE 最经典的坑:路由坍缩(Routing Collapse)。训练刚开始时,假如某两个专家因为随机初始化稍微占了一点便宜、分到了更多梯度,它们就会学得比别的专家更快;下一轮路由器一看它们表现更好,又把更多 Token 派给它们,形成“赢家通吃”的正反馈,最后 8 个专家里有 6 个彻底闲置,白白浪费了多出来的参数。

为了防止坍缩,我们采用 Switch Transformer(Fedus et al., 2021) 与 Mixtral 通用的 负载均衡辅助损失(Load-Balancing Auxiliary Loss)。在一个包含 $N$ 个 Token 的批次里,对第 $i$ 个专家(共 $E = 8$ 个)统计两个量:

  1. 实际分到的槽位比例 $f_i$:在全部 2N 次专家指派里,真正落到第 $i$ 号专家头上的比例(满足 $\sum_{i=1}^E f_i = 1$);
  2. 路由器的平均概率质量 $P_i$:全部 $N$ 个 Token 在 Softmax 后给第 $i$ 号专家打出的平均概率 $P_i = \frac{1}{N}\sum_{n=1}^N p_{n,i}$(同样满足 $\sum_{i=1}^E P_i = 1$)。

单层的负载均衡损失定义为:

$$L_{\text{aux}} = E \sum_{i=1}^{E} f_i \cdot P_i$$

注意这里的梯度流向:$f_i$ 来自离散的 Top-k 截断,本身不回传梯度,梯度只流经连续概率 $P_i$。如果某个专家抢了太多 Token($f_i$ 偏大),它在求和里的权重就大,优化器在压低 $L_{\text{aux}}$ 时就会重点把它的路由概率 $P_i$ 往下压;当 8 个专家完全均匀分担流量时($f_i = \frac{1}{8}$ 且 $P_i = \frac{1}{8}$),$L_{\text{aux}}$ 取得理想参考值 $8 \times 8 \times \frac{1}{64} = 1.0$。训练时我们把 12 层的平均 $L_{\text{aux}}$ 乘上系数 $\alpha = 0.01$ 加进总损失:

$$L_{\text{train}} = L_{\text{CE}} + \alpha \cdot \frac{1}{L}\sum_{\ell=1}^{L} L_{\text{aux}}^{(\ell)}$$

实现时有两处细节需要注意:

  1. 评估时必须剥离 aux_loss,只记录纯交叉熵 $L_{\text{CE}}$:训练时的 batch_loss 里混有约 0.01 的负载均衡惩罚项;如果在 estimate_loss() 里也把它算进去,MoE 的验证集 Loss 就会凭空比稠密模型高出约 0.01,没法公平对比。因此在 GPT.forward 里,只有 self.training=True 时才加上辅助损失,验证评估时严格只算 F.cross_entropy。
  2. 先按专家编号重排(Permute)再切片执行:如果用最朴素的写法遍历 8 个专家、每次用布尔掩码 x[mask] 挑出属于该专家的 Token,不仅会产生大量碎片化的显存拷贝,还会让 torch.compile 在每一层撞上动态形状断点。我们在 MoE.forward 里先把 N × 2 个指派按专家编号 0 .. 7 排序(argsort),使发往同一个专家的所有 Token 在显存里连续排列,再用零拷贝的 .split(counts) 切成连续块交给各自专家做矩阵乘法,算完后用 .scatter 还原回原位置加权求和。

同样在 NVIDIA B200 上以完全相同的超参数(micro_batch = 128, grad_accum = 1,每步 131,072 Token)跑完 8,000 步,总耗时为 1,709.6s(约 28.5 分钟,峰值显存 85.50 GiB):

step    1 ( 10.4s) | lr=9.00e-06 | batch_loss=9.891 | train=9.791 | val=9.794
step  800 (204.6s) | lr=1.78e-03 | batch_loss=4.133 | train=4.166 | val=4.196
step 1600 (371.6s) | lr=1.67e-03 | batch_loss=3.787 | train=3.808 | val=3.848
step 2400 (539.2s) | lr=1.50e-03 | batch_loss=3.663 | train=3.643 | val=3.692
step 3200 (706.6s) | lr=1.28e-03 | batch_loss=3.514 | train=3.527 | val=3.582
step 4000 (874.1s) | lr=1.02e-03 | batch_loss=3.395 | train=3.436 | val=3.497
step 4800 (1041.1s) | lr=7.65e-04 | batch_loss=3.347 | train=3.353 | val=3.425
step 5600 (1208.4s) | lr=5.30e-04 | batch_loss=3.340 | train=3.283 | val=3.362
step 6400 (1375.3s) | lr=3.42e-04 | batch_loss=3.199 | train=3.225 | val=3.311
step 7200 (1542.6s) | lr=2.22e-04 | batch_loss=3.311 | train=3.186 | val=3.275
step 8000 (1709.6s) | lr=1.80e-04 | batch_loss=3.155 | train=3.159 | val=3.254

把三版模型在各评估节点的纯交叉熵验证集 Loss 放在一起对照:

训练步数累计训练 Token6.1 MHA (97.54M)6.2 GQA (86.92M)6.3 GQA+MoE (256.86M / 86.99M 激活)MoE 单变量收益 (6.3 - 6.2)
800104.86M4.2154.2264.196-0.030
1600209.72M3.8753.8883.848-0.040
3200419.43M3.6263.6433.582-0.061
4800629.15M3.4823.5033.425-0.078
6400838.86M3.3753.3983.311-0.087
80001,048.58M3.3243.3473.254-0.093

从表里能看到两个明显变化:

  1. 验证 Loss 差距随训练步数一路拉大:6.3 和 6.2 注意力层完全一样,每个 Token 激活的专家矩阵合计宽度也都是 2048,区别在于每层备选的前馈总参数扩大到了 4 倍(全模型总参数涨到约 2.96 倍)。随着训练推进,6.3 相对 6.2 的领先幅度从第 800 步的 -0.030 一路扩大到第 8,000 步的 -0.093(困惑度从 28.4 降到 25.9)。跑到第 6,400 步(838.86M Token)时,6.3 的验证 Loss(3.311)已经低于 6.1 MHA 跑满 8,000 步的 3.324,最后不仅补回了 GQA 少参数带来的 +0.023 差距,还比 6.1 基线低了 0.070。同时,参数量翻了近 3 倍后,终点 train=3.159、val=3.254(相差 0.095),虽然随机抽样仍有局部文本重复,但在 1.09B Token 的语料上并没有出现验证 Loss 回升。
  2. 单步专家矩阵乘规模没变,但训练耗时和显存还是涨了:6.3 跑完 8,000 步花了 1,709.6s,比 6.2(1,067.3s)慢了约 60%,峰值显存也从 55.83 GiB 涨到 85.50 GiB。多出来的开销主要来自三块:一是全部 256.86M 参数连同梯度、AdamW 优化器状态都要常驻显存;二是除了路由打分、加权合并和辅助损失,重排(argsort)与还原(scatter)还要把 (131072, 768) 的激活张量翻倍成 (262144, 768) 并存下反向传播中间值;三是这份纯 PyTorch 代码每层都调了 bincount(...).tolist()(把计数同步回 CPU,打断了 torch.compile 整图编译),再用 Python 循环串行跑 8 个专家,没有用工业框架里的融合 Grouped GEMM 算子。不过算总账,多花 60% 的训练时间换来近 3 倍的全模型参数量,还是比直接把稠密模型加宽 3 倍省得多。

训练结束后,我们在固定的 2,560 条验证集序列上抽查了路由统计(单层理想均匀值为 1 / 8 = 12.5%):

Mean validation token share per expert across all 12 layers (ideal = 12.5%):
  E0: 12.5% | E1: 11.5% | E2: 11.7% | E3: 13.5% | E4: 11.0% | E5: 13.4% | E6: 14.2% | E7: 11.9%
  Layer  0: E0:  5.1% | E1:  5.2% | E2:  7.5% | E3: 26.0% | E4:  2.3% | E5:  8.8% | E6: 34.9% | E7: 10.2%
  Layer  5: E0: 14.3% | E1: 12.1% | E2: 11.2% | E3: 12.8% | E4: 10.5% | E5: 19.4% | E6: 12.9% | E7:  6.8%
  Layer 11: E0: 16.6% | E1:  7.8% | E2: 18.6% | E3:  7.2% | E4:  6.5% | E5:  5.7% | E6: 12.4% | E7: 25.2%

看这组统计时,有两处细节值得留意:

  • 第一行的跨层平均其实看不出单层忙闲:不同层的 E0 是各自独立的参数,12 层一共有 12 × 8 = 96 个专家。把 12 层的同编号专家混在一起平均出 11.0% ~ 14.2%,很容易把不同层之间的偏载互相抵消掉;真要确认 96 个专家里有没有闲置,得逐层看每一层的最低占比,不能只看第一行。
  • 打印出来的三层(Layer 0 / 5 / 11)都没有专家归零,但单层负载并不平均:第 0 层里 E6 吃掉了 34.9% 的流量,而 E4 只有 2.3%;第 5 层分布在 6.8% ~ 19.4%;第 11 层在 5.7% ~ 25.2%。也就是说,系数 0.01 的辅助损失并没有把每层硬压成 12.5% 均分。因为这次没有跑去掉辅助损失(aux_loss_coef = 0)的对照,也没有统计每个专家具体接了哪些词,所以这里只能看到这三层没有坍缩到两三个专家上,至于辅助损失单独起了多大作用、第 0 层 E6 偏高是不是因为高频词集中,还要靠额外的消融和词频统计才能下结论。

再看 6.3 的生成样例:

输入 在计算机科学中,操作系统的主要职责是管理:

在计算机科学中,操作系统的主要职责是管理计算机硬件资源和软件资源。操作系统要为计算机硬件资源和软件资源服务。 操作系统是计算机系统的重要组成部分,是计算机系统资源管理的中枢系统…… 操作系统一般由用户操作系统、管理操作系统和操作系统三部分组成。 用户操作系统:用户操作系统是为用户提供各种用户管理功能的计算机系统。它的主要任务是管理用户的基本信息,如用户名、工作目录、文件、目录、任务……

输入 地球的大气层从地表向上依次可以分为对流层、:

地球的大气层从地表向上依次可以分为对流层、对流层、对流层、对流层、极地低气层和极地高气层。这些低气层与大气中氧、水分子、核素和地球的成分有关…… 大气中的氧主要以二氧化碳、一氧化碳(CO)、一氧化碳(CO2、HC)、二氧化碳(CO2)和氢气(H2)的形式存在,其中大部分为二氧化碳。它们具有许多共同特征,包括强大的氧化性、易燃性、可燃性、可燃性、毒性等……

两段输出里已经能看到“用户名、工作目录、文件”、“CO、CO2、H2”这类贴近主题的词汇,但写长之后还是会局部打转(第一段后面反复出现“设置用户权限”),事实性胡编也很明显(连写四个“对流层”、把二氧化碳说成氧的存在形式)。换上 MoE 虽然把验证集 Loss 压低了 0.093,但靠 87M 激活参数和 1.05B Token 的训练量,还远不足以消除复读和常识错误。

最后看同一张 B200 上 6.3 的 KV Cache 等价性校验与推理测速(测速脚本沿用前两节的 [base_ids] * batch_size 复制同一提示词,并以 top_k = 1 贪心解码):

Max logit abs diff (fp32): 4.46e-03 | 64-token greedy match: True
[batch= 1, new_tokens=512, kv_cache=   4.6 MiB] no_cache:  5.819s (   88.0 tok/s) | kv_cache:  2.961s (  172.9 tok/s) | speedup: 1.97x
[batch=64, new_tokens=512, kv_cache= 295.3 MiB] no_cache: 10.663s ( 3073.1 tok/s) | kv_cache:  3.219s (10178.0 tok/s) | speedup: 3.31x
[batch=128, new_tokens=512, kv_cache= 590.6 MiB] no_cache: 17.121s ( 3827.8 tok/s) | kv_cache:  3.514s (18651.3 tok/s) | speedup: 4.87x

把三版模型在 B200 上开启 KV Cache、按同一重复提示词批量续写 512 个 Token 的表现合在一张表里:

并发批大小(重复提示词贪心解码)6.1 MHA (97.54M)6.2 GQA (86.92M)6.3 GQA+MoE (256.86M)
KV Cache 占用(batch=128)2,362.5 MiB590.6 MiB590.6 MiB
batch = 1 解码速度1.263s (405.5 tok/s)1.280s (399.9 tok/s)2.961s (172.9 tok/s)
batch = 64 解码速度1.797s (18,238.8 tok/s)1.299s (25,231.2 tok/s)3.219s (10,178.0 tok/s)
batch = 128 解码速度2.680s (24,457.3 tok/s)1.452s (45,132.3 tok/s)3.514s (18,651.3 tok/s)

看这组测速结果时,同样要结合脚本的写法拆开看:

  1. KV Cache 保持 590.6 MiB 不变,64 步贪心校验一致:MoE 只改前馈层、不动注意力层,总参数虽然涨到近 3 倍,KV Cache 依然和 6.2 一样大;经过 64 × 12 = 768 次 Top-2 路由选择后,fp32 下带缓存与不带缓存的贪心输出依然逐字一致(True)。在重复提示词下把批大小从 1 拉到 128,6.3 的耗时只从 2.961s 涨到 3.514s(吞吐 18,651.3 tok/s,相对自身无缓存提速 4.87x)。
  2. 为什么每层只跑 2 个专家,6.3 还是比 6.2 慢了 2.3x ~ 2.4x? 测速代码用 [base_ids] * batch_size 复制同一条提示词,又设了 top_k = 1 贪心解码,因此批内 128 条序列每一步的输入完全相同,在同一层会全部落进同样的 2 个专家(其余 6 个专家计数为 0 直接跳过)。即便如此,在未编译的 generate 循环里,6.3 每层仍要多做路由打分、argsort 重排、bincount(...).tolist()(每步触发 12 次 GPU 到 CPU 同步,512 步就是 6,144 次)、scatter 还原,并且把原来 1 次 2048 宽矩阵乘拆成 2 次 1024 宽矩阵乘,这些纯 PyTorch 调度和重排直接拖慢了单步延迟。
  3. 如果换成不同提示词并发,开销还会更大:线上服务同时处理 128 条不同请求时,同一步的 Token 会分散落到更多甚至全部 8 个专家上,每步需要从显存读取的专家权重和矩阵切分次数都会比这里的重复提示词测速更多。那种场景下的真实吞吐,需要换用多样化提示词(最好再配上融合 Grouped GEMM 算子)单独测。

#4. 小结

把这一篇从扩规模初试到 MHA -> GQA -> GQA + Sparse MoE 的四组对照实验汇总如下:

实验版本注意力与前馈层结构总参数 / 激活参数训练预算与硬件训练耗时 / 峰值显存终点 Loss (train / val)batch=128 续写 512 Token(重复提示词 KV Cache)
6.0 L4 初试MHA (12Q:12KV) + SwiGLU (2048)97.54M / 97.54M131.07M (L4)2,991.7s / 16.59 GiB3.946 / 4.004消除小语料验证 Loss 反弹,但欠训练且单卡太慢
6.1 MHA 基线MHA (12Q:12KV) + SwiGLU (2048)97.54M / 97.54M1.05B (B200)1,185.0s / 61.03 GiB3.253 / 3.324缓存 2,362.5 MiB,24,457.3 tok/s
6.2 + GQAGQA (12Q:3KV) + SwiGLU (2048)86.92M / 86.92M1.05B (B200)1,067.3s / 55.83 GiB3.278 / 3.347缓存砍至 590.6 MiB,提速至 45,132.3 tok/s(1.85x)
6.3 + GQA + MoEGQA (12Q:3KV) + 8×SwiGLU (1024) Top-2256.86M / 86.99M1.05B (B200)1,709.6s / 85.50 GiB3.159 / 3.254缓存保持 590.6 MiB,18,651.3 tok/s;激活参数相近,验证 Loss 较 6.2 降 0.093

回头看这个系列的六篇文章:我们从第一篇最简单的字符级 Bigram 查找表出发,搭起标准 GPT-2,接着陆续换上 FlashAttention、Byte-Level BPE、RoPE、RMSNorm、SwiGLU 和 KV Cache;到这一篇把训练语料扩到 1B Token 量级,用 GQA 把推理时的 KV Cache 压到四分之一,再用 Sparse MoE 在激活参数(86.99M)和缓存大小基本不变的前提下,把总参数量扩到了 256.86M。受限于单卡预算,这个模型离工业级基座还差着几个数量级的预训练语料,也还没做指令微调(SFT)和强化学习对齐(RLHF / GRPO),但主流开源大模型基座的主要结构模块,到这里都已经在这几百行 PyTorch 代码里逐一跑通了。