第 18 章 · 序列与 Transformer

Transformer 的完整结构

注意力是发动机,但光有发动机还开不了车。要把注意力堆成又深又能训的网络, 还需要几个关键配件:残差连接、LayerNorm、前馈网络, 再加上让模型知道词序的位置编码。把它们组装起来,就是一块完整的 Transformer Block——今天所有大模型的基本积木。

1. 残差连接:给信息和梯度修一条高速公路

网络一深,就容易“训不动”:梯度反传到前面几层时已经衰减得几乎为 0(梯度消失)。 残差连接(residual connection)的解法简单得惊人—— 让每个子层的输出加上它自己的输入:

这里的 x 不是“整篇文章”那样的抽象输入,而是某个位置当前这一个 token 的隐藏向量。 如果整层输入是一条序列矩阵 X = [x₁; x₂; ...; x_n], 那残差相加做的其实是:

这条“x +”的捷径有两个好处:① 梯度可以原路直通回前面的层(高速公路), 深网络也不怕梯度消失;② 每个子层只需要学“在原有基础上改进多少”,比从零学一个新表示容易得多。

例如 attention 子层输出的不是“最后答案”,而是“这个 token 看完整句后该往哪边改一点”;FFN 子层输出的也不是“替换掉原表示的新向量”, 而是“这个 token 经过逐词加工后该补上的那一笔”。残差连接把这些“改一点”的结果稳稳叠回去,网络就能一层层细修,而不是每层都推翻重来。

last_residual_1_ = input;                          1
for (int i ...) for (int j ...)
  last_residual_1_[i][j] += last_attention_output_[i][j];   2
attention_norm_.Forward(last_residual_1_, last_norm_1_);    3

2. LayerNorm:把每个词的特征“拉回正常范围”

训练中,各层数值的大小、波动会乱飘,拖慢甚至搞崩训练。LayerNorm(层归一化) 对每一个词向量单独做标准化:减去均值、除以标准差,把它拉成“均值 0、波动 1”的分布, 再用两个可学习参数 γ(scale)和 β(bias)做微调:

这里的 x 同样指某一个 token 当前那一条向量,不是整句一起混着算。 如果一层输入是一整条序列矩阵 X = [x₁; ...; x_n], 那 LayerNorm 做的是:

double mean = 0;
for (double v : token) mean += v;
mean /= feature_dim_;                                  1

double variance = 0;
for (double v : token) variance += (v - mean) * (v - mean);
variance /= feature_dim_;                              2

double denom = std::sqrt(variance + epsilon_);
for (int i = 0; i < feature_dim_; i++)
  token[i] = ((token[i] - mean) / denom) * scale_[i] + bias_[i];  3

下面把一个最小的“未归一化 token 向量”手算一遍。假设某个词在经过子层和残差相加后,当前表示变成了 [1, 2, 3]:三个维度整体偏正,均值不在 0 附近,尺度也还没被拉回稳定范围。 如果一层层传下去的向量总是这样忽大忽小、整体漂移,后面的 attention 和 FFN 就得不断适应输入分布的变化,训练会更不稳。 先设 γ=1、β=0,看看 LayerNorm 怎么把它拉回标准范围:

所以你可以把 LayerNorm 理解成“给每个 token 自己洗一遍数值”。它不负责让 token 之间互相交流, 也不负责提取新特征;它只是保证“这个 token 现在这条向量的各维数值别乱飘”,让后面的 attention 和 FFN 都在更稳定的尺度上工作。

3. 前馈网络 FFN:逐个词再加工一次

注意力让每个词“看了全局”,但融合方式基本是线性加权。前馈网络(FFN) 紧随其后,对每个词独立地做一次“放大 → 非线性 → 压缩”:先用一个矩阵升到更高维度(比如 4 倍), 过 ReLU,再压回原维度。这给了模型额外的非线性加工能力。

