w wyl123ly 的博客
MD

注意力机制与QKV

45 KB 2026.10.18 原文件

注意力机制与QKV

定义

注意力机制(attention mechanism)是以查询向量与键向量的相似度为权重、对值向量集合做加权求和,从而为每个查询产生一个输出的运算。缩放点积注意力(scaled dot-product attention)是其中取相似度为查询与键的内积除以 、并用 softmax 沿键维度归一化权重的一种具体形式。

本篇符号约定如下。

符号含义
序列长度,即查询、键、值的个数
模型维度 ,输入表示的通道数
注意力头数
单个头的查询与键维度,
单个头的值维度,通常取
输入表示,第 行为
查询投影、键投影
值投影
多头输出投影
查询矩阵、键矩阵
值矩阵
打分矩阵
位置 对位置 的打分
加性掩码,元素取 或
注意力权重矩阵
位置 分配给位置 的权重
输出

术语定义:查询(query)是发起检索的向量,记 ;键(key)是被检索项的索引向量,记 ;值(value)是被检索项的内容向量,记 ;注意力权重是打分经 softmax 归一化后得到的非负、行和为 1 的系数;掩码是加到打分上、用于禁止某些位置配对的矩阵,元素取 表示允许、 表示禁止;缩放因子 乘在打分上;头(head)是一组独立的 及其产生的注意力。

为什么重要

序列到序列模型必须把源序列的信息传给解码器。循环网络把整个源序列压缩为一个固定维度向量 ,解码第 步只能访问 ,而 的信息容量与 同阶、与源序列长度 无关,长度增加时单位 token 可用的维度按 下降;同时梯度从解码末端回传到源序列首端需经过 次矩阵乘与非线性,路径长度随 线性增长,长距离依赖的梯度按连乘衰减。注意力把读取路径缩短为常数:位置 直接对所有位置做加权求和,任意两个位置之间只隔一次加权聚合。

注意力同时消除了循环结构的串行依赖。给定 ,三次投影与两次矩阵乘法都是批量运算, 个位置在一次前向中并行完成;循环网络必须执行 次串行步骤,每步都是小矩阵乘法,GPU 的并行度受限于单步规模。这一差别使 Transformer 能在长序列上训练,也是 Transformer架构详解 中整个层可以堆叠到数十层的前提。

若没有注意力而只保留固定向量传递,还会带来参数效率问题:解码器每一步读取同一组参数与同一个向量,无法按内容选择信息来源;注意力用同一组投影参数在不同输入上产生不同权重,位置选择由数据决定而非由参数记忆。

在本库中的位置:本篇是 05 阶段的核心推导篇,从RNN到注意力机制 给出加性注意力的动机与瓶颈分析,因果注意力与多头注意力 把本篇的单头、无掩码形式改造为可自回归训练的多头形式,位置编码-正弦与RoPE 修补本篇结构对位置不敏感的缺陷,Transformer架构详解 把注意力、前馈网络与残差连接组装成层。对应学习目标三项:懂原理要求完成 的方差推导与复杂度分析;能复现要求写出 NumPy 与 PyTorch 两份实现并核对每个中间张量的形状;会评估要求能根据 与 判断计算瓶颈落在 项还是 项。

原理与推导

1 检索视角:查询、键、值的语义分工

把注意力理解为一次软检索,需要固定三个对象:键值表是 个二元组 ,查询是单个向量 ,检索结果是 。硬检索要求 与某个键相等,输出对应的值,权重为指示函数 。硬检索有两个不可用之处:连续向量之间几乎不存在精确相等;相等判断的梯度恒为零,键与值无法通过梯度下降学习。

软检索用相似度 替换相等判断,权重取 softmax:

该定义给出三条性质。第一, 且 ,因此 落在 的凸包内,输出不会超出值向量的取值范围。第二,softmax 对加性常数不变, 与 给出相同权重,起作用的只有相似度的相对差异。第三, 可微时 存在,键、值与打分函数都可训练。

取 有三条理由。其一,它是两个向量之间最简单的非平凡双线性函数,不含额外参数;若允许参数, 可被对 的线性投影吸收,因此"点积加线性投影"已经覆盖带参数的双线性打分。其二,当 固定时 与夹角余弦单调,相似度的序关系与方向一致;不做归一化时内积同时编码方向与模长,模长较大的键获得更大权重,这一行为由 的尺度在训练中调节。其三,全部 个打分可在一次矩阵乘法 中算出,复杂度 ,硬件利用率高;加性注意力含 与逐对相加,无法化为单次批量矩阵乘。

