上一课，我们把 Transformer 里那个经常被一笔带过的 MLP 拆开了。

到那里，一个 Token 在 Transformer Block 里已经会做两件事：

Attention（注意力）负责跨 Token 找信息，MLP（多层感知机）负责在 Token 内部继续加工这些信息。

换句话说，一层 Transformer 已经可以完成一轮：

信息交换 → 特征加工。

但问题也正是在这里出现的。

如果一层会修改一次 Representation（表示），那么 32 层就修改 32 次，80 层就修改 80 次。

那最开始的信息呢？

会不会改着改着就没了？

更麻烦的是，训练时最后一层产生的 Gradient（梯度），又怎么穿过几十层，一路找到最前面的参数？

这正是上一课故意留下来的问题，也是课程设计里第十五课要接住的核心：Residual Connection（残差连接）、LayerNorm（层归一化）、RMSNorm（均方根归一化），以及 Pre-Norm / Post-Norm 到底为什么存在。

这一课我不想让你背四个名词。

我想让你最后真正看见一件事：

Transformer 之所以能做深，不是因为每一层都可以随便改，而是因为架构从一开始就在控制“怎么改、改多少、旧信息怎么继续往后走”。

---

一、先把 Transformer 想象成一份被连续修改 80 次的文档

假设一个 Token 刚进入 Transformer 时，它的 Representation 是：

x0

第一层处理以后：

x1=F1(x0)

第二层：

x2=F2(x1)

第三层：

x3=F3(x2)

一直到第 80 层：

x80=F80(F79(⋯ F1(x0)))

数学上当然没问题。

但从工程直觉看，这个设计其实挺吓人的。

你可以把 (x_0) 想象成一份非常重要的合同。

第一个人拿过来修改，保存。

第二个人只能拿到第一个人改过的版本，再继续修改。

第三个人再改。

第四个人继续。

整整 80 个人。

没有原稿。

没有版本历史。

没有撤销。

后面的人永远只能拿到前面的人已经修改过的版本。

现在问题来了：

如果第 17 个人把一句重要内容改没了，第 18 个人甚至不知道那里以前存在过什么。

神经网络同样如此。

如果每一层都必须：

彻底用新 Representation 覆盖旧 Representation，

深度越大，信息传播就越困难。

而且反向传播时也有同样的问题。

最后的 Loss（损失）需要把“哪里错了”一路传回第一层。

网络越深，这条路越长。

所以深层网络真正困难的从来不只是：

“算得多。”

而是：

前向传播时，信息还能不能走过去；反向传播时，梯度还能不能走回来。

这才是 Residual Connection 出现的真正背景。

---

二、Residual 最重要的，不是“多了一个加号”

如果没有 Residual，一层网络可以写成：

xl+1=F(xl)

什么意思？

当前这一层接收到：

xl

然后必须输出一个完整的新 Representation：

xl+1

也就是说，这一层承担的是：

Full Rewrite

完整重写。

它必须回答：

“经过我这一层以后，新的 Representation 到底应该长什么样？”

这其实是一个很重的任务。

Residual Connection 换了一个完全不同的思路：

xl+1=xl+F(xl)

表面看：

只是多加了一个 (x_l)。

但真正的变化是：

这一层的工作职责变了。

它不再需要回答：

“新的 Representation 应该是什么？”

它只需要回答：

“原来的 Representation 基本保留，我这一层应该在上面补充什么？”

于是我们甚至可以把：

F(xl)

重新理解成：

Δ xl

那么公式变成：

xl+1=xl+Δ xl

突然就好理解了。

这一层不是重新创造 (x_{l+1})。

而是在已有 (x_l) 上：

做一次增量修改。

这就是 Residual 最值得记住的地方。

Residual 真正改变的不是公式，而是每一层的任务：从“重新创造整个表示”，变成“只学习这一次应该修改什么”。

---

三、Transformer 的几十层，其实更像“不断改稿”

举一个特别简单的数字例子。

假设某个 Token 当前的 Representation 是：

xl=
[10,\ 20,\ 30]

