大模型入门教程5 - 归一化(RMSNorm)、门控前馈层(SwiGLU)与 KV Cache

#归一化(RMSNorm)、门控前馈层(SwiGLU)与 KV Cache

系列导读:这个系列从 第一篇(从 Bigram 到 GPT-2) 开始,经过 第二篇(钢琴曲生成) 和 第三篇(算子加速与多模态),在 第四篇(分词器与位置编码) 回到纯文本主线,加上了自训练的 4,096 词表 BPE 分词器与旋转位置编码(RoPE),把验证集最佳 Loss 降到了 3.820。这一篇我们以第四篇最后的 4.2(BPE + RoPE) 为起点,继续保持同样的数据划分、约 12.19M 的参数量和 2,000 步训练预算,逐个替换 Transformer Block 内部的归一化层(RMSNorm)、前馈网络(SwiGLU),最后在推理阶段加上 KV Cache。


#1. 从 LayerNorm 到 RMSNorm

在 4.2 的代码里,每个 Transformer Block 包含两处 LayerNorm(分别在自注意力和 MLP 之前),整个模型最后进入输出层 lm_head 前还有一处 ln_f,一共 13 个归一化层。

因为我们在配置里已经把 bias 设为了 False,原本的 LayerNorm 对长度为 $d = 384$ 的特征向量 $x$ 做的事情分两步:先算均值 $\mu$ 把向量中心化,再除以标准差做缩放,最后乘上可学习的缩放参数 $\gamma$:

$$\mu = \frac{1}{d}\sum_{i=1}^d x_i, \quad \sigma^2 = \frac{1}{d}\sum_{i=1}^d (x_i - \mu)^2, \quad y_i = \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon}} \gamma_i$$

现在主流开源模型(Llama、Qwen、DeepSeek 等)普遍改用了 RMSNorm(Root Mean Square Layer Normalization)。它的改动非常直接:不再计算均值 $\mu$,也不做减均值的中心化,只按均方根(RMS)做缩放:

$$\text{RMS}(x) = \sqrt{\frac{1}{d}\sum_{i=1}^d x_i^2 + \epsilon}, \quad y_i = \frac{x_i}{\text{RMS}(x)} \gamma_i$$

为了公平对比,我们在实现时注意了两个细节:

  1. 直接调用 PyTorch 原生接口 F.rms_norm:如果手写一串逐元素算子(平方、mean、rsqrt、乘法),在没有 torch.compile 的情况下可能拆成多个小 Kernel,增加启动和访存开销。这里两边都用 PyTorch 提供的实现,避免把手写版本的额外开销混进对比;具体采用什么 Kernel,还取决于 PyTorch 版本和输入条件。
  2. 其他变量严格对齐:取和 nn.LayerNorm 相同的 $\epsilon = 10^{-5}$,可学习参数 $\gamma$ 的形状依然是 (384,) 且初始化为全 1。这样一来,模型的总参数量(12.19M,其中衰减参数 12,189,696 个,不衰减参数 4,992 个)、所有线性层与词表的随机初始化权重、每一步抽到的训练 batch 都和 4.2 完全一致,唯一的区别就是拿掉了减均值这一步。

跑完 2,000 步的训练日志如下:

step    1 (  1.2s) | batch_loss=8.393 | train=8.020 | val=8.018
step  200 ( 32.5s) | batch_loss=4.597 | train=4.584 | val=4.904
step  400 ( 69.3s) | batch_loss=3.979 | train=3.695 | val=4.305
step  600 (108.4s) | batch_loss=3.262 | train=3.166 | val=4.054
step  800 (145.2s) | batch_loss=2.892 | train=2.734 | val=3.889
step 1000 (183.5s) | batch_loss=2.421 | train=2.384 | val=3.839
step 1200 (220.5s) | batch_loss=2.487 | train=2.097 | val=3.823
step 1400 (258.0s) | batch_loss=2.060 | train=1.823 | val=3.822
step 1600 (295.6s) | batch_loss=1.993 | train=1.588 | val=3.876
step 1800 (332.7s) | batch_loss=1.618 | train=1.380 | val=3.927
step 2000 (369.8s) | batch_loss=1.627 | train=1.188 | val=3.997