内积不满足度量的公理: 可为负,不满足非负性与三角不等式, 随 增大而无界。注意力只需要一个与相关性单调的排序量,不需要距离公理。若确实需要距离,可改用 ,它展开为 ,在 固定时与内积给出相同排序。

三个角色的语义分工如下。 由位置 的表示经 投影得到,表示该位置为构造自身输出而需要检索的内容; 由位置 的表示经 投影得到,是该位置可被检索的索引; 由位置 的表示经 投影得到,是该位置实际被读取的内容。三组参数独立,因此同一个 可以同时充当键(被其他位置检索)与查询(检索其他位置),两种角色的数值不同。

2 三次线性投影:维度与参数量

把单查询形式推广到 个查询,得到矩阵形式。输入 的第 行为 ,三个投影定义为

形状链为 、、。逐行写出即 ,等价于 。批量情形把 换成 ,得到 。

参数量: 与 各 个, 有 个。取 时三者合计 ;每个投影加偏置再各加 或 ,合计 。多头情形把 个头的投影按输出通道拼接为 的单一矩阵,参数总量不变,仍为 ,加输出投影 后为 ,推导见第 8 节。

三组投影必须相互独立。若取 ,则打分 关于 对称,,注意力矩阵对称,因果注意力要求 与 可以不同,对称打分把" 对 的关注"与" 对 的关注"强制绑定。若取 ,值空间与键空间共享方向, 与 成比例,值的模长直接进入打分,键与值的角色无法分别调节。

参数量占比可作为规模判断依据。GPT-2 small 配置 、、:每层注意力参数 ,12 层共 ,占 1.24 亿总参数的 22.8%;同层前馈网络 ,是注意力的两倍。注意力不是参数主体,而是计算量与显存随 增长的部分,见第 6 节。

3 缩放点积注意力的完整形式

对 定义

其中 表示对每一行独立归一化, 为掩码矩阵。展开为标量形式

逐项解释如下。

  • 的第 元素为 ,是位置 的查询与位置 的键的内积;对角线元素为自匹配 。矩阵乘法把 个内积一次算出,每个内积需 次乘加,总乘加量为 。
  • 是 维内积在单位方差假设下的标准差,除以它使打分的方差为 1,推导见第 4 节。
  • 为加性掩码,允许的配对为 ,禁止的配对为 ;加 不改变打分,加 使该项指数为 0。
  • 沿键维(最后一维)归一化, 的每一行为长度 的概率向量,全部元素非负、每行和为 1。
  • 的形状链为 ,第 行为 ,即值的加权平均。

缩放因子的位置有两种等价写法。其一是 ,其二是先把 缩放为 再做内积,前向结果逐元素相同。两者的差别只在反向:第一种写法使 与 同乘 ,第二种写法只对 的参数施加该常数, 一侧的梯度尺度不同。两种写法都正确,但在同一模型中不可同时使用,否则等效缩放因子为 ,方差变为 ,权重分布过于平坦。

4 除以 :方差推导与 softmax 饱和

考虑单个打分 。假设 与 相互独立、均值为 0、方差为 1,即

第一步,求均值。由独立性 ,故

第二步,求二阶矩。按定义

把双重和拆为 与 两部分。当 时,四个随机变量 相互独立,故

当 时, 与 独立,故

因此

第三步,缩放。令 ,则

结论: 维内积的标准差随 增长,除以 后与 无关。若不做缩放, 时打分标准差为 8, 时为 22.6;模型宽度变化会同时改变 softmax 输入的尺度,学习率与初始化方案无法共用。

第四步,说明尺度为何影响梯度。记 ,,则

当 趋近 one-hot 时 :设 ,则 ;其余分量 使第 行整体趋于零。损失对打分的梯度为 , 意味着 几乎收不到梯度,而 的梯度全部经由 回传,因此键与查询的参数更新停滞。

