w wyl123ly 的博客
MD

因果注意力与多头注意力

43 KB 2026.10.18 原文件

因果注意力与多头注意力

定义

因果注意力(causal attention)是在自注意力中把位置 的允许配对集合限制为 的形式,使位置 的输出只依赖前缀 ,不依赖任何未来位置。因果掩码(causal mask)是实现该限制的加性矩阵 ,满足 ()与 ()。多头注意力(multi-head attention)是并行计算 组独立投影的注意力、把 个头的输出沿通道维拼接后再做一次线性投影的运算,定义见 注意力机制与QKV 第 8 节。

本篇符号约定如下,与 注意力机制与QKV 一致的部分只列形状。

符号含义
批量大小
序列长度
模型维度,即 ;代码用 ,复杂度表达式沿用
注意力头数
每头维度,
一层注意力的输入
、位置 的 token 及其输入向量,
因果掩码
分头后的查询、键、值
分头后的打分与权重
掩码预分配的最大长度,代码中的 block_size
负对数似然损失

术语定义:自回归语言模型(autoregressive language model)是把序列概率分解为逐位置条件概率乘积的模型;教师强制(teacher forcing)指训练时每个位置的输入取真实前缀而非模型自身的输出;预填充(prefill)指推理时对整段提示一次性前向;解码(decode)指逐个生成新 token 的阶段;头专门化(head specialization)指不同注意力头在训练后呈现不同的关注模式。

为什么重要

自回归语言模型的目标是建模 ,标准做法是写成条件概率的乘积并对每个位置做下一 token 预测。这一分解要求预测 时只能使用 ;等价地,位置 的表示只能读取 ,其中 是该位置自身的输入 token(生成第 个 token 时它已经存在),不能读取 。若注意力不做掩码,第 个位置的表示会混入后续 token 的信息,训练损失可以降到接近零:模型只需通过值向量与输出投影把下一个 token 复制到当前位置,不需要学习任何语言规律。这样的模型在训练集上表现完美,在生成时无法使用,因为待预测的 token 尚不存在。

因果掩码同时是训练并行化的前提。有了掩码,一次前向可以对全部 个位置同时计算条件分布,反向也只做一次,每层代价为 ;若按位置循环,第 步需重算前 个位置,总代价为 。训练与推理的计算结构差异全部源于这一点:训练时所有位置的输入已知,可以并行;推理时第 步的输入是第 步的输出,只能串行。这一差异直接决定 KV缓存 的必要性,也决定推理阶段的瓶颈从算力转向显存带宽。

多头的意义在容量与表示分工。单个 softmax 只给出一个归一化分布,需要同时读取多个位置时权重被摊薄; 个头给出 个独立分布,参数量与单头全维相同(),计算量也相同,只增加张量重排的开销。多头的实现细节是工程正确性的高发区:头维与 token 维的顺序、拆分与拼接的互逆性、缩放使用的维度;其中一部分错误(如头维顺序)不会报错,只表现为性能下降,另一部分(如掩码切片)会直接抛出形状错误。

在本库中的位置:本篇承接 注意力机制与QKV 的缩放点积注意力,给出因果约束的推导与多头的完整实现;KV缓存 在本篇第 4 节的推理结构上展开;Transformer架构详解 把本层与残差、LayerNorm、前馈网络组装成完整模型;位置编码-正弦与RoPE 处理本篇结构对位置不敏感的问题。对应学习目标:懂原理要求证明因果性在整栈中的传递;能复现要求写出可运行的 CausalSelfAttention 并核对形状与参数量;会评估要求能判断训练与推理的瓶颈差异。

原理与推导

1 自回归分解与因果约束

设词表为 ,序列为 ,。链式法则给出精确分解

训练目标为最小化负对数似然

该目标对模型结构提出一条约束:记第 层第 个位置的表示为 ,则对任意 必须有

即 是前缀的函数。满足该性质的结构称为因果的。下面用归纳法证明:由嵌入、因果注意力、逐位置前馈、残差与 LayerNorm 组成的栈是因果的。

基础情形 :,其中 是 token 的嵌入向量、 是位置编码,两者都只涉及位置 ,故 只用 ,而 是前缀 的一部分。

归纳步。设第 层满足因果性,考察第 层的四个组成。

  • 注意力子层:。其中 依赖 ;打分 由 与 决定,二者分别依赖 与 ;求和下标限制为 。三项合起来使 只依赖 。
  • 残差:,两个加项都只依赖 。
  • LayerNorm:对单个位置的通道维做归一化,不跨位置混合,保持因果性。
  • 前馈网络:对每个位置独立施加同一个 MLP,不跨位置混合,保持因果性。

四项都不引入对 的依赖,故第 层满足因果性,归纳成立。