把这条曲线和上一篇 4.2(LayerNorm) 放在一起看,几乎完全重合:

  • 第 200 步验证集 Loss:4.902(LayerNorm)对比 4.904(RMSNorm);
  • 第 600 步验证集 Loss:4.056(LayerNorm)对比 4.054(RMSNorm);
  • 最佳验证集 Loss:4.2 在第 1,200 步达到 3.820(第 1,400 步为 3.825),5.1 在第 1,200 步为 3.823、第 1,400 步为 3.822;
  • 第 2,000 步验证集 Loss:4.002(LayerNorm)对比 3.997(RMSNorm)。

生成文本的表现也和上一版差不多(下面取自第 2,000 步模型):

输入 《中华人民共和国民法典》第五百七十七条:当事人一方不履行合同义务:

《中华人民共和国民法典》第五百七十七条:当事人一方不履行合同义务或者履行债务等义务的,对方可以先向对方履行请求,但是不影响合同效力的除外。 《中华人民共和国民法典》第五百七十八条:当事人一方不履行债务或者不履行债务不符合约定的,对方可以请求其承担违约责任;但是,债权人对债务履行不影响当事人选择权的,不影响合同中约定不明确的,不影响当事人在约定期限或者履行不明确,不影响当事人在抵销的中履行债务、解除权债务等消灭的,对方可以请求人民法院或者仲裁机构予以确认。

输入 犯故意伤害罪,判处:

犯故意伤害罪,判处有期徒刑十三年六个月;被告人刘某桂犯故意伤害罪,判处有期徒刑三年六个月;被告人刘某桂犯故意伤害罪,判处有期徒刑三年六个月,并处罚金人民币二十万元;被告人熊某桂犯故意伤害罪,判处有期徒刑十一年六个月,并处罚金人民币一万元;被告人刘某桂犯故意伤害罪,判处有期徒刑三年六个月,并处罚金人民币一万元;被告人刘某桂犯抢劫罪,判处有期徒刑十三年六个月,并处罚金人民币一万余元。宣判后,没有上诉、抗诉,判决已发生法律效力。

这次民法典开头没有卡在“义务”上,但后半段又连用了几个“不影响”,最后一段判词也反复念了好几遍“被告人刘某桂犯故意伤害罪”。在这次实验里,RMSNorm 没有明显改变验证 Loss,两组生成样例也都还有复读和不通顺的问题。

那现代大模型为什么还要普遍换成 RMSNorm?

RMSNorm 原论文(Zhang & Sennrich, 2019) 尝试去掉减均值的中心化(Re-centering),只保留按幅度缩放(Re-scaling)。在作者测试的多种任务和模型上,这种更简单的归一化取得了与 LayerNorm 接近的效果。我们的结果也支持一个较窄的结论:在当前模型和数据上,去掉中心化没有明显影响验证 Loss。这还不能说明中心化在任何模型里都是多余的。

这次总训练时间从 372.4s 变成 369.8s,只差 2.6s,不到 1%。单次计时看不出稳定的速度优势。RMSNorm 的公式更简单,但 LayerNorm 的均值和方差也可以在融合 Kernel 中计算,不能把公式里少了一步直接算成少一次显存读写。实际能省多少时间,还要看算子实现和整个模型的耗时分布。


#2. 从 GELU MLP 到 SwiGLU

这次 RMSNorm 的效果与 LayerNorm 接近,我们就保留它,接着改 Transformer Block 里的另一半核心组件:前馈神经网络(MLP / FFN)。

在标准 GPT-2 里,MLP 是一个两层线性变换,中间把维度从 $d = 384$ 放大 4 倍到 $4d = 1536$,过一遍 GELU 激活函数后再投影回 $384$:

$$\text{MLP}(x) = \text{GELU}(x W_1) W_2$$

而现代主流架构大多改成了带门控机制的 SwiGLU(由 Shazeer, 2020 提出):输入 $x$ 先同时经过两个并行的线性投影,一路过 $\text{SiLU}$ 激活函数(即 $x \cdot \sigma(x)$)充当“门控开关”,另一路保持线性,两路逐元素相乘后,再经过第三个矩阵 $W_{\text{down}}$ 投影回原维度:

$$\text{SwiGLU}(x) = \big(\text{SiLU}(x W_{\text{gate}}) \odot (x W_{\text{up}})\big) W_{\text{down}}$$

这里有一个做控制变量实验必须注意的参数量陷阱:原本的 MLP 只有 2 个矩阵,而 SwiGLU 有 3 个矩阵($W_{\text{gate}}, W_{\text{up}}, W_{\text{down}}$)。如果中间维度继续保持 $4d = 1536$ 不变,每个 Block 的 MLP 参数量就会膨胀 $1.5$ 倍,全模型直接多出约 3.5M 参数,那就分不清到底是结构更好,还是单纯靠堆参数赢了。

为了把总参数量严格锁死,我们按照论文的做法,把中间维度缩小到原来的 $\frac{2}{3}$,也就是:

$$d_{\text{ff}} = \frac{2}{3} \times 4d = \frac{2}{3} \times 1536 = 1024$$

算一下账就能看到,这样调整之后,单个 Block 里 MLP 的参数量是 $3 \times 384 \times 1024 = 1,179,648$,和原来两层矩阵的 $2 \times 384 \times 1536 = 1,179,648$ 一个参数都不差,全模型依然精确保持在 12.19M(且 1024 刚好是 64 的整数倍,对 GPU Tensor Core 依然友好)。在代码里,我们还可以像之前合并 QKV 那样,把 $W_{\text{gate}}$ 和 $W_{\text{up}}$ 拼成一个 nn.Linear(384, 2048) 一次算完再用 .chunk(2, dim=-1) 切开。相比分开计算这两路,合并后少启动一次矩阵乘法;整个前馈层和原来的 GELU 版本一样,都是两次线性投影。

同样训练 2,000 步,日志如下:

step    1 (  1.1s) | batch_loss=8.402 | train=8.113 | val=8.099
step  200 ( 31.6s) | batch_loss=4.338 | train=4.321 | val=4.769
step  400 ( 63.8s) | batch_loss=3.688 | train=3.364 | val=4.226
step  600 ( 98.1s) | batch_loss=2.933 | train=2.788 | val=3.998
step  800 (134.2s) | batch_loss=2.544 | train=2.340 | val=3.913
step 1000 (169.2s) | batch_loss=2.117 | train=1.981 | val=3.909
step 1200 (204.8s) | batch_loss=2.146 | train=1.706 | val=3.936
step 1400 (240.2s) | batch_loss=1.754 | train=1.447 | val=3.979
step 1600 (275.3s) | batch_loss=1.704 | train=1.246 | val=4.056
step 1800 (310.5s) | batch_loss=1.381 | train=1.062 | val=4.122
step 2000 (345.9s) | batch_loss=1.395 | train=0.899 | val=4.203

初看最后几行结果,SwiGLU 似乎还不如上一节的 GELU:最佳验证集 Loss 只停在第 1,000 步的 3.909(不如 GELU 的 3.822),到第 2,000 步甚至反弹到了 4.203(高于 GELU 的 3.997)。

但如果把整条训练曲线拆成前后两段,再把 train 和 val 对照起来看,事情就清楚了:

训练步数折算训练轮数(约)5.1 GELU 训练 Loss5.2 SwiGLU 训练 Loss5.1 GELU 验证 Loss5.2 SwiGLU 验证 Loss
2003.6 遍4.5844.3214.9044.769
4007.1 遍3.6953.3644.3054.226
60010.7 遍3.1662.7884.0543.998
80014.3 遍2.7342.3403.8893.913
100017.8 遍2.3841.9813.8393.909
140025.0 遍1.8231.4473.8223.979
200035.7 遍1.1880.8993.9974.203

