4.2 注意力机制:Query、Key、Value 的分工

本页范围:第 4 章第 2 节 | 整理时间:2026-09-29

快速浏览

核心问题一个 token 更新自己的表示时,应该听句子里哪些 token 的、各听多少?
本节主张注意力机制让每个 token 用 Query 主动报出需求,用 Key 亮出名片供人匹配,用 Value 提供真正的内容;按"匹配打分 → 缩放 → softmax → 加权求和"四步,把相关 token 的信息按比例搬进自己的新表示。
一句话结论Attention(Q,K,V) = softmax(QKᵀ/√d_k)V:先算谁和谁相关,再按相关程度把内容加权取回来。
关键词
Query / Key / Value缩放点积注意力softmax 权重加权求和掩码并行计算

  4.1 节搭起了两塔骨架,注意力是骨架里最关键的引擎,这一节把它拆到底。要回答的问题很具体:一个 token 更新自己的表示时,该听句子里哪些 token 的、各听多少?本节按"先直觉、再公式、后手算"的主线推进:

  1. 注意力在解决什么问题:每个 token 该听谁的(4.2.1):静态词向量装不下语境,RNN 的接力传话又慢又丢信息,注意力让每个 token 直接环顾全句;
  2. Query、Key、Value:三个角色各司其职(4.2.2):同一个向量乘三个投影矩阵,分出"需求、名片、内容"三种身份;
  3. 公式拆解:四步完成一次注意力(4.2.3):匹配打分、缩放、softmax、加权求和,并讲清为什么要除以 √d_k;
  4. 手算一遍:3 个 token、4 维向量的完整推演(4.2.4):以矩阵形式把打分、缩放、掩码、softmax、加权求和五步走完,看清注意力权重这张分配表;
  5. 同一个公式,三种用法(4.2.5):编码器自注意力、解码器掩码自注意力、编码器-解码器注意力,区别只在 Q、K、V 从哪里来、每个位置能看哪些位置;
  6. 为什么注意力取代了循环(4.2.6):用原论文(Vaswani et al., 2017)的复杂度对比表收账——换来 O(1) 的顺序操作与信息路径,代价是 O(n²) 的计算量。

  读完全节,softmax(QKᵀ/√d_k)V 这个公式对你来说应该不再是一串符号,而是"先算谁和谁相关,再按相关程度取内容"这四步的速写。

  拆开之前先定位:注意力坐在整条前向链路的哪一站。4.1 节把 Transformer 层比作链路的引擎室,本节拆的是引擎室里最关键的那台机器:

原创示意图 · 非论文原图 原始文本: 「我爱中国」 (输入起点) 分词器: 切成 token ID 序列 (第 2 章) Embedding 层: 查表:ID → 词向量 (3.1 节) 位置编码: 注入“第几格” (3.2–3.5 节) Transformer 层: 本节内容:注意力机制 (第 4 章) 输出投影: 算各 token 的概率 (4.6 节) 采样: 吐出下一个 token (第 12 章) 生成的新 token 接回输入,继续循环(自回归,第 12 章) 浅色实线框:已讲章节 紫底框:本节内容 虚线框:后续章节
图 1:注意力在前向链路中的位置。前面各站(分词、Embedding、位置编码)已讲完,本节拆的是 Transformer 层里的核心部件——注意力机制。输出投影见 4.6 节,采样与自回归循环见第 12 章。

  这台机器的内部是一连串矩阵运算。沿用第 3 章的 3 个 token 与 minimind 的真实尺寸(嵌入 768 维、每个注意力头 96 维),把它逐步画出来:

原创示意图 · 非论文原图 局部放大:注意力机制——输入 3 × 768,输出 3 × 96(单个注意力头) 第 1 步:同一个输入 X 乘三个投影矩阵,分出 Q、K、V(投影矩阵是训练学出来的参数) … X:3 × 768(3 个 token) ⋮ W_Q ⋮ W_K ⋮ W_V 投影矩阵:768 × 96 Q:3 × 96 K:3 × 96 V:3 × 96 V 在第 2 步末尾才上场 第 2 步:打分 → 缩放 → 掩码 → softmax → 乘 V 加权求和(为什么除以 √96 见 A.2 节) Q 3 × 96 K 3 × 96 × Q·Kᵀ ① 原始分数 3 × 3 ÷√96 ≈ 9.8 −∞ −∞ −∞ ② 掩码:挡未来(4.5 节) softmax ③ 权重:每行和为 1 V 3 × 96 × ⋯ 输出 3 × 96 打分:这一步就是算相关性——Q·Kᵀ 让每个 query 与每个 key 各点积一次(点积越大越相关,A.2 节),9 个配对得 9 个原始分数 读法:行 = 谁在看,列 = 看谁;格子 (i, j) = 第 i 个 query 与第 j 个 key 的点积(相关分);原始分数未缩放、未归一化,÷√96 稳住尺度 掩码(橙色虚线):上三角是未来的位置(列 > 行),填入 −∞,softmax 后权重恰为 0——不许偷看还没生成的词 softmax 后第 i 行 = token i 给三个 token 分配的注意力份额(和为 1),按份额对三行 V 加权求和(4.2.4 节手算全过程) 8 个这样的头并行工作再拼接(4.3 节多头注意力)
图 2:注意力机制的内部结构(单个注意力头)。第 1 步,输入矩阵 X(3 × 768)分别乘三个投影矩阵,得到 Q、K、V(各 3 × 96);第 2 步,Q 与 K 的转置相乘得 3 × 3 原始分数,除以 √96 缩放,上三角掩码挡住未来位置,softmax 把每行变成和为 1 的注意力权重,最后乘 V 得输出(3 × 96)。图中 3 × 3 小格只画结构不填数字,完整数字推演见 4.2.4 节。

4.2.1 注意力在解决什么问题:每个 token 该听谁的

  第 3 章讲过,Embedding 层给每个 token 查出一个静态向量:只要 token 相同,查出来的向量就相同。但语言的意思高度依赖语境。"苹果"在"我吃了一个苹果"和"苹果发布了新手机"里指的东西完全不同;"小猫追蝴蝶,因为它饿了"里的"它"指谁,也必须看了上下文才能确定。静态向量装不下这些信息,模型还缺一层机制:让每个 token 看一眼整句话,再决定自己的新表示要融入谁的信息。

  在 Transformer 之前,这个活儿主要靠循环神经网络(RNN)干:从头到尾逐个读词,每读一个词更新一次记忆,靠记忆把前文的信息带到现在。这种做法有两个硬伤:信息必须一站一站往后传,隔得越远越容易丢失;而且必须按顺序计算,第 100 个词要等前 99 个算完才能开工,GPU 的并行能力用不上。原论文第 1 节正是从这两个痛点出发,提出完全抛弃循环结构。

  注意力机制换了一条路:不搞接力传话,让每个 token 直接环顾全句。它主动向所有 token(包括自己)发出询问:你和我关系有多紧密?然后按紧密程度把对方的信息按比例搬过来,融合成自己的新表示。隔得再远的两个 token 也能一步到位直接对话,而且所有 token 的询问可以同时进行。

  「融合成新表示」在向量空间里到底是什么意思?先把输入输出两侧钉死。注意力层输入的一行,是这个 token「在词典里」的向量:它由训练收敛而来,浓缩的是这个词在全部语料里的平均用法(3.1 节),静态、孤立,在哪儿都长一个样。输出的一行,是这个 token「在这句话里」的向量:因为输出是所有 token 的内容按注意力份额做的加权平均(份额和为 1),几何上就是这个点从原位置被「拉向」它关注的那些 token,停在按份数定的中间位置。

  先借用 4.2.4 节的手算结果看一眼这次拉动长什么样(数字怎么来的留到那一节,这里只看含义)。句子"我 爱 猫"中,token 3「猫」的新旧表示:

\[ v_3 = [2,\ 1,\ 0,\ 0] \;\xrightarrow{\text{听完全句}}\; o_3 = 0.507\,v_1 + 0.186\,v_2 + 0.307\,v_3 \approx [1.12,\ 0.68,\ 1.20,\ 0.69] \]
输入侧 \(v_3\) 是词典里孤零零的「猫」;输出侧 \(o_3\) 里掺进了 50.7% 的「我」和 18.6% 的「爱」的内容——「猫」不再只是猫,而是「被我爱着的猫」的向量雏形。符号说明:\(v_i\) 是第 i 个 token 的内容向量(Value,4.2.2 节细讲);\(o_3\) 是 token 3 的新表示;三个系数是注意力权重,和为 1。

  这次拉动有什么用?回到本节开头的「苹果」。词向量是静态的,水果和公司共用同一个向量;但放进句子,「我吃了一个苹果」里「苹果」的新向量被「吃」拉向食物一侧,「苹果发布了新手机」里同一行输入被「发布」和「手机」拉向公司一侧。下游层读到的不再是词典释义,而是已经消歧、带角色的句中词义——谁是主语、修饰谁、指代谁,都编码进被拉动后的新位置里了。

  注意力层可以读作一台「词义现场改写机」:输入是词典释义,输出是结合全句语境后的临时释义。4.2.4 节会把这次「改写」的每一步用上面的数字完整算一遍。

  所以这步在干嘛:注意力给每个 token 一次"向全句提问并收集答案"的机会,把静态的词向量升级为结合上下文的新表示。这一步怎么做,就是本节的主题。

4.2.2 Query、Key、Value:三个角色各司其职

  注意力机制把一次"提问"拆成三个角色,每个 token 都会同时扮演这三个角色:

Query(查询)

这个 token 想找什么。由它主动发出,拿去和所有 token 的 Key 做匹配。

Key(键)

这个 token 的名片,标注自己能提供什么信息,用来被别人的 Query 匹配。

Value(值)

这个 token 真正提供的内容。名片一旦被看中,被取走的就是它。

  这三者的关系,可以想象成在图书馆查资料:你走到咨询台报出自己的需求(Query),书目系统里每本书都有一张索引卡片,写着书名和关键词(Key)。你拿需求和卡片逐一对照,卡片只是判断哪本书相关的线索;真正被你借走、读进脑子里的,是书的内容(Value)。需求和哪张卡片对得上,就重点取哪本书的内容,对不上就少取甚至不取。这套「检索词—索引—内容」的分工并非随手比喻:Query、Key、Value 三个名字本来就出自信息检索领域,词源与定名经过见附录 A.15;那张打分矩阵 QKᵀ 与统计里的协方差矩阵像在哪、差在哪,见附录 A.14。

点积(Dot Product) dot product = 两个向量对应分量相乘,再全部相加

点积是最常用的向量相似度度量:两个向量长度相当时,方向越一致,点积越大;方向越无关(接近垂直),点积越接近 0。注意力机制正是用 Query 和 Key 的点积来衡量"需求"和"名片"有多匹配。

  三个角色并不是三个互不相干的向量,而是同一个 token 向量乘以三个不同投影矩阵变出来的。第 3 章得到的 token 向量 \(x\),分别乘上三个可学习的权重矩阵 \(W^Q\)、\(W^K\)、\(W^V\),就得到这个 token 的 \(q = xW^Q\)、\(k = xW^K\)、\(v = xW^V\)。这三个矩阵是训练出来的参数,模型通过学习不断调整"该怎么描述需求、该怎么写名片、该怎么提供内容"。同一个 token 因此身兼三职:既去查别人(Query),也被别人查(Key),还随时准备好被取走内容(Value)。

  Query、Key、Value 是同一个 token 向量的三种化身:投影矩阵 \(W^Q\)、\(W^K\)、\(W^V\) 让模型学会从三个角度描述每个 token。注意力要做的,就是用 Query 和 Key 算出"该听谁的",再从 Value 里把信息取回来。

  原论文中每个 token 向量的维度是 \(d_{\text{model}} = 512\);实际实现用了 8 个并行的注意力头,每个头里 Query、Key 的维度 \(d_k = 64\),Value 的维度 \(d_v = 64\)(即 \(512 \div 8\))。多头是下一节的主题,本节先用单头的视角把原理讲透。