量化饱和程度。设 个打分近似独立、标准差为 。最大值的典型规模为 ,其余项在 量级,因此除最大项与次大项之外,每一项与最大值之差约为 ,其指数权重约为 。取 、,未缩放时 ,,该量约为 ,在 fp32 下与 0 不可区分。最大权重主要由最大项与次大项的竞争决定:两者差距的典型规模为 ,若差距恰为该值,最大权重为 ;差距是随机变量,实测均值为 ,低于该值。softmax 实现中减去行最大值可避免 溢出,但非最大项会下溢为精确 0,对应梯度也为精确 0。

数值验证取 、500 组标准正态打分,比较未缩放与缩放后的最大权重均值、以及分数梯度 的范数( 为标准正态随机方向):

未缩放最大权重缩放后最大权重未缩放 缩放后
10.01690.01690.05120.0512
40.11040.01680.13350.0513
160.44060.01700.25660.0515
640.70040.01630.21800.0514
2560.84760.01590.13200.0510

读法:缩放后最大权重稳定在 –,约为均匀分布 的 17 倍,与 无关;未缩放时最大权重随 单调升至 。梯度一列呈非单调,原因是 过小时打分接近均匀、对分数不敏感, 过大时饱和、梯度衰减,两种情形都削弱可学习性;缩放后该量恒定在 ,这正是缩放的作用:把有效梯度尺度固定在与 无关的水平。

关于假设的适用范围:推导假设初始化时 各分量独立、零均值、单位方差。训练后 与 随数据与损失改变,方差不再恰好为 1,缩放也就不再保证单位方差。缩放消除的是方差对 的依赖,使不同 的模型可以共用同一学习率与初始化尺度,这是它在工程上的实际作用。输出的尺度不需要额外缩放,因为 的每行和为 1, 是值的凸组合,其范数被 控制。

5 注意力矩阵、因果性与两种掩码实现

称为注意力矩阵,元素非负且每行和为 1,因此每一行是 维概率单纯形上的一个点。按允许的配对集合分为两类。

非因果(双向)注意力允许 全部配对, 稠密,每个位置的输出融合整条序列的信息,用于编码器与 BERT与双向编码模型 一类模型。因果注意力只允许 , 的严格上三角为零,位置 的输出只依赖前缀,用于自回归语言模型,动机与训练方式见 因果注意力与多头注意力。

因果掩码的两个等价定义:

后者称为严格因果,用于避免位置 通过自身的值向量复制输入,某些逐位置预测任务采用。语言模型采用前者,位置 必须能看到自己以预测下一个 token。

实现一,加性浮点掩码:,禁止位置取 或充分小的负数(如 )。 加有限数仍为 ,,且该项不进入分母。用 时 在 fp32 下下溢为 0,结果相同,但 超出 fp16 的可表示范围(约 ),在混合精度下应改用 torch.finfo(dtype).min 或直接使用布尔掩码。

实现二,布尔掩码:构造布尔矩阵 , 表示禁止,再用 masked_fill 或 np.where 把对应打分置为 。两种实现在数值上等价,区别在于布尔掩码不构造浮点 ,在混合精度下更安全,且不依赖掩码值的大小。

掩码必须在 softmax 的归一化之前生效。softmax 的分母遍历整行,若在 softmax 之后把禁止位置置零而不重新归一化,行和变为 ,且各位置的缩小比例不同。以例 1 的确定性矩阵实测,错误实现的行和为 ,第 0 行只剩自匹配项,输出被整体缩小到 22.1%,第 2 行缩小到 95.5%,第 3 行不受影响;缩小比例随位置变化,并会进入后续所有层。若在置零后除以行和重新归一化,精确算术下与前置掩码等价(同一矩阵上实测最大绝对差 ,为 float64 舍入量级),但多一次除法,且在低精度下先产生精确 0 再相除会放大误差。因此正确的做法是让归一化只在允许集合上进行,前置 是最直接的实现。

整行全为 时 softmax 的分母为 0,结果为 NaN。因果掩码的对角线恒为 ,保证每行至少有一个允许位置,因此单独的因果掩码不会产生 NaN;把因果掩码与 padding 掩码相加时,若某行的全部位置都是 padding,仍会得到全 ,需要在实现层排除这些行,或保证每行至少保留一个位置。

6 计算复杂度与瓶颈

记单个注意力头的计算量。打分矩阵乘法需 次乘加,softmax 需对 个元素做指数与求和、约 次浮点运算,加权求和 需 次乘加。 个头合计

最后一步用到 。投影部分为 三次 与输出投影一次,共