可以看到两个很明显的现象:

  1. 这次 SwiGLU 的拟合速度更快:在参数量分毫不差(同为 12.19M)的前提下,从第 200 步到第 2,000 步,SwiGLU 的训练集 Loss 全程比 GELU 低 0.26 到 0.40,最后压到了 0.899(GELU 为 1.188)。记录的总耗时也从 369.8s 降到了 345.9s。但不能直接把这段时间差归因于激活张量更小:合并后的 gate/up 投影输出宽度是 2048,比 GELU 的 1536 还宽,两版又都是两次线性投影。具体快在哪里,需要看实际的算子耗时。
  2. 前 600 步 SwiGLU 验证集占优,但更早达到最低点:第 200 步验证 Loss 是 4.769 对 4.904,第 600 步是 3.998 对 4.054;到第 800 步,GELU 的验证 Loss 已经更低。SwiGLU 在第 1,000 步达到最低点,随后训练 Loss 继续下降,验证 Loss 却开始回升,出现了过拟合。我们的训练集只有约 0.92M(918K)个 Token,2,000 步抽样的总量折算下来约为语料的 35.7 遍。在这组数据和训练设置下,SwiGLU 拟合训练集更快,也更早出现验证 Loss 的反弹。

换成更大的数据集,SwiGLU 的表现还可能不同。

数据规模、重复次数、训练预算和正则化都会影响结果。上面这次小语料实验,不能直接解释 SwiGLU 在大规模预训练中的优势,也不能把大模型的整个训练过程当成这里的“前 600 步”。这次只跑了一个随机种子,而且 MLP 矩阵形状改变后,初始化消耗的随机数序列也会跟着变化。我们先记下这次观察:训练 Loss 更低,但最佳验证 Loss 没有超过 GELU,而且更早开始回升。

看看第 2,000 步模型的生成结果,也能直观感受到这种“背书感”:

输入 《中华人民共和国劳动合同法》第三十九条:劳动者有下列情形之一的,用人单位可以解除劳动合同::

《中华人民共和国劳动合同法》第三十九条:劳动者有下列情形之一的,用人单位可以解除劳动合同: (一)未按照劳动合同约定提供劳动保护或者劳动条件的; (二)未按照劳动合同约定支付劳动报酬的; (三)未按照劳动合同约定支付劳动者的; (四)未依法为劳动者缴纳社会保险费的; (五)劳动者按照劳动者的履行地的有关规定执行。

输入 犯故意伤害罪,判处:

犯故意伤害罪,判处有期徒刑二年,并处罚金人民币三万元。二、被告人谢检军犯开设赌场罪,判处有期徒刑二年,并处罚金人民币二万元。三、被告人高尔樵犯开设赌场罪,判处有期徒刑三年,并处罚金人民币二万元;被告人高尔樵犯开设赌场罪,判处有期徒刑二年,并处罚金人民币二万元。四、被告人高尔樵犯开设赌场罪,判处有期徒刑三年,并处罚金人民币二万元……

第一段里列出的“未按照劳动合同约定提供劳动保护或者劳动条件的”、“未依法为劳动者缴纳社会保险费的”,其实是《劳动合同法》第三十八条(劳动者单方解除)的原文条款,被模型原封不动背出来嫁接到了第三十九条下面;第二段里反复出现的“谢检军”、“高尔樵”,则是训练集指导案例(指导案例 106 号)里的真实被告人姓名。这些样例里能看到训练语料中的字句,但模型把不同条文和案件拼在了一起。训练 Loss 降到 0.899,也没有解决内容混用和复读的问题。


#3. 推理加速:KV Cache

前面两节改的都是模型结构,这一节我们不改任何权重,也不重新设计训练目标,只解决自回归生成(model.generate)时的一个严重算力浪费问题。

回看目前的 generate 循环:假设提示词有 15 个 Token,我们要往后续写 450 个 Token。

  • 生成第 1 个新 Token 时,模型把长度 15 的序列喂进去,算出全部 15 个位置的 Q, K, V,最后只取第 15 个位置的输出预测下一个词;
  • 生成第 2 个新 Token 时,模型把拼好后的 16 个 Token 从头再喂一遍,前 15 个位置的 Embedding、RMSNorm、QKV 投影和 MLP 被原封不动重算了一次;
  • 一直到第 450 步,模型要把长度 464 的整条序列从头算一遍,仍然只取最后一个位置的 logits[:, -1, :]。