4.2.3 公式拆解:四步完成一次注意力

  原论文把这套机制命名为缩放点积注意力(Scaled Dot-Product Attention),全部计算浓缩在一个公式里:

\[ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V \tag{1} \]
公式 (1):缩放点积注意力(原论文公式 (1),逐字核对)。\(Q\)、\(K\)、\(V\) 是把所有 token 的 Query、Key、Value 分别堆成的矩阵,输出同样是每个 token 一行的新矩阵。符号说明:\(Q,K,V\) 由输入向量乘投影矩阵 \(W^Q,W^K,W^V\) 得来(4.2.2 节),每行对应一个 token;\(K^{\top}\) 是 \(K\) 的转置,\(QK^{\top}\) 算出所有 token 两两之间的匹配分;\(d_k\) 是 Key 向量的维度,\(\sqrt{d_k}\) 是缩放因子,防止点积过大把 softmax 推进梯度极小的区域;softmax 把每行分数归一化成和为 1 的权重;最后乘 \(V\) 即按权重对 Value 加权求和。

  从右往左读会晕,按计算顺序拆成四步就清楚了:

  1. 匹配打分 \(QK^{\top}\):每个 Query 和每个 Key 做点积,得到一个 \(n \times n\) 的分数矩阵(\(n\) 是 token 数),第 \(i\) 行第 \(j\) 列表示 token \(i\) 对 token \(j\) 的看中程度。这步在干嘛:算出谁和谁相关。
  2. 缩放:所有分数除以 \(\sqrt{d_k}\)。这步在干嘛:把分数拉回合适的数值范围,防止下一步 softmax 被撑爆(原因下文细说)。
  3. softmax 归一化:对分数矩阵的每一行做 softmax,把一行分数变成和为 1 的权重。这步在干嘛:把看中程度换算成分配比例,每个 token 手里的注意力总预算是 1,按比例分给所有 token。
  4. 加权求和:用权重矩阵去乘 \(V\),输出的第 \(i\) 行就是所有 token 的 Value 按第 \(i\) 行权重的加权和。这步在干嘛:按比例把别人的内容搬进自己的新表示。
\[ \mathrm{softmax}(z_i) = \frac{e^{z_i}}{\sum_{j} e^{z_j}} \]
softmax 把任意一行实数变成和为 1 的比例:指数运算放大分数之间的差距,分母负责归一化。原始分数差一点,权重可能差出好几倍。符号说明:\(z_i\) 是这一行第 \(i\) 个原始分数;\(e^{z_i}\) 是它的指数(\(e\) 是自然常数);\(\sum_j e^{z_j}\) 是对整行所有分数的指数求和,作分母把结果归一化。

  配上张量形状看得更清楚。设序列有 \(n\) 个 token,Query 和 Key 是 \(d_k\) 维,Value 是 \(d_v\) 维:

\[ \underset{n \times d_k}{Q}\;\cdot\;\underset{d_k \times n}{K^{\top}}\;=\;\underset{n \times n}{S}\;\xrightarrow{\;\div \sqrt{d_k},\ \mathrm{softmax}\;}\;\underset{n \times n}{W}\;\cdot\;\underset{n \times d_v}{V}\;=\;\underset{n \times d_v}{\text{输出}} \]
中间那个 \(n \times n\) 矩阵是注意力的指挥表:每一行是一个 token 对所有 token 的注意力分配。符号说明:\(n,d_k,d_v\) 的含义见上一段(token 数、Key 维度、Value 维度);\(S\) 是缩放前的分数矩阵;\(W\) 是 softmax 之后每行和为 1 的注意力权重矩阵;矩阵下方的标注是各自的形状。

