第 17 章 · 序列与 Transformer

注意力机制

上一章我们想通了“为什么要让每个词直接看全局”。这一章不玩虚的:我们把这台机器 彻底拆开,还会拿三个词、几个小数字,陪你从头到尾手算一遍。 你会发现它没那么神秘——说到底,注意力只是在做一件你早就会的事:加权平均。 前面学过的点积、softmax、加权求和,在这里全都用得上,一个新公式都不需要背。

1. 一句话直觉:注意力就是“按相关性加权平均”

在钻进 Q、K、V 那些字母之前,先把唯一真正重要的那句话记住。 注意力对句子里的每一个词都做同一件事:

把其他所有词的内容拿过来,按“和我有多相关”打一组权重,然后做一次加权平均, 得到这个词的“新版本”——一个已经融合了上下文的向量。

“加权平均”你其实天天都在用。比如算平时成绩:期末占 0.6、作业占 0.3、考勤占 0.1, 把三个分数按这组权重加起来,就是加权平均。这里的权重是老师定死的; 注意力的唯一新意,是让权重不再写死,而是根据“词和词的相关性”当场算出来。

2. 三个角色:Query、Key、Value

要算“相关性权重”,得先让每个词能被“查找”和“比对”。注意力借用了去图书馆查资料的思路, 把每个词拆成三副面孔:

• Query 查询我“想找什么”。就像你走进图书馆时脑子里的问题:“我要找关于猫的书”。
• Key 键我对外挂出的“标签”,用来被别人匹配。就像每本书书脊上的标题/索引。
• Value 值我真正的“内容”,一旦被选中就把它取出来用。就像翻开书后里面的正文。

查资料的过程就是:拿着你的问题(Query),去比对每本书的标题(Key), 越对得上的书,你越会去读它的正文(Value)。注意力干的是一模一样的事, 只不过“比对”用的是点积,“越对得上就越多读一点”用的是加权平均。

为什么偏偏要三个?一个不行吗?

这是新手最大的一个坎,我们掰开说。同一个词,在句子里扮演的角色是分裂的:

• 它作为提问者时,关心的是“我该去找谁”——这是 Query;
• 它作为被查的对象时,要挂出一个方便别人匹配的标签——这是 Key;
• 它被选中之后,真正要交出去的信息又是另一回事——这是 Value。

“找人时说的话”“被找时挂的牌子”“真正肚子里的货”,本来就该是三样东西。 所以我们用三个不同的权重矩阵 W_Q、W_K、W_V, 把同一份词向量投影成三副面孔。关键点:

三个矩阵长什么样?

在本仓库 SelfAttention 里,它们就是三组名叫 query_weight_、key_weight_、 value_weight_ 的二维表。若 model_dim = d,则每个矩阵形状都是 d×d—— 和 MNIST 一层全连接权重同类型,只是这里要三套,再加一个多头拼回去用的 W_O(第 8 节)。

对序列里每一个词都重复同一件事:取出它的输入向量 x,分别乘三张表,得到三个小向量。 代码里一行 ProjectSequence(input, query_weight_) 就是在做“整句每个位置各乘一次 W_Q” (第 9 节会对着源码再走一遍)。

3. 完整流程:先投影,再四步走

完整前向其实是“投影 + 四步”:先把每个词的输入向量 x 乘 W_Q/W_K/W_V, 得到 Q、K、V(第 4 节第 0 步手算); 再锁定某一个词当 query(其余每个词也会各自轮一遍),做下面四件事:

1. 打分(比相关性):拿我的 Query,和每个词的 Key 做点积。点积越大 = 越“对得上” = 越相关。
2. 缩放(除以 √d):把每个分数除以 √d(d 是向量维度)。维度一大,点积容易冲得很大,缩放让它别太极端。
3. softmax(变成权重):把一排分数压成一排加起来等于 1 的权重(第 4 章学过)。这就是那组“加权平均”的权重。
4. 加权求和(混合内容):用这排权重,对所有词的 Value 做加权平均,得到当前词的新向量。

4. 跟着算一遍:一个能手算的小例子

光看流程还是抽象。我们把维度砍到 2 维、句子只留 3 个词, 用真实数字把整条链路从头算到尾:先由三个矩阵投影出 Q/K/V,再做打分与加权平均。 算完这一节,注意力对你就“通”了。

第 0 步:输入向量 × 三个矩阵 → Q、K、V

设句子里有三个词:猫、睡、它。 它们进到这一层 attention 时,各自已经是一条 2 维向量 x(可以想成 embedding + 位置编码之后的结果;此处不展开来源,只关心形状):

这一层 attention 自带三张可训练的 2×2 矩阵(为手算方便,下面直接写出具体数字):

投影规则就是第 2 章的矩阵乘:行向量左乘矩阵。 以“猫”为例,x = [1, 0]:

三个词各算一遍,得到整张 Q/K/V 表——后面打分用的就是这里的结果:

下面聚焦“它”当 query(其余词也会各当一次 query,流程相同),用 q = [2, 0] 和全表的 Key、Value 继续走第 3 节的四步。

第①②步:打分,再缩放

拿 q = [2, 0] 分别和每个词的 Key 做点积(点积 = 对应位置相乘再相加),然后除以 √d = √2 ≈ 1.41:

第③步:softmax,把分数变成权重

softmax 会先给每个分数取 e 的指数(放大差距,且都变正),再除以总和,让它们加起来正好等于 1:

看这排权重 [0.93, 0.01, 0.06]——这就是“它”的注意力分配: 它把 93% 的注意力放在了“猫”上,几乎不理“睡”。

第④步:加权求和,得到“它”的新向量

用这排权重,对三个词的 Value 做加权平均(数值来自上表第 0 步):

5. 为什么“点积”能当相关性?

第①步用点积打分,凭什么点积大就代表“相关”?回到刚才的数字就懂了: Query q = [2, 0] 指向“横轴”方向,而“猫”的 Key [3, 0] 也指向横轴—— 两个向量方向一致,点积就大(6);“睡”的 Key [0, 3] 指向“纵轴”, 和 q 垂直,点积就等于 0。

所以点积其实在衡量“两个向量方向有多合拍”:方向越接近,点积越大,越相关; 方向垂直,点积为 0,毫不相关;方向相反,点积为负,是“负相关”。 模型训练的目标,就是学会那三个矩阵,让该相关的词,它们的 Q 和 K 方向刚好凑得很近。

6. 自己上手玩一玩

道理算通了,再来玩个实时的。下面这个实验台,句子里每个词都有自己的向量; 你选一个 query 词,它会实时算出打分、softmax 权重和最终加权结果——和你刚才手算的完全是同一套流程。建议试试:

• 切换不同的 query 词,看注意力分布怎么变;
• 拖动 Temperature:调高会让权重更“平均”(谁都看一点),调低会更“尖锐”(死盯少数词);
• 勾上 causal mask,看它怎么把“后面的词”屏蔽掉(下一节细讲)。

7. 不能偷看未来:causal mask

语言模型要做的事是“根据前文预测下一个词”。训练和生成时有一条铁律: 预测第 t 个词时,只能看第 1 到 t 个词,绝不能看到它后面的词 ——否则就是“偷看答案”,学不到真本事。这条铁律有个正式名字,叫 causal mask(因果掩码),也叫“自回归掩码”。

具体怎么“遮”?办法很巧妙:不真的去删词,而是在打分之后,把所有“未来位置”的分数改成负无穷(−∞)。 回忆第③步——softmax 要先算 e^分数, 而 e^−∞ ≈ 0,所以这些未来位置的权重就变成了 ≈ 0,一点都参与不进加权求和,相当于被彻底屏蔽。

① 一张下三角表:到底谁能看谁

把“谁能看谁”画成一张方格表最清楚:行是“正在当 query 的词”,列是“被它看的词”, 从左到右、从上到下就是词在句子里的先后顺序。亮起来的格子表示“这一对允许打分”。 causal mask 允许的,恰好是一个下三角(含对角线)——每个词只能看到自己和它左边(更早)的词:

② 为什么是改成 −∞,而不是直接删掉或填 0

初学最容易冒出的疑问:既然不让看,把那一格分数直接设成 0 不就行了?为什么非要 −∞? 关键在于 mask 这一步发生在 softmax 之前,而 softmax 是“相对”的——它把每个分数变成 e^分数 再归一化:

• 若把未来位置的分数填 0:e⁰ = 1,它照样贡献了一份不小的权重,等于“还是偷看了一点”,没屏蔽干净。
• 若填 −∞:e^−∞ ≈ 0,这一份权重被彻底压没,softmax 归一化时其余位置自动补齐到 1,干净利落。

代码里当然写不了真正的“负无穷”,通常用一个极小的数(如浮点最小值)代替,效果一样。这就是 第 9 节代码里那句 score[col] = lowest() 的由来。

③ 训练时:一次并行,靠 mask 让每个位置“各看各的前文”

这一点最容易困惑,却也是 causal mask 真正威力所在。你可能以为:要让第 1、2、3…个位置各自“只看前文”, 得一个位置一个位置地跑很多遍?其实不用——训练时整句一次性喂进去, 一次前向就同时算出所有位置的预测,靠的正是这张下三角 mask 让它们互不串味:

这就是第 19 章会讲的 teacher forcing 能高效并行的根基:把标准答案的前半段整段喂进去, mask 保证每个位置都“看不到自己的答案”,于是 T 个位置的损失可以一次算完、一起反向传播,而不必逐字循环——训练因此快了很多。

8. 多头注意力:请几位专家各看一遍