若无掩码,约束被破坏的方式如下。去掉掩码后 , 依赖全部 。若在位置 之后接输出层预测 ,则预测的输入中已包含 的嵌入。优化器可以把整条读取路径(、注意力权重、 与输出投影)学成近似恒等映射并令 ,从而直接读出答案,损失趋零而模型不具备任何生成能力。这一现象称为信息泄漏(information leakage),它不是过拟合,而是训练目标与推理条件不一致。

2 因果掩码的构造

因果掩码按位置定义

时

实现上有两种等价表示。其一是浮点矩阵,允许位置为 、禁止位置为 或充分小的负数(如 ),直接与打分相加。其二是布尔矩阵,取 表示禁止,再用 masked_fill 置为 。布尔版本的存储为每元素 1 字节,浮点版本为 4 或 2 字节,且布尔版本不依赖具体数值,在混合精度下不会出现表示范围问题。

构造方式利用三角矩阵函数:

import numpy as np
import torch

T = 4
mask_float = np.triu(np.full((T, T), -np.inf), k=1)                        # NumPy
mask_bool = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1)     # PyTorch

np.triu(..., k=1) 保留严格上三角、其余置零,因此传入全 矩阵时得到"上三角为 、下三角与对角线为 "的结果。 会把对角线一起置零,得到严格因果掩码,即位置 看不到自身,用于逐位置预测任务;语言模型的下一 token 预测需要位置 看到自身,故取 。

工程上掩码在模块初始化时一次构造并注册为缓冲区,调用形式为 self.register_buffer("mask", tensor, persistent=False)。

缓冲区的语义有三条。第一,它随 module.to(device)、module.half() 一起迁移与转换,使用者不必手动搬运;若每次前向重新构造,必须显式指定 device 与 dtype,否则会出现设备不一致或精度不一致的错误。第二,它不被优化器更新,也不计算梯度,因为它不是 nn.Parameter。第三,persistent=False 使它不进入 state_dict,保存与加载检查点时不产生冗余键;旧版本模型加载新检查点时也不会因多出键而报错。

掩码的尺寸按最大上下文 预分配,前向时切片 mask[:, :, :T, :T]。这要求 ,实现中应当显式断言;若 ,切片不会报错而是返回较短的掩码,随后与打分矩阵相加时形状不匹配,或在某些广播布局下静默截断,导致部分位置未被掩码。前一种情况容易发现,后一种不会报错,是长上下文实验中需要重点排查的问题。

3 归一化必须在掩码之后

记未掩码的打分为 ,允许集合为 。正确的权重是 softmax 在 上的归一化:

前置掩码实现这一点的机制是: 使禁止位置的指数为 0,且 进入分母不改变分母的值,因此分母恰好是 。

后置掩码有两种写法,结果不同。第一种是 softmax 之后置零而不重新归一化:

此时行和为 ,输出被整体缩小,缩小比例随 变化: 越小,允许的位置越少,被丢弃的质量越多。极端情形 只剩一个允许位置,输出被缩小到该位置的原始权重。这一偏差不是常数缩放,无法被后续层学到的偏置吸收,因为不同位置的缩放比例不同。

第二种是先置零再除以行和:

与前置掩码逐元素相等。推导中分子分母的公共因子 被约去,因此两种写法在精确算术下等价,实测差值在 float64 舍入量级(例 3)。

两种写法并非完全可互换,差别有三点。其一是中间量:后置写法需要先算出完整的 softmax,再置零、再求和、再相除,多两次 规模的逐元素运算与一个临时张量;前置写法把这些并入 softmax 内核。其二是梯度路径:前置写法中被屏蔽位置在计算图中取值为 ,其指数恒为 0,反向时该位置不接收梯度;不重新归一化的后置写法中,被屏蔽位置的打分仍出现在分母里,因此仍会收到非零梯度,而它本不应参与归一化,这部分梯度是错误的。其三是数值范围:后置写法先得到一组行和小于 1 的概率,再相除;若某些 在低精度下下溢为 0,除法会把相对误差放大。

由此得到准确的表述:约束不是"掩码必须在 softmax 之前"这一实现细节,而是"归一化必须只在允许集合上进行"。前置 是最直接、最省中间量、梯度语义最清晰的实现,因此成为标准做法。

4 训练时并行与推理时逐 token

训练阶段的输入是完整的 token 序列,形状为 、元素取值于 。前向一次得到 logits ,与右移一位的目标比较,损失对全部 个位置求和。每一层注意力的打分是 个 矩阵的批量乘法,代价 。因果掩码保证第 行的计算只读取前 列,因此同时计算全部位置不违反因果性。这一并行性依赖教师强制:位置 的输入是真实 token ,与模型在第 步会输出什么无关,所以全部位置可以同时送入。

