w wyl123ly 的博客
MD

残差连接与LayerNorm

27 KB 2026.10.22 原文件

残差连接与LayerNorm

定义

残差连接(residual connection)是把子层输出与子层输入相加的结构:

其中 是第 层的表示, 是注意力或前馈子层。层归一化(LayerNorm,LN)对单个 token 的通道维做中心化与方差归一化,再施加逐通道仿射:

均方根归一化(RMSNorm)去掉中心化与偏置,只按均方根缩放:

符号与术语如下。

符号含义
单个 token 的 维表示; 为嵌入层输出
第 个子层:注意力或前馈网络
层数,代码中 n_layer
单个 token 在通道维上的均值与方差
数值稳定项;PyTorch 的 F.rms_norm 在未指定时取 finfo(dtype).eps
逐通道增益与偏置;nanochat 的 RMSNorm 两者都没有
残差缩放系数,代码中 resid_lambdas[l]
初始嵌入混合系数,代码中 x0_lambdas[l](勿与上面的 混淆)

Pre-LN 指归一化放在子层分支内部、残差相加之前;Post-LN 指先相加再做归一化。二者只差归一化的位置,梯度性质不同。

为什么重要

没有残差连接时,第 层的表示是 ,反向传播的梯度是各层雅可比的连乘。若每层雅可比的谱范数略小于 ,连乘随深度指数衰减;略大于 ,则指数放大。深网络因此对初始化与学习率极端敏感。残差把表示变成“输入 + 各层增量”,反向时至少保留一条不经过子层雅可比的恒等路径,梯度不再必然随深度衰减。nanochat 的 d24 模型有 个块,每个块含注意力与前馈两个残差子层,恒等路径是它能稳定训练的前提之一。

归一化解决另一半问题:子层输入的尺度。注意力打分与矩阵乘都对输入尺度敏感,若每层输出的尺度随训练漂移,深层需要不断适应新的量级。LayerNorm 的归一化部分把每个 token 的通道向量拉到零均值、单位方差(再经增益与偏置);RMSNorm 只拉到单位均方根。nanochat 选择 RMSNorm,并且不设可学习增益,进一步减少参数与内核开销。它的代价是失去中心化与逐通道缩放,但在这个架构里,残差流与线性层承担了尺度调节。

两者结合还决定了一个实现细节:nanochat 的块在初始化时是恒等映射。attn.c_proj 与 mlp.c_proj 都零初始化,因此 ,。这使得“加残差”在训练第一步不会改变表示,梯度也不会被随机子层打乱;随后子层输出逐渐偏离零。若把零初始化换成普通初始化,这一步的性质消失,早期训练更抖。

在全书中的位置:本篇承接 自注意力机制 与 多头注意力,解释它们外层 x + F(norm(x)) 的结构;前馈层与激活函数 是第二个子层;GPT模型类与config 与 从第一性看nanochat的gpt.py 会把这里的公式放回 GPT.forward 的完整循环。跨库 Transformer架构详解 给出 Post-LN 原始结构与 Pre-LN 的通用对比,本篇只写 nanochat 的实现选择与标量参数。

原理与推导

1 残差的前向展开

把递推式展开:

输出是初始表示与各层增量之和。这个式子是精确的,不含近似。它带来两个直接性质。

第一,恒等映射是默认行为。若某层 的输出为零(nanochat 初始化时正是如此),该层不改变表示;若某层学到的是小增量,表示只被轻微修改。模型可以选择“跳过”某些层,而不需要学习一个恒等矩阵。

第二,表示的尺度随层数增长。若各层增量与 同量级, 约为 或 量级,取决于增量之间的相关性。nanochat 用 resid_lambdas 显式控制这一增长(「在 nanochat 中的落地」一节),并在最后用一次 norm 把尺度收回。

2 残差的反向性质

设损失为 ,第 层雅可比为 。由链式法则,

把乘积展开:

共 项,其中第一项是单位阵,对应“从第 层直接回到第 层、不经过任何子层”的路径。因此

即梯度中恒有一份原样的 ,不会被 次连乘压掉。其余项可能很小,也可能很大,取决于 的谱;但“必然衰减到零”这一失效模式被消除了。

一维标量例子可以手算。设 为常数。没有残差时, 层后的梯度因子为 ;有残差时,因子为 。若 ,有残差时因子为 ,仍然会衰减:恒等项保证的是“存在一条不衰减的路径”,不是“每个因子都大于 ”。实践中的风险是 的谱半径过大导致爆炸,这也是需要归一化与残差缩放的原因。