目前为止只有一套注意力权重,也就是一种关注视角。但一句话里, 词与词的关系是多维度的:有的是“主语—谓语”,有的是“动词—宾语”,有的只是“位置相邻”。 只用一套权重,等于逼一个人同时盯所有这些关系,顾此失彼。

多头注意力(multi-head attention)的想法很朴素: 请几位各有专长的读者,各自把同一句话读一遍—— 一位专盯“谁是主语”,一位专盯“动词配哪个宾语”,一位专盯“相邻词”。 每位读者(每个“头”)独立走一遍上面的四步流程,给出自己的一套注意力权重和结果,最后把大家的结论拼起来。

9. 逐行读懂 self-attention 的前向

回到真实代码。你会发现它就是上面四步的“逐字翻译”,没有任何额外魔法。 第一步:把输入投影成 Q、K、V。

last_query_ = ProjectSequence(input, query_weight_);   1
last_key_   = ProjectSequence(input, key_weight_);
last_value_ = ProjectSequence(input, value_weight_);   2

第二步:打分并缩放。(下面是针对某个 query 行 row、某个头的内层循环——对应第①②步)

for (int col = 0; col < n; col++) {
  if (mask != nullptr && mask[row][col] <= 0) {
    score[col] = lowest();   // 屏蔽未来位置(causal mask)  1
    continue;
  }
  double dot = 0;
  for (int i = 0; i < head_dim_; i++)
    dot += last_query_[row][head_start + i]
         * last_key_[col][head_start + i];                 2
  score[col] = dot / std::sqrt(head_dim_);                 3
}

第三步:softmax,再用权重对 Value 加权求和。(对应第③④步)

auto weight = Softmax(score);                  1
for (int col = 0; col < n; col++)
  for (int i = 0; i < head_dim_; i++)
    merged_output[row][head_start + i]
        += weight[col] * last_value_[col][head_start + i];   2

第四步:把各个头的结果拼起来,再过一个输出投影融合。

output = ProjectSequence(last_merged_output_, output_weight_);   1

10. 这四个矩阵到底是怎么训练出来的?

到这儿你八成憋着一个问题:我们反复说 W_Q、W_K、W_V、W_O 是“训练出来的”,可到底怎么训?是不是又有一套没学过的新算法? 是不是每一层还各有一套、各训各的?好消息:完全没有新算法—— 更新方式和 MNIST、和 FFN 的权重,一字不差。

每一层各有一套矩阵,彼此不共享

这是第二个常见误会:不是全模型只有一套 W_Q/W_K/W_V 给所有层共用。 每堆一层 Transformer Block,里面就嵌一个独立的 SelfAttention, 带着自己那一套四个矩阵。GPT 堆 N 层,就有 N 套 attention 参数。

先把两样东西彻底分清

注意力里有两种“数”,新手最容易把它们搅成一团:

• 注意力权重(手算出的那排 [0.93, 0.01, 0.06]):是每次前向当场用 Q·K 算出来的,换个句子就变,不是参数、不用存、也不用训。
• 三个投影矩阵 W_Q/W_K/W_V(还有输出矩阵 W_O):才是真正的参数,和第 2 章那些“权重旋钮”一模一样,要靠训练慢慢调、要存进模型文件。

一句话:被训练的从来不是权重,而是“生产权重的那三个矩阵”。 训练它们,就是在教模型“该拿什么去问、该挂什么标签、该交出什么内容”。

老三样:前向 → 算损失 → 反向传播 → 微调

这三个矩阵和网络里其它所有参数一样,走的还是第 5、6 章那条流水线:

1. 前向:用当前矩阵算一遍注意力,一路算到模型的最终输出(比如“下一个字的概率”)。
2. 算损失:拿输出和“正确答案”比,得到一个误差(第 4 章的损失函数)。
3. 反向传播:用链式法则(第 6 章)把误差反着传回去,一直传到 W_Q/W_K/W_V,算出“每个矩阵元素该往哪边改”(梯度)。
4. 微调:沿梯度反方向,把每个矩阵元素挪一小步(梯度下降,第 5 章)。

这样“挪一小步”重复亿万次,三个矩阵就从最初的随机数,长成了“懂得该关注谁”的样子。

这几步落到真实代码里,就是 Backward 结尾的四行——和第 2 章“参数 = 参数 − 学习率 × 梯度”一字不差:

for (int out = 0; out < model_dim_; out++)
  for (int in = 0; in < model_dim_; in++) {
    query_weight_[out][in]  -= learning_rate * grad_query_weight[out][in];   1
    key_weight_[out][in]    -= learning_rate * grad_key_weight[out][in];
    value_weight_[out][in]  -= learning_rate * grad_value_weight[out][in];
    output_weight_[out][in] -= learning_rate * grad_output_weight[out][in];  2
  }

动手与思考

注意力是核心,但单靠它还不够。下一章我们给它配上残差连接、LayerNorm、前馈网络和位置编码, 拼出一块真正能堆叠的完整积木——Transformer Block。