推理阶段的条件不同。生成第 个 token 需要分布 ,而 尚未产生,前缀只能由模型自己逐步扩展。于是必须逐 token 前向,第 步的输出位置只有一个,但该位置的表示需要读取前 个位置的值向量。

不做缓存时,第 步要把长度 的前缀完整重算一遍,代价 ,生成 个 token 的总代价为

是训练一次前向的 倍。做缓存时,第 层的键与值 、 在生成过程中不变,可以保存下来复用,每步只需为新 token 计算 并追加,代价降为 的打分与 的投影,总代价回到 。缓存的显存公式与实现见 KV缓存。

两种阶段的计算特征不同。训练阶段每次前向处理 个位置,矩阵乘的规模大,受算力限制;推理阶段每步只处理 1 个位置,却要读入全部权重与全部缓存,受显存带宽与内核启动开销限制。同一模型在两种阶段的吞吐差异可达两个数量级,这是 模型推理优化 中批处理、量化与算子融合的出发点。

因果掩码与缓存的交互需要单独说明。使用缓存时,查询长度为 1(只有新 token),键长度为 (缓存加新 token),且全部键都位于查询之前,因果掩码退化为全允许,不需要再施加。若沿用形状 的三角掩码,会与 的打分广播,可能掩掉合法位置或触发形状错误;若缓存中的键顺序与位置编码不一致,掩码即使形状正确也会对应错误的位置。正确做法是解码阶段不施加因果掩码,或构造形状 的全零掩码,并在实现中区分预填充与解码两条路径。

阶段输入注意力打分规模总代价主要瓶颈
训练 全部位置 个 一次算力
推理,无缓存逐步前缀第 步 算力
推理,有缓存新 token 与缓存第 步 累计显存带宽

5 多头的维度布局

多头实现的核心是把通道维拆成"头数 × 每头维度",并在矩阵乘法前后做正确的转置。以 、、、 为例,形状链如下。

步骤操作形状
输入
合并投影c_attn,权重
切分split(384, dim=2)三个
拆头view(B,T,h,d_h)
换轴transpose(1,2)
打分
softmax沿最后一维
加权
并头transpose(1,2)
展平contiguous().view(B,T,C)
输出投影c_proj,权重

拆分的语义:view(B,T,h,d_h) 把最后一维 按行优先顺序切成 段,第 个头占据通道区间 。transpose(1,2) 只交换步长,不复制数据,得到的张量在内存中不连续。两次矩阵乘法都作用在最后两维上,PyTorch 与 NumPy 的批量矩阵乘都接受非连续输入,因此这一步不产生复制。真正的复制发生在 contiguous():它把 的布局改写为 的连续布局,随后 view 把最后两维合并为 ,此时第 个头的 个通道恰好落在输出通道区间 ,与拆分时的顺序一致。

若把 contiguous() 换成 reshape(),结果相同:reshape 在无法返回视图时会隐式复制。若写成 view(),非连续张量会使该调用抛出错误。两种写法都对,但显式 contiguous() 把复制点暴露在代码中,便于分析显存峰值;隐式复制则可能在性能分析时表现为来源不明的算子。

并头的顺序必须与拆头的顺序互逆。transpose(1,2) 是自逆操作,view(B,T,C) 是 view(B,T,h,d_h) 的逆操作,因此"拆开再合并"恢复原顺序。若中途出现别的重排而没有相应逆操作,头与通道的对应关系被改变。若该改变只是一个固定置换,输出投影 的列可以学到补偿,模型仍能训练;若改变把 token 维卷入了头维,则不是置换:不同 token 的通道被分配到同一个头,位置语义被破坏,因果掩码也随之失效,而这一切不会产生任何形状错误。例 4 给出这一错误的数值表现。

6 缩放、dropout 与残差

缩放因子为 ,其中 是每头维度,不是 。以 、 为例,,,两者相差 倍。用错维度的后果是打分尺度过大或过小:用 会过度缩小,等价于把有效温度调高,注意力分布趋于均匀;用 之类更小的常数则会加剧饱和。

缩放只施加一次。两种等价位置是作用在打分上(att / math.sqrt(d_h))或预先作用在查询上(q / math.sqrt(d_h) 后再做内积)。同时施加两次会使等效因子变为 ,打分方差变为 ,分布过于平坦;反向时查询与键的梯度尺度也会与预期不符。

dropout 有两处。第一处作用在注意力权重上,位于 softmax 之后、与 相乘之前,原论文基础模型的配置中丢弃率为 。它按元素独立地把权重置零,并对保留下来的元素乘以 ,使权重的期望不变。训练时行和不再等于 1(被置零的位置质量为 0,保留位置按比例放大),这是正则化的预期行为;推理时关闭 dropout,行和恢复为 1。因此任何以"行和为 1"作为正确性检验的代码都必须在 eval() 模式下运行。

