---
tags: [AI, LLM, Transformer, 架构]
阶段: 05-Transformer与LLM原理
难度: ★★★
created: 2026-10-18
related: "[[注意力机制与QKV]], [[位置编码-正弦与RoPE]], [[KV缓存]]"
---

# Transformer架构详解

## 定义

**Transformer** 是由 $L$ 个结构相同的编码器层与 $L$ 个结构相同的解码器层堆叠而成的序列到序列模型；每层由多头注意力子层与逐位置前馈子层组成，每个子层外包残差连接与 LayerNorm。编码器把源序列 $\mathbf{x}=(x_1,\dots,x_{T_{\text{src}}})$ 映射为同长度的上下文表示序列 $\mathbf{H}$；解码器以 $\mathbf{H}$ 与已生成的目标前缀为输入，输出下一个 token 在词表上的条件分布。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $B$ | 批大小 |
| $T_{\text{src}},T_{\text{tgt}}$ | 源序列长度、目标序列长度 |
| $d$ | 模型维度 $d_{\text{model}}$ |
| $h$ | 注意力头数 |
| $d_k,d_v$ | 每个头的键维度、值维度，$d_k=d_v=d/h$ |
| $d_{ff}$ | 前馈网络中间维度，原论文取 $4d$ |
| $L$ | 编码器层数，也是解码器层数 |
| $V$ | 词表大小 |
| $\mathbf{X}\in\mathbb{R}^{T_{\text{src}}\times d}$ | 编码器某层的输入 |
| $\mathbf{Y}\in\mathbb{R}^{T_{\text{tgt}}\times d}$ | 解码器某层的输入 |
| $\mathbf{H}\in\mathbb{R}^{T_{\text{src}}\times d}$ | 编码器最终输出，供交叉注意力读取 |
| $\mathbf{W}_{Q},\mathbf{W}_{K},\mathbf{W}_{V},\mathbf{W}_{O}$ | 注意力的查询、键、值、输出投影矩阵 |
| $\mathbf{M}$ | 掩码矩阵，允许位置为 0，禁止位置为 $-\infty$ |
| $\boldsymbol{\gamma},\boldsymbol{\beta}$ | LayerNorm 的缩放与平移参数 |
| $\epsilon$ | LayerNorm 分母中的数值稳定项，也用于标签平滑时另行说明 |
| $\theta$ | 模型全部可训练参数 |

其余术语在正文首次出现处定义。**子层**（sublayer）是层内独立计算的模块，包括自注意力、交叉注意力与前馈网络；**残差流**（residual stream）是贯穿各子层的 $d$ 维向量序列，每个子层读取它并把自己的输出加回；**Post-LN** 指先做子层计算与残差相加、再做 LayerNorm；**Pre-LN** 指先做 LayerNorm、再进入子层，残差相加在子层输出之后；**交叉注意力**（cross-attention）是查询来自解码器、键与值来自编码器输出的注意力；**教师强制**（teacher forcing）指训练时用真实前缀作为解码器输入；**移位标签**（shifted labels）指解码器输入比预测目标右移一位。

## 为什么重要

循环网络必须按时间步串行计算，位置 $t$ 的隐状态依赖位置 $t-1$，因此训练无法在时间维并行，任意两个位置之间的信息路径长度为 $O(T)$。Transformer 用注意力把任意两个位置直接连接，路径长度为 $O(1)$，同一层内所有位置可以并行计算；代价是注意力矩阵的 $O(T^{2})$ 计算与显存开销。这一取舍使训练可以扩展到长序列与大参数量，是 2017 年之后语言模型规模增长的结构前提。

| 结构 | 每层计算复杂度 | 顺序操作数 | 任意两位置的最大路径长度 |
|---|---|---|---|
| 自注意力 | $O(T^{2}d)$ | $O(1)$ | $O(1)$ |
| 循环网络 | $O(Td^{2})$ | $O(T)$ | $O(T)$ |
| 卷积网络 | $O(kTd^{2})$ | $O(1)$ | $O(\log_{k}T)$ |

残差连接与 LayerNorm 决定深堆叠能否训练。没有残差时，$L$ 层网络的梯度是 $L$ 个雅可比矩阵的乘积，谱范数略小于 1 就指数衰减，略大于 1 就指数增长；没有归一化时，各层输入尺度随深度漂移，学习率难以统一设定。这两项不是性能技巧，而是把"可以堆很多层"变成事实的必要条件。

Transformer 是后续模型族的共同骨架。编码器-only 路线（[[BERT与双向编码模型]]）用双向自注意力做表示学习；解码器-only 路线（[[GPT系列架构]]）用因果自注意力做下一 token 预测；编码器-解码器路线保留交叉注意力，适合翻译、摘要等输入输出长度不同的任务。理解每个子层的形状、参数量与梯度通路，是从零实现（[[从零实现小型GPT指南]]）与阅读模型代码的前提。

在本库中的位置：本篇承接 [[注意力机制与QKV]]、[[因果注意力与多头注意力]] 与 [[位置编码-正弦与RoPE]]，把组件组装成完整层与完整模型；[[KV缓存]] 分析解码阶段的显存与计算，[[Llama-2架构复盘]] 给出 Pre-LN、RMSNorm、SwiGLU 与 RoPE 的工程组合。对应学习目标中的"懂原理""能复现""会评估"：能画出数据流、逐项算参数量、写出可运行模块，并能定位形状与掩码错误。

## 原理与推导

### 1 整体结构与数据流

编码器与解码器的堆叠关系如下。源序列先经过 token 嵌入与位置编码，进入 $L$ 层编码器；每层先做多头自注意力，再做前馈网络，两个子层各带残差与归一化。编码器输出 $\mathbf{H}$ 被每一层解码器的交叉注意力读取。目标序列右移一位后经过同样的嵌入与位置编码，进入 $L$ 层解码器；每层依次做掩码自注意力、交叉注意力与前馈网络。最后一层输出经线性层映射到词表维度，softmax 给出下一个 token 的分布。

```mermaid
flowchart TD
    SRC["源序列 token id<br/>(B, T_src)"] --> SE["嵌入 + 位置编码<br/>(B, T_src, d)"]
    SE --> ENC["Encoder × L<br/>自注意力 + FFN"]
    ENC --> MEM["编码器输出 H<br/>(B, T_src, d)"]
    TGT["目标序列（右移一位）<br/>(B, T_tgt)"] --> TE["嵌入 + 位置编码<br/>(B, T_tgt, d)"]
    TE --> DEC["Decoder × L<br/>掩码自注意力 + 交叉注意力 + FFN"]
    MEM --> DEC
    DEC --> LIN["线性层<br/>(B, T_tgt, V)"]
    LIN --> OUT["softmax 后的下一个 token 分布"]
```

编码器层内部的数据流如下。Pre-LN 结构下，LayerNorm 位于子层输入端；Post-LN 结构下，LayerNorm 位于残差相加之后。两种结构的模块顺序不同，但张量形状相同。