这里最容易误解的就是公式里的 x。它不是整句文本,也不是“所有 token 一起拼成的大矩阵”直接一次性揉成一个向量; 它指的是某一个位置当前那一个 token 的隐藏向量。如果 attention 之后整条序列的表示是 X = [x₁; x₂; ...; x_n], 那 FFN 真正在做的是:

所以如果一条句子有 128 个 token,FFN 不是把这 128 个词糊成一团一起做变换,而是把同一个两层小 MLP 对 128 个 token 各跑一遍。它看的是“某个词已经融合过上下文后的表示”,再把这个表示加工得更适合下一层使用。

for (int token_idx = 0; token_idx < norm_1.size(); token_idx++) {      1
  hidden = ApplyLinear(norm_1[token_idx], W1, b1);   // model_dim → ff_dim
  for (double &v : hidden) v = Relu(v);                                2
  ff_output[token_idx] = ApplyLinear(hidden, W2, b2); // ff_dim → model_dim 3
}

把这一节压成两句话就是: attention 负责“跨词混合”,FFN 负责“逐词深加工”; 之所以要“先升维、再降维”,是因为把每个 token 摊到更宽的空间里,ReLU 才能切出更多“分段”、拟合更复杂的非线性变换, 加工完再压回原维度,好和残差相加、继续往下堆。

4. 把它们拼成一块 Block

一块标准 Transformer Block,就是“注意力 + 残差 + 归一化”和“FFN + 残差 + 归一化”这两段串起来:

关键在于:这块 Block 的输入和输出形状完全一样(都是“一串词向量”)。 所以它能像乐高一样一块叠一块:堆 6 块、12 块、96 块……越深,模型能力越强。 这正是“GPT-3 有 96 层”这类说法的含义。

5. 位置编码:告诉模型“谁在前谁在后”

注意力有个“缺陷”:它对所有位置一视同仁,本身并不知道词的先后顺序 ——把“狗咬人”和“人咬狗”打乱了它也分不清。解决办法是给每个位置造一个独特的“位置指纹”, 加到词向量上。经典做法用不同频率的正弦和余弦:

double angle = pos / std::pow(10000.0, (double)i / model_dim);  1
encoding[pos][i]     = std::sin(angle);                         2
encoding[pos][i + 1] = std::cos(angle);
// 之后: sequence[i][j] += encoding[i][j];                      3

这和二进制计数是一个道理——低位翻得快、高位翻得慢,合起来给每个数一个唯一编码:

把公式真代进去,给一个 4 维位置编码算前几个位置(d=4,偶数维用 sin、奇数维用 cos):

6. Encoder 与 Decoder

同样的 Block,按“能看到哪些词”分成两种用法:

• Encoder 编码器不加 causal mask,每个词能看到整句(双向)。适合“理解”类任务(如 BERT)。
• Decoder 解码器加上 causal mask(第 17 章),每个词只能看到它之前的词。适合“生成”类任务——因为生成时本来就还没有后文。GPT 系列就是纯 decoder。

7. 合体:那张最经典的 Transformer 全图

把前面所有零件拼齐,就得到了 2017 年论文 Attention Is All You Need 里那张最经典的架构图。 很多人第一次看它就发怵,其实图里每一个方块你都已经学过了。我们照着把它画出来,再一块块讲清楚“它到底在说什么”。

顺着数据流走一遍

左边这座塔是编码器(Encoder),负责“读懂输入”:

1. 输入嵌入 + 位置编码:把输入每个词查成向量(第 19 章),⊕ 上位置编码(第 5 节),让它既知道“是什么词”又知道“在第几位”。
2. N× 编码器块:每块 = 自注意力 → Add & Norm → 前馈网络 → Add & Norm(第 1–4 节);堆 N 层(原论文 N=6),越堆理解越深。
3. 编码器输出:一串“看过全句上下文”的向量,原样送给右边的解码器备用。

右边这座塔是解码器(Decoder),负责“一个词一个词生成输出”:

1. 输出嵌入 + 位置编码:把“到目前为止已生成的词”嵌入 + 位置编码。注意底部写着 Outputs(shifted right,右移一位)——预测第 t 个词时,喂进去的是第 1…t−1 个词,这正是第 19 章的 teacher forcing。
2. 掩码自注意力:带 causal mask 的自注意力,保证生成时只能看前文、不能偷看未来(第 17 章)。
3. 交叉注意力(cross-attention):关键一环——它一边看解码器自己的状态,一边回头查阅编码器的输出(下面细讲)。
4. 前馈网络,再 Add & Norm;同样堆 N 层。
5. Linear + Softmax:最顶上把解码器输出投影到词表大小、过 softmax,得到“下一个词的概率”——这就是第 19 章的 LM Head。

全图的“三种注意力”,一次看懂

很多人卡在“怎么突然冒出三个 Multi-Head Attention?”其实它们是同一套机制(第 17 章),只是Q、K、V 来自哪里不同。 这张表,是读懂整张图的钥匙:

三种家族:后来的模型只取半张图

这张全图是“编码器 + 解码器”的完整版。后来的模型常常只取其中一半:

• Encoder-only只留左塔,双向看全句,擅长理解(分类、检索)。代表:BERT。
• Decoder-only只留右塔(并去掉交叉注意力),带 causal mask 专心生成。代表:GPT 系列——今天的大模型几乎都是这一派。
• Encoder-Decoder两塔都要,适合“输入 → 输出”的转换任务,如翻译、摘要。代表:T5、原始 Transformer。

8. GPT 这种模型:把右塔堆很多层,再接一个 LM Head

既然如今大模型大多是 decoder-only,那把第 7 节那张“完整 Transformer 全图”裁开后, GPT 这类模型到底还剩什么?答案很干脆:只留右塔,把掩码自注意力的 Block 反复堆叠, 最顶上再接一个把隐藏状态投影到词表大小的输出层(LM Head)。训练目标始终不变: 预测下一个 token。

顺着这张图走一遍

1. Prompt tokens → Embedding + Position:先把输入提示切成 token,查表变向量,再加上位置信息。到这一步,模型拿到的是“一串带顺序的词向量”。
2. N× Decoder Block:整座主干就是很多层一模一样的 decoder block。每一层都只有两段:带 causal mask 的自注意力,再加一个逐 token 的 FFN。它没有 encoder,也没有 cross-attention,因为它不需要“回头看原文”那条支路。更重要的是: 每一层都有自己的一套 attention 参数,不是全网共用同一套 Q/K/V 投影矩阵。
3. Final LayerNorm + LM Head:最顶上把最后一层隐藏状态做一次归一化,再投影到词表大小,得到的是每个位置的 logits,还不是最终选出来的 token。
4. 训练:拿所有位置的 logits 和“正确的下一个 token”去算交叉熵;这就是大模型预训练时那条最核心的 loss 链路。
5. 生成:只取最后一个位置的 logits,过 softmax 后 greedy 或采样选一个新 token,把它追加到序列末尾。这个循环就是自回归生成。

层和层之间,到底传的是什么?

很多人第一次看 GPT 架构图会有个困惑:这些方块之间到底在传什么?其实从头到尾,主角几乎只有两类东西: 一串 token id,和它们对应的一串向量。从 embedding 往上到 Transformer 主干内部, 每一层传来传去的基本都是同一种对象:一张 序列长度 × model_dim 的矩阵——也就是 “这句话里每个位置,当前各自的一份隐藏表示”。

带着数字走完前向:整矩阵 + 逐步手算

上表讲的是阶段语义。下面先给整矩阵形状链(每一步的矩阵乘与形状), 再用第 16 章那句诗的开头 「床前明」把具体数字也走通,看它怎么猜出下一个字 月。真实 GPT 会堆几十上百层、维度也大得多,但运算类型完全一样。

配置与目标

整矩阵流水线:从输入到输出的形状链

下面把同一句「床前明」从头到尾写成矩阵版。 约定:每一行是一个 token,列是向量各维;矩阵乘法和第 1 章、 第 17 章一致——行向量左乘权重表。