这一层 Attention 或 MLP 计算以后认为：

当前只需要做一点调整：

Δ xl=
[1,\ -2,\ 0.5]

那么：

xl+1
xl+Δ xl

得到：

[11,\ 18,\ 30.5]

看到区别了吗？

这一层并没有说：

“前面的东西全部作废，我重新生成一份。”

而是在说：

“前面的东西先留下，我只负责把自己学到的新东西补进去。”

于是第一层：

x1=x0+Δ x0

第二层：

x2=x1+Δ x1

第三层：

x3=x2+Δ x2

……

深度突然有了一个非常不一样的理解：

Iterative Refinement

迭代精炼。

模型不是一层层把 Representation 推倒重建。

更像是：

第一层改一遍。

第二层根据修改后的结果继续改。

第三层继续精炼。

第四层再补充新的信息。

所以以后看到：

“80-layer Transformer”

不要只理解成：

“80 个模块摞起来。”

更值得理解的是：

同一条 Representation，在 80 个阶段里被持续加工和精炼。

这就是深度真正有意义的地方。

---

四、Residual 还有一个特别聪明的性质：这一层暂时不会，也可以少添乱

再看：

xl+1=xl+F(xl)

现在假设某一层暂时没有学到什么有价值的东西。

如果：

F(xl)≈0

那么：

xl+1≈ xl

也就是说，这一层至少存在一种比较简单的状态：

Identity Mapping

恒等映射。

输入什么，基本继续传什么。

这件事非常重要。

如果没有 Residual：

你增加一层网络，就等于新增了一次必须执行的完整 Transformation（变换）。

这一层如果学不好，它照样会改变 Representation。

有了 Residual：

新增的一层至少可以先学到：

“我目前没什么好改的，那就少改一点。”

所以我特别喜欢用一句话理解它：

Residual 不要求每一层都成为天才，它至少允许一层在没学明白的时候，先别把前面的成果毁掉。

当然，这只是理解方式。

真实训练里 (F(x)) 不会永远接近 0，模型也完全可能对 Representation 做很强的改变。

但 Residual 提供了一条非常重要的：

Identity Path

恒等路径。

旧 Representation 有一条相对直接的路可以继续往后走。

而这条路不仅对前向传播重要。

到了反向传播，它还会再救模型一次。

---

五、为什么一个小小的加号，会让 Gradient 更容易往前传？

这里稍微碰一点数学。

但这一段一定值得看懂。

没有 Residual 时：

xl+1=F(xl)

那么：

∂ xl+1∂ xl
∂ F(xl)∂ xl

如果整个模型特别深，反向传播时 Gradient 需要连续经过很多层。

可以粗略想象成不断乘：

JLJL-1JL-2⋯ J1

这里的 (J) 是 Jacobian（雅可比矩阵）。

不用学雅可比矩阵的完整数学。

你现在只需要知道：

它描述了“这一层的输出对输入变化有多敏感”。

问题在于，这么多东西一路乘下去：

如果整体不断变小，Gradient 就可能越来越弱。

这就是：

Vanishing Gradient

梯度消失。

如果整体越来越大：

就可能出现：

Exploding Gradient

梯度爆炸。

---

现在加入 Residual：

xl+1=xl+F(xl)

再求导：

∂ xl+1∂ xl
I+
∂ F(xl)∂ xl

看见了吗？

突然多了一个：

I

Identity Matrix。

单位矩阵。

这个 (I) 就来自那条：

xl

直接加到下一层的路径。

这意味着 Gradient 不再只能穿过：

F

那一整套复杂计算。

它还有一个来自 Identity Path 的直接贡献。

如果暂时不谈数学，可以把它理解成：

没有 Residual：

梯度想回去，只能穿过加工厂。

有了 Residual：

加工厂旁边多了一条相对直接的通道。

所以 Residual 的价值有两面。

前向：

让已有 Representation 更容易继续传播。

反向：

让 Gradient 拥有更直接的传播路径。

但注意，我故意没有说：

“Residual 解决了梯度消失。”

这种话太绝对。