3 Pre-LN 与 Post-LN

两种排列的定义与梯度路径如下。

结构定义残差主干上的运算性质
Post-LN每层都过 LN原始 Transformer 采用;深层需要 warmup,梯度对初始化敏感
Pre-LN主干不过 LN梯度恒等路径干净;主干尺度随深度增长,末端需一次 LN

Pre-LN 的反向路径中,,恒等项仍是 ;LN 的雅可比只出现在分支项里。Post-LN 的 ,恒等路径也要经过 LN 的雅可比,归一化的缩放会乘到整条路径上。这是 Pre-LN 在深层更稳定的机制性原因。

nanochat 是 Pre-LN,并且在末端补一次归一化:

# Block.forward:块内结构
x = x + self.attn(norm(x), ve, cos_sin, window_size, kv_cache)   # 注意力子层
x = x + self.mlp(norm(x))                                        # 前馈子层

# GPT.forward 循环结束后
x = norm(x)                                                      # 进入 lm_head 之前

没有这次末端归一化,残差流经多层放大后直接进入 lm_head,logits 的尺度会随深度漂移;有了它,lm_head 看到的输入尺度与训练初期一致。

4 LayerNorm 与 RMSNorm 的差异

LayerNorm 做两件事:减均值、除标准差。RMSNorm 只做第二件,且用均方根代替标准差。对同一向量 :

两者都满足缩放不变性:对任意 ,、(忽略 )。差异在平移:LN 对 不变,RMSNorm 会改变。因此 LayerNorm 的输出零均值,RMSNorm 的输出保留输入的均值方向。

速度差异来自归约次数与逐元素运算。LN 需要一次求和得到 、再一次求和得到 ,再做减法、除法、乘加;RMSNorm 只需一次平方和,没有减法与偏置。两者都是显存受限的逐元素内核,减少一趟读写与几个逐元素算子即可带来可观吞吐提升。nanochat 的 norm 还不带可学习增益,省去了逐通道乘法与对应参数。dev/LOG.md 2026-05-05 记录了用 DyT 替换归一化的尝试:没有超过基线,吞吐还低约 ,说明在这个规模上 RMSNorm 的简洁实现已经接近最优。

RMSNorm 没有可学习增益,并不等于“没有尺度自由度”。逐通道增益无法被残差缩放替代,但 nanochat 把尺度控制放在两处:残差流上的 resid_lambdas,以及每个线性层自身的权重。对 QK norm 而言,无可学习增益是刻意的:它的目的只是把每个头的查询、键固定到单位 RMS,任何逐通道增益都会重新引入尺度漂移。

5 归一化与残差流的交互

Pre-LN 的一个直接推论是:残差流的绝对尺度不影响子层输入。因为每个子层入口都先做 norm,把输入拉到单位均方根,resid_lambdas 放大残差流不会改变分支看到的分布。这与 dev/LOG.md 2026-01-18 的一条观察一致:给 QKV 加逐头标量门控几乎没有效果,因为随后的 RMSNorm 会消掉标量倍数;作者记录了约 的损失改善,认为收益不足以抵消复杂度,最终放弃 sa_lambdas。理解这一点可以避免在 norm 之前加缩放、期待它改变模型行为。

残差流尺度仍然影响两处。第一,最终 norm 之前的数值范围:若放大过多,bf16 的表示范围可能不够,但 RMSNorm 在末端会把尺度收回,只要中间不发生溢出。第二,x0 混合项的相对权重:x 被放大后,固定系数的 x0 项占比下降,模型需要通过 x0_lambdas 补偿。nanochat 的初始化把 resid_lambdas 设为略大于 、x0_lambdas 设为递减的正数,正是为这两项设定初始平衡。

在 nanochat 中的落地

归一化函数。 nanochat/gpt.py 顶部只有一行:

def norm(x):
    return F.rms_norm(x, (x.size(-1),))  # 在 bf16 下运行

F.rms_norm 的第二个参数是归一化维度,(x.size(-1),) 表示只对最后一维(通道维)归一,不对 batch 或 token 维做任何混合。没有传 weight,因此没有可学习增益;eps 未指定,取当前 dtype 的机器 epsilon(bf16 为 ,fp32 为 )。bf16 下 eps 较大,当输入 RMS 很小时会显著改变输出;在正常训练中 RMS 约为 ,影响可忽略。

块结构。 Block.forward 只有两行:

def forward(self, x, ve, cos_sin, window_size, kv_cache):
    x = x + self.attn(norm(x), ve, cos_sin, window_size, kv_cache)
    x = x + self.mlp(norm(x))
    return x

两个子层都是“先归一化、再计算、再加回”。norm 的输入是当前残差流,输出进入子层;子层输出加回未归一化的残差流。注意力与 MLP 内部都没有偏置,也没有 dropout。

残差标量的位置。 Block.forward 里没有 resid_lambdas;缩放发生在 GPT.forward 的循环中、进入块之前:

x0 = x
for i, block in enumerate(self.transformer.h):
    x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0
    ve = self.value_embeds[str(i)](idx).to(x.dtype) if str(i) in self.value_embeds else None
    x = block(x, ve, cos_sin, self.window_sizes[i], kv_cache)

顺序是“先缩放、再加 x0、再进块”。x0 在循环之前保存,等于 norm(wte(idx)) 再经过 smear 之后的表示;也就是说,x0 是初始归一化嵌入,不包含任何块的计算。把 x0 保存为 wte(idx) 的原始输出(未归一化)会改变混合项的尺度,属于实现差异而非等价变换。

初始化。 两个标量的真实值在 init_weights 中写入,__init__ 里只放占位:

self.resid_lambdas = nn.Parameter(torch.ones(config.n_layer))
self.x0_lambdas = nn.Parameter(torch.zeros(config.n_layer))
# 以上是占位值,真实值在 init_weights 中写入
for i in range(n_layer):
    self.resid_lambdas.data[i] = 1.15 - (0.10 * i / max(n_layer - 1, 1))
for i in range(n_layer):
    self.x0_lambdas.data[i] = 0.20 - (0.15 * i / max(n_layer - 1, 1))

d12 的 resid_lambdas 从 线性降到 ,x0_lambdas 从 降到 ;d24 的端点相同,步长更小。d12 的乘性部分累计放大 ,d24 约为 (不含 x0 项);pre-norm 保证这一放大不改变子层输入的分布,最终由末端 norm 收口。

为什么要递减:浅层保留更多残差、深层逐渐减弱,同时浅层混合更多初始嵌入、深层减少。dev/LOG.md 2026-01-11 的解释是“early layers get more input embedding blending”;同一节的实验显示 x0 标量在 d8–d20 上稳定降低 val bpb(d8 从 到 ,d12 从 到 ,d16 从 到 ,d20 从 到 ),而 resid_lambdas 的增益较小。

学习率敏感性。 两类标量的优化器设置不同:resid_lambdas 的学习率是 scalar_lr * 0.01,x0_lambdas 用完整的 scalar_lr(默认 )。理由是乘性缩放会逐层复合,等效学习率被放大;加性混合不复合。dev/LOG.md 2026-01-11 明确记录:“resid_lambdas 需要约 倍更小的学习率”。把两者放进同一个参数组、用同一学习率,会让残差流在训练早期被乘性放大或压缩,损失出现尖峰。

零初始化输出投影。 init_weights 把 attn.c_proj 与 mlp.c_proj 都置零,c_q/c_k/c_v/c_fc 用均匀分布初始化:

torch.nn.init.zeros_(block.attn.c_proj.weight)
torch.nn.init.zeros_(block.mlp.c_proj.weight)
torch.nn.init.uniform_(block.mlp.c_fc.weight, -s * 0.4, s * 0.4)

attn.c_proj 与 mlp.c_proj 为零意味着两个子层的输出为零,块的增量为零、块在第一步是恒等映射。若这两处不零初始化, 在初始化时就有随机输出,残差流被随机扰动,梯度与激活的方差随深度增长。注意这些零初始化必须写在 init_weights 中:GPT.__init__ 运行在 meta device 上下文,任何在 __init__ 里写入的数值都会被丢弃。

末端归一化与 lm_head。 循环结束后 x = norm(x),再进入 logits = self.lm_head(x)。lm_head 也是无偏置 Linear,权重按 std 初始化;小的输出权重使初始 logits 接近零,softcap 与交叉熵在数值上更稳定。这些选择与 LayerNorm 无关,但它们共同决定了“深度增加时 logits 不失控”。

关键直觉

机制性表述

