---
tags: [nanochat, transformer, normalization]
阶段: 04-Transformer架构
难度: ★★☆
created: 2026-10-22
related: "[[前馈层与激活函数]], [[GPT模型类与config]], [[Transformer架构详解]], [[从第一性看nanochat的gpt.py]]"
---

# 残差连接与LayerNorm

## 定义

**残差连接**（residual connection）是把子层输出与子层输入相加的结构：

$$
\mathbf{h}_l=\mathbf{h}_{l-1}+F_l(\mathbf{h}_{l-1}),
$$

其中 $\mathbf{h}_l\in\mathbb{R}^{C}$ 是第 $l$ 层的表示，$F_l$ 是注意力或前馈子层。**层归一化**（LayerNorm，LN）对单个 token 的通道维做中心化与方差归一化，再施加逐通道仿射：

$$
\operatorname{LN}(\mathbf{x})=\boldsymbol{\gamma}\odot\frac{\mathbf{x}-\mu}{\sqrt{\sigma^2+\epsilon}}+\boldsymbol{\beta},\qquad
\mu=\frac{1}{C}\sum_{i=1}^{C}x_i,\qquad
\sigma^2=\frac{1}{C}\sum_{i=1}^{C}(x_i-\mu)^2 .
$$

**均方根归一化**（RMSNorm）去掉中心化与偏置，只按均方根缩放：

$$
\operatorname{RMSNorm}(\mathbf{x})=\boldsymbol{\gamma}\odot\frac{\mathbf{x}}{\sqrt{\frac{1}{C}\sum_{i=1}^{C}x_i^2+\epsilon}} .
$$

符号与术语如下。

| 符号 | 含义 |
|---|---|
| $\mathbf{x},\mathbf{h}_l$ | 单个 token 的 $C$ 维表示；$\mathbf{h}_0$ 为嵌入层输出 |
| $F_l$ | 第 $l$ 个子层：注意力或前馈网络 |
| $L$ | 层数，代码中 `n_layer` |
| $\mu,\sigma^2$ | 单个 token 在通道维上的均值与方差 |
| $\epsilon$ | 数值稳定项；PyTorch 的 `F.rms_norm` 在未指定时取 `finfo(dtype).eps` |
| $\boldsymbol{\gamma},\boldsymbol{\beta}$ | 逐通道增益与偏置；nanochat 的 RMSNorm 两者都没有 |
| $\alpha_l$ | 残差缩放系数，代码中 `resid_lambdas[l]` |
| $\beta_l$ | 初始嵌入混合系数，代码中 `x0_lambdas[l]`（勿与上面的 $\boldsymbol{\beta}$ 混淆） |

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

## 为什么重要

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

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

两者结合还决定了一个实现细节：nanochat 的块在初始化时是恒等映射。`attn.c_proj` 与 `mlp.c_proj` 都零初始化，因此 $F_l(\cdot)=0$，$\mathbf{h}_l=\mathbf{h}_{l-1}$。这使得“加残差”在训练第一步不会改变表示，梯度也不会被随机子层打乱；随后子层输出逐渐偏离零。若把零初始化换成普通初始化，这一步的性质消失，早期训练更抖。

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

## 原理与推导

### 1 残差的前向展开

把递推式展开：

$$
\mathbf{h}_L=\mathbf{h}_0+\sum_{l=1}^{L}F_l(\mathbf{h}_{l-1}).
$$

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

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

第二，表示的尺度随层数增长。若各层增量与 $\mathbf{h}$ 同量级，$\|\mathbf{h}_L\|$ 约为 $\sqrt{L}$ 或 $L$ 量级，取决于增量之间的相关性。nanochat 用 `resid_lambdas` 显式控制这一增长（「在 nanochat 中的落地」一节），并在最后用一次 `norm` 把尺度收回。

### 2 残差的反向性质

设损失为 $\mathcal{L}$，第 $l$ 层雅可比为 $\mathbf{J}_l=\partial F_l/\partial\mathbf{h}_{l-1}$。由链式法则，

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{h}_0}
=\frac{\partial\mathcal{L}}{\partial\mathbf{h}_L}\prod_{l=1}^{L}\big(\mathbf{I}+\mathbf{J}_l\big).
$$

把乘积展开：