ids [n]                                          [3]
  →  EmbeddingTable[ids]           X₀  [n × d]     [3 × 2]
  →  X₀ + PE                       X   [n × d]     [3 × 2]   ← 进 Block 的输入
  →  Masked Self-Attention         A   [n × d]     [3 × 2]   (中间 S/M 是 [3 × 3])
  →  LayerNorm(X + A)              H₁  [n × d]     [3 × 2]
  →  FFN(每行独立,共用 W1/W2)      F   [n × d]     [3 × 2]   (中间升到 [3 × 4])
  →  LayerNorm(H₁ + F)             H₂  [n × d]     [3 × 2]   ← 1 层时即 H_final
  →  H₂ · W_lm + b_lm              L   [n × V]     [3 × 5]   ← 每个位置一份 logits
  →  softmax(最后一行)             p   [V]         [5]       ← 生成时只取最后一个位置

各步展开:矩阵怎么乘

①② Embedding + 位置 — 先把 3 个 id 查成 3 行向量,再逐行加上位置指纹:

示意(数字仅作形状演示,不是真训练权重):

       维0    维1
床  [  0.2,  -0.5 ]   ← X₀ 第 0 行
前  [  0.9,   0.1 ]
明  [ -0.3,   0.8 ]   ← +PE 后第 2 行变成 [0.61, 0.38]

形状: X₀ 是 3×2 → +PE(3×2) → X 仍是 3×2

③～⑦ Masked Self-Attention(单头示范, h=1) — 整表一次算完,不必逐 token 循环。真模型几乎总是 h > 1,见下节「多头矩阵版」:

因果 mask 后,S 的上三角(未来列)作废;对每一行做 softmax 得权重矩阵 M(3×3 下三角,每行和为 1):

        床    前    明          ← 被看的列 j
床  [ 1.00,  0.0,  0.0 ]      ← 第 0 行只能看自己
前  [ 0.32, 0.68,  0.0 ]      ← 第 1 行看床/前
明  [ 0.21, 0.34, 0.45 ]      ← 第 2 行可看床/前/明三列

形状: Q·Kᵀ = [3×2]·[2×3] = 3×3(注意力矩阵是「词×词」,和 d 无关)

直觉:M 的第 i 行是“第 i 个词该听谁的”;乘 V 就是把各词的 Value 行按这排权重混成新第 i 行。 注意这里形状先从 3×2 撑成 3×3(打分),又被 M·V 收回 3×2——这就是第 17 章手算的矩阵批量版。

多头矩阵版:把 ③～⑦ 拆成 h 条并行路(h=2)

上一段为了形状最简,设 h=1(单头)。真实 GPT 会用多个头—— 第 17 章第 8 节讲过: 把每个词的 d 维向量切成 h 段,每段各算一套注意力,最后再拼回去。 仍用本例 d=2, n=3,取 h=2,则每头宽度 d_h = d / h = 1(每头只分到 1 维,虽然极端,但正好看清“切分—各算—拼回”的形状流转)。

Q, K, V  =  X·W_Q , X·W_K , X·W_V          各 [n × d] = [3 × 2]

头 1 取各行的前 d_h=1 列 →  Q₁,K₁,V₁  各 [n × d_h] = [3 × 1]
  S₁ = Q₁·K₁ᵀ / √d_h                              [3 × 3]
  M₁ = softmax(S₁, 按行) + causal mask
  O₁ = M₁·V₁                                      [3 × 1]

头 2 取各行的后 d_h=1 列 →  Q₂,K₂,V₂  各 [3 × 1]
  S₂ = Q₂·K₂ᵀ / √d_h                              [3 × 3]
  M₂ = softmax(S₂, 按行) + causal mask
  O₂ = M₂·V₂                                      [3 × 1]

拼回  O_cat = [ O₁ | O₂ ]   按列拼接              [3 × 2]
输出  A = O_cat·W_O                                 [3 × 2]

切片长什么样? — 以「明」那一行(第 2 行)为例,投影后 Q[2] 是 2 个数,切成两段(每段 1 个数):

Q[2] = [ q0 | q1 ]     ← 整行 2 维
          头1  头2