Residual 会显著改善深层网络的 Optimization（优化）条件，但训练稳定性还受：

Learning Rate（学习率）、Initialization（初始化）、Optimizer（优化器）、Normalization（归一化）、Precision（数值精度）等很多因素影响。

更严谨的表述应该是：

Residual Connection 为 Representation 和 Gradient 都提供了更直接的跨层传播路径，从而让深层网络更容易被优化。

---

六、现在终于能理解一个经常出现的词：Residual Stream

以后看现代大模型论文或者源码，你会经常碰到：

Residual Stream

残差流。

如果只是把它理解成：

“模型里那些残差连接。”

其实还没有真正理解。

更好的方式是：

把它想象成 Transformer 内部一直存在的一条：

Representation 主干。

假设当前状态是：

x

Attention 不一定把 (x) 整个替换掉。

它更像在说：

“我刚刚从上下文里找回来一些有价值的信息，把它写进去。”

所以：

x'
x+Attention(⋯)

然后 MLP 接着说：

“我又对这些 Feature 做了一轮加工，再把加工结果补进去。”

于是：

x''
x'+MLP(⋯)

下一层继续。

所以整个 Transformer 里发生的事情可以换一个视角看：

Residual Stream：

保存当前工作状态。

Attention：

读取上下文，生成一次 Update（更新）。

MLP：

加工 Feature，再生成一次 Update。

然后：

这些 Update 一次次写回 Residual Stream。

这和开发里维护一个 State（状态）非常像。

有一个持续存在的状态：

State

各个模块不会每次重新创建整个 State。

它们更像提交一个 Patch（补丁）：

State'=State+Patch

这就是 Residual Stream 最有价值的直觉。

Attention 和 MLP 决定“这一轮应该写进去什么”，Residual Stream 决定“前面已经形成的 Representation 还有一条路继续往后走”。

到这里，第十四课和第十五课已经真正接上了。

上一课讲的是：

Attention 和 MLP 分别负责什么计算。

这一课开始回答：

这些计算结果到底怎样在几十层之间持续积累。

---

七、但这时候又冒出一个问题：一直加，数值不会越来越乱吗？

我们现在有：

xl+1=xl+Fl(xl)

然后下一层：

xl+2=xl+1+Fl+1(xl+1)

再下一层继续。

几十层一直加。

那么新的问题出现了：

Representation 的数值尺度怎么办？

有些 Feature 可能越来越大。

有些非常小。

不同层接收到的输入 Magnitude（幅度）也可能不断变化。

你可以想象一个分析师每天拿到一份业务数据。

星期一：

销售额单位是“元”。

星期二：

突然换成“万元”。

星期三：

又变成“百万美元”。

数据本身都没错。

问题是：

尺度一直变。

你的分析系统每次都得重新适应。

神经网络也一样。

如果 Attention 和 MLP 每一层收到的输入 Numerical Scale（数值尺度）一直乱跑：

优化就会变得更加困难。

于是第二个关键模块出现：

Normalization

归一化。

所以 Residual 和 Normalization 根本不是两个应该分开死记的知识点。

它们是在解决同一条深层信息通路上的两个问题。

Residual 更关心：

信息有没有一条稳定的路径往后走。

Normalization 更关心：

沿着这条路传递的 Representation，数值尺度是不是好处理。

这里可以留下这一课的第二句核心金句：

Residual 保护的是“路”，Normalization 管理的是“路上传递的数值尺度”。

---

八、Normalization 到底是什么？先把三个误解扔掉

Normalization 不是：

“把所有数值压到 0～1。”

那更像 Min-Max Normalization（最小最大归一化）。

也不是：

Softmax。

Softmax 是把 Logits（未归一化分数）转换成概率分布。

更不是：

“让所有 Token 变得差不多。”

Transformer 里的 Normalization，更应该理解成：

对当前 Representation 的数值统计尺度进行整理。

比如当前 Token 是：

[2,\ 4,\ 6,\ 8]

另一次可能出现：

[200,\ 400,\ 600,\ 800]

它们表现出的相对 Pattern 很相似。

但 Magnitude 差了 100 倍。