$$
\prod_{l=1}^{L}(\mathbf{I}+\mathbf{J}_l)
=\mathbf{I}+\sum_{l}\mathbf{J}_l+\sum_{l_1<l_2}\mathbf{J}_{l_2}\mathbf{J}_{l_1}+\cdots+\prod_{l}\mathbf{J}_l .
$$

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

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{h}_0}
=\frac{\partial\mathcal{L}}{\partial\mathbf{h}_L}+\text{其余项},
$$

即梯度中恒有一份原样的 $\partial\mathcal{L}/\partial\mathbf{h}_L$，不会被 $L$ 次连乘压掉。其余项可能很小，也可能很大，取决于 $\mathbf{J}_l$ 的谱；但“必然衰减到零”这一失效模式被消除了。

一维标量例子可以手算。设 $F_l'(x)=0.5$ 为常数。没有残差时，$10$ 层后的梯度因子为 $0.5^{10}\approx9.8\times10^{-4}$；有残差时，因子为 $(1+0.5)^{10}\approx57.7$。若 $F_l'=-0.9$，有残差时因子为 $(1-0.9)^{10}=10^{-10}$，仍然会衰减：恒等项保证的是“存在一条不衰减的路径”，不是“每个因子都大于 $1$”。实践中的风险是 $\mathbf{J}_l$ 的谱半径过大导致爆炸，这也是需要归一化与残差缩放的原因。

### 3 Pre-LN 与 Post-LN

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

| 结构 | 定义 | 残差主干上的运算 | 性质 |
|---|---|---|---|
| Post-LN | $\mathbf{h}_l=\operatorname{LN}\big(\mathbf{h}_{l-1}+F_l(\mathbf{h}_{l-1})\big)$ | 每层都过 LN | 原始 Transformer 采用；深层需要 warmup，梯度对初始化敏感 |
| Pre-LN | $\mathbf{h}_l=\mathbf{h}_{l-1}+F_l\big(\operatorname{LN}(\mathbf{h}_{l-1})\big)$ | 主干不过 LN | 梯度恒等路径干净；主干尺度随深度增长，末端需一次 LN |

Pre-LN 的反向路径中，$\partial\mathbf{h}_l/\partial\mathbf{h}_{l-1}=\mathbf{I}+\mathbf{J}_l^{\text{branch}}\cdot\mathbf{J}^{\text{LN}}$，恒等项仍是 $\mathbf{I}$；LN 的雅可比只出现在分支项里。Post-LN 的 $\partial\mathbf{h}_l/\partial\mathbf{h}_{l-1}=\mathbf{J}^{\text{LN}}(\mathbf{I}+\mathbf{J}_l)$，恒等路径也要经过 LN 的雅可比，归一化的缩放会乘到整条路径上。这是 Pre-LN 在深层更稳定的机制性原因。

nanochat 是 Pre-LN，并且在末端补一次归一化：

```python
# 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 只做第二件，且用均方根代替标准差。对同一向量 $\mathbf{x}=(1,2,3,4)$：

$$
\mu=2.5,\quad \sigma=\sqrt{1.25}\approx1.1180,\quad \operatorname{rms}=\sqrt{7.5}\approx2.7386,
$$

$$
\operatorname{LN}(\mathbf{x})\approx(-1.3416,-0.4472,0.4472,1.3416),\qquad
\operatorname{RMSNorm}(\mathbf{x})\approx(0.3651,0.7303,1.0954,1.4606).
$$

两者都满足缩放不变性：对任意 $c>0$，$\operatorname{LN}(c\mathbf{x})=\operatorname{LN}(\mathbf{x})$、$\operatorname{RMSNorm}(c\mathbf{x})=\operatorname{RMSNorm}(\mathbf{x})$（忽略 $\epsilon$）。差异在平移：LN 对 $\mathbf{x}+c\mathbf{1}$ 不变，RMSNorm 会改变。因此 LayerNorm 的输出零均值，RMSNorm 的输出保留输入的均值方向。

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

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

### 5 归一化与残差流的交互

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

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

### 在 nanochat 中的落地

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

```python
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 为 $2^{-7}=0.0078125$，fp32 为 $1.19\times10^{-7}$）。bf16 下 eps 较大，当输入 RMS 很小时会显著改变输出；在正常训练中 RMS 约为 $1$，影响可忽略。

**块结构。** `Block.forward` 只有两行：