```mermaid
flowchart LR
    X["x<br/>(B,T,d)"] --> LN1["LayerNorm"]
    LN1 --> ATT["多头自注意力"]
    X --> ADD1["+"]
    ATT --> ADD1
    ADD1 --> LN2["LayerNorm"]
    LN2 --> FFN["FFN<br/>d → d_ff → d"]
    ADD1 --> ADD2["+"]
    FFN --> ADD2
    ADD2 --> Y["y<br/>(B,T,d)"]
```

各张量的形状如下表。表中省略批维与头维的展开细节，第 3 节给出逐步形状。

| 张量 | 形状 | 说明 |
|---|---|---|
| 输入 id | $(B,T_{\text{src}})$ 或 $(B,T_{\text{tgt}})$ | 整数张量 |
| 嵌入输出 $\mathbf{X}$ | $(B,T,d)$ | 查表后加位置编码 |
| $\mathbf{Q},\mathbf{K},\mathbf{V}$ | $(B,h,T,d_k)$ | 投影后拆分头 |
| 注意力分数 $\mathbf{S}$ | $(B,h,T,T)$ | 查询与键两两内积 |
| 单头输出 | $(B,h,T,d_v)$ | 对值加权求和 |
| 多头拼接 | $(B,T,d)$ | 头维合并后过 $\mathbf{W}_{O}$ |
| FFN 中间量 | $(B,T,d_{ff})$ | 逐位置升维 |
| 编码器输出 $\mathbf{H}$ | $(B,T_{\text{src}},d)$ | 供交叉注意力使用 |
| 交叉注意力分数 | $(B,h,T_{\text{tgt}},T_{\text{src}})$ | 目标位置对源位置 |
| logits | $(B,T_{\text{tgt}},V)$ | 词表上的未归一化分数 |

### 2 输入嵌入与位置编码

token id 先经嵌入矩阵查表：

$$
\mathbf{E}_{tok}\in\mathbb{R}^{V\times d},\qquad
\mathbf{e}_{t}=\mathbf{E}_{tok,t,:}\in\mathbb{R}^{d}.
$$

原论文把嵌入乘以 $\sqrt{d}$，再加上位置编码，最后做 dropout：

$$
\mathbf{X}^{0}=\mathrm{Dropout}\left(\sqrt{d}\;\mathbf{E}_{tok}[\mathbf{ids}]+\mathbf{PE}\right),
\qquad
\mathbf{PE}\in\mathbb{R}^{T\times d}.
$$

$\mathbf{PE}$ 的第 $p$ 行只依赖位置 $p$，与 batch 无关，因此对批内所有序列广播。正弦编码、可学习位置嵌入与 RoPE 的对比见 [[位置编码-正弦与RoPE]]；本节只关心形状与组合方式。

乘以 $\sqrt{d}$ 的作用是调整两项的相对尺度。正弦编码的范数为 $\sqrt{d/2}$，若嵌入分量初始尺度约为 1，则两者量级接近；不缩放时嵌入项偏小，位置项在残差流中的占比偏大。该缩放是原论文的实现选择，不属于架构定义；Pre-LN 结构对输入尺度的敏感度低于 Post-LN，但缩放仍影响初始阶段的梯度。

位置编码与嵌入必须逐元素相加，而不是拼接。相加保持维度为 $d$，后续所有投影矩阵的形状不变；拼接会把维度变为 $2d$，第一层注意力的参数量翻倍，且位置子空间与内容子空间被强制分离，模型无法在同一线性变换中组合两者。位置编码加在嵌入之后、第一层之前，不能只在最后一层加，因为每一层的注意力都需要位置信息。

### 3 编码器层

### 3.1 多头自注意力

设层输入为 $\mathbf{X}\in\mathbb{R}^{T\times d}$。对第 $i$ 个头，用独立的投影得到查询、键、值：

$$
\mathbf{Q}_i=\mathbf{X}\mathbf{W}_{Q}^{(i)},\qquad
\mathbf{K}_i=\mathbf{X}\mathbf{W}_{K}^{(i)},\qquad
\mathbf{V}_i=\mathbf{X}\mathbf{W}_{V}^{(i)},
$$

其中 $\mathbf{W}_{Q}^{(i)},\mathbf{W}_{K}^{(i)}\in\mathbb{R}^{d\times d_k}$，$\mathbf{W}_{V}^{(i)}\in\mathbb{R}^{d\times d_v}$。缩放点积注意力为

$$
\mathrm{head}_i=\mathrm{softmax}\left(\frac{\mathbf{Q}_i\mathbf{K}_i^{\top}}{\sqrt{d_k}}\right)\mathbf{V}_i
\in\mathbb{R}^{T\times d_v}.
$$

$h$ 个头的结果沿最后一维拼接，再乘输出投影：

$$
\mathrm{MultiHead}(\mathbf{X})
=\mathrm{Concat}\left(\mathrm{head}_1,\dots,\mathrm{head}_h\right)\mathbf{W}_{O},
\qquad
\mathbf{W}_{O}\in\mathbb{R}^{hd_v\times d}.
$$

取 $d_k=d_v=d/h$，则拼接后的维度为 $d$，输出投影把 $d$ 维映回 $d$ 维。全部投影的参数量为

$$
\underbrace{3dd_k}_{Q,K,V\text{ 的投影}}+\underbrace{dd_v}_{\text{输出投影}}
+\underbrace{3d_k+d_v}_{\text{偏置}}
=4d^{2}+4d\quad(d_k=d_v=d).
$$

除以 $\sqrt{d_k}$ 的理由在该篇给出：若 $\mathbf{q},\mathbf{k}$ 各分量独立、均值 0、方差 1，则内积方差为 $d_k$，除以 $\sqrt{d_k}$ 使 logits 方差回到 1，softmax 不会因维度过大而饱和。多头的作用不是增加参数量，而是在相同总维度下提供 $h$ 个不同的投影子空间：每个头用 $d/h$ 维计算，全部头的计算量与单头 $d$ 维注意力同阶。

逐步形状如下。设 $\mathbf{X}$ 为 $(B,T,d)$，$h=8$，$d=512$，$d_k=64$。

$$
(B,T,d)\xrightarrow{\mathbf{W}_{Q}}(B,T,d)
\xrightarrow{\text{view}}(B,T,h,d_k)
\xrightarrow{\text{transpose}}(B,h,T,d_k).
$$

$\mathbf{Q}$ 与 $\mathbf{K}^{\top}$ 相乘：

$$
(B,h,T,d_k)\times(B,h,d_k,T)\to(B,h,T,T).
$$

softmax 逐行作用在最后一维，形状不变。与 $\mathbf{V}$ 相乘：

$$
(B,h,T,T)\times(B,h,T,d_v)\to(B,h,T,d_v).
$$

合并头维：

$$
(B,h,T,d_v)\xrightarrow{\text{transpose}}(B,T,h,d_v)
\xrightarrow{\text{view}}(B,T,d).
$$