残差让每一层只学习“增量”,反向时保留一条不经过子层的恒等路径,因此梯度不会因深度指数衰减;Pre-LN 把归一化放进分支,主干保持干净,代价是主干尺度随深度增长、末端需要一次归一化。RMSNorm 只按均方根缩放、不减均值、不带增益,比 LayerNorm 少一次归约与一组参数。nanochat 在此基础上加两个逐层标量:resid_lambdas 在块前缩放残差流,x0_lambdas 把初始嵌入加回;二者初始化不同、学习率相差 倍。

该表述与严格定义的关系:第 1、2 节给出前向展开与反向展开,恒等项来自 的展开;第 3 节给出 Pre-LN/Post-LN 的雅可比位置差异;第 4 节给出 LN 与 RMSNorm 的公式与数值对照;「在 nanochat 中的落地」一节把标量的位置、初始化、学习率与零初始化逐条对应到 gpt.py。所谓“主干尺度增长”不是缺陷,而是 Pre-LN 的设计前提:分支输入被归一化,主干只需在末端收口。

例子与代码

例 1:NumPy 实现 RMSNorm 并与 PyTorch 对照

import numpy as np
import torch
import torch.nn.functional as F

def rms_norm_numpy(x, eps=1e-6):
    rms = np.sqrt((x ** 2).mean(axis=-1, keepdims=True) + eps)
    return x / rms

def layer_norm_numpy(x, eps=1e-12):
    mu = x.mean(axis=-1, keepdims=True)
    var = ((x - mu) ** 2).mean(axis=-1, keepdims=True)
    return (x - mu) / np.sqrt(var + eps)

x = np.array([[1.0, 2.0, 3.0, 4.0], [1.0, 1.0, 1.0, 1.0]])
xt = torch.tensor(x)
print("NumPy RMSNorm\n", rms_norm_numpy(x).round(6))
print("PyTorch RMSNorm\n", F.rms_norm(xt, (4,)).numpy().round(6))
print("NumPy LayerNorm\n", layer_norm_numpy(x).round(6))
print("均值", x.mean(-1), "均方根", np.sqrt((x ** 2).mean(-1)).round(6))
NumPy RMSNorm
 [[0.365148 0.730297 1.095445 1.460593]
 [1.       1.       1.       1.      ]]
PyTorch RMSNorm
 [[0.365148 0.730297 1.095445 1.460593]
 [1.       1.       1.       1.      ]]
NumPy LayerNorm
 [[-1.341641 -0.447214  0.447214  1.341641]
 [ 0.        0.        0.        0.      ]]
均值 [2.5 1. ] 均方根 [2.738613 1.      ]

NumPy RMSNorm 与 PyTorch RMSNorm 在六位小数的打印精度下一致;两者的 默认值不同(NumPy 版取 ,PyTorch 版取当前 dtype 的机器 epsilon),差异在 量级。LayerNorm 一栏按定义式在 NumPy 中计算,用于与 RMSNorm 对照。第二行输入全为 ,RMSNorm 输出仍为全 ,LayerNorm 输出全 :LayerNorm 的中心化把常数向量映射到零,而 RMSNorm 只改变长度、不改变方向。这就是选择 RMSNorm 后“归一化不能提供零均值”的具体表现。

例 2:深度与残差对梯度范数的影响

下面的实验用 维向量、 个随机线性层与 构造链式模型,比较无残差、有残差、有残差且前置 RMSNorm 三种结构在不同深度下损失对输入的梯度范数。

import math
import torch

torch.manual_seed(0)

def grad_norm(depth, mode):
    d = 8
    Ws = [0.5 * torch.randn(d, d) / math.sqrt(d) for _ in range(depth)]
    x = torch.randn(1, d, requires_grad=True)
    h = x
    for W in Ws:
        if mode == "preln":
            h_in = h / h.pow(2).mean(-1, keepdim=True).add(1e-6).sqrt()
        else:
            h_in = h
        f = torch.tanh(h_in @ W)
        h = h + f if mode != "plain" else f
    h.pow(2).sum().backward()
    return x.grad.norm().item()

for mode, label in [("plain", "无残差"), ("res", "残差"), ("preln", "残差 + pre-RMSNorm")]:
    print(label, ["d%d %.2e" % (L, grad_norm(L, mode)) for L in (4, 8, 12, 16)])
无残差 ['d4 1.31e-02', 'd8 2.66e-04', 'd12 6.87e-08', 'd16 5.46e-11']
残差 ['d4 1.38e+01', 'd8 2.42e+01', 'd12 2.99e+01', 'd16 3.61e+01']
残差 + pre-RMSNorm ['d4 5.74e+00', 'd8 1.03e+01', 'd12 1.72e+01', 'd16 1.60e+01']