Q₁[2] = [ q0 ]          ← 只在维 0 上打分、做注意力
Q₂[2] = [ q1 ]          ← 只在维 1 上,可能盯完全不同的词

代码里对应 head_start = head * head_dim_,内层循环只在 [head_start … head_start+head_dim_) 那段维上做内积 (第 17 章第 9 节源码)。

两个头,两张不同的 M — 单头只有一张 3×3 权重表;多头各有自己的表(数字仅示意):

头 1  M₁ (可能更盯相邻词)          头 2  M₂ (可能更盯语义相关)
     床   前   明                       床   前   明
明 [ .15 .30 .55 ]                  明 [ .40 .12 .48 ]
     ↑ 头1 对「明」行的分配                 ↑ 头2 对同一行,另一套分配

同一行「明」,两个头可以分给「前」「明」不同的比重;拼回 O_cat[2] 后,再经 W_O 合成最终第 2 行输出。

本仓库默认 demo 常设 head_num=2、model_dim=64 → head_dim=32。 上面 d=2, h=2 只为手算形状(每头 d_h=1);换成 d=64, h=8 时,每头 d_h=8,流程完全相同,只是数字更大。

⑧ Add & Norm — 矩阵逐元素加,再每一行单独做 LayerNorm(不是整表一个大矩阵乘):

⑨ FFN — 整句写成矩阵,但token 之间仍不通信(每行只和自己的列做乘加):

形状链:

H₁  [n × d ]  =  [3 × 2]
         · W₁ [d × f]  =  [2 × 4]  →  Z  [3 × 4]   ← 每行从 2 维升到 4 维
    ReLU(逐元素,形状不变)          [3 × 4]
         · W₂ [f × d]  =  [4 × 2]  →  F  [3 × 2]   ← 再压回 2 维

和第 3 节 FFN一致:同一套 W₁/W₂ 对 3 行各算一遍,等价于代码里 for (token_idx…) 循环。

⑩ Block 出口:

⑪⑫ LM Head + Softmax — 把每个位置的 2 维向量投影到 5 个字的分数:

H₂[2]  (1×2)  ·  W_lm (2×5)  +  b_lm  →  logits (1×5)
                                              →  softmax  →  p(月) 最高

若堆 N 层 Block,把上面 ③～⑩ 原样重复 N 次:每层输入输出都是 [n×d]=[3×2], 但每层有自己的一套 W_Q/W_K/W_V/W_O/W₁/W₂(第 17 章第 10 节)。 下面「逐步手算」把同一流水线拆成 9 步,并补上具体数字。第 19 章 §4.4 用另一组维度(n=2, d=4 的「床前」)把同一条流水线再走一遍——两处维度特意不同,对照着看最能分清“哪个数是 n(几个词)、哪个是 d(每个词多宽)”。

逐步手算(同一流水线的数字版)

1. 1
   Tokenizer 文本 → 一串 id 床前明 → [0, 1, 2] · 形状 [3] 的整数,还没有向量
2. 2
   Embedding 查表 每个 id → 一条 d_model 维向量 E = EmbeddingTable[[0,1,2]] → 矩阵 X₀ ∈ R^(3×2) 示意: 床→[0.2,−0.5] · 前→[0.9,0.1] · 明→[−0.3,0.8] · 形状 3×2
3. 3
   + 位置编码 逐行相加,标上“第几位” X = X₀ + PE · 仍 3×2(第 5 节) 例: 明(位置 2) 的行 = [−0.3,0.8] + [0.91,−0.42] = [0.61,0.38] · 形状不变 3×2
4. 4
   Masked Self-Attention 整表投影 Q/K/V,再按位置加权融合 Q = X·W_Q · K = X·W_K · V = X·W_V · 各 [3×2]·[2×2]=3×2 打分 S = Q·Kᵀ 形状 [3×2]·[2×3]=3×3;对位置 i: 分数_ij = Q_i·K_j/√d (只看 j≤i) → softmax → 输出_i = Σ_j≤i 权重_ij·V_j “明”(i=2) 只能看 床/前/明;算完得新行 A[2] = [0.31, 0.55] · 全序列输出 A ∈ R^(3×2)(中间 S/M 是 3×3)