最后过 $\mathbf{W}_{O}$，形状仍为 $(B,T,d)$。编码器自注意力不加因果掩码，因为编码器需要看到完整源序列；若批内有 padding，则用 padding mask 禁止注意力读取填充位置。

### 3.2 残差与 LayerNorm

原论文采用 Post-LN，编码器层的计算顺序为

$$
\mathbf{Z}=\mathrm{LN}\left(\mathbf{X}+\mathrm{MultiHead}(\mathbf{X},\mathbf{X},\mathbf{X})\right),
$$

$$
\mathbf{X}'=\mathrm{LN}\left(\mathbf{Z}+\mathrm{FFN}(\mathbf{Z})\right).
$$

先做子层计算，再加残差，最后归一化。$\mathbf{X}$ 与子层输出形状相同，才能逐元素相加；这要求所有子层保持 $d$ 维。LayerNorm 在每个位置上独立计算，输入 $(B,T,d)$，输出 $(B,T,d)$，归一化维度是最后一维 $d$。

### 3.3 前馈网络

每个位置独立经过同一个两层网络：

$$
\mathrm{FFN}(\mathbf{x})=\mathbf{W}_{2}\,\sigma\left(\mathbf{W}_{1}\mathbf{x}+\mathbf{b}_{1}\right)+\mathbf{b}_{2},
$$

$$
\mathbf{W}_{1}\in\mathbb{R}^{d\times d_{ff}},\qquad
\mathbf{W}_{2}\in\mathbb{R}^{d_{ff}\times d},
$$

$\sigma$ 为逐元素激活函数，原论文用 ReLU，现代实现常用 GELU 或 SwiGLU。$d_{ff}=4d$ 是原论文的默认值。参数量为

$$
d\,d_{ff}+d_{ff}+d_{ff}\,d+d=2dd_{ff}+d_{ff}+d.
$$

$d=512$、$d_{ff}=2048$ 时为 $2{,}099{,}712$，占单层参数量的约三分之二。FFN 对每个位置使用相同权重，不跨位置混合；跨位置的信息交换完全由注意力完成。若去掉激活函数，$\mathbf{W}_{2}\mathbf{W}_{1}$ 退化为一个 $d\times d$ 矩阵，两层结构与一层线性变换等价，深度带来的非线性容量消失。

### 4 解码器层

解码器层有三个子层：掩码自注意力、交叉注意力、前馈网络。设层输入为 $\mathbf{Y}\in\mathbb{R}^{T_{\text{tgt}}\times d}$，编码器输出为 $\mathbf{H}\in\mathbb{R}^{T_{\text{src}}\times d}$。Post-LN 下依次为

$$
\mathbf{Z}_{1}=\mathrm{LN}\left(\mathbf{Y}+\mathrm{MaskedMH}(\mathbf{Y},\mathbf{Y},\mathbf{Y})\right),
$$

$$
\mathbf{Z}_{2}=\mathrm{LN}\left(\mathbf{Z}_{1}+\mathrm{MH}(\mathbf{Z}_{1},\mathbf{H},\mathbf{H})\right),
$$

$$
\mathbf{Y}'=\mathrm{LN}\left(\mathbf{Z}_{2}+\mathrm{FFN}(\mathbf{Z}_{2})\right).
$$

### 4.1 掩码自注意力

解码器训练时一次性输入完整目标序列，但位置 $t$ 只能使用 $0,\dots,t$ 的信息。定义掩码矩阵

$$
M_{ij}=
\begin{cases}
0, & j\le i,\\
-\infty, & j>i,
\end{cases}
$$

把掩码加到 softmax 之前的分数上：

$$
\mathbf{S}=\frac{\mathbf{Q}\mathbf{K}^{\top}}{\sqrt{d_k}}+\mathbf{M},
\qquad
\mathrm{softmax}(\mathbf{S})\in\mathbb{R}^{T_{\text{tgt}}\times T_{\text{tgt}}}.
$$

当 $j>i$ 时，$S_{ij}=-\infty$，$\exp(S_{ij})=0$，位置 $i$ 对位置 $j$ 的注意力权重为零。softmax 的分母只对 $j\le i$ 求和，行归一化仍然成立。掩码必须在 softmax 之前加：若先 softmax 再把上三角置零，每行的和不再为 1，输出尺度随位置变化，后续层收到的表示不再位于同一尺度。

$\mathbf{M}$ 的形状为 $(T_{\text{tgt}},T_{\text{tgt}})$，加到 $(B,h,T_{\text{tgt}},T_{\text{tgt}})$ 的分数上时对批维与头维广播。批量内每条序列的掩码相同，因此不需要为每个样本构造独立掩码；padding mask 则与样本有关，形状为 $(B,T)$，需要扩展为 $(B,1,1,T)$ 后才能与分数相加。

训练时，一次前向即可得到所有位置的预测，因为因果掩码保证位置 $t$ 的输出只依赖 $0,\dots,t$，与逐 token 生成的结果一致。这是 Transformer 训练并行性的来源：时间维不需要循环，循环被掩码替代。

### 4.2 交叉注意力

交叉注意力的查询来自解码器，键与值来自编码器：

$$
\mathbf{Q}=\mathbf{Z}_{1}\mathbf{W}_{Q},\qquad
\mathbf{K}=\mathbf{H}\mathbf{W}_{K},\qquad
\mathbf{V}=\mathbf{H}\mathbf{W}_{V}.
$$

分数形状为

$$
(B,h,T_{\text{tgt}},d_k)\times(B,h,d_k,T_{\text{src}})
\to(B,h,T_{\text{tgt}},T_{\text{src}}).
$$

每个目标位置对全部源位置计算权重，输出为源位置值向量的加权和，形状 $(B,h,T_{\text{tgt}},d_v)$，合并头后回到 $(B,T_{\text{tgt}},d)$。交叉注意力通常不加因果掩码，因为源序列对每个目标位置都可见；若源序列有 padding，则对键的位置加 padding mask，禁止读取填充。

查询、键、值三者来源不能混。若三者都取自解码器，交叉注意力退化为自注意力，编码器输出完全不被使用；若查询取自编码器而键值也取自编码器，则退化为编码器自注意力，解码器当前状态不参与查询，无法按当前生成位置检索源序列。正确的组合是"查询来自当前解码位置，键与值来自源序列"。

### 4.3 解码器前馈网络

与编码器相同：逐位置两层网络，$d\to d_{ff}\to d$，参数量 $2dd_{ff}+d_{ff}+d$。三个子层都带残差与 LayerNorm，因此解码器层比编码器层多一个交叉注意力子层与一个 LayerNorm。

### 5 Post-LN 与 Pre-LN

两种放置方式的差别只在 LayerNorm 与残差相加的先后。Post-LN 为

$$
\mathbf{x}_{l+1}=\mathrm{LN}\left(\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l})\right),
$$

Pre-LN 为