如果后面的模块永远都需要同时兼容极端不同的输入尺度：

优化难度自然会增加。

所以 Normalization 做的一件重要事情就是：

先把当前 Representation 整理到一个更容易处理的数值条件下，再交给 Attention 或 MLP。

---

九、LayerNorm 到底干了什么？别急着背公式

经典的 LayerNorm：

Layer Normalization

层归一化。

假设一个 Token 的 Representation 有 (d) 个 Feature：

x=[x1,x2,⋯,xd]

首先计算 Mean（均值）：

μ=
1d
Σi=1dxi

然后计算 Variance（方差）：

σ2
1d
Σi=1d
(xi-μ)2

接着：

x̂i
xi-μ
√σ2+ε

最后再加上 Learnable Parameter（可学习参数）：

yi=
γix̂i+βi

第一次看公式有点长。

但把它拆开，其实就两个核心动作。

第一件事叫：

Centering

中心化。

也就是：

xi-μ

把当前这一组 Feature 相对于自己的均值重新拉到一个中心附近。

第二件事：

Scaling

尺度调整。

再除以标准差。

所以 LayerNorm 实际上在问：

“你这一组 Feature 整体偏到哪里去了？”

以及：

“你这一组 Feature 的尺度到底有多大？”

然后统一整理。

最后为什么还有：

γ,β

？

因为神经网络并不希望 Normalization 把所有 Representation 永久固定死。

(γ) 和 (β) 允许模型在归一化之后：

继续学习自己需要的 Scale（缩放）和 Shift（偏移）。

---

十、一个特别容易忽略的点：LayerNorm 是每个 Token 自己整理自己

假设：

X∈ℝN× d

其中：

(N) 是 Sequence Length（序列长度）。

(d) 是 Hidden Size（隐藏维度）。

Transformer 里的 LayerNorm，通常是在当前 Token 自己的 Hidden Dimension 上工作。

也就是说：

Token 1：

看自己的 (d) 个 Feature。

Token 2：

看自己的 (d) 个 Feature。

Token 3：

也是如此。

它不是：

“Token 1 和 Token 2 放在一起求平均。”

因为 Token 与 Token 之间的信息交互，本来就是 Attention 更主要负责的事情。

于是到这里，一个非常清楚的分工出来了：

Attention：

跨 Token 信息路由。

MLP：

Token 内 Feature 加工。

Normalization：

Token 内 Representation 数值尺度整理。

这三个模块一下子就不乱了。

---

十一、既然已经有 LayerNorm，为什么现代 LLM 又经常出现 RMSNorm？

现在来看：

RMSNorm

Root Mean Square Normalization

均方根归一化。

它的核心首先是计算：

RMS(x)
√
1d
Σi=1dxi2
+ε

然后：

x̂i
xiRMS(x)

再乘 Learnable Scale：

yi=
γix̂i

如果你刚刚真的理解了 LayerNorm，现在应该马上发现一个区别。

RMSNorm 没有：

xi-μ

也就是说：

RMSNorm 不做 LayerNorm 那种显式 Mean Centering（均值中心化）。

它更集中地处理：

Magnitude

当前 Representation 整体有多大。

这个差别不能只靠背定义。

我们直接算一次。

---

十二、只用两个数字，就能把 LayerNorm 和 RMSNorm 彻底分清楚

假设：

x=[3,4]

先看 RMSNorm。

RMS 是：

√32+422
√12.5
≈3.536

所以归一化以后大约：

[0.849,\ 1.131]

观察一下：

原来两个值都是正数。

归一化以后：

还是两个正数。

它主要是在重新控制整个 Vector（向量）的幅度。

---

再看 LayerNorm。

Mean：

μ= 3+42
3.5

先减掉 Mean：

[3,4]-3.5
[-0.5,0.5]

再经过标准差调整，大致会得到：

[-1,1]

现在区别是不是特别明显？

同一个：

[3,4]

RMSNorm 更接近：

保持方向关系，调整整体尺度。

LayerNorm 则还额外进行了：

围绕均值的中心化。