第二处作用在子层输出上(残差 dropout),位于输出投影之后、进入残差相加之前。它随机丢弃部分通道,迫使后续层不依赖单一通道。两处 dropout 的随机性不同:前者作用于 的权重矩阵,后者作用于 维的通道。

dropout 与掩码的交互是安全的,但原因需要说明:注意力 dropout 是乘性缩放,被掩码位置的权重在 softmax 后已精确为 0,乘以任何缩放因子仍为 0,因此 dropout 不会"复活"被屏蔽的位置。若把噪声加在打分上而不是权重上,则被屏蔽位置可能因噪声而重新获得质量,这与标准做法不同。

7 多头与多个独立注意力的关系

多头常被描述为" 个独立的注意力",这一描述只在部分意义上成立。逐项对照如下。

参数层面:每个头有独立的 ,各自 ,不同头之间不共享参数,这一点与"多个独立注意力"一致。

计算层面:每个头的 softmax 独立进行,第 个头的权重分布只由第 个头的打分决定,不与其他头交互,这一点也一致。

输出层面: 个头的输出不是各自独立地进入后续层,而是沿通道拼接后乘同一个 :

其中 是 的第 个列块。输出是 项之和,每项都经一个稠密矩阵映射,因此各头的贡献在输出端被线性混合,无法分配给某个头单独的语义。

梯度层面:损失不分别作用于各个头。 汇聚全部头的输出, 只经过第 个头,因此参数更新部分解耦、部分耦合。若 恰为分块对角且每块为 ,各头在输出端完全不交互,多头退化为 个并行的单头注意力再拼接;训练中 稠密,一般不会停在该形式。

函数层面:单个头只能输出一个凸组合,多头输出是 个凸组合经不同线性映射后的和。以 为例,为便于与单头比较,设两个头使用相同的值投影(取 且 ),头 1 的权重集中在位置 、头 2 的权重集中在位置 ,并取 ,则输出为 。单个头的输出必须形如 且 ,要等于 需要权重之和为 2,一般无解。反过来,取 时多头公式退化为单头公式,因此多头在同等参数量与计算量下是单头的严格推广。

结论:多头是"参数独立、分布独立、输出混合"的结构。称其为多个独立注意力,只在描述前两项时准确;忽略输出端共享的 ,会高估各头的独立性与可解释性。

8 头的专门化:经验观察与解释边界

在公开模型上可视化注意力权重,可以观察到若干重复出现的模式。位置模式:部分头系统性地关注前一个 token 或某个固定偏移的过去位置(因果模型中不存在关注未来位置的头)。句法模式:部分头在依存关系两端之间分配较高权重。复制模式:部分头在""出现时把权重从当前的 移向先前的 ,这一模式与上下文学习中的复制行为相关。稀有 token 模式:部分头集中关注低频 token,可能与信息汇聚有关。

这些观察的解释力有四条边界。

第一,权重不等于贡献。注意力权重只说明读取了哪些位置,不说明读取到的信息对输出起了多大作用。值向量在拼接与投影后可能被后续通道抑制,前馈网络也可以改写该信息。因果证据需要干预实验(替换激活、消融单个头、测量输出变化),仅凭权重图不能得出"该头负责某功能"的结论。

第二,头之间存在冗余。消融单个头通常只造成小幅性能变化,同时移除多个头的影响也常小于线性叠加,说明功能由多组头分担。专门的解释需要说明剩余头如何补偿,而这一点难以从权重图直接读出。

第三,专门化依赖训练数据、初始化与模型规模,跨模型不可直接迁移。同一索引的头在不同模型中呈现不同模式,同一功能在不同模型中可能由不同索引承担,因此"第 层第 个头是句法头"这类陈述只在特定检查点上成立。

第四,可视化受归一化约束。softmax 使每行和为 1,一行的权重高只说明相对分配,不说明绝对读取强度;不同层的权重尺度不可直接比较,图中颜色深浅也不对应信息量。

因此,关于头专门化的合理表述是:训练后的多头模型中存在可重复观察到的关注模式,这些模式与某些语言现象相关;它们是否构成功能分工,需要消融或干预实验支持,且结论限于被研究的检查点。

关键直觉

机制性表述

因果掩码把注意力矩阵的允许集合限制为下三角,使第 行只在 上归一化;这一限制在整栈中逐层传递,保证位置 的表示是前缀的函数。训练时全部位置同时前向,因为每个位置的输入都是真实 token;推理时只能逐 token 前向,因为下一步的输入依赖上一步的输出,这一结构差异使缓存键与值成为必要。多头在这个框架内并行执行 次归一化,每个头在自己的 维子空间内独立分配权重,输出端经共享的 混合。