$$
\mathbf{x}_{l+1}=\mathbf{x}_{l}+F_{l}\left(\mathrm{LN}(\mathbf{x}_{l})\right),
\qquad
\mathbf{y}=\mathrm{LN}(\mathbf{x}_{L}).
$$

Post-LN 中，每个子层的输出都经过一次归一化，残差流被反复重新居中与缩放；Pre-LN 中，残差流本身不被归一化，归一化只作用于子层的输入，主路径上是连续的加法。

梯度通路的差异可以直接写出。对 Pre-LN，

$$
\frac{\partial\mathbf{x}_{l+1}}{\partial\mathbf{x}_{l}}
=\mathbf{I}+\frac{\partial F_{l}(\mathrm{LN}(\mathbf{x}_{l}))}{\partial\mathbf{x}_{l}},
$$

从损失到第 $l$ 层的梯度包含一条不经过 $F_{l}$ 的恒等路径，深层网络的梯度不会因连乘而整体消失。对 Post-LN，

$$
\frac{\partial\mathbf{x}_{l+1}}{\partial\mathbf{x}_{l}}
=\mathbf{J}_{\mathrm{LN}}\left(\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l})\right)\left(\mathbf{I}+\mathbf{J}_{F_{l}}\right),
$$

每个 block 的梯度都必须穿过输出端的 LayerNorm 雅可比 $\mathbf{J}_{\mathrm{LN}}$。初始化时残差分支输出较小，LayerNorm 的归一化会放大相对变化，使初始阶段的梯度范数整体偏大；层数增加时这种放大在连乘中累积。原论文因此使用 4000 步学习率 warmup，先以小学习率稳定初始阶段。Pre-LN 把归一化移到子层输入端，主路径不含 $\mathbf{J}_{\mathrm{LN}}$，对 warmup 的依赖显著降低，但残差流的方差随深度累积，因为每个 block 都把自己的输出加到一个未归一化的流上；因此 Pre-LN 必须在最后加一个 LayerNorm，再送入输出层。

| 项目 | Post-LN | Pre-LN |
|---|---|---|
| 计算顺序 | $\mathrm{LN}(\mathbf{x}+F(\mathbf{x}))$ | $\mathbf{x}+F(\mathrm{LN}(\mathbf{x}))$ |
| 主路径归一化 | 每个 block 输出都归一化 | 主路径不归一化 |
| 梯度通路 | 必须穿过每个输出 LN | 含恒等路径 |
| 对 warmup 的依赖 | 强 | 弱 |
| 残差流方差 | 被每层重置 | 随深度累积 |
| 末端处理 | 无需额外 LN | 需要最终 LN |
| 典型使用 | 原论文、早期实现 | GPT-2 之后的多数 decoder-only 模型 |

两种结构都能训练到相同量级的效果，差别主要在优化稳定性与超参数敏感度。复现原论文时用 Post-LN 与 warmup；从零实现现代 decoder-only 模型时用 Pre-LN，代码更简单，深层配置更稳。

### 6 残差连接的必要性

设第 $l$ 层的输入输出关系为

$$
\mathbf{x}_{l+1}=\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l}).
$$

对 $\mathbf{x}_{l}$ 求雅可比：

$$
\frac{\partial\mathbf{x}_{l+1}}{\partial\mathbf{x}_{l}}
=\mathbf{I}+\mathbf{J}_{l},
\qquad
\mathbf{J}_{l}=\frac{\partial F_{l}}{\partial\mathbf{x}_{l}}.
$$

从第 $L$ 层反传到第 0 层，链式法则给出

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{x}_{0}}
=\frac{\partial\mathcal{L}}{\partial\mathbf{x}_{L}}
\left(\mathbf{I}+\mathbf{J}_{L-1}\right)\cdots\left(\mathbf{I}+\mathbf{J}_{0}\right).
$$

把乘积展开：

$$
\left(\mathbf{I}+\mathbf{J}_{L-1}\right)\cdots\left(\mathbf{I}+\mathbf{J}_{0}\right)
=\mathbf{I}+\sum_{l=0}^{L-1}\mathbf{J}_{l}
+\sum_{l_{1}<l_{2}}\mathbf{J}_{l_{2}}\mathbf{J}_{l_{1}}+\cdots
+\mathbf{J}_{L-1}\cdots\mathbf{J}_{0}.
$$

展开式中存在 $\mathbf{I}$ 项，它对应一条不经过任何子层的梯度路径。即使所有 $\mathbf{J}_{l}$ 的谱范数都小于 1，梯度仍然可以通过 $\mathbf{I}$ 项直接到达浅层；其余高阶项则提供经过不同层组合的路径。没有残差时，

$$
\frac{\partial\mathbf{x}_{L}}{\partial\mathbf{x}_{0}}=\prod_{l=0}^{L-1}\mathbf{J}_{l},
$$

若每层雅可比的谱范数为 $\rho<1$，梯度范数按 $\rho^{L}$ 衰减；若 $\rho>1$，按 $\rho^{L}$ 增长。两种情形都使深层网络难以用统一学习率训练。残差把"连乘"变为"连乘加恒等"，最坏情况下仍保留一条不衰减的恒等路径。

残差还改变了学习目标的参数化。若某层的最优变换接近恒等，$F_{l}$ 只需学习接近零的函数，而不是让一整组权重逼近单位矩阵；后者在有限步梯度下降中更难达到。前向上，残差流把各层输出累加，每一层只需学习一个增量，而不是重新构造完整表示。

残差要求子层输入输出同维，即 $d\to d$。注意力的输出投影与 FFN 的第二层都映射回 $d$，正是为了满足这一条件。若某一子层改变了维度，残差加法无法进行，必须引入额外的投影，这会增加参数并破坏恒等路径。

### 7 LayerNorm 的公式与作用维度

对单个位置的向量 $\mathbf{x}\in\mathbb{R}^{d}$，LayerNorm 计算

$$
\mu=\frac{1}{d}\sum_{j=1}^{d}x_{j},
\qquad
\sigma^{2}=\frac{1}{d}\sum_{j=1}^{d}\left(x_{j}-\mu\right)^{2},
$$

$$
\mathrm{LN}(\mathbf{x})
=\boldsymbol{\gamma}\odot\frac{\mathbf{x}-\mu}{\sqrt{\sigma^{2}+\epsilon}}
+\boldsymbol{\beta},
$$

其中 $\boldsymbol{\gamma},\boldsymbol{\beta}\in\mathbb{R}^{d}$ 是可学习参数，$\odot$ 为逐元素乘法，$\epsilon$ 取 $10^{-5}$ 量级，防止方差为零时除零。减去均值使输出均值为零，除以标准差使输出方差为一，再经 $\boldsymbol{\gamma},\boldsymbol{\beta}$ 恢复可学习的尺度与偏移。若 $\boldsymbol{\gamma}=\mathbf{1}$、$\boldsymbol{\beta}=\mathbf{0}$，输出被限制在零均值、范数为 $\sqrt{d}$ 的 $d-2$ 维球面上，表达能力由后续线性层提供。