```python
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` 的循环中、进入块之前：

```python
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__` 里只放占位：

```python
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` 从 $1.15$ 线性降到 $1.05$，`x0_lambdas` 从 $0.20$ 降到 $0.05$；d24 的端点相同，步长更小。d12 的乘性部分累计放大 $\prod_l\alpha_l\approx3.12$，d24 约为 $9.76$（不含 `x0` 项）；pre-norm 保证这一放大不改变子层输入的分布，最终由末端 `norm` 收口。

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

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

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

```python
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` 为零意味着两个子层的输出为零，块的增量为零、块在第一步是恒等映射。若这两处不零初始化，$F_l(\mathbf{h})$ 在初始化时就有随机输出，残差流被随机扰动，梯度与激活的方差随深度增长。注意这些零初始化必须写在 `init_weights` 中：`GPT.__init__` 运行在 meta device 上下文，任何在 `__init__` 里写入的数值都会被丢弃。

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

## 关键直觉

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

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

## 例子与代码

### 例 1：NumPy 实现 RMSNorm 并与 PyTorch 对照

```python
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))
```

```text
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 在六位小数的打印精度下一致；两者的 $\epsilon$ 默认值不同（NumPy 版取 $10^{-6}$，PyTorch 版取当前 dtype 的机器 epsilon），差异在 $10^{-7}$ 量级。LayerNorm 一栏按定义式在 NumPy 中计算，用于与 RMSNorm 对照。第二行输入全为 $1$，RMSNorm 输出仍为全 $1$，LayerNorm 输出全 $0$：LayerNorm 的中心化把常数向量映射到零，而 RMSNorm 只改变长度、不改变方向。这就是选择 RMSNorm 后“归一化不能提供零均值”的具体表现。

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

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

```python
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)])
```

```text
无残差 ['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']
```

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

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

```python
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]))
```

```text
块输出与输入逐元素相等 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”的模型相同。残差标量的端点由公式直接给出：首层 $1.15$ 与 $0.20$，末层 $1.05$ 与 $0.05$。仅乘性项就把 d24 的残差流放大约 $9.76$ 倍；pre-norm 在每个块入口归一化，因此这一放大只改变主干的绝对尺度，不改变子层输入。

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

```python
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` 是另一条负残差路径：在中点缓存表示，末端减去 $0.2$ 倍，用于削弱低层特征；`dev/LOG.md` 2026-01-16 曾把它记为 “No improvement”，当前代码仍保留该参数，两者不一致说明该实验在此后还有变动，以代码为准。

## 易错点

> [!warning] 以下六条均可由数值、形状或单元测试直接检验。
> 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` 中完成，否则加载检查点前它们保持占位值（$1$ 与 $0$）。
> 4. 两类标量共用学习率。`resid_lambdas` 是乘性、逐层复合，需要 `scalar_lr * 0.01`；把它与 `x0_lambdas` 放进同一组会让残差流被过度放大或压缩，表现为损失尖峰或训练停滞。
> 5. 在 norm 之前加缩放并期待效果。RMSNorm 对正标量不变，给 QKV 乘一个标量门控会被随后的 `norm` 消掉；`dev/LOG.md` 2026-01-18 记录了约 $10^{-4}$ 的损失改善，作者因收益不足以抵消复杂度而放弃 `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 的定义式，指出恒等路径在哪一种结构中被归一化的雅可比污染。
- [ ] 把 $\prod_{l=1}^{L}(\mathbf{I}+\mathbf{J}_l)$ 展开，说明恒等项对应哪条路径，并用一维 $F'=0.5$、$L=10$ 的例子计算有/无残差的梯度因子。
- [ ] 写出 LayerNorm 与 RMSNorm 的公式，给出 $\mathbf{x}=(1,2,3,4)$ 的两组输出，并解释为什么 RMSNorm 不产生零均值。
- [ ] 运行例 2，报告三种结构在 $L=4,8,12,16$ 的梯度范数，并解释“有残差但梯度仍增长”与“pre-RMSNorm 有界”的原因。
- [ ] 写出 d12 与 d24 的 `resid_lambdas`、`x0_lambdas` 端点与乘积，说明为什么 `resid_lambdas` 的学习率要小 $100$ 倍。
- [ ] 解释为什么 `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 节的残差、归一化与深层训练稳定性讨论。