该表述与严格定义的关系:下三角归一化是定义中的掩码条件;逐层传递依赖第 1 节的归纳证明,其中逐步指出注意力、残差、LayerNorm、前馈都不引入对未来的依赖;输出端混合由第 7 节的分解式给出,它同时说明"独立"只成立于参数与分布两个层面。

例子与代码

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

例 1:构造因果掩码

import numpy as np

T = 4
mask_float = np.triu(np.full((T, T), -np.inf), k=1)      # 严格上三角为 -inf
mask_bool = np.triu(np.ones((T, T), dtype=bool), k=1)    # True 表示禁止
print(mask_float)
print(mask_bool)
print(mask_bool.sum(1))                                   # 每行被禁止的位置数
[[  0. -inf -inf -inf]
 [  0.   0. -inf -inf]
 [  0.   0.   0. -inf]
 [  0.   0.   0.   0.]]
[[False  True  True  True]
 [False False  True  True]
 [False False False  True]
 [False False False False]]
[3 2 1 0]

np.triu 的第 3 个参数 k 指定保留的对角线偏移:k=1 保留主对角线以上的元素、把其余位置写为零,因此全 输入得到"上三角 、其余 "。k=0 会把主对角线一并置零,得到位置 看不到自身的严格掩码。mask_bool.sum(1) 给出每行的禁止位置数 ,等于 ,可用于核对行列方向:若误把 triu 写成 tril,该向量会变成 ,掩码方向相反,模型将只能看到未来。布尔版本每元素 1 字节, 时占 16.8 MB,浮点版本占 67 MB,长上下文中前者更省显存。

例 2:信息泄漏的检测与量化

构造一条 的输入,只在最后一个位置加入偏移,观察位置 0 的输出是否改变。若改变,说明位置 0 读取了未来位置。

import numpy as np

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

def attention(X, Wq, Wk, Wv, mask=None):
    Q, K, V = X @ Wq, X @ Wk, X @ Wv
    S = Q @ K.transpose(0, 2, 1) / np.sqrt(Q.shape[-1])
    if mask is not None:
        S = S + mask
    return softmax(S, -1) @ V

rng = np.random.default_rng(7)
B, T, C, d = 1, 4, 6, 6
X = rng.standard_normal((B, T, C))
Wq, Wk, Wv = (rng.standard_normal((C, d)) for _ in range(3))
causal = np.triu(np.full((T, T), -np.inf), k=1)[None]     # 广播到 (B,T,T)

X2 = X.copy()
X2[0, 3, :] += 5.0                                        # 只改最后一个位置

for name, mask in [("无掩码", None), ("因果掩码", causal)]:
    o1 = attention(X, Wq, Wk, Wv, mask)
    o2 = attention(X2, Wq, Wk, Wv, mask)
    print("%s:位置 0 变化 %.4f,位置 3 变化 %.4f"
          % (name, np.abs(o1[0, 0] - o2[0, 0]).max(),
             np.abs(o1[0, 3] - o2[0, 3]).max()))
无掩码:位置 0 变化 2.8155,位置 3 变化 18.0133
因果掩码:位置 0 变化 0.0000,位置 3 变化 18.0133

无掩码时修改位置 3 使位置 0 的输出改变 2.8155,泄漏被直接观测到;加因果掩码后该变化为精确 0。位置 3 在两种实现下的变化相同,因为位置 3 的允许集合在两种情形下都是全体位置,被改动的 token 本来就在它的读取范围内。这一对照说明掩码的作用范围:它只切断"从未来读现在"的边,不改变每个位置对自身与前缀的读取。

该测试可作为一种单元检验:随机初始化一层注意力,扰动位置 的输入,检查所有 的输出是否保持不变(差值应为 0)。若差值非零,掩码方向、掩码应用位置或维度顺序至少有一处错误。

例 3:四种掩码实现的数值对照

import numpy as np

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

rng = np.random.default_rng(11)
T = 6
S = rng.standard_normal((T, T))                            # 未掩码打分
causal = np.triu(np.full((T, T), -np.inf), k=1)

A_ref = softmax(S + causal, -1)                            # 前置 -inf
A_nine = softmax(S + np.where(np.isinf(causal), -1e9, 0.), -1)   # 前置 -1e9
A_post = softmax(S, -1) * (causal == 0)                    # 后置置零
A_post = A_post / A_post.sum(-1, keepdims=True)            # 后置置零并重归一化
A_bad = softmax(S, -1) * (causal == 0)                     # 后置置零,不重归一化