作用维度是最后一维 $d$，不是批维，也不是序列维。对 $(B,T,d)$ 的输入，LayerNorm 对每个 $(b,t)$ 组合独立计算 $d$ 个分量的均值与方差，共 $BT$ 组统计量。PyTorch 中写作

```python
norm = torch.nn.LayerNorm(d)          # normalized_shape = d
y = norm(x)                           # x: (B, T, d) -> y: (B, T, d)
```

`normalized_shape=d` 表示对最后一维归一化；若误写成 `LayerNorm((B, T))` 或手动对 `dim=(0, 1)` 求均值，统计量会跨位置、跨样本混合，每个位置的输出依赖于同批其他序列，推理时行为随批组成变化。

与 BatchNorm 的差别在于统计量的来源。BatchNorm 对每个特征在批维上求均值与方差，训练时依赖批内样本，推理时使用滑动平均；批较小或序列长度不一时，统计量噪声大。LayerNorm 对每个样本、每个位置单独归一化，训练与推理的计算完全一致，不依赖批大小，适合变长序列与自回归解码。Transformer 的残差流是逐位置的 $d$ 维向量，LayerNorm 正好沿特征维作用，不需要跨位置统计。

LayerNorm 的计算量为 $O(BTd)$，相对注意力的 $O(BT^{2}d)$ 可以忽略。它的梯度包含两部分：对输入的缩放与中心化，以及对 $\boldsymbol{\gamma},\boldsymbol{\beta}$ 的更新。中心化使梯度中与均值方向平行的分量被投影掉，缩放使梯度的尺度与输入方差解耦，这是深层网络能用统一学习率的原因之一。

### 8 前馈网络作为逐位置非线性变换

前馈网络对序列中每个位置独立作用：

$$
\mathbf{h}_{t}=\mathrm{FFN}(\mathbf{x}_{t}),\qquad t=1,\dots,T.
$$

把整条序列写成矩阵：

$$
\mathrm{FFN}(\mathbf{X})=\sigma\left(\mathbf{X}\mathbf{W}_{1}+\mathbf{1}\mathbf{b}_{1}^{\top}\right)\mathbf{W}_{2}+\mathbf{1}\mathbf{b}_{2}^{\top},
$$

其中 $\mathbf{1}$ 为全 1 列向量，偏置对每个位置广播。该式说明 FFN 不包含任何跨位置的项：$\mathbf{h}_{t}$ 只依赖 $\mathbf{x}_{t}$，与 $\mathbf{x}_{s}$（$s\ne t$）无关。序列中的信息交换全部由注意力完成，FFN 只增加每个位置的非线性变换容量。

两层结构与激活函数缺一不可。若 $\sigma$ 为恒等映射，

$$
\mathbf{W}_{2}\left(\mathbf{W}_{1}\mathbf{x}+\mathbf{b}_{1}\right)+\mathbf{b}_{2}
=\left(\mathbf{W}_{2}\mathbf{W}_{1}\right)\mathbf{x}+\left(\mathbf{W}_{2}\mathbf{b}_{1}+\mathbf{b}_{2}\right),
$$

两层线性变换等价于一层 $d\times d$ 线性变换，参数量从 $2dd_{ff}$ 降为 $d^{2}$，但表达能力也降为线性。若去掉整个 FFN，层内只剩注意力与逐元素归一化，模型无法对每个位置单独做非线性特征组合，注意力输出的每个分量只能线性混合。

$d_{ff}=4d$ 是原论文的选择。更大的 $d_{ff}$ 增加每个位置的变换容量，参数量与计算量按 $2dd_{ff}$ 线性增长；更小的 $d_{ff}$ 降低 FFN 占比，但注意力已经是 $O(T^{2}d)$，在短序列上 FFN 的 $O(Tdd_{ff})$ 更容易成为主要计算。$d=512$、$d_{ff}=2048$ 时 FFN 占单层参数的 66.6%，是参数量的主体；这也是把 $d_{ff}$ 作为独立超参数调节的原因。

GELU 是常用的平滑激活：

$$
\mathrm{GELU}(x)=x\,\Phi(x)
\approx0.5x\left(1+\tanh\left(\sqrt{\frac{2}{\pi}}\left(x+0.044715x^{3}\right)\right)\right),
$$

其中 $\Phi$ 为标准正态分布的累积分布函数。与 ReLU 相比，GELU 在负值区间有非零输出与梯度，原点附近平滑，训练时梯度更连续；ReLU 计算更简单，原论文使用 ReLU。两者都是逐元素函数，不改变形状。

### 9 参数量逐项计算

取原论文 base 配置：$L=6$，$d=512$，$h=8$，$d_k=d_v=64$，$d_{ff}=2048$，词表 $V=37000$。先算单个编码器层。

注意力投影：四个 $512\times512$ 矩阵，每个 $262{,}144$ 个权重，加四个长度为 512 的偏置：

$$
4\times512^{2}+4\times512=1{,}048{,}576+2{,}048=1{,}050{,}624.
$$

两个 LayerNorm：每个含 $\boldsymbol{\gamma},\boldsymbol{\beta}$ 各 512 个参数：

$$
2\times(2\times512)=2{,}048.
$$

前馈网络：

$$
512\times2048+2048+2048\times512+512
=1{,}048{,}576+2{,}048+1{,}048{,}576+512
=2{,}099{,}712.
$$

单个编码器层合计：

$$
1{,}050{,}624+2{,}048+2{,}099{,}712=3{,}152{,}384.
$$

六个编码器层：

$$
6\times3{,}152{,}384=18{,}914{,}304.
$$

解码器层比编码器层多一个交叉注意力子层与一个 LayerNorm。交叉注意力同样有四个 $d\times d$ 投影与四个偏置，参数量 $1{,}050{,}624$；多出的 LayerNorm 为 $1{,}024$。单个解码器层：

$$
3{,}152{,}384+1{,}050{,}624+1{,}024=4{,}204{,}032.
$$

六个解码器层：

$$
6\times4{,}204{,}032=25{,}224{,}192.
$$

输入嵌入与输出投影共享同一矩阵时，嵌入参数量为

$$
Vd=37{,}000\times512=18{,}944{,}000.
$$

总参数量为

$$
18{,}944{,}000+18{,}914{,}304+25{,}224{,}192=63{,}082{,}496.
$$

若输入嵌入与输出投影不共享，需再加一份 $Vd$，总参数为 $82{,}026{,}496$。以上计数不含输出层偏置；若计入，需再加 $V=37{,}000$，对比例没有影响。原论文报告 base 模型约 65M，与本算例的 63.1M 相差约 3%，差异来自词表规模与实现细节的取整；分项比例与量级一致。三部分占比分别为编码器 30.0%、解码器 40.0%、嵌入 30.0%，嵌入不是主要部分，原因是 $Vd$ 与 $12Ld^{2}$ 同阶但层数更多时后者增长更快。