所以不要再把 RMSNorm 理解成：

“LayerNorm 换了个名字。”

两者的核心区别应该这样记：

LayerNorm 同时处理 Centering 和 Scaling；RMSNorm 去掉显式 Centering，更集中地控制 Representation 的 Magnitude。

这已经足够你以后看绝大多数大模型配置了。

---

十三、RMSNorm 为什么会成为现代大模型里的常客？

这里最容易写成一句没营养的话：

“RMSNorm 比 LayerNorm 更先进。”

不建议这么理解。

架构设计从来不是：

新的一定把旧的全方位碾压。

真正应该问的是：

我们为什么需要 Norm？

目的之一，是让进入 Attention 和 MLP 的 Representation 拥有更容易处理的数值尺度。

RMSNorm 在不执行显式 Mean Centering 的情况下，依旧能对 Representation Magnitude 进行规范化，同时结构相对简洁。

所以很多现代 Decoder-only LLM 会使用 RMSNorm。

但到这里必须保持严谨：

不能推出：

“所有模型用 RMSNorm 都一定更好。”

也不能推出：

“只要使用 RMSNorm，训练就不会崩。”

Normalization 只是整个 Optimization System（优化系统）中的一部分。

训练稳定性还会受到：

Optimizer、Learning Rate、Initialization、Precision、Gradient Clip 等大量因素影响。

我们真正应该理解的是设计取舍，而不是制造神话。

---

十四、现在 Residual 和 Norm 终于可以拼在一起了

如果只有 Residual：

xl+1=xl+F(xl)

信息路径比较直接。

但随着一层层累积：

Representation 的数值尺度又可能越来越难处理。

如果只有 Normalization：

数值条件整理好了。

但如果每层还是：

xl+1=F(xl)

旧 Representation 没有那条更直接的跨层路径。

所以它们实际上互补。

Residual：

主要解决：

Path

传播路径。

Normalization：

主要处理：

Scale

数值尺度。

所以如果这一课你最后只能记一句非常简单的话，我会让你记：

Residual 决定信息怎么穿过深度，Normalization 决定这些信息以怎样的数值状态进入下一次计算。

但事情还没结束。

因为现在还有一个非常现实的问题：

Norm 应该放在哪里？

---

十五、Post-Norm：先把事情干完，再统一整理

一种经典写法是：

xl+1
Norm(xl+F(xl))

这叫：

Post-Norm

后置归一化。

流程可以理解成：

当前 Representation

↓

进入 Attention / MLP

↓

得到新信息

↓

和原输入进行 Residual Add（残差相加）

↓

Normalization

↓

交给下一层

翻译成人话就是：

先干活。

再把新旧信息合起来。

最后统一整理一下。

很自然。

但现在别只看前向传播。

看那条 Identity Path。

即使 (x_l) 通过 Residual 直接加到了后面：

最终它还是要经过：

Norm

也就是说：

从这一层到下一层，并不是存在一条完全绕开子模块和 Norm 的直接 Identity Path。

这个细节对于深层网络的优化很重要。

于是另一种布局开始变得特别有意思。

---

十六、Pre-Norm：真正值得看的不是“Norm 在前”，而是那条直通车

Pre-Norm 可以写成：

xl+1
xl+F(Norm(xl))

流程发生了变化。

输入：

xl

分成两条路径。

第一条：

直接往最终的加法走。

第二条：

先经过 Norm。

然后进入：

Attention 或 MLP。

最后产生一个 Update：

再加回：

xl

所以：

xl

本身拥有一条非常直接的路径：

xl
→
xl+1

它不用经过：

Norm。

也不用经过：

(F)。

这就是 Pre-Norm 真正值得理解的地方。

很多人背的是：

Pre-Norm：

Norm 在前。

Post-Norm：

Norm 在后。

这只是位置。

真正重要的是：

Pre-Norm 把复杂计算放在 Residual Branch（残差分支）里，让 Residual Stream 本身保留了一条更加直接的 Identity Path。

看到这里，Residual、Gradient 和 Pre-Norm 就全部连起来了。

它们不是三个知识点。