因为在因果自注意力(Causal Mask)下,前面的 Token 看不见后面新追加的 Token,所以在推理模式下、已有前缀和位置不变时,历史位置的特征表示和 K、V 可以复用。每一步只需要计算最新生成的这 1 个 Token 自己的 q, k, v:把新的 k, v 追加到历史缓存(KV Cache)末尾,再用这 1 个位置的 q 去和缓存里所有历史位置的 K, V 做注意力加权,后续的投影和 SwiGLU MLP 也只需要处理这一个位置。

设当前上下文长度为 $t$,固定模型宽度后,每一步投影和 MLP 的计算量就从 $O(t)$ 降到了 $O(1)$。如果提示词长度固定,生成 $N$ 个 Token,且上下文持续增长、不做截断,这部分的总计算量从 $O(N^2)$ 降到了 $O(N)$。但注意力仍然需要让新的 Query 访问全部历史 K/V,单步开销是 $O(t)$,整段生成的注意力计算仍然是 $O(N^2)$。

把 KV Cache 接进模型里,只需要把生成拆成两步:Prefill(预填充,一次性算完整个提示词并存下每层的 K, V) 和 Decode(解码,每次只喂入最新的 1 个 Token)。实现时有两个非常容易踩坑的细节:

  1. RoPE 的旋转位置偏移量 past_len:在 Decode 阶段,虽然每次喂进 CausalSelfAttention 的张量长度 T 只有 1,但这个 Token 在整句话里的真实位置并不是第 0 位,而是 past_len(即缓存里已有的历史 Token 数)。切取正余弦表时必须取 rope_cos[:, :, past_len : past_len + T, :],并且把旋转之后的 k 存入缓存,这样新位置 $m$ 的 q 和缓存里旧位置 $n$ 的 k 做内积时,夹角差依然正好是 $n - m$。
  2. 单 Token Decode 阶段关掉 SDPA 的 is_causal=True:PyTorch 的 F.scaled_dot_product_attention 在收到形状不对称的 q(长度 1)和 k(长度 past_len + 1)时,如果仍然传入 is_causal=True,它会按矩阵左上角对齐因果掩码,导致第 0 行的 q 只能看第 0 个 k,把后面缓存的 1 .. past_len 全给遮掉了。在单步解码(T = 1)时,最新的这个 Token 本来就排在整句话最末尾,理应看到缓存里的全部历史 Token,所以此时应当令 is_causal=False。

这份实现仍然限制在 block_size = 512。当提示词加已生成内容超过 512 个 Token 后,generate 会在每一步重新 Prefill 最近的 512 个 Token,以保持和原来裁剪窗口后的重算行为一致。这次续写 450 个 Token 的基准没有超过窗口上限;直接增大 max_new_tokens,并不能测试几千 Token 的持续缓存效果。

因为训练代码和模型参数没有改动,2,000 步的训练曲线与 5.2 完全重合(第 2,000 步同样停在 train=0.899 | val=4.203)。训练结束后,我们先检查缓存前后的数值误差和贪心输出,再分别测试单条生成(batch=1)和并发批量生成(batch=16)续写 450 个新 Token 的耗时:

Max logit abs diff (fp32): 3.81e-06 | 64-token greedy match: True
[batch= 1, new_tokens=450] no_cache:  3.147s ( 143.0 tok/s) | kv_cache:  2.532s ( 177.7 tok/s) | speedup: 1.24x
[batch=16, new_tokens=450] no_cache:  5.598s (1286.2 tok/s) | kv_cache:  3.373s (2134.6 tok/s) | speedup: 1.66x

这里有两处细节值得拆开看。

第一是结果等价性。这次 fp32 检查中,Prefill + 逐步 Decode 算出来的 Logits 与每次整句重算的最大绝对误差只有 3.81e-06,贪心解码连续生成 64 个 Token 也完全一致。不过如果翻看 Notebook 里的采样输出(开启了 fp16 混合精度与 temperature=0.7 随机采样),会发现 4 条提示词里有 2 条与 5.2 一字不差,另外 2 条在半途走向了不同分支。缓存前后的矩阵形状不同,底层 Kernel 和浮点运算顺序也可能不同。小的数值差异就可能改变某一步的采样结果,随后上下文也会跟着分叉。这里没有测量 fp16 的 Logits 误差幅度,fp32 下的检查也不保证混合精度随机采样逐字一致。