为什么要除以 √d_k

  原论文 3.2.1 节给出的理由是:当 \(d_k\) 较大时,点积的数值会变得很大,从而把 softmax 函数推进梯度极小的区域;为了抵消这种影响,用 \(1/\sqrt{d_k}\) 缩放点积。梯度极小意味着参数几乎收不到更新信号,模型在这一层就学不动了。

  一个帮助理解的定量直觉:若 Query、Key 各分量是相互独立、均值为 0、方差为 1 的随机数,点积是 \(d_k\) 个分量乘积之和,其标准差约为 \(\sqrt{d_k}\)。\(d_k = 64\) 时,分数的典型波动就有 ±8 上下。softmax 对差距极其敏感:分差放大 8 倍,\([1, 0]\) 的 softmax 结果会从 \([0.73, 0.27]\) 变成 \([0.9997, 0.0003]\),几乎变成胜者全拿,输家那边的梯度趋近于 0。除以 \(\sqrt{d_k}\)(\(d_k = 64\) 时即除以 8)恰好把波动拉回单位尺度。这是后人的直觉解释,论文原文只给出"点积变大导致 softmax 饱和"的结论。

  原论文 3.2.1 节还对比过两种打分方式:加性注意力用一个带单隐藏层的小前馈网络计算匹配度;点积注意力就是公式 (1) 去掉缩放因子。两者理论复杂度相当,但点积可以直接调用高度优化的矩阵乘法,实践中更快、更省显存。只是 \(d_k\) 较大时,未缩放的点积注意力会落后于加性注意力,论文的对策正是加上缩放因子 \(1/\sqrt{d_k}\),缩放点积注意力由此得名。今天的 LLM 几乎清一色使用缩放点积注意力。

4.2.4 手算一遍:3 个 token、4 维向量的完整推演

  公式看完,用一个能跟着算的小例子,把图 2 这条流水线的完整链条——打分 → 缩放 → 掩码 → softmax → 加权求和——以矩阵形式走一遍。三个 token 组成一句话:"我 爱 猫"。先把尺寸对齐到图 2:真实模型里输入 \(X\) 是 \(3 \times 768\)(每行一个 token 的 768 维嵌入),三个投影矩阵各是 \(768 \times 96\),分别乘出 \(Q,K,V\) 三个 \(3 \times 96\) 的矩阵。手算扛不动 96 维,把单头维度缩成 4——相当于假装投影矩阵是 \(768 \times 4\),于是 \(Q,K,V\) 各是 \(3 \times 4\)。维度缩了,矩阵形状与运算顺序一个不变。假设投影已经完成,得到的三个矩阵如下(示例数字,仅为演示,不代表真实模型的计算结果):

\[ Q = \begin{bmatrix} 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 1 & 0 & 0 \end{bmatrix} \quad K = \begin{bmatrix} 2 & 0 & 0 & 0 \\ 0 & 0 & 2 & 0 \\ 0 & 1 & 0 & 0 \end{bmatrix} \quad V = \begin{bmatrix} 1 & 0 & 2 & 1 \\ 0 & 2 & 1 & 1 \\ 2 & 1 & 0 & 0 \end{bmatrix} \]
每行一个 token:第 1 行「我」、第 2 行「爱」、第 3 行「猫」。例如 \(q_3 = [1,\ 1,\ 0,\ 0]\) 是「猫」的需求描述,\(k_2 = [0,\ 0,\ 2,\ 0]\) 是「爱」的名片。三个矩阵由 \(X\) 分别乘 \(W^Q,W^K,W^V\) 得来(4.2.2 节),这里把投影结果当作已知。

  第 1 步,打分:\(S = QK^{\top}\)。\(Q\) 的每一行与 \(K\) 的每一行两两点积,一次矩阵乘法把 9 个匹配分全部算出:

\[ S = QK^{\top} = \begin{bmatrix} 2 & 2 & 0 \\ 0 & 0 & 1 \\ 2 & 0 & 1 \end{bmatrix} \]
格子 \((i, j)\) = \(q_i \cdot k_j\),即 token i 对 token j 的原始兴趣分。抽查一格:\(S_{13} = q_1 \cdot k_3 = 1\times0 + 0\times1 + 1\times0 + 0\times0 = 0\)——「我」对「猫」没兴趣;而 \(S_{11} = S_{12} = 2\),「我」对自己和「爱」都感兴趣。

  第 2 步,缩放。\(\sqrt{d_k} = \sqrt{4} = 2\),每个格子都除以 2(为什么除,见 4.2.3 节):

\[ S / \sqrt{4} = \begin{bmatrix} 1 & 1 & 0 \\ 0 & 0 & 0.5 \\ 1 & 0 & 0.5 \end{bmatrix} \]

  第 3 步,掩码。解码器生成时,token i 不许看 \(j > i\) 的未来位置(4.1.3 节)。做法很直接:把上三角格子的分数改成 \(-\infty\):

\[ \begin{bmatrix} 1 & -\infty & -\infty \\ 0 & 0 & -\infty \\ 1 & 0 & 0.5 \end{bmatrix} \]
上三角的三个 \(-\infty\) 是被封口的未来位置。看第 1 行:「我」是句首,右边全是未来,只剩自己能看。掩码只用于解码器自注意力,编码器不做(三种用法对比见 4.2.5 节)。

  第 4 步,softmax 按行。\(e^{-\infty} = 0\),被封口的格子权重归零,每行剩下的份额和为 1:

\[ W = \begin{bmatrix} 1 & 0 & 0 \\ 0.5 & 0.5 & 0 \\ 0.507 & 0.186 & 0.307 \end{bmatrix} \]
以第 3 行细算:\(e^1 \approx 2.718\)、\(e^0 = 1\)、\(e^{0.5} \approx 1.649\),分母 \(2.718 + 1 + 1.649 = 5.367\),三个权重依次是 \(2.718/5.367 \approx 0.507\)、\(1/5.367 \approx 0.186\)、\(1.649/5.367 \approx 0.307\)。这张 \(3 \times 3\) 的 \(W\) 就是全句的注意力分配表:第 i 行是 token i 的收听表,给谁分了多少一目了然。

  第 5 步,加权求和:\(O = WV\)。用权重矩阵乘 Value 矩阵,输出仍是「每行一个 token」的 \(3 \times 4\) 矩阵:

\[ O = WV = \begin{bmatrix} 1 & 0 & 0 \\ 0.5 & 0.5 & 0 \\ 0.507 & 0.186 & 0.307 \end{bmatrix} \begin{bmatrix} 1 & 0 & 2 & 1 \\ 0 & 2 & 1 & 1 \\ 2 & 1 & 0 & 0 \end{bmatrix} \approx \begin{bmatrix} 1.00 & 0.00 & 2.00 & 1.00 \\ 0.50 & 1.00 & 1.50 & 1.00 \\ 1.12 & 0.68 & 1.20 & 0.69 \end{bmatrix} \]
输出第 i 行 = 用 \(W\) 第 i 行对三行 \(V\) 加权求和。第 1 行权重是 \([1,\ 0,\ 0]\),所以 \(o_1\) 原样等于 \(v_1\)——「我」只听得见自己。第 3 行 \(o_3\) 是三个 Value 按 50.7% / 18.6% / 30.7% 调出的混合液。可以抽查 \(o_3\) 第 2 个分量:\(0.507\times0 + 0.186\times2 + 0.307\times1 \approx 0.68\)。

  单拎一行细看(以第 3 行「猫」为例):\(q_3 = [1,\ 1,\ 0,\ 0]\) 先和三个名片点积得 \([2,\ 0,\ 1]\),÷2 得 \([1,\ 0,\ 0.5]\),它是句尾、没有未来可封,softmax 得 \([0.507,\ 0.186,\ 0.307]\),最后 \(o_3 = 0.507\,v_1 + 0.186\,v_2 + 0.307\,v_3 \approx [1.12,\ 0.68,\ 1.20,\ 0.69]\)。矩阵乘法里这样的一行式计算共有 3 份,互不依赖、可以同时算——请记住"互不依赖"这四个字,4.2.6 节会用到它。

  所以这步在干嘛:五个环节走完,每个 token 都把自己的表示换成了「按注意力份额调和的上下文混合液」。掩码守住时间线(不看未来),softmax 把兴趣分换成份额,矩阵乘法让所有位置同时算完。一句话:分数矩阵 \(QK^{\top}\) 决定"看谁",权重矩阵 \(W\) 决定"看多少",乘 \(V\) 负责"把内容搬回来"。