单层总计算量

两项之比为 ,在 时相等。取 :

投影 注意力 合计注意力占比
51225.0%
102440.0%
204857.2%
409672.7%
819284.2%

瓶颈分析给出三条结论。第一, 翻倍时注意力部分变为 4 倍, 翻倍时投影部分变为 4 倍而注意力只变为 2 倍,因此长上下文的瓶颈在 项,宽模型的瓶颈在 项;对 的模型, 后注意力成为主项。第二,注意力矩阵本身占显存 个元素,fp32 下 、、 时约 MB, 时约 GB,这是长上下文训练显存峰值的主要来源之一;FlashAttention 一类实现的改进在于避免把 矩阵完整写入显存并按块重算,而不改变算术量 。第三,注意力对 的依赖是二次的,而循环网络对 是线性的,注意力的优势在于并行度而非渐近复杂度,序列越长,二次项越需要专门优化。

7 与 Bahdanau 加性注意力的对比

Bahdanau 注意力为每个解码状态 与编码状态 计算

其中 、、。参数量为 ,与点积注意力的 ( 时)同阶。

对比维度加性注意力(Bahdanau)缩放点积注意力
打分函数
是否含非线性含 ,打分对输入非线性无,打分对 双线性
计算形式逐对计算 维变换后投影两次批量矩阵乘法
复杂度,常数含 与中间张量,常数小
中间显存若不融合,需
并行性逐对计算,难以映射为单次 GEMM全部配对一次 GEMM 完成
数值行为 有界,打分范围受限方差随 线性增长,需缩放
表达能力可表示 的非线性交互固定投影后为秩不超过 的双线性型

两条需要精确说明的结论。其一,点积注意力的表达能力并不因缺少非线性而更弱到不可用: 是输入上的双线性型,其秩不超过 ,多层堆叠与逐位置前馈可补足非线性;加性注意力的 提供逐对非线性,在单层内表达更灵活。其二,Vaswani 等指出, 较小时两种机制效果相近, 较大时未缩放的点积注意力劣于加性注意力,原因正是第 4 节的方差增长;缩放后点积注意力在大 下不再退化,且计算更省,这是当代模型统一采用点积形式的原因。

8 多头注意力

单个 softmax 只产生一个权重分布,输出是单一凸组合。单个分布无法同时给两个位置接近 1 的权重,需要同时读取两个位置时只能折中为各 ,而单头输出的每个分量都来自这同一个加权和。多头注意力用 个独立的打分空间分别产生分布,再把结果拼接。

拆分方式为对每个头 取

其中 表示沿最后一维拼接,形状链为 ,再乘 得 。

参数量: 个头的 拼成 的一个矩阵,共 ;、 同理,各 ;输出投影 为 ,。合计

计算量:每头打分 、加权 , 头合计 ;投影合计 ,与单头全维()完全相同。因此多头在参数与计算上都不比单头贵,改变的是函数形式:它把输出写成 个凸组合经不同线性映射后的和。

多头不等价于单头,论证如下。单头的可达输出集合为

即值向量集合的凸包。多头的输出为

是 个凸包在 个不同线性映射下的像之和;即使取 ,和 的每行权重总和为 而非 1,当 不在原点处退化时该和一般落在单个凸包之外。反之,取 时多头公式退化为单头形式,故多头在同等参数量下是单头的严格推广。

多头还改变了低秩结构。单头输出 的秩不超过 ;多头拼接后的秩不超过 ,两者上限相同,但多头的每个头独立归一化,权重矩阵 被分解为 个块,每块在自己的 维子空间内单独饱和,因此同样的总维度下可以表达 个互不相同的集中分布。这一性质是 因果注意力与多头注意力 中讨论头专门化的起点,工程上的头数选择与 KV 显存权衡见 分组查询注意力GQA。

关键直觉

机制性表述

注意力是一次可微的软检索:位置 用查询 与全部键 做内积,得到 个相对分数,经 softmax 变成和为 1 的权重,再对值做加权平均。输出因此必然落在值向量的凸包内,权重只由分数的相对差异决定。除以 把打分的方差固定为 1,使 softmax 既不因 增大而饱和(梯度趋零),也不因 减小而近似均匀(无法区分位置)。多头把这个过程并行执行 次,得到 个不同的权重分布,拼接后经 线性混合。