print("前置 -inf 行和", A_ref.sum(-1))
print("前置 -1e9 与 -inf 的最大差", np.abs(A_nine - A_ref).max())
print("后置重归一化与前置的最大差", np.abs(A_post - A_ref).max())
print("后置不重归一化的行和", np.round(A_bad.sum(-1), 4))
前置 -inf 行和 [1. 1. 1. 1. 1. 1.]
前置 -1e9 与 -inf 的最大差 0.0
后置重归一化与前置的最大差 1.1102230246251565e-16
后置不重归一化的行和 [0.1008 0.2541 0.4297 0.6357 0.6271 1.    ]

前三行印证第 3 节: 与 在 fp32 下给出逐元素相同的结果,因为 下溢为 0;后置重归一化与前置的差为 ,属于 float64 舍入。最后一行给出错误实现的偏差:第 0 行只剩 的质量,第 4 行剩 ,第 5 行未受影响。缩小比例随位置单调变化(除随机波动),与"允许位置越少、丢弃质量越多"一致。这类偏差会被后续层逐层放大,且无法通过偏置或缩放吸收,因为每一行的缩放系数不同。

例 4:头维顺序错误的表现

用 、、 的输入演示两种拆分。三个 token 的通道值都取 ,正确拆分下头 0 应始终拿到通道 –。

import numpy as np

C, h = 8, 2
d_h = C // h
x = np.arange(1., C + 1.)[None, None, :].repeat(3, axis=1)   # (1,3,8),三个 token 相同

right = x.reshape(1, 3, h, d_h).transpose(0, 2, 1, 3)         # 正确:(1,h,3,d_h)
wrong = x.reshape(1, h, 3, d_h)                               # 错误:把 T 折进 h
print("正确 头0\n", right[0, 0])
print("正确 头1\n", right[0, 1])
print("错误 头0\n", wrong[0, 0])
正确 头0
 [[1. 2. 3. 4.]
 [1. 2. 3. 4.]
 [1. 2. 3. 4.]]
正确 头1
 [[5. 6. 7. 8.]
 [5. 6. 7. 8.]
 [5. 6. 7. 8.]]
错误 头0
 [[1. 2. 3. 4.]
 [5. 6. 7. 8.]
 [1. 2. 3. 4.]]

正确拆分下,头 0 的三个 token 都取通道 –,头 1 都取 –,头内的 token 维保持独立。错误写法 reshape(1,h,3,d_h) 把 的元素按行优先顺序连续切分,于是头 0 的第 0 行拿到 token 0 的通道 –,第 1 行拿到 token 1 的通道 –,第 2 行拿到 token 2 的通道 –:头内混合了不同 token 的不同通道,位置与通道的对应关系被破坏。这种错误不会引发任何形状异常,注意力仍然能算出一个 矩阵,只是每一行的含义与设计不符;在因果模型中,它还会让位置 的查询携带其他位置的通道,破坏因果性。

例 5:从零实现 CausalSelfAttention

以下代码需 PyTorch 2.0 及以上,结构与 nanoGPT 的 CausalSelfAttention 一致。

import math
import torch
import torch.nn as nn
import torch.nn.functional as F


class CausalSelfAttention(nn.Module):
    def __init__(self, d_model=384, n_head=6, block_size=256, dropout=0.1):
        super().__init__()
        assert d_model % n_head == 0, "d_model 必须被头数整除"
        self.d_model = d_model
        self.n_head = n_head
        self.d_head = d_model // n_head
        self.block_size = block_size
        self.c_attn = nn.Linear(d_model, 3 * d_model, bias=False)   # Q,K,V 合并投影
        self.c_proj = nn.Linear(d_model, d_model, bias=False)       # 输出投影
        self.attn_dropout = nn.Dropout(dropout)                     # 作用于权重
        self.resid_dropout = nn.Dropout(dropout)                    # 作用于子层输出
        mask = torch.tril(torch.ones(block_size, block_size, dtype=torch.bool))
        self.register_buffer("mask", mask.view(1, 1, block_size, block_size),
                             persistent=False)

    def forward(self, x):
        B, T, C = x.shape
        assert T <= self.block_size, "序列长度超过 block_size"
        qkv = self.c_attn(x)                        # (B,T,3C)
        q, k, v = qkv.split(C, dim=2)               # 三个 (B,T,C)
        q = q.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        k = k.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        v = v.view(B, T, self.n_head, self.d_head).transpose(1, 2)
        att = (q @ k.transpose(-2, -1)) / math.sqrt(self.d_head)     # (B,h,T,T)
        att = att.masked_fill(~self.mask[:, :, :T, :T], float("-inf"))
        att = F.softmax(att, dim=-1)                # 沿键维归一化
        att = self.attn_dropout(att)
        y = att @ v                                 # (B,h,T,d_head)
        y = y.transpose(1, 2).contiguous().view(B, T, C)
        return self.resid_dropout(self.c_proj(y))