原创示意图 · 非论文原图 ① 打分 S = QKᵀ ② 缩放 ÷2 ③ 掩码 ④ softmax → 权重 W 220 001 201 ÷ 2 110 000.5 100.5 置 −∞ 1−∞−∞ 00−∞ 100.5 softmax 100 0.50.50 0.5070.1860.307 掩码与 −∞ token i 不许看 j > i 的未来位置 被封口的格子置 −∞,softmax 后归零 第 1 行只剩自己可看:句首没有过去 红色 = 被封口的未来位置 ⑤ 加权求和 O = W × V:输出第 i 行 = 用 W 第 i 行对 V 的三行加权求和 100 0.50.50 0.5070.1860.307 W:3 × 3 × 1021 0211 2100 V:3 × 4 = 1.000.002.001.00 0.501.001.501.00 1.120.681.200.69 O:3 × 4 细看第 3 行(「猫」的新表示怎么来的) 打分:q₃·k₁ = 2,q₃·k₂ = 0,q₃·k₃ = 1 缩放:÷ 2 → [1, 0, 0.5];句尾没有未来,掩码不封口 softmax:[0.507, 0.186, 0.307](和为 1) 混合:o₃ = 0.507·v₁ + 0.186·v₂ + 0.307·v₃    ≈ [1.12, 0.68, 1.20, 0.69] 三行互不依赖,可同时算完(并行性见 4.2.6 节);掩码只用于解码器自注意力(三种用法对比见 4.2.5 节)
图 3:4.2.4 手算例的矩阵视角全流程。上行是 3 × 3 的分数与权重:QKᵀ 打分 → 缩放 → 掩码(红色为被封口的未来位置)→ softmax 得权重矩阵 W;下行是 W 乘 V 得输出矩阵 O,紫色带标出第 3 行的来龙去脉。图中数字与正文手算例一致(示例数字,仅为演示)。

4.2.5 同一个公式,三种用法

  缩放点积注意力这个公式,原论文在 Transformer 里用了三次(3.2.3 节),区别只在 Q、K、V 从哪里来、每个位置能看哪些位置:

编码器自注意力

Q、K、V 全部来自编码器前一层的输出。每个 token 都能看到同句所有 token,没有任何限制。

解码器自注意力(带掩码)

Q、K、V 来自解码器前一层,但每个位置只允许看自己及之前的位置。做法是把 softmax 输入中所有对应非法连接的分数设为 \(-\infty\),softmax 之后这些位置的权重变成 0。

编码器-解码器注意力(交叉注意力)

Q 来自解码器前一层,K、V 来自编码器的输出。解码器借此回头查输入句子的每一个位置。

  前两种用法的 Q、K、V 同源,所以叫自注意力(self-attention);第三种的 Q 与 K、V 不同源,常叫交叉注意力(cross-attention),主要服务机器翻译这类输入一种语言、输出另一种语言的场景。今天主流的 GPT 类模型只保留解码器,只用带掩码的自注意力这一种用法:生成第 \(n\) 个词时看不到第 \(n\) 个词之后的内容,这就是模型不能剧透未来的原因。掩码的实现细节与因果生成的关系,本章后续小节还会展开。

  三种注意力的区别:三者使用相同的计算方法,区别在于可见位置和信息来源。理解句子时(编码器)可以读取全部位置,生成文字时(解码器)只能读取当前位置之前的 token,翻译对照时(交叉注意力)由解码器读取编码器输出。