它们都在围绕一个问题设计：

怎么让深层网络的信息和梯度更容易穿过去。

---

十七、把 Attention 和 MLP 放回来，一个现代 Transformer Block 终于不再是“几个方块”

假设当前 Residual Stream 是：

xl

先经过 Attention 部分。

可以粗略写成：

hl
xl+
Attention(RMSNorm(xl))

不要急着看公式。

翻译成人话。

第一步：

把当前 Representation：

xl

做一次 RMSNorm。

目的：

整理当前输入的 Scale。

第二步：

交给 Attention。

Attention 去做上一课已经讲过的事情：

从其他 Token 获取当前需要的上下文信息。

第三步：

Attention 得到的结果不把 (x_l) 覆盖掉。

而是：

+

写回 Residual Stream。

所以：

hl

其实可以理解成：

原来的状态 + 这一次从上下文里得到的新信息。

---

接下来进入 MLP：

xl+1
hl+
MLP(RMSNorm(hl))

还是一样。

先 RMSNorm。

然后 MLP 对当前 Token 内部 Feature 做非线性加工。

得到一个新的 Update。

再：

+

写回当前 Residual Stream。

于是一个 Block，真正的运行逻辑其实是：

当前 Representation

↓

整理尺度

↓

Attention 去找上下文

↓

产生一次增量 Update

↓

写回当前 Representation

↓

整理尺度

↓

MLP 加工内部 Feature

↓

再产生一次增量 Update

↓

再次写回

↓

交给下一层

这时候再回头看 Transformer 架构图：

Attention。

Add。

Norm。

MLP。

Add。

Norm。

它们终于不是几个互不相干的小方块了。

你开始看到的是：

一条持续存在的 Representation 主干，以及围绕它不断运行的计算模块。

---

十八、现在回头看，第十课到第十五课其实一直只在讲一件事

第十课问：

Token 怎么从上下文找信息？

于是出现：

Attention。

第十一课继续问：

到底怎么找？

于是有：

Q、K、V。

第十二课问：

训练时整句话都进 GPU，为什么不能偷看未来？

于是有：

Causal Mask（因果掩码）。

第十三课问：

为什么一个 Attention Pattern 不够？

于是有：

Multi-Head Attention（多头注意力）。

第十四课问：

信息找回来以后怎么办？

于是进入：

MLP、GELU、SwiGLU。

到了第十五课，我们问的其实是：

这些模块每一层都在改变 Representation，那几十层之后，模型怎么还训练得下去？

于是自然出现：

Residual。

Normalization。

RMSNorm。

Pre-Norm。

你看，这才是一门课程应该有的样子。

不是：

今天背 Attention。

明天背 MLP。

后天背 RMSNorm。

而是：

前一个方案产生新的问题，新的问题逼出下一个结构。

真正学会架构，靠的不是记忆。

而是因果。

---

十九、为什么说 Transformer 没有简单“失忆”？现在终于能给出准确答案了

文章开头问：

如果 Representation 被改 80 次：

第一层的信息是不是早没了？

现在答案应该已经不是：

“因为有残差连接。”

这太浅。

更加完整的答案是：

Transformer 并不要求每一层：

彻底替换上一层的 Representation。

Residual Connection 让它可以采用：

xl+1=xl+Δ xl

这种 Incremental Update（增量更新）方式。

于是旧 Representation 存在一条更加直接的传播路径。

当前子层只需要学习：

Δ xl

与此同时：

Normalization 控制进入各个计算模块的 Representation Scale。

而采用 Pre-Norm 时：

Residual Stream 又拥有更加直接的 Identity Path。

所以真正答案是：

Residual 把“保存已有信息”和“学习新的变化”拆成了两件事：主干负责继续往前走，子模块负责计算这一次应该增加什么。

这句话，比“防止信息丢失”准确得多。

---

二十、但别走向另一个极端：Residual 不是“永远保留原始 Embedding”

这里很容易产生一个新的误解。

有人会想：

既然：

xl+1=xl+F(xl)

那最开始的 Embedding，是不是一路原封不动送到了第 80 层？