第二是为什么加速比只有 1.24x 和 1.66x,没有动辄十倍的提速?

先看上面两行数字:开启 KV Cache 后,把并发从 batch=1 扩大 16 倍到 batch=16(总生成量从 450 个 Token 变成 7,200 个 Token),总耗时只从 2.532s 涨到了 3.373s,多了 0.84 秒。

这提示 batch=1 时 GPU 的并行能力可能没有充分利用,但仅凭两组总耗时,还分不清 Python 调度、Kernel 启动、读取权重、缓存复制和实际计算各占多少。这里有两个值得进一步测量的地方:

  1. 模型较小且上下文较短:我们的模型只有 6 层、隐藏层维度 384,上下文窗口也只有 512。单 Token 解码时,每层处理的数据很少,调度、内核启动和读取权重的成本可能比较显眼。要确认是不是这些成本限制了速度,需要查看 Profiler 的时间线。
  2. 教学版 torch.cat 的动态拼接开销:为了代码直观,我们每一步都用 torch.cat((past_kv[0], k), dim=2) 动态分配新张量并拷贝历史缓存,6 层跑 450 步就要做几千次小张量拼接。预分配缓存、按位置原地写入,可以避免反复拼接历史张量;也可以进一步比较使用 CUDA Graphs 后的耗时。这些优化分别能省多少,需要单独测试。

在 batch=16 时,启用缓存让吞吐量从 1,286.2 tok/s 提到了 2,134.6 tok/s(1.66x)。这些加速比只代表本次 T4、模型规模和窗口长度下的结果,而且每种配置只计时了一次。更大的模型和更长的上下文会改变计算量与访存量,加速比要重新测量。

KV Cache 也有代价:每个新 Token 的注意力计算仍然要访问历史 K 和 V,缓存越长,访存量就越大。权重和缓存的读取可能成为解码瓶颈,是否已经受显存带宽限制,仍要结合具体实现和测量来看。缓存所需字节数约为 2 × batch_size × seq_len × n_layer × n_kv_head × head_dim × 每元素字节数,其中 2 对应 K 和 V;本例是普通多头注意力,n_kv_head = n_head。


#4. 小结

把这一篇在 4.2(BPE + RoPE) 基础上做的三次对照实验汇总如下:

实验版本归一化与前馈层推理方式参数量最佳验证 Loss第 2,000 步 Loss (train / val)这次观察到的变化
4.2 基线LayerNorm + GELU (1536)全序列重算12.19M3.8201.184 / 4.002上一篇终点,训练耗时 372.4s
5.1 + RMSNormRMSNorm + GELU (1536)全序列重算12.19M3.8221.188 / 3.997砍掉减均值中心化,Loss 曲线几乎完全重合
5.2 + SwiGLURMSNorm + SwiGLU (1024)全序列重算12.19M3.9090.899 / 4.203前 600 步 train/val 双优;小语料重复约 36 遍下拟合更快、过拟合也更早
5.3 + KV CacheRMSNorm + SwiGLU (1024)Prefill + KV Cache12.19M3.9090.899 / 4.203FP32 数值接近,贪心生成 64 Token 一致;续写 450 Token 时 batch=1 提速 1.24x,batch=16 提速 1.66x

到这里,我们的迷你模型在单层结构上已经对齐了主流开源模型的基本模样(BPE + RoPE + RMSNorm + SwiGLU + KV Cache)。下一篇(规模扩展、分组查询注意力与稀疏混合专家)我们顺着最后留下的两个问题继续往下改:一是用 GQA(分组查询注意力,Grouped-Query Attention) 让多个 Query 头共享同一组 K/V 头,给刚刚加上去的 KV Cache“瘦身”;二是用 Sparse MoE(稀疏混合专家) 把前馈层拆成多个专家按需激活,看看在单步计算量不变的前提下能不能塞进更多参数。