torch.manual_seed(0)
m = CausalSelfAttention(d_model=384, n_head=6, block_size=256)
x = torch.randn(2, 16, 384)
y = m(x)
print(y.shape)                                   # torch.Size([2, 16, 384])
print(sum(p.numel() for p in m.parameters()))    # 589824
print(m.mask.shape, m.mask.dtype)                # torch.Size([1, 1, 256, 256]) torch.bool
print("mask" in m.state_dict())                  # False

预期输出为形状 、参数量 、掩码形状 与类型 torch.bool、以及掩码不在 state_dict 中的 False。

逐段说明。c_attn 用一次 的矩阵乘同时算出 ,相比三个独立的 投影,矩阵乘的调用次数从 3 降为 1,在 GPU 上少两次内核启动与两次读入 ;参数量相同,都是 。split(C, dim=2) 沿通道维三等分,得到的三块依次对应 ,顺序必须与 c_attn 权重初始化时的排列一致,交换任意两块会使查询去匹配值、键去承载内容。

view(B,T,h,d_head).transpose(1,2) 是拆头,规则见第 5 节。q @ k.transpose(-2,-1) 在最后两维上转置,得到 ;若用 .T,四维张量全部维都会反转。/ math.sqrt(self.d_head) 用 而非 ,两者相差 倍。

~self.mask[:, :, :T, :T] 把"True 表示允许"取反为"True 表示禁止",与 masked_fill 的语义对齐。若省略取反,masked_fill 会把下三角(允许位置)全部置为 、上三角保持原值,结果是每个位置只能看到未来,训练损失几乎不下降,而代码不会报错。若把切片写成 self.mask[:, :, :T],得到的是 ,与打分的 无法广播(仅当 时形状恰好相同),会抛出形状错误;这类错误容易被发现,更难发现的是第 4 条易错点所列的拆分顺序错误。

F.softmax(att, dim=-1) 沿键维归一化。attn_dropout 放在 softmax 之后、@ v 之前。y.transpose(1,2).contiguous().view(B,T,C) 三步缺一不可:缺 transpose 则头维与 token 维错配;缺 contiguous 则 view 抛出步长错误;view 的第三个参数必须是 而不是 或 。最后 c_proj 把拼接结果映射回模型维度,resid_dropout 在返回前施加,残差相加由调用方完成。

参数量核对: 有 个, 有 个,合计 。掩码缓冲区不计入参数量,也不在 state_dict 中,因为 persistent=False;若去掉该参数,检查点会多出 的布尔张量,加载到没有该缓冲区的模型时会报缺失键。

例 6:nn.MultiheadAttention 的掩码接口

import torch
import torch.nn as nn

mha = nn.MultiheadAttention(embed_dim=384, num_heads=6, dropout=0.1, batch_first=True)
mha.eval()                                       # 关闭 dropout,两次调用才可比
x = torch.randn(2, 16, 384)

causal_bool = torch.triu(torch.ones(16, 16, dtype=torch.bool), diagonal=1)
additive = torch.zeros(16, 16).masked_fill(causal_bool, float("-inf"))

out_f, _ = mha(x, x, x, attn_mask=additive, need_weights=False)
out_c, _ = mha(x, x, x, is_causal=True, need_weights=False)
out_w, w = mha(x, x, x, attn_mask=additive, need_weights=True,
               average_attn_weights=False)
print(out_f.shape, w.shape)                      # torch.Size([2, 16, 384]) torch.Size([2, 6, 16, 16])
print(torch.allclose(out_f, out_c, atol=1e-6))   # True

接口差异有四点。第一,batch_first=True 使输入为 ;默认 False 时输入为 ,与本文其余部分的约定相反,混用会导致把批量与序列长度对调。第二,浮点 attn_mask 在 softmax 之前加到注意力权重上,语义与本文的加性掩码一致,形状可以是 或 。第三,is_causal=True 使用内置的因果路径,等价于传入尺寸正确的三角掩码;它与 attn_mask 不能同时使用,同时传入会在部分版本中报错。第四,need_weights=True 会关闭融合的高效路径;average_attn_weights=True(默认)对头求平均,只返回 ,要看单头权重必须显式设为 False。

attn_mask 同时接受布尔与浮点两种张量。布尔版本的取值语义与 key_padding_mask 相反(后者以 True 表示忽略该位置),且历史上经过调整;混用时最稳妥的检验是构造一个只有单个允许位置的 掩码,检查另一列的权重是否恰为 0。这类检验比查阅文档更快,也不受版本差异影响。

易错点

以下六条均可在形状、行和或单测中直接检验。

1. 掩码形状与广播错误: 的掩码要与 的打分相加,必须先扩为 ;若写成 ,广播会把它视为 ,只有当 时才静默通过,此时掩码的第二维被当作头维解释,含义已经错位,其余情形直接报错。检验方法:打印 att 与 mask 的形状,确认掩码的维数不大于打分且可从右侧对齐。