该表述与严格定义的关系:凸包性质来自 softmax 的非负性与行和为 1 的归一化;方差为 1 来自第 4 节的独立同分布假设,只在初始化意义下成立;多头输出的可达集合是凸包线性像之和,比单头更大,但每个头内部仍受同一凸包约束。

例子与代码

以下代码在 Python 3.12.14、NumPy 2.3.5 下运行,输出为实际打印结果。PyTorch 部分标注所需版本,本机未安装 PyTorch,形状与参数量按定义推出。

例 1:NumPy 缩放点积注意力(含因果掩码)

取 、、,构造整数矩阵使打分可手算核对。

import numpy as np


def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)      # 减去最大值,防止 exp 溢出
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)   # 沿指定轴归一化,行和为 1


def scaled_dot_product_attention(Q, K, V, mask=None):
    d_k = Q.shape[-1]
    S = Q @ K.transpose(0, 2, 1) / np.sqrt(d_k)  # (B,T,d_k)(B,d_k,T) -> (B,T,T)
    if mask is not None:
        S = S + mask                             # 加性掩码,禁止位置为 -inf
    A = softmax(S, axis=-1)                      # 沿键维归一化,不是查询维
    return A @ V, A                              # (B,T,T)(B,T,d_v) -> (B,T,d_v)


Q = np.array([[1., 0.], [0., 2.], [1., 1.], [-1., 1.]])
K = np.array([[1., 0.], [0., 1.], [2., 2.], [1., -1.]])
V = np.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., 1., 0.]])

T = Q.shape[0]
causal = np.triu(np.full((T, T), -np.inf), k=1)  # 严格上三角为 -inf
print("mask")
print(causal)

Q1, K1, V1 = Q[None], K[None], V[None]           # 增加批量维,形状 (1,T,d)
O, A = scaled_dot_product_attention(Q1, K1, V1, causal)
print("scores")
print(np.round(Q1 @ K1.transpose(0, 2, 1) / np.sqrt(2), 3))
print("A")
print(np.round(A, 4))
print("row sums", A.sum(-1))
print("O")
print(np.round(O, 4))
print("max masked weight", A[causal[None] == -np.inf].max())
mask
[[  0. -inf -inf -inf]
 [  0.   0. -inf -inf]
 [  0.   0.   0. -inf]
 [  0.   0.   0.   0.]]
scores
[[[ 0.707  0.     1.414  0.707]
  [ 0.     1.414  2.828 -1.414]
  [ 0.707  0.707  2.828  0.   ]
  [-0.707  0.707  0.    -1.414]]]
A
[[[1.     0.     0.     0.    ]
  [0.1956 0.8044 0.     0.    ]
  [0.0967 0.0967 0.8066 0.    ]
  [0.131  0.5388 0.2657 0.0646]]]
row sums [[1. 1. 1. 1.]]
O
[[[1.     0.     0.    ]
  [0.1956 0.8044 0.    ]
  [0.0967 0.0967 0.8066]
  [0.1956 0.6034 0.2657]]]
max masked weight 0.0

手算核对。第 0 行只允许 ,权重为 ,输出等于 。第 1 行允许 ,打分为 ,、,归一化得 。第 2 行打分为 ,指数为 ,和为 ,权重 ,输出 。第 3 行打分为 ,指数为 ,和为 ,权重 ,输出为 ,与打印一致。

逐段说明。K.transpose(0, 2, 1) 交换最后两维,把 变为 ,使 得到全部 配对;若写成 Q @ K, 与 无法相乘,批量时即使能广播也不是配对关系。softmax(S, axis=-1) 沿最后一维(键维)归一化,保证每行和为 1;若取 axis=-2,归一化沿查询维进行,每列和为 1,权重语义变为"位置 被哪些位置关注"。causal[None] 把 广播到 ,与打分相加;把掩码加在 softmax 之后会使行和小于 1,对照见下。A[causal[None] == -np.inf].max() 取出所有被屏蔽位置的权重,结果为精确 ,说明 经指数后为 0 且未进入分子。去掉 x - x.max(...) 一行,当打分较大时 np.exp 溢出为 inf,归一化得到 nan;本例打分最大 2.828,去掉该行仍能运行,因此数值稳定措施在小例子上看不出差别,在 以上的真实模型中必需。

在同一组矩阵上对照掩码的三种位置:

S_full = Q1 @ K1.transpose(0, 2, 1) / np.sqrt(2)     # (1,4,4),未掩码打分
A_full = softmax(S_full, axis=-1)                    # 先 softmax
A_bad = A_full * (causal[None] == 0)                 # 再置零,未重新归一化
print("bad row sums", np.round(A_bad.sum(-1), 4))
A_renorm = A_bad / A_bad.sum(-1, keepdims=True)      # 置零后重新归一化
A_good = softmax(S_full + causal[None], axis=-1)     # 先掩码再 softmax
print("max diff", np.abs(A_renorm - A_good).max())
bad row sums [[0.2212 0.2295 0.9545 1.    ]]
max diff 2.7755575615628914e-17

行和等于未掩码时该行前 个权重之和。第 0 行只剩自匹配项 ,输出被缩小到 22.1%;第 2 行缩小到 95.5%;第 3 行没有禁止位置,行和仍为 1。两种正确写法(前置 与置零后重新归一化)的最大差为 ,属于 float64 的舍入量级,说明二者在精确算术下等价;错误写法与它们的差异达到 量级。

例 2:方差与饱和的数值验证

以下代码复现第 4 节的两组数字。

import numpy as np

rng = np.random.default_rng(0)
d_k, n = 64, 200000
q = rng.standard_normal((n, d_k))        # 零均值单位方差
k = rng.standard_normal((n, d_k))
s = (q * k).sum(-1)                      # 逐样本内积
print("var(s) = %.3f, theory = %d" % (s.var(), d_k))
print("std(s) = %.3f, theory = %.3f" % (s.std(), np.sqrt(d_k)))
print("var(s/sqrt(d_k)) = %.4f" % (s / np.sqrt(d_k)).var())


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


T = 1000
c = rng.standard_normal((500, T))                      # 固定随机方向,用于测分数梯度
print("d_k  maxw  scaled  |Jc|  scaled")
for d_k in [1, 4, 16, 64, 256]:
    Z = rng.standard_normal((500, T)) * np.sqrt(d_k)   # 模拟未缩放打分
    A_raw = softmax(Z)
    A_scaled = softmax(Z / np.sqrt(d_k))
    Jc = A_raw * (c - (A_raw * c).sum(-1, keepdims=True))        # J c = a*(c - a·c)
    Jc_s = A_scaled * (c - (A_scaled * c).sum(-1, keepdims=True))
    print("%4d %.4f %.4f %.4f %.4f" % (
        d_k, A_raw.max(1).mean(), A_scaled.max(1).mean(),
        np.linalg.norm(Jc, axis=-1).mean(), np.linalg.norm(Jc_s, axis=-1).mean()))
var(s) = 63.767, theory = 64
std(s) = 7.985, theory = 8.000
var(s/sqrt(d_k)) = 0.9964
d_k  maxw  scaled  |Jc|  scaled
   1 0.0169 0.0169 0.0512 0.0512
   4 0.1104 0.0168 0.1335 0.0513
  16 0.4406 0.0170 0.2566 0.0515
  64 0.7004 0.0163 0.2180 0.0514
 256 0.8476 0.0159 0.1320 0.0510

第一段验证 的方差为 :20 万个样本的样本方差为 ,与 相差 ,标准差 与 一致;缩放后方差为 ,抽样误差量级为 ,故与 相符。第二段验证饱和与梯度: 从 1 增至 256,未缩放的最大权重从 升至 ,缩放后稳定在 –;未缩放的分数梯度范数先升后降(),缩放的始终为 。Z 的构造直接使用 倍的标准正态,等价于第 4 节假设下未缩放打分的分布;若改用真实的 投影,方差还取决于权重初始化尺度,但对 的依赖关系不变。Jc 一行利用 ,避免显式构造 的雅可比矩阵。

例 3:PyTorch 多头注意力(含拆分与拼接)

需 PyTorch 2.0 及以上。代码中 view 与 transpose 的顺序是多头实现的核心。

import math
import torch
import torch.nn as nn