4.2.6 为什么注意力取代了循环

  回到本节开头的问题,现在可以给注意力一个公正的评价。RNN 像击鼓传花的传话游戏:一句话从第一个人传到最后一个人,传得越远越走样,而且必须排队,快不起来。注意力像把所有人拉进一个群聊:每个人直接跟所有人对话,同时开口,距离再远也是一步到位。

  原论文第 4 节用一张表把这种差别量化(表 1):

层类型每层复杂度顺序操作数最大路径长度
自注意力\(O(n^2 \cdot d)\)\(O(1)\)\(O(1)\)
循环\(O(n \cdot d^2)\)\(O(n)\)\(O(n)\)
卷积\(O(k \cdot n \cdot d^2)\)\(O(1)\)\(O(\log_k(n))\)
自注意力(受限)\(O(r \cdot n \cdot d)\)\(O(1)\)\(O(n/r)\)

  表 1(原论文表 1):\(n\) 是序列长度,\(d\) 是表示维度,\(k\) 是卷积核大小,\(r\) 是受限自注意力的邻域大小。重点看右边两列。顺序操作数衡量能不能并行:自注意力每个位置的新表示互不依赖(4.2.4 节手算例子里三行就是各算各的),全部位置可以同时算,GPU 终于能火力全开。最大路径长度衡量远距离信息要走几步:自注意力任意两个位置一步直连,隔了 50 个词的指代也能一把抓住,而 RNN 要传 50 站。

  代价也写在表里:每层复杂度中的 \(n^2\)。序列长度翻倍,注意力的计算量翻两番。

  \(n^2\) 是注意力为"任意直连"付的账单。今天的长上下文需求(几万到上百万 token)让这项开销成为系统瓶颈,怎么给注意力减负,是第 5 章(GQA、MLA 等架构变体)和第 13 章(KV Cache、推理优化)要解决的问题。

  一句话:注意力用 \(O(n^2)\) 的计算量,换来 \(O(1)\) 的顺序操作和 \(O(1)\) 的信息路径。计算量可以靠堆 GPU 并行消化,顺序依赖和长路径却是 RNN 绕不开的结构性瓶颈。这就是 Transformer 取代 RNN 的根本原因。

🧭本节要点回顾
Query、Key、Value 三个角色分别负责什么?它们从哪里来?
Query 描述这个 token 想找什么,Key 是供人匹配的名片,Value 是真正被取走的内容。三者由同一个 token 向量分别乘可学习投影矩阵 \(W^Q\)、\(W^K\)、\(W^V\) 得到。
为什么点积之后要除以 \(\sqrt{d_k}\) 再做 softmax?
原论文 3.2.1 节的理由:\(d_k\) 较大时点积数值变大,会把 softmax 推进梯度极小的饱和区,模型学不动。除以 \(\sqrt{d_k}\) 把分数拉回合适的数值范围。
注意力凭什么取代 RNN?
任意两个位置一步直连(最大路径长度 \(O(1)\)),且所有位置的新表示互不依赖、可以并行计算(顺序操作数 \(O(1)\))。代价是 \(O(n^2)\) 的计算量,但它能被并行硬件消化。

参考来源

  • Vaswani et al., 2017. Attention Is All You Need(arXiv:1706.03762)。本节的注意力定义、公式 (1)、缩放因子 \(1/\sqrt{d_k}\) 的理由、加性与点积注意力的对比、注意力的三种用法出自其 3.2 节;RNN 的串行瓶颈出自第 1 节;层类型复杂度对比出自第 4 节表 1。引用内容均以工程内中译本 ref_paper/2016_attention_is_all_you_need/2016_attention_is_all_you_need_zh.md 逐字核对。本页正文所称「原论文」即此篇。
  • minimind 工程(Apache 2.0):model/model_minimind.py 中 Attention 类的实现。
  • 4.2.4 节的数值例子为自编演示数字(文中已标注),仅用于演示计算流程,不来自任何真实模型。