5. 5
   Add & Norm 残差相加,再 LayerNorm H₁ = LayerNorm(X + A) · 仍 3×2 “明”行: 先 [0.61,0.38]+[0.31,0.55]=[0.92,0.93],再对该行减均值除标准差 → H₁[2] ≈ [−1.0, 1.0](2 维标准化后必是一正一负)
6. 6
   FFN(逐 token) 每个位置独立跑同一个小 MLP F[t] = W₂·ReLU(W₁·H₁[t] + b₁) + b₂ · 2→4→2 维(中间升到 d_ff=4) “明”行: H₁[2](2 维)→ 升到 4 维 → ReLU → 降回 2 维 → F[2] = [0.08, 0.62] · token 之间不通信
7. 7
   Add & Norm Block 出口 H₂ = LayerNorm(H₁ + F) → H_final ∈ R^(3×2) 最后一行 h = H_final[2] = [0.18, 0.92] = “看完床前明后,这个位置对下一字的判断”
8. 8
   LM Head 最后一行 → 词表上每个字的分数 logits = h · W_lmᵀ + b · [1×2]·[2×5]=1×5 → logits ∈ R^5 示意 logits: 床−0.3 · 前−0.1 · 明0.2 · 月 1.1(最高) · 山0.0
9. 9
   Softmax 分数 → 概率 p = softmax(logits) · 生成时取 argmax 或采样 → 下一 token 月 示意概率: 月 ≈ 0.42(最高) · 明 0.21 · 前 0.18 · …

把注意力单独放大:第 4 步里,“明”这一行的新表示,本质上就是第 17 章手算那套 打分 → softmax → 对 Value 加权求和,只不过这里是对床/前/明 三个位置各算一组权重,再融合三个 Value 行。 训练时第 8 步会对三个位置都算 logits(每个位置都猜“自己的下一个字”),生成时只取最后一行 (第 19 章 4.3)。

和 MNIST 比一比:都在做加权求和,关联方式不同

如果你从MNIST 手写数字一路读过来,可能会问: 语言模型是不是也在用权重 W 做加权求和?和 MNIST 到底差在哪? 答案是:都在做加权求和,差别不在“用不用 W”,而在关联是固定的还是随输入现算的。

所以前面那句“MNIST 用 W 求和关联、LLM 用 attention 关联”方向对,但要补半句: LLM 的 FFN、LM Head 仍然在用固定的 W做加权求和;真正和 MNIST 不一样的,是跨词混合那一步——Attention 的权重不是写死在参数里的,而是读句子时当场算出来的。 注意力权重本身不是参数(不存盘、不训练),被训练的是生成 Q/K/V 的 WQ/WK/WV (第 17 章)。

几个最容易混的点

你也可以把隐藏状态想成一份“整句草稿”。最开始,每个 token 只有一个比较粗糙的“词向量草稿”;过一层 attention 后, 每个位置都读了一遍左边上文,草稿里多了“它和前文是什么关系”;再过一层 FFN,这份草稿又被逐词加工一遍。 所以层和层之间真正传递的,不是“一个个单词轮流往上送”,而是整条序列在当前时刻的一整版草稿。

真正的 GPT 家族会换配件,但骨架不变。 上图画的是最稳定的共通骨架。真实模型会在细节上换代: 位置编码可能从论文里的 sin/cos 换成可学习位置向量或 RoPE;LayerNorm 可能换成 RMSNorm;FFN 里的激活可能从 ReLU / GELU 变成 SwiGLU。但它们都没改那件根本事实: 这是一个 decoder-only Transformer,目标仍是预测下一个 token。

动手与思考

积木齐了!下一章我们把 embedding、Transformer、再加一个“输出层”接起来, 做成一个真正能一个字一个字写下去的字符级语言模型,并看看它怎么采样、怎么评估。