无残差时梯度从 降到 ,随深度指数衰减;加残差后同一深度区间内梯度保持在 量级,没有消失。有残差且前置 RMSNorm 时,梯度量级被压在 –,深度增加不再单调放大。这里的绝对数值依赖随机权重与初始化尺度,可比较的是随深度的趋势:无残差单调衰减,有残差保持,pre-RMSNorm 有界。若把残差结果中的增长理解为“残差一定让梯度爆炸”,就把“存在恒等路径”与“分支雅可比有界”混为一谈;pre-RMSNorm 的作用正是限制后者。

例 3:恒等初始化与标量数组

import math
import torch
import torch.nn as nn
import torch.nn.functional as F

class Block(nn.Module):
    def __init__(self):
        super().__init__()
        self.c_fc = nn.Linear(8, 32, bias=False)
        self.c_proj = nn.Linear(32, 8, bias=False)
        torch.nn.init.zeros_(self.c_proj.weight)      # 与 nanochat 一致

    def forward(self, x):
        x = x + self.c_proj(F.relu(self.c_fc(F.rms_norm(x, (x.size(-1),)))).square())
        return x

torch.manual_seed(0)
b = Block()
x = torch.randn(2, 3, 8)
print("块输出与输入逐元素相等", torch.equal(b(x), x))

for L in (12, 24):
    resid = [1.15 - 0.10 * i / max(L - 1, 1) for i in range(L)]
    x0 = [0.20 - 0.15 * i / max(L - 1, 1) for i in range(L)]
    print("L=%d resid 首尾 %.2f %.2f,乘积 %.2f"
          % (L, resid[0], resid[-1], math.exp(sum(math.log(v) for v in resid))))
    print("L=%d x0 首尾 %.2f %.2f" % (L, x0[0], x0[-1]))
块输出与输入逐元素相等 True
L=12 resid 首尾 1.15 1.05,乘积 3.12
L=12 x0 首尾 0.20 0.05
L=24 resid 首尾 1.15 1.05,乘积 9.76
L=24 x0 首尾 0.20 0.05

零初始化使块在初始时严格等于恒等映射,这解释了为什么训练第一步的损失与“只有嵌入 + lm_head”的模型相同。残差标量的端点由公式直接给出:首层 与 ,末层 与 。仅乘性项就把 d24 的残差流放大约 倍;pre-norm 在每个块入口归一化,因此这一放大只改变主干的绝对尺度,不改变子层输入。

例 4:仓库中的残差与归一化语句

def norm(x):
    return F.rms_norm(x, (x.size(-1),))

class Block(nn.Module):
    def forward(self, x, ve, cos_sin, window_size, kv_cache):
        x = x + self.attn(norm(x), ve, cos_sin, window_size, kv_cache)
        x = x + self.mlp(norm(x))
        return x

# GPT.forward 中的循环与末端归一化
x0 = x
for i, block in enumerate(self.transformer.h):
    x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0
    ve = self.value_embeds[str(i)](idx).to(x.dtype) if str(i) in self.value_embeds else None
    x = block(x, ve, cos_sin, self.window_sizes[i], kv_cache)
    if i == backout_layer:
        x_backout = x
if x_backout is not None:
    x = x - self.backout_lambda.to(x.dtype) * x_backout
x = norm(x)

这段代码把第 3–5 节的结论集中在三处:块内两次“归一化—子层—相加”是 Pre-LN;循环开头的 resid_lambdas/x0_lambdas 是块前的标量混合;循环后的 norm(x) 是末端收口。backout 是另一条负残差路径:在中点缓存表示,末端减去 倍,用于削弱低层特征;dev/LOG.md 2026-01-16 曾把它记为 “No improvement”,当前代码仍保留该参数,两者不一致说明该实验在此后还有变动,以代码为准。

易错点

以下六条均可由数值、形状或单元测试直接检验。

1. 归一化位置放反。nanochat 是 Pre-LN:x = x + F(norm(x));写成 Post-LN 的 x = norm(x + F(x)) 不影响形状,但恒等路径要经过 LN 的雅可比,深层训练更抖,且与检查点的参数含义不同。检验方法:打印块输出与输入的差值,零初始化时 Pre-LN 的差值为零,Post-LN 的差值为 norm(x)-x。

2. x0 保存位置错误。x0 = x 必须在 norm(wte(idx)) 与 smear 之后、循环之前;若保存原始嵌入 wte(idx),混合项的尺度与训练时不同,损失曲线会偏移。