计算量可按每 token 每层的乘加次数估算。注意力投影 $4d^{2}$；分数与加权求和各需 $Td$，合计 $2Td$；FFN 为 $2dd_{ff}=8d^{2}$。总计

$$
4d^{2}+2Td+8d^{2}=12d^{2}+2Td.
$$

$d=512$、$T=512$ 时为

$$
12\times262{,}144+2\times512\times512
=3{,}145{,}728+524{,}288=3{,}670{,}016.
$$

其中 FFN 占 $2{,}097{,}152$，注意力线性投影占 $1{,}048{,}576$，分数与加权求和占 $524{,}288$。序列较短时 FFN 是主要计算；序列长度增加到 $T>2d$ 时，注意力的总计算 $4d^{2}+2Td$ 超过 FFN 的 $8d^{2}$，注意力分数成为瓶颈。注意力分数矩阵的显存为 $B h T^{2}$ 个元素，$B=1$、$h=8$、$T=8192$ 时约 $5.4\times10^{8}$ 个 float32，约 2.1 GB，这是长上下文需要 FlashAttention 一类分块算法的直接原因。

### 10 训练目标与推理差异

训练时使用教师强制。给定源序列 $\mathbf{x}$ 与目标序列 $\mathbf{y}=(y_1,\dots,y_{T})$，在序列首部加起始符 $y_{0}=\mathrm{BOS}$，解码器输入为

$$
\mathbf{y}_{\text{in}}=(y_{0},y_{1},\dots,y_{T-1}),
$$

预测目标为右移一位的标签

$$
\mathbf{y}_{\text{out}}=(y_{1},y_{2},\dots,y_{T}).
$$

位置 $t$ 的输出经过线性层与 softmax 得到 $p_{\theta}(\cdot\mid y_{<t},\mathbf{x})$，交叉熵损失为

$$
\mathcal{L}(\theta)
=-\frac{1}{T}\sum_{t=1}^{T}\log p_{\theta}\left(y_{t}\mid y_{0},\dots,y_{t-1},\mathbf{x}\right).
$$

由于因果掩码，一次前向即可并行计算全部 $T$ 个条件概率，不需要逐步循环。若不做移位，解码器在位置 $t$ 看到的就是 $y_{t}$ 本身，任务退化为复制输入，损失可以降到接近零而模型没有预测能力。若移位方向相反，位置 $t$ 看到的是 $y_{t+1}$，同样造成标签泄漏。

| 位置 $t$ | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| 解码器输入 | BOS | $y_{1}$ | $y_{2}$ | $y_{3}$ |
| 预测目标 | $y_{1}$ | $y_{2}$ | $y_{3}$ | EOS |

原论文还使用标签平滑，把目标分布从 one-hot 改为

$$
q_{t}=(1-\epsilon_{ls})\,\mathbf{e}_{y_{t}}+\frac{\epsilon_{ls}}{V}\mathbf{1},
\qquad
\epsilon_{ls}=0.1,
$$

损失改为 $-\sum_{t}\sum_{v}q_{t,v}\log p_{\theta}(v\mid y_{<t})$。标签平滑防止模型对单一 token 输出过高的概率，降低过拟合；它改变的是训练目标，不改变模型结构。批内 padding 位置不参与损失，需用 `ignore_index` 屏蔽，否则填充 token 的预测会主导梯度。

推理时没有真实前缀可用。编码器对源序列做一次前向，得到 $\mathbf{H}$ 并缓存；解码器从 BOS 开始，每一步把已生成的 token 序列作为输入，取最后一个位置的输出分布，采样或取 argmax 得到下一个 token，再拼回输入。训练与推理的差异如下表。

| 项目 | 训练 | 推理 |
|---|---|---|
| 输入前缀 | 真实标签（教师强制） | 模型已生成的 token |
| 并行性 | 整条目标序列一次前向 | 逐 token 自回归 |
| 掩码作用 | 保证位置 $t$ 只看到 $<t$ | 同样保证，但每步只有前缀 |
| 输出使用 | 全部位置参与损失 | 只取最后一个位置的分布 |
| 缓存 | 不需要 | 缓存编码器输出与历史键值 |

训练与推理的分布差异称为曝光偏差：训练时前缀来自数据分布，推理时前缀来自模型自身，早期错误会改变后续输入。缓解方法包括 scheduled sampling、强化学习目标与更大的数据覆盖，但标准 Transformer 的训练目标本身不消除该差异。解码阶段的键值缓存与显存分析见 [[KV缓存]]。

## 关键直觉

> [!tip] 一个 Transformer 层由两个作用不同的部分构成：注意力是唯一的跨位置混合操作，它按内容相似度把其他位置的值向量加权聚合到当前位置；前馈网络是逐位置的非线性变换，它在每个位置上独立地升维、激活、降维。残差流把各子层的输出累加，使每一层只需学习增量；LayerNorm 控制每次读取残差流时的尺度。该表述与第 3 节的 $\mathrm{MultiHead}$、第 8 节的 $\mathrm{FFN}(\mathbf{X})$ 逐行独立、第 6 节的 $\mathbf{x}_{l+1}=\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l})$ 严格对应：去掉注意力则位置之间不再交换信息，去掉 FFN 则每个位置只剩线性混合，去掉残差则深度无法训练。

## 例子与代码

### 例 1：参数量逐项核算

以下纯 Python 代码按第 9 节的公式计算各组件参数量，不依赖深度学习框架，输出为实际运行结果。

```python
def count_params(d=512, d_ff=2048, n_layers=6, vocab=37000, tied=True):
    attn = 4 * d * d + 4 * d          # W_Q, W_K, W_V, W_O 与四个偏置
    ln = 2 * d                        # gamma 与 beta
    ffn = d * d_ff + d_ff + d_ff * d + d
    enc_layer = attn + 2 * ln + ffn
    dec_layer = 2 * attn + 3 * ln + ffn
    emb = vocab * d
    total = n_layers * (enc_layer + dec_layer) + emb
    if not tied:
        total += emb
    return attn, ln, ffn, enc_layer, dec_layer, emb, total

attn, ln, ffn, enc, dec, emb, total = count_params()
for name, value in [("attention", attn), ("layernorm", ln), ("ffn", ffn),
                    ("encoder_layer", enc), ("decoder_layer", dec),
                    ("embedding", emb), ("total_tied", total),
                    ("total_untied", total + emb)]:
    print(f"{name:16s} {value:>12,d}")
print("share", f"{6*enc/total:.1%}", f"{6*dec/total:.1%}", f"{emb/total:.1%}")
```

```text
attention           1,050,624
layernorm               1,024
ffn                 2,099,712
encoder_layer       3,152,384
decoder_layer       4,204,032
embedding          18,944,000
total_tied         63,082,496
total_untied       82,026,496
share 30.0% 40.0% 30.0%
```