class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=512, num_heads=8, dropout=0.0):
        super().__init__()
        assert d_model % num_heads == 0, "d_model 必须被头数整除"
        self.d_model = d_model
        self.h = num_heads
        self.d_k = d_model // num_heads
        self.W_q = nn.Linear(d_model, d_model, bias=False)   # d^2 参数
        self.W_k = nn.Linear(d_model, d_model, bias=False)
        self.W_v = nn.Linear(d_model, d_model, bias=False)
        self.W_o = nn.Linear(d_model, d_model, bias=False)   # 拼接后的输出投影
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        B, T, _ = x.shape
        q = self.W_q(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        k = self.W_k(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        v = self.W_v(x).view(B, T, self.h, self.d_k).transpose(1, 2)
        scores = q @ k.transpose(-2, -1) / math.sqrt(self.d_k)  # (B,h,T,T)
        if mask is not None:
            scores = scores.masked_fill(mask, float("-inf"))    # True 表示禁止
        attn = self.dropout(torch.softmax(scores, dim=-1))
        out = attn @ v                                          # (B,h,T,d_k)
        out = out.transpose(1, 2).contiguous().view(B, T, self.d_model)
        return self.W_o(out), attn


torch.manual_seed(0)
mha = MultiHeadAttention(d_model=512, num_heads=8)
x = torch.randn(2, 5, 512)
causal = torch.triu(torch.ones(5, 5, dtype=torch.bool), diagonal=1)
y, a = mha(x, mask=causal)
print(y.shape)                                    # torch.Size([2, 5, 512])
print(a.shape)                                    # torch.Size([2, 8, 5, 5])
print(a.sum(-1)[0, 0])                            # tensor([1., 1., 1., 1., 1.])
print(sum(p.numel() for p in mha.parameters()))   # 1048576

预期输出为 torch.Size([2, 5, 512])、torch.Size([2, 8, 5, 5])、每行和为 1 的向量、参数量 1048576。

逐行说明与删除后果。view(B, T, self.h, self.d_k) 把最后一维 切成 个连续块,每块 64 维,头 占据通道区间 ;随后 transpose(1, 2) 把 变为 ,只交换步长、不复制数据。若省略 transpose 而直接写 view(B, self.h, T, self.d_k),则 token 维被折进头维,头 0 会拿到位置 0 与位置 1 的部分通道,位置与头的对应关系被破坏,因果掩码也随之失效。k.transpose(-2, -1) 在最后两维上转置,是批量内积的标准写法;若用 .T,四维张量的所有维都会被反转,得到 。/ math.sqrt(self.d_k) 用每头维度 64 而非模型维度 512,两者相差 倍。masked_fill(mask, float("-inf")) 中布尔掩码 True 表示禁止,与例 1 的加性掩码语义相反,混用会导致全掩码或完全不掩码。attn @ v 后必须 transpose(1, 2) 回到 ,再 contiguous().view(B,T,d) 把 个块按 的顺序拼回;view 要求连续内存,省略 contiguous() 会抛出步长错误,说明前面的 transpose 产生了非连续张量,也说明拼接顺序依赖这一步的实现。最后 W_o 把 维映射回 维,参数量 ;去掉它则各头输出直接拼接,头之间无法线性混合,等价于把 固定为单位矩阵。

参数量核对:四个 nn.Linear(d,d,bias=False) 各 个参数,合计 ,与打印一致。若加偏置,每个投影多 个,合计 。

例 4:常见配置的参数量与计算量核对

配置单层注意力参数 单层 注意力 FLOPs
小模型384664589 824
GPT-2 small76812642 359 296
GPT-2 medium102416644 194 304
7B 级40963212867 108 864

计算方式: 与 直接代入。 时 ,。 时单层注意力参数 ,32 层共 ,与 7B 模型的总参数量同阶,说明大模型中注意力参数与 FFN 参数共同构成主体,而 一项随 平方增长。

易错点

以下六条均可在代码或形状推导中直接检验。

1. 打分写成 或忘记转置最后两维:正确形式为 ,形状 。批量时用 k.transpose(-2,-1),不可用 .T,后者会反转全部维度。检验方法:打印打分矩阵形状,应为 。

2. 掩码加在 softmax 之后且不重新归一化:行和变为 ,例 1 的确定性矩阵上实测为 ,位置越靠前输出被缩小得越多。检验方法:A.sum(-1) 应逐行等于 1。

3. 缩放遗漏或除错维度:应除以 (每头维度),不是 (模型维度); 时两者相差 2.83 倍。同时缩放 与打分两次会使等效因子为 ,权重过于平坦。检验方法:初始化时打印打分的标准差,应接近 1。

4. softmax 沿错误维度归一化:dim=-1 是键维,dim=-2 是查询维;后者使每列和为 1,权重语义变为"位置 被哪些位置关注"。此时因果掩码仍能屏蔽配对,但输出不再是值的凸组合,尺度也不受控。检验方法:检查 A.sum(-1) 而非 A.sum(-2)。

5. 多头拆分与拼接顺序不一致:拆分必须是 view(B,T,h,d_k).transpose(1,2),拼接必须是 transpose(1,2).contiguous().view(B,T,h*d_k),两者互为逆变换。若拆分写成 view(B,h,T,d_k),token 维被折进头维,头与位置错配,且不报错、只表现为性能下降。

6. 掩码导致整行 :softmax 分母为 0,结果为 NaN,且 NaN 会经残差传播到全部参数。因果掩码的对角线恒为 0 可避免此问题;叠加 padding 掩码时必须保证每行至少保留一个允许位置,或在实现中把全掩码行的权重置为均匀分布。

关联笔记

  • 前置 从RNN到注意力机制:该篇从 seq2seq 的固定向量瓶颈与 Bahdanau 加性注意力出发,给出注意力要解决的问题;本篇第 7 节把两种打分函数放在同一张对比表中。
  • 前置 预备知识-token与嵌入:注意力在嵌入序列 上做三次投影,本篇的形状约定与 的记法沿用该篇。
  • 后续 因果注意力与多头注意力:把本篇的无掩码单头形式改造为因果掩码加多头,给出 CausalSelfAttention 的完整实现、训练并行与推理逐 token 的差异。
  • 后续 位置编码-正弦与RoPE:本篇的打分只依赖内容,对位置置换等变;该篇证明这一性质并给出位置信息的注入方式。
  • 后续 Transformer架构详解:注意力作为子层与残差、LayerNorm、前馈网络组合,该篇给出层的完整结构与参数量核算。

达标检测

  • [ ] 写出 的形状链,并计算 、 时单层注意力参数量与 12 层占总参数的百分比,误差不超过 0.5 个百分点。
  • [ ] 在不查资料的情况下推出 ,逐项说明独立性、零均值、单位方差三条假设分别用在哪一步。
  • [ ] 用 softmax 的雅可比 证明 one-hot 时 ,并说明为何 的梯度随之消失。
  • [ ] 手算例 1 中第 2 行的打分、指数、权重与输出,与打印结果逐位核对,并说明第 0 行为何恰为 one-hot。
  • [ ] 运行例 1 的代码,报告被屏蔽位置权重的最大值与四行的行和;再把掩码改到 softmax 之后,报告行和的变化并解释偏差来源。
  • [ ] 实现例 3 的多头注意力,打印 、注意力矩阵与参数量,并说明去掉 transpose(1,2)、contiguous()、W_o 三者各自的后果。
  • [ ] 取 ,判断 与 时计算瓶颈分别落在 项还是 项,给出两项的数值与占比。

参考来源

  • Vaswani et al., "Attention Is All You Need", arXiv:1706.03762, 第 3.2 节 —— 对应本篇第 3 节的缩放点积公式、第 3.2.1 节关于 增大时点积注意力劣于加性注意力的结论与缩放动机、第 3.2.2 节的多头定义。
  • d2l.ai《动手学深度学习》「注意力机制与 Transformer」一章 —— 对应本篇第 1 节的打分函数视角(加性、点积与缩放点积)、第 5 节的 masked softmax 与掩码位置。
  • Stanford CS224n 关于 Self-Attention 与 Transformer 的讲义 —— 对应本篇第 1 节的 QKV 检索视角与第 8 节的多头拆分动机。
  • Karpathy, nanoGPT 仓库与 "Let's build GPT" 讲义 —— 对应第 2 节把 合并为单次投影的实现结构、第 5 节的因果掩码 buffer 与例 3 的拆分拼接写法。
  • Raschka, Build a Large Language Model (From Scratch), 2024, 第 3 章 —— 对应第 8 节多头注意力的形状变换逐步推导与第 2 节的参数量核对方法。
  • PyTorch 官方文档 torch.nn.MultiheadAttention 与 torch.nn.functional.scaled_dot_product_attention —— 对应 attn_mask 的布尔与浮点两种语义、批量维约定与例 3 的模块接口。