3. 标量的初始化写在 __init__。GPT.__init__ 在 meta device 上下文运行,写入的数值立即被丢弃;resid_lambdas/x0_lambdas 的真实初始化必须在 init_weights 中完成,否则加载检查点前它们保持占位值( 与 )。

4. 两类标量共用学习率。resid_lambdas 是乘性、逐层复合,需要 scalar_lr * 0.01;把它与 x0_lambdas 放进同一组会让残差流被过度放大或压缩,表现为损失尖峰或训练停滞。

5. 在 norm 之前加缩放并期待效果。RMSNorm 对正标量不变,给 QKV 乘一个标量门控会被随后的 norm 消掉;dev/LOG.md 2026-01-18 记录了约 的损失改善,作者因收益不足以抵消复杂度而放弃 sa_lambdas。若要改变尺度,应作用在 norm 之后或残差流上。

6. 假设存在 LayerNorm 的增益与偏置。nanochat 的 norm 不传 weight,检查点中没有 ln.weight/ln.bias;从 GPT-2 或其它实现移植权重时,不能按 LayerNorm 的字段名加载,也不能假设输出零均值。检验方法:遍历 model.state_dict(),确认没有归一化参数键。

关联笔记

  • 后续 前馈层与激活函数:前馈层是第二个残差子层,mlp(norm(x)) 的输出加回残差流;该篇给出 4 倍扩张、ReLU² 与初始化。
  • 后续 GPT模型类与config:该篇把 norm、残差标量、零初始化与末端归一化放回 GPT.forward 的完整前向,并解释 meta device 与 init_weights 的分工。
  • 后续 从第一性看nanochat的gpt.py:该篇逐行拆解 gpt.py,本篇的公式是其中“残差流”一节的数学基础。
  • 对照 Transformer架构详解(跨库):该篇给出 Post-LN 原始结构与 Pre-LN 的通用对比、LayerNorm 的反向公式;本篇只保留 nanochat 的 RMSNorm、残差标量与初始化取舍。
  • 对照 nanochat架构特化技巧:该篇汇总 x0、backout、smear 等非标准残差技巧;本篇给出它们共同的“残差 + 标量”框架。

达标检测

  • [ ] 写出 Pre-LN 与 Post-LN 的定义式,指出恒等路径在哪一种结构中被归一化的雅可比污染。
  • [ ] 把 展开,说明恒等项对应哪条路径,并用一维 、 的例子计算有/无残差的梯度因子。
  • [ ] 写出 LayerNorm 与 RMSNorm 的公式,给出 的两组输出,并解释为什么 RMSNorm 不产生零均值。
  • [ ] 运行例 2,报告三种结构在 的梯度范数,并解释“有残差但梯度仍增长”与“pre-RMSNorm 有界”的原因。
  • [ ] 写出 d12 与 d24 的 resid_lambdas、x0_lambdas 端点与乘积,说明为什么 resid_lambdas 的学习率要小 倍。
  • [ ] 解释为什么 attn.c_proj 与 mlp.c_proj 零初始化会让块成为恒等映射,并说明这些初始化为何不能放在 __init__ 中。
  • [ ] 列出 nanochat 的 norm 与标准 LayerNorm 的三处差别(中心化、增益、偏置),并说明各自的影响。

参考来源

  • Zhang & Sennrich, "Root Mean Square Layer Normalization", arXiv:1910.07467 —— 对应本篇第 4 节的 RMSNorm 公式、缩放不变性与计算量对比。
  • Vaswani et al., "Attention Is All You Need", arXiv:1706.03762, 第 3.1 节与图 1 —— 对应第 1 节的子层与残差定义、第 3 节的 Post-LN 原始结构。
  • Radford et al., "Language Models are Unsupervised Multitask Learners"(GPT-2 技术报告),2019 —— 对应第 3 节的 Pre-LN 结构与第 4 节的归一化位置选择。
  • Karpathy, nanochat,nanochat/gpt.py 的 norm、Block、GPT.forward、init_weights,dev/LOG.md 2026-01-11「Per-Layer Residual Scalars」与 2026-01-18「More various experiments」(commit 92d63d4)—— 对应「在 nanochat 中的落地」一节的标量初始化、学习率与 sa_lambdas 观察。
  • Raschka, Build a Large Language Model (From Scratch), 2024, 第 4 章 —— 对应第 1–3 节的残差、归一化与深层训练稳定性讨论。