代码把每个子层的参数写成 $d$ 与 $d_{ff}$ 的表达式，再按层数累加。`attention` 的 $4d^{2}+4d$ 包含四个投影与偏置；`layernorm` 的 $2d$ 是一组 $\boldsymbol{\gamma},\boldsymbol{\beta}$；`ffn` 的 $2dd_{ff}+d_{ff}+d$ 包含两层权重与偏置。`total_tied` 只计一份嵌入，`total_untied` 再加一份输出投影。若把 $d_{ff}$ 误取为 $d$，单个前馈网络从 $2dd_{ff}+d_{ff}+d$ 降为 $2d^{2}+2d$，每层少 $1{,}574{,}400$ 个参数，六个编码器层与六个解码器层合计少 $18{,}892{,}800$，约占总参数的 30%。若漏算全部线性层偏置，编码器每层少 $4{,}608$、解码器每层少 $6{,}656$，总计少 $67{,}584$，相对 6,300 万可以忽略，但逐项核对时会出现不一致。

### 例 2：掩码必须在 softmax 之前

以下 NumPy 代码在 NumPy 2.3.5 下运行，比较"先加 $-\infty$ 再 softmax"与"先 softmax 再把上三角置零"的差别。

```python
import numpy as np

def softmax(x, axis=-1):
    e = np.exp(x - x.max(axis=axis, keepdims=True))
    return e / e.sum(axis=axis, keepdims=True)

scores = np.array([[1.0, 2.0, 3.0],
                   [1.0, 2.0, 3.0],
                   [1.0, 2.0, 3.0]])
causal = np.triu(np.ones((3, 3), dtype=bool), k=1)   # 上三角为 True，表示禁止
correct = softmax(np.where(causal, -np.inf, scores))
wrong = softmax(scores)
wrong[causal] = 0.0
print(np.round(correct, 4))
print(correct.sum(axis=1))
print(np.round(wrong, 4))
print(wrong.sum(axis=1))
```

```text
[[1.     0.     0.    ]
 [0.2689 0.7311 0.    ]
 [0.09   0.2447 0.6652]]
[1. 1. 1.]
[[0.09   0.     0.    ]
 [0.09   0.2447 0.    ]
 [0.09   0.2447 0.6652]]
[0.09003057 0.33475904 1.        ]
```

`correct` 的三行和均为 1，位置 0 只能看到自己，权重为 1；位置 1 在位置 0 与自身之间分配，权重分别为 0.2689 与 0.7311；位置 2 看到全部三个位置。`wrong` 先对完整行做 softmax，再把禁止位置置零，行和变为 0.09、0.3348、1，不再归一化。若把这样的权重送入后续层，不同位置的输出尺度不同，位置 0 的输出被压缩到原尺度的约 9%，梯度尺度也随之缩小。正确做法是在指数运算之前把禁止位置的 logits 设为 $-\infty$，使 $\exp$ 直接给出 0，分母只对允许位置求和。

### 例 3：Pre-LN TransformerBlock 与因果性检验

以下代码在 PyTorch 2.0 及以上运行，实现 Pre-LN、GELU、可切换因果掩码的单层模块，并检验掩码是否真的阻止了未来信息。本机未安装 PyTorch，形状与参数量已按定义核对。

```python
import math
import torch
import torch.nn as nn

class CausalSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        assert d_model % n_heads == 0
        self.n_heads = n_heads
        self.d_head = d_model // n_heads
        self.q_proj = nn.Linear(d_model, d_model)
        self.k_proj = nn.Linear(d_model, d_model)
        self.v_proj = nn.Linear(d_model, d_model)
        self.o_proj = nn.Linear(d_model, d_model)

    def forward(self, x, causal=True):
        B, T, _ = x.shape
        q = self.q_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        k = self.k_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        v = self.v_proj(x).view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.d_head)   # (B,h,T,T)
        if causal:
            mask = torch.full((T, T), float("-inf"), device=x.device, dtype=scores.dtype)
            mask = torch.triu(mask, diagonal=1)                     # 上三角为 -inf
            scores = scores + mask                                  # 广播到 (B,h,T,T)
        attn = torch.softmax(scores, dim=-1)
        out = attn @ v                                              # (B,h,T,d_head)
        out = out.transpose(1, 2).contiguous().view(B, T, -1)       # (B,T,d_model)
        return self.o_proj(out)

class TransformerBlock(nn.Module):
    def __init__(self, d_model=512, n_heads=8, d_ff=2048):
        super().__init__()
        self.ln1 = nn.LayerNorm(d_model)
        self.attn = CausalSelfAttention(d_model, n_heads)
        self.ln2 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Linear(d_ff, d_model),
        )

    def forward(self, x, causal=True):
        x = x + self.attn(self.ln1(x), causal=causal)   # 子层读归一化后的输入
        x = x + self.ffn(self.ln2(x))                   # 残差相加保留恒等路径
        return x

torch.manual_seed(0)
block = TransformerBlock()
x = torch.randn(2, 5, 512)
y = block(x)
print("x:", tuple(x.shape), "y:", tuple(y.shape))
print("params:", sum(p.numel() for p in block.parameters()))

x2 = x.clone()
x2[:, -1, :] += 1.0                                  # 只改最后一个位置
y2 = block(x2)
print("prefix unchanged:", torch.allclose(y[:, :-1], y2[:, :-1], atol=1e-6))
print("last changed:", not torch.allclose(y[:, -1], y2[:, -1], atol=1e-6))

y3 = block(x, causal=False)                          # 关闭掩码作为对照
y4 = block(x2, causal=False)
print("no mask, prefix unchanged:", torch.allclose(y3[:, :-1], y4[:, :-1], atol=1e-6))
```

```text
x: (2, 5, 512) y: (2, 5, 512)
params: 3152384
prefix unchanged: True
last changed: True
no mask, prefix unchanged: False
```

代码分为注意力与层两个模块。注意力先做四个线性投影，把 $d$ 维拆成 $h$ 个头；分数除以 $\sqrt{d_k}$ 后，若开启因果开关，就构造上三角为 $-\infty$ 的掩码并加到分数上，softmax 后与值相乘，合并头维，再过输出投影。层按 Pre-LN 组合：`ln1` 的输出进入注意力，注意力输出与原始 `x` 相加；`ln2` 的输出进入 FFN，FFN 输出再与残差流相加。全模块没有 dropout，因此同一输入的前向结果完全确定。单层模块不包含模型末端的 LayerNorm：Pre-LN 的最终归一化位于第 $L$ 层之后、输出投影之前，属于模型级组件，不属于单个 block。

输出第一行确认形状从 $(2,5,512)$ 到 $(2,5,512)$，第二行给出参数量 3,152,384，与第 9 节的单层公式一致。因果性检验只修改位置 4 的输入：开启掩码时，位置 0 至 3 的查询看不到位置 4 的键与值，输出必须逐元素不变，`prefix unchanged` 为 True；位置 4 自己的输出会变化，`last changed` 为 True。关闭掩码后，位置 4 的键值进入所有查询的加权和，前缀输出随之改变，`no mask, prefix unchanged` 为 False。这一组对照直接验证了掩码的作用位置与因果性。