2. 掩码取值语义反转:masked_fill 把 True 位置置为 ,而 torch.tril 构造的掩码中 True 表示允许,两者语义相反,必须取反。写反后模型只能看到未来,损失几乎不降,但形状与运行都不报错。

3. 缓存与掩码的交互错误:解码阶段查询长度为 1、键长度为 ,全部键都在查询之前,不应再施加 的三角掩码;沿用训练时掩码会掩掉合法位置或触发形状不匹配。正确做法是把预填充与解码分成两条路径,解码路径不加因果掩码。

4. 头维顺序错误:拆分必须写成 view(B,T,h,d_h).transpose(1,2);写成 view(B,h,T,d_h) 会把 token 维折进头维,位置与通道错配,且不产生任何形状错误。检验方法:用三个 token 取相同通道值的输入,检查每个头的输出是否只含固定的通道区间(例 4)。

5. 缩放维度或次数错误:应为 ,;用 会过度缩小,对查询与打分同时缩放则等效因子为 。检验方法:初始化时打印打分的标准差,应在 1 附近。

6. 训练与推理路径不一致:训练时施加 dropout 与因果掩码,推理时若忘记 model.eval(),dropout 仍生效,权重行和随机且输出不可复现;若解码路径误加掩码,可能整行为 ,softmax 分母为 0,产生 NaN 并沿残差传播污染全部参数。

关联笔记

  • 前置 注意力机制与QKV:该篇给出缩放点积注意力、 的方差推导与多头定义;本篇在其上加入因果约束,并展开多头的维度布局与实现细节。
  • 后续 KV缓存:本篇第 4 节指出推理逐 token 的结构与缓存必要性,该篇给出显存公式、预填充与解码的代价分解及实现。
  • 后续 Transformer架构详解:本层的输出经残差相加与 LayerNorm 后进入前馈网络,该篇给出整层的组装顺序与参数量核算。
  • 对照 BERT与双向编码模型:双向注意力不施加因果掩码,训练目标为掩码语言建模,与本篇的自回归目标形成对照;两者的注意力计算形式相同,差别在允许集合与损失。
  • 后续 Llama-2架构复盘:该篇的注意力层由 RMSNorm、RoPE、因果掩码与 GQA 组合,本篇的 CausalSelfAttention 是去掉 RoPE 与 GQA 后的基础形式。

达标检测

  • [ ] 用归纳法证明"嵌入 + 因果注意力 + 残差 + LayerNorm + 前馈"组成的栈是因果的,并指出哪一步会因去掉掩码而失效。
  • [ ] 写出 的因果掩码矩阵,说明 np.triu(..., k=1) 与 k=0 的区别,并给出每行允许位置数。
  • [ ] 证明后置置零并重归一化与前置 逐元素相等,并说明不重归一化时行和为何随位置变化。
  • [ ] 运行例 2,报告无掩码与有掩码时位置 0 的输出变化,并解释位置 3 的变化为何相同。
  • [ ] 写出 CausalSelfAttention 的完整代码,打印 、参数量与掩码形状,并说明去掉 ~、contiguous()、transpose(1,2) 三者各自的后果。
  • [ ] 说明 nn.MultiheadAttention 的 attn_mask、key_padding_mask、is_causal 三者的语义差异,并给出一个检验布尔掩码方向的单测。
  • [ ] 用两个头的具体例子说明多头输出不在单个凸包内,并指出这一结论依赖 的哪条性质。

参考来源

  • Vaswani et al., "Attention Is All You Need", arXiv:1706.03762, 第 3.2.3 节 —— 对应本篇第 2 节的因果掩码定义与第 1 节信息泄漏的动机;第 3.2.2 节对应第 5 节与第 7 节的多头拆分与拼接;第 5.4 节对应第 6 节的残差 dropout。
  • Karpathy, nanoGPT 仓库与 "Let's build GPT" 讲义 —— 对应例 5 的 CausalSelfAttention 结构:合并 QKV 投影、register_buffer 的三角掩码、masked_fill 取反、注意力权重 dropout 与输出投影的顺序。
  • d2l.ai《动手学深度学习》「注意力机制与 Transformer」一章 —— 对应第 3 节的 masked softmax 与第 4 节的训练并行、推理串行对比。
  • Raschka, Build a Large Language Model (From Scratch), 2024, 第 3 章 —— 对应第 5 节的形状链推导、第 6 节的缩放与 dropout 位置,以及例 5 的参数量核对。
  • PyTorch 官方文档 torch.nn.MultiheadAttention —— 对应例 6 的 batch_first、attn_mask、key_padding_mask、is_causal 参数语义与 average_attn_weights 的返回形状。