不是。

第一层：

x1=x0+F1(x0)

第二层处理的已经是：

x1

于是：

x2=x1+F2(x1)

第三层：

x3=x2+F3(x2)

所以 Residual Stream 一直都在改变。

Residual 保护的是：

Path Continuity

传播路径的连续性。

它不是：

Content Immutability

“内容永远不许变化。”

如果 Representation 永远不能改变：

那 Transformer 也不可能逐层形成越来越复杂的语义表示。

所以：

Residual 的作用不是让模型“不改变”，而是让模型可以在“持续改变”的同时，不必每一层都彻底断掉与上一层的联系。

这才是真正准确。

---

二十一、RMSNorm 也不是“防止模型忘记知识”

同样的道理。

RMSNorm 做的主要不是：

保存 Knowledge（知识）。

它更不是 Memory（记忆系统）。

它处理的是：

Representation 的 Numerical Scale。

所以不要把所有东西都解释成：

“为了不忘记。”

那会越学越乱。

更加清晰的分工是：

Residual Connection：

改善深层的信息与梯度传播路径。

LayerNorm / RMSNorm：

改善各层计算时的数值尺度与优化条件。

Attention：

负责上下文信息路由。

MLP：

负责逐 Token 的非线性特征变换。

一旦这个职责边界建立起来：

Transformer 就开始变得非常清楚。

---

二十二、这一课真正值得带走的，不是 RMSNorm 公式，而是一套“深度思维”

很多人学 Transformer，只看 Width（宽度）。

Hidden Size 多大。

Intermediate Size 多大。

Head 有多少。

Expert 有多少。

但现代模型还有一个同样重要的维度：

Depth

深度。

深度不是简单地：

“多堆几层。”

因为每增加一层，都会重新提出：

信息怎么走？

梯度怎么走？

不同层之间应该怎么交换 Representation？

当前这种：

Layer1
→
Layer2
→
Layer3
→
⋯

加普通 Residual 的方式，是不是已经是最好的答案？

现在先不要回答。

但把这个问题记住。

因为再往后学习现代 Frontier Model（前沿模型）的时候，你会遇到：

mHC。

AttnRes。

以及其他重新思考跨层 Information Routing（信息路由）的设计。

那时候你会发现：

它们并不是凭空出现的。

研究者继续追问的，其实还是今天这个问题：

如果网络越来越深，我们到底应该怎样让信息穿过“深度”本身？

课程设计里也正是先用第十五课建立普通 Residual Stream，再在后面的现代架构部分重新打开这个问题。

所以今天这一课非常重要。

它不只是教 RMSNorm。

它其实是在给后面的：

Deep Scaling（深度扩展）

打地基。

---

二十三、这一课最容易讲错的几个地方，我一次说清楚

“Residual 就是为了解决梯度消失。”

不完整。

Gradient Propagation 是重要原因之一，但 Residual 同时改变了每一层学习 Representation Transformation 的方式：

从完整重写，变成增量更新。

---

“有 Residual，信息就一定不会丢。”

也不对。

Representation 依然会不断被重新编码、增强、削弱甚至覆盖。

Residual 提供的是更直接的传播路径，不是永久只读备份。

---

“Normalization 就是把数据变成 0～1。”

错误。

LayerNorm、RMSNorm 和 Min-Max Normalization 根本不是一回事。

---

“RMSNorm 就是新版 LayerNorm。”

太粗糙。

最关键的结构区别是：

LayerNorm 有显式 Mean Centering。

RMSNorm 没有。

---

“Pre-Norm 就是 Norm 放前面。”

只说了位置。

真正需要理解的是：

x+F(Norm(x))

里面 (x) 本身拥有一条更加直接的 Identity Path。

---

“用了 Residual + RMSNorm，模型就不会训练崩。”

当然不是。

深度训练稳定性是整个：

Architecture + Initialization + Optimizer + Learning Rate + Precision + Data

共同决定的。

任何单一组件都不应该被神化。

---

二十四、这一课如果公式全部忘了，我希望你至少还记得这些话

第一句：