形状追踪如下表。`view` 与 `transpose` 不改变元素总数，只重排维度；`contiguous` 在合并头维前把内存布局恢复为连续，否则 `view` 可能报错。

| 步骤 | 形状 |
|---|---|
| 输入 `x` | $(2,5,512)$ |
| `ln1(x)` | $(2,5,512)$ |
| `q_proj(x)` | $(2,5,512)$ |
| `view + transpose` | $(2,8,5,64)$ |
| `scores` | $(2,8,5,5)$ |
| `softmax(scores)` | $(2,8,5,5)$ |
| `attn @ v` | $(2,8,5,64)$ |
| `transpose + view` | $(2,5,512)$ |
| `o_proj` | $(2,5,512)$ |
| 第一次残差相加 | $(2,5,512)$ |
| `ln2` | $(2,5,512)$ |
| FFN 第一层 | $(2,5,2048)$ |
| GELU | $(2,5,2048)$ |
| FFN 第二层 | $(2,5,512)$ |
| 第二次残差相加 | $(2,5,512)$ |

若把 `mask` 加在 `softmax` 之后，前缀不变性检验仍可能通过，因为未来位置的权重被置零；但行和不再为 1，输出尺度错误，训练损失下降更慢。若把 `mask` 加到错误的维度，例如对 $(T,T)$ 掩码取转置，模型会看到未来而看不到过去，训练损失异常低而生成质量极差。若把 Pre-LN 写成 Post-LN 但保留 `x + attn(ln1(x))` 的写法，LayerNorm 的位置与残差顺序不一致，深层训练会不稳定。若忘记 `contiguous()`，在某些 PyTorch 版本与形状下 `view` 会抛出 `RuntimeError`。

## 易错点

> [!warning] 以下六条均可在形状推导或代码运行中直接检验。
> 1. LayerNorm 的作用维度写错：Transformer 的 LayerNorm 沿特征维 $d$ 归一化，对 $(B,T,d)$ 产生 $BT$ 组统计量；若对批维或序列维归一化，推理结果会依赖同批样本或序列长度，且与训练时行为不一致。
> 2. 残差顺序与归一化位置混用：Post-LN 是 $\mathrm{LN}(x+F(x))$，Pre-LN 是 $x+F(\mathrm{LN}(x))$；把 Pre-LN 的残差写法与 Post-LN 的末端结构拼在一起，或 Pre-LN 忘记最终 LayerNorm，都会使深层训练发散或表示尺度失控。
> 3. 掩码时机与广播错误：掩码必须在 softmax 之前以加性 $-\infty$ 加入，形状 $(T,T)$ 广播到 $(B,h,T,T)$；softmax 后置零破坏行归一化，掩码转置则泄漏未来信息，掩码未放到正确设备会直接报错。
> 4. 位置编码相加方式错误：位置编码必须与 token 嵌入逐元素相加且维度为 $d$，在进入第一层之前加入一次；拼接会改变维度，只在最后一层加则前几层没有位置信息，广播时把 $(T,d)$ 加到批维也会错位。
> 5. 标签移位方向错误：解码器输入应为 $(y_0,y_1,\dots,y_{T-1})$，目标是 $(y_1,\dots,y_T)$；不移位会使模型直接看到答案，反向移位则看到未来标签，两种错误都会让训练损失异常低而推理无效。
> 6. 交叉注意力的 Q/K/V 来源错误：查询必须来自解码器当前层，键与值必须来自编码器输出；三者都取自解码器会退化为自注意力，查询取自编码器则解码器状态无法参与检索。

## 关联笔记

- 前置 [[注意力机制与QKV]]：第 3 节的缩放点积注意力、$\sqrt{d_k}$ 与多头拆分以该篇的推导为基础，本篇只补充层内组合与形状。
- 前置 [[因果注意力与多头注意力]]：解码器的掩码自注意力直接使用该篇的因果掩码实现，掩码时机与广播规则相同。
- 前置 [[位置编码-正弦与RoPE]]：第 2 节的嵌入相加、位置编码维度与长上下文行为由该篇给出推导与代码。
- 后续 [[KV缓存]]：第 10 节的解码过程在工程上通过缓存历史键值加速，该篇给出显存公式与 prefill/decode 的计算特征。
- 后续 [[Llama-2架构复盘]]：该篇把本篇的 Pre-LN、FFN 与注意力替换为 RMSNorm、SwiGLU、RoPE 与分组查询注意力的具体配置。

## 达标检测

- [ ] 画出编码器-解码器的数据流，写出嵌入、注意力、FFN、logits 各张量的形状，说明批维与头维在何处展开与合并，并指出交叉注意力中 Q、K、V 的来源。
- [ ] 写出 Post-LN 与 Pre-LN 的层公式，说明两者在梯度通路上的差别，以及 Pre-LN 为什么需要末端 LayerNorm。
- [ ] 从 $\mathbf{x}_{l+1}=\mathbf{x}_{l}+F_{l}(\mathbf{x}_{l})$ 推出 $\partial\mathcal{L}/\partial\mathbf{x}_{0}$ 的展开式，指出恒等项的作用。
- [ ] 对 $d=512$、$d_{ff}=2048$、$L=6$、$V=37000$ 逐项计算注意力、LayerNorm、FFN、嵌入与总参数量，误差不超过 1%。
- [ ] 解释掩码为什么必须在 softmax 之前加入，并说明 softmax 后置零会导致行和与梯度出现什么问题。
- [ ] 运行例 3 的代码，报告参数量与三项因果性检验结果，并把 `causal` 改为 `False` 后解释输出变化。
- [ ] 给定解码器输入与标签，写出正确的移位方式，并指出不移位、反向移位各自造成的标签泄漏。

## 参考来源

- Vaswani et al., "Attention Is All You Need", arXiv:1706.03762 —— 对应本篇第 1 至 4 节的整体架构、编码器/解码器层、多头注意力、位置编码相加、第 9 节参数量配置与第 10 节标签平滑。
- d2l.ai《动手学深度学习》"注意力机制与 Transformer" 一章 —— 对应第 3 节多头注意力的形状变换、第 4 节掩码实现与第 10 节教师强制的训练流程。
- Stanford CS224n 关于 Transformer 的讲义 —— 对应第 5 节 Post-LN/Pre-LN 的稳定性讨论、第 6 节残差梯度通路与第 7 节 LayerNorm 的作用维度。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 4 章 —— 对应第 3 节 Pre-LN 模块的组织方式、第 8 节 GELU 前馈网络与第 9 节的参数量核对方法。
- PyTorch 官方文档 `torch.nn.LayerNorm` 与 `torch.nn.MultiheadAttention` —— 对应第 7 节 `normalized_shape` 的语义与第 3 节多头注意力的输入输出形状约定。
- Touvron et al., "Llama 2: Open Foundation and Fine-Tuned Chat Models", arXiv:2307.09288 —— 对应第 5 节现代 decoder-only 模型的 Pre-LN 类结构与第 8 节前馈网络的工程变体。