深层网络真正难的不是“层多”，而是信息和梯度能不能穿过这么多层。

第二句：

Residual 最重要的不是多了一个加号，而是把“完整重写”变成了“增量修改”。

第三句：

深层 Transformer 更像连续改稿，而不是每一层重新写一份稿子。

第四句：

Residual 不要求每一层都成为天才；某一层暂时没学会，也至少可以少改一点。

第五句：

Attention 和 MLP 负责计算 Update，Residual Stream 负责承载一层层累积起来的 Representation。

第六句：

Residual 管的是“路”，Normalization 管的是“尺度”。

第七句：

LayerNorm 同时处理 Centering 和 Scaling；RMSNorm 更集中地处理 Representation Magnitude。

第八句：

Pre-Norm 最重要的从来不是“Norm 在前面”，而是 Residual Stream 获得了一条更加直接的 Identity Path。

最后一句，也是我认为整篇最值得记住的一句：

Transformer 能堆到几十层，不是因为每一层都足够聪明，而是因为它不要求每一层重新创造世界——每一层只需要回答：在已有 Representation 上，这一次我应该改什么？

如果这句话真正理解了：

Residual。

RMSNorm。

Pre-Norm。

其实就不再是三个需要死记的名词。

它们都是同一个深层网络问题长出来的答案。

---

二十五、别急着看下一课，先检查自己是不是真的懂了

现在把公式遮住。

你应该能够自己解释：

为什么：

xl+1=F(xl)

和：

xl+1=xl+F(xl)

看起来只差一个 (x_l)，但整个深层网络的工作方式却发生了很大变化？

为什么可以把：

F(xl)

理解成：

Δ xl

？

为什么：

F(xl)≈0

时，Residual Block 可以接近 Identity Mapping？

为什么求导以后：

I+
∂ F∂ x

里的 (I) 很重要？

Residual Stream 到底是什么？

为什么说：

Attention 和 MLP 更像是在 Residual Stream 上不断写入 Update？

为什么 Residual 解决了一部分问题以后，又自然引出了 Normalization？

LayerNorm 的 Centering：

到底是在做什么？

RMSNorm 为什么没有：

x-μ

？

Pre-Norm：

x+F(Norm(x))

和 Post-Norm：

Norm(x+F(x))

真正重要的区别，到底是不是只有“前”和“后”两个字？

最后再想一个问题。

如果一个 80 层 Transformer，并不是进行了 80 次彻底重写，而是在不断执行：

xl+1=xl+Δ xl

那么：

Depth

是不是应该被重新理解成：

Iterative Representation Refinement

表示的迭代精炼？

如果这一题你已经能自己讲出来：

第十五课就真的学懂了。

---

下一课：我们终于可以把前十五课的零件装成一台真正的大模型了

到今天为止：

Tokenizer 告诉我们文字怎么变成 Token。

Embedding 告诉我们 Token 怎么变成 Vector。

Position / RoPE 告诉模型顺序在哪里。

Attention 让 Token 从上下文读取信息。

Q、K、V 决定信息怎样匹配和传递。

Causal Mask 阻止模型偷看未来。

Multi-Head Attention 让模型在不同表示子空间里建立不同的信息路由。

MLP 负责把读取回来的 Feature 继续加工。

Residual 让 Representation 以增量方式一层层更新。

RMSNorm 帮助控制进入计算模块的数值尺度。

现在真正缺的已经不是新的零件了。

而是：

把所有东西串起来。

给模型一句：

“今天天气真”

Tokenizer 到底怎么处理？

Embedding 后面的 Tensor Shape 是什么？

经过一层 Transformer 之后 Shape 会不会变？

几十层以后为什么还能够映射回 Vocabulary？

LM Head 到底是什么？

Logits 又从哪里来？

为什么最后一个 Hidden State，可以变成“不错”“很好”“冷”这些 Token 的概率？

所以下一课，我们不再拆零件。

我们第一次把整台机器从头跑到尾。

大模型训练原理（16）｜从一句话到下一个 Token：Decoder-only Transformer 这次终于完整跑通了