1. 多头自注意力：别再死记公式，我用外卖订单给你讲明白
第一次接触“多头自注意力”这个概念的时候，我盯着论文里的公式看了整整一个下午，脑子里全是“这到底是什么玩意儿”。后来做了几年深度学习相关的项目，踩过不少坑，再回头看，发现这个概念其实并没有想象中那么高深。它本质上解决的是一个非常朴素的问题：一段话里面，哪些词和哪些词之间是有关系的，而且这种关系不止一种。
这篇文章我想用做菜的方式来拆解这个概念，把那些看起来很吓人的矩阵运算转化成你日常就能理解的逻辑。我会详细讲清楚多头自注意力的核心思路、每一个环节的来龙去脉，以及我在实际项目中遇到的那些教科书上不会写的问题。适合刚接触自然语言处理、正在看Transformer论文、或者准备面试被问到大模型的你。
1.1 自注意力到底在做什么
我们先从最基础的“注意力”说起。你在超市里找一瓶酱油，你会扫一眼货架，然后目光锁定在放酱油的那一排，这就是注意力。你在看一篇文章，读到“它”这个字，你会自动往前翻去找“它”指代的是苹果还是桌子，这也是注意力。
自注意力，特别之处在于“自”。它不是说某个词去关注外部的东西，而是句子里的每个词，都在和句子里的其他词做关联度打分。一句话有10个词，每个词都要和其他9个词算一遍关系，最后每个词都带着整个句子的信息重新更新一遍自己的表示。
我拿外卖订单来举例。假设订单上写着“一碗牛肉面，不要香菜，多加辣”。这句话里的“不要”和“香菜”关系极强，“多加”和“辣”关系极强，而“一碗”和“牛肉面”则是数量上的关联。当模型处理“不要”这个词的时候，它需要知道“不要”的对象是“香菜”，而不是“牛肉面”或者“辣”。这就是自注意力在做的事情：让每个词都能从全局视角找到自己应该关注的目标。
如果是传统的词向量方法，每个词就是一个固定的向量，不管在什么句子里，它的含义都一样。“苹果”这个词在“苹果很好吃”和“苹果手机很贵”里，向量是完全相同的，这显然不合理。自注意力机制让每个词都能根据当前的上下文动态地调整自己的表示，这就是它最核心的价值所在。
1.2 “多头”是什么意思
既然自注意力能够全局关联，为什么还要“多头”呢？这个问题的答案，直接决定了你是否真的理解了Transformer架构。
回到外卖订单的例子。订单里有几个不同的关注维度：数量关系（一碗对应牛肉面）、口味调整（不要对应香菜）、动作对象（加对应辣）。如果只有一个注意力头，它就要同时兼顾所有这些关系，就像让一个人同时盯着所有灶台、所有案板、所有订单，很容易顾此失彼。
多头注意力做的事情，就是把这些不同维度拆开，分配给不同的“头”去处理。每个头拥有自己独立的查询、键、值权重矩阵，也就是说每个头都在用不同的视角去看同一个句子。有的头专门学习词序关系，有的头专门学习语义关联，有的头专门学习指代关系。最后把这些头的输出拼接在一起，再做一次线性变换，融合成最终的表示。
打个比方：你开了一家餐厅，订单多到一个人处理不过来，于是你请了三个点单员。第一个专门负责记录菜品名称，第二个专门负责记录口味偏好，第三个专门负责记录送餐地址。三个人各司其职，最后把三张纸条汇总到一起，就是一份完整的订单。多头注意力就是这个逻辑。
1.3 为什么需要缩放点积
大多数讲自注意力的文章会把缩放点积放在前面讲，但我倾向于把它放在后面，因为理解了前面的逻辑，这个部分只是最后的数学实现细节。
注意力分数的计算方式有很多种，加法注意力、点积注意力、双线性注意力。Transformer选择的是缩放点积注意力。计算方式是对查询向量和键向量做点积，然后除以键向量维度的平方根，再做softmax得到权重，最后加在值向量上。
点积的意义在于衡量两个向量的相似度。两个向量方向越一致，点积越大，意味着关联度越高。除以根号d_k这个缩放操作，很多人不理解为什么要做。原因很简单：当维度d_k比较大的时候，点积的结果会变得很大，进入softmax的饱和区，梯度极其微小，模型几乎学不动。
我举个例子你就明白了。假设你有两个向量，每个维度都是独立均匀分布的，均值为0，方差为1。它们的点积的方差大约是d_k。当d_k是64的时候，点积的方差是64，标准差是8。这意味着点积的结果大概率落在正负几个标准差的范围里，但偶尔会出现特别大的值。如果不做缩放直接进softmax，那些大值对应的概率会变成1，其他的全部变成0，梯度消失了。除以8之后，方差变回1，概率分布就没那么极端了。
这就像你在考试，满分是1000分的时候，成绩分布会非常悬殊；满分改成100分，差距就没那么刺眼了。缩放就是为了让数字落在一个合理的区间里。
2. 多头自注意力的完整计算流程：从头到尾手写一遍
理论说再多，不如实际算一遍。接下来我带你完整走一遍多头自注意力的计算流程。我们不用框架，完全手写逻辑，这样你才能真正明白每个步骤在做什么。
假设我们有一个句子，包含3个词：“我”、“爱”、“你”。每个词的输入向量维度是4，我们使用2个注意力头，每个头的维度是3。
2.1 准备工作：生成查询、键、值
输入矩阵X的形状是（3，4），表示3个词，每个词4维向量。我们需要为每个头准备独立的权重矩阵。第一个头的W_Q1、W_K1、W_V1的形状都是（4，3），第二个头的同理。
为什么每个头要有独立的权重矩阵呢？因为如果所有头共用一套权重，那它们关注的东西就完全一样了，“多头”就失去了意义。独立的权重矩阵让每个头可以学习到不同的映射方式，也就能够关注到句子中不同类型的关联关系。
以第一个头为例，输入X乘以W_Q1得到查询矩阵Q1，乘以W_K1得到键矩阵K1，乘以W_V1得到值矩阵V1，形状都是（3，3）。查询代表的是“我在找什么”，键代表的是“我是什么”，值代表的是“我真正的内容”。这个区分很关键：键和查询决定了两两之间的关联权重，而真正被加权求和的是值。
用外卖来类比：查询是你的偏好要求，键是菜品标签，值是菜品本身。你拿着“不吃辣”的要求，去和每个菜品的标签匹配，然后根据匹配度来决定最终取哪道菜。
2.2 计算注意力权重：相似度打分与归一化
对于第一个头，Q1和K1的转置做矩阵乘法，得到一个（3，3）的分数矩阵。S[i][j]表示第i个词对第j个词的关注度。然后除以根号3，约为1.732，做缩放。
接着对每一行做softmax。这里的行索引是查询所在的词，列索引是被关注的词。softmax的作用是把分数转换成概率分布，让所有被关注词的权重之和等于1，并且拉开差距。
这里有一个实操中常见的细节：softmax之后的分布往往非常尖锐，也就是说某个词的注意力权重会特别大，其他词几乎接近0。这是正常的，特别在训练初期。真正训练充分之后，注意力分布通常会变得更加分散和可解释。
2.3 加权求和与多头拼接
得到注意力权重矩阵之后，和值矩阵V1做矩阵乘法，得到第一个头的输出Z1，形状是（3，3）。这个过程相当于按照注意力权重，把每个词的值向量做加权平均。关联度高的词，它的信息就被更多地融入当前词的表示中。
第二个头重复同样的过程，得到Z2，形状也是（3，3）。然后把两个头的输出在特征维度上拼接，Z的最终形状是（3，6）。
注意这里的维度变化：输入3个词每个4维，经过多头注意力后变成3个词每个6维。6=2个头乘以每个头3维。这个维度是我们可以设计的超参数。拼接之后，通常还会乘以一个输出权重矩阵W_O，形状是（6，4），把维度映射回4维，方便残差连接和后续层处理。
2.4 残差连接与层归一化：稳定训练的关键
多头注意力计算完之后，并不是直接送入下一层，而是先做残差连接，再做层归一化。残差连接就是输出加上原始的输入，这个操作让梯度可以绕过注意力层直接回传，在很大程度上缓解了深层网络中的梯度消失问题。
层归一化是在特征维度上做归一化，让每一层的输出保持稳定的均值和方差。为什么Transformer用层归一化而不是批量归一化？关键在于批量归一化依赖batch内样本的统计信息，在NLP任务里，句子长度不一、batch大小受限，批量归一化的统计量往往很不稳定。层归一化则完全不需要跨样本统计，每个样本自己就能完成归一化，更加适合序列数据。
实际操作中还有一个经常会踩到的坑：层归一化是对特征维度做的，而不是对序列长度做的。很多人把这两个搞混，导致实现出来的效果不对。输入形状如果是（batch, seq_len, d_model），层归一化作用的维度是d_model这一维。
3. 代码实现：从零搭建一个多头自注意力模块
理论环节都过完了，现在我们用代码把它变成现实。这里我用PyTorch实现一个完整的多头自注意力模块，代码里包含了所有关键的细节。你可以直接拿去用，也可以在此基础上做修改扩展。
3.1 完整实现代码
import torch import torch.nn as nn import torch.nn.functional as F class MultiHeadSelfAttention(nn.Module): def __init__(self, d_model, n_heads, dropout=0.1): """ d_model: 输入特征维度 n_heads: 注意力头数量 dropout: 注意力权重的dropout比率 """ super(MultiHeadSelfAttention, self).__init__() assert d_model % n_heads == 0, "d_model必须能被n_heads整除" self.d_model = d_model self.n_heads = n_heads self.d_k = d_model // n_heads self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): """ x: 输入张量，形状为(batch_size, seq_len, d_model) mask: 可选的注意力掩码，形状为(batch_size, seq_len, seq_len) """ batch_size, seq_len, _ = x.size() # 线性变换并拆分为多个头 # 形状变化: (batch, seq_len, d_model) -> (batch, seq_len, n_heads, d_k) -> (batch, n_heads, seq_len, d_k) q = self.w_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) k = self.w_k(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) v = self.w_v(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) # 计算注意力分数并缩放 # 形状: (batch, n_heads, seq_len, seq_len) scores = torch.matmul(q, k.transpose(-2, -1)) / (self.d_k ** 0.5) # 应用掩码 if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) # softmax归一化 + dropout attn_weights = F.softmax(scores, dim=-1) attn_weights = self.dropout(attn_weights) # 加权求和 # 形状: (batch, n_heads, seq_len, d_k) context = torch.matmul(attn_weights, v) # 拼接多头结果 # (batch, n_heads, seq_len, d_k) -> (batch, seq_len, n_heads, d_k) -> (batch, seq_len, d_model) context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, -1) # 输出线性变换 output = self.w_o(context) return output3.2 关键代码细节解读
有几个地方特别值得关注。第一处是view和transpose的配合使用。我们把形状为（batch, seq_len, d_model）的张量view成（batch, seq_len, n_heads, d_k），然后transpose成（batch, n_heads, seq_len, d_k）。为什么要这样做？因为我们需要让n_heads维度提前，这样矩阵乘法才能同时对所有头并行计算，而不是用for循环逐个处理，效率差距是非常大的。
第二处是缩放因子self.d_k ** 0.5。这里一定用平方根，不要直接用d_k。前面的理论部分讲过，缩放是为了控制方差，让softmax不至于进入饱和区。
第三处是masked_fill。在训练Transformer模型时，解码器需要防止未来信息的泄露，因此需要上三角掩码，把未来位置的注意力分数设为负无穷。这样经过softmax之后，这些位置的权重会变成0。如果你在建模型的时候发现训练loss不下降，而且不想让模型“偷看未来”，检查一下mask是否应用正确是非常必要的。
第四处是dropout的应用位置。Dropout是在注意力权重上做的，不是在分数上，也不是在输出上。这个顺序来自原始论文的设计，实践证明在注意力权重上做dropout可以增强模型的泛化能力。
3.3 使用示例和输出验证
# 快速测试代码 torch.manual_seed(42) d_model = 8 n_heads = 2 seq_len = 4 batch_size = 2 x = torch.randn(batch_size, seq_len, d_model) attention = MultiHeadSelfAttention(d_model, n_heads) output = attention(x) print(f"输入形状: {x.shape}") print(f"输出形状: {output.shape}")运行之后，输出形状不变，还是（2，4，8）。这里要强调一个设计正确性的检验标准：多头自注意力模块的输入输出维度应当保持一致，这样它才能像一个积木一样，在Transformer的任意层中自由堆叠。
4. 实际项目中踩过的坑和排查经验
这部分内容是教科书和论文里不会告诉你的，全是我在实际项目中真实遇到过的经验总结。如果你正在自己实现Transformer或者搞大模型相关的工作，这些坑大概率也会碰上。
4.1 训练不收敛，损失居高不下
我最开始自己实现多头注意力的时候，在Transformer训练任务上遇到过一个极其头疼的问题：训练了好几个epoch，损失不但不降，反而还出现了小幅上升。排查了很久，网上的建议试遍了都没用。
后来定位到的原因让我印象深刻：初始化出了问题。在自注意力模块中，如果输出层的权重初始化过大，前向传播的输出方差会越来越大，经过多层堆叠之后直接爆炸。而且缩放点积虽然做了，但如果输入特征的方差本身很大，除以根号d_k之后依然不够稳定。
解决办法有两个。第一个是使用Xavier初始化或Kaiming初始化，让权重保持适当的方差。第二个更加保险，给每个子层之后的残差连接加上LayerNorm，这样不管前面怎么折腾，进入下一层的时候分布已经被拉回来了。现在的很多大模型直接用Pre-LN结构，把LayerNorm放在注意力机制之前，训练稳定性又上了一个台阶。
4.2 上下文长度增加时内存暴涨
这是部署阶段的经典难题。自注意力的复杂度是序列长度的平方，序列长度从512变成1024，计算量翻了4倍，显存占用也跟着暴涨。你训练的时候序列长度是512，完全没问题；但部署时用户输入一长串文本，显存直接爆掉。
我遇到这个问题的场景是在做一个长文档的文本分类项目。文档长度经常超过2000个字，而训练时最长也就512。解决方案是用滑动窗口注意力或者稀疏注意力。简单来说，不要让每个词都关注所有词，而是只关注前后一定范围内的词，比如窗口大小为128。这样复杂度从O(n^2)变成O(n*w)，在大规模长文本场景下效果非常明显。
还有一个更工程化的手段：在推理阶段使用KV Cache。自注意力的计算中有大量的重复计算，生成第n个词的时候，前n-1个词的键值其实已经算过了，没必要重新算一遍。把它们缓存起来，直接把新查询和缓存的键值做计算，推理速度提升非常可观。
4.3 多头的数量怎么选：过犹不及
有段时间我迷信“头越多效果越好”这个说法，把一个模型的注意力头从8个增加到16个，结果效果不但没提升，反而变差了，训练还更慢。后来我才明白，多头数量的选择本质上存在一个取舍：头太少，每个头需要学习过于复杂的关系，单个头的能力不够；头太多，每个头学的东西重复度很高，而且参数量变大，需要更多数据来拟合。
有一个经验性的规律：总维度d_model固定时，头的数量增加，每个头的维度d_k就会变小。当d_k太小时（比如小于16），每个头能够表达的信息量就很有限了。我在实际项目中使用的是128的模型维度加8个头，每个头16维，效果比较理想。一些更大的模型会用到64或者128维，搭配16至32个头。初学者在不知道如何选的情况下，从d_model=512、n_heads=8开始尝试，通常是个稳妥的起点。
4.4 Masked-Fill前后的数据类型陷阱
这个坑比较隐蔽。在使用masked_fill的时候，因为mask的类型不匹配，结果所有位置的注意力都被mask掉了，模型完全没有学到任何东西。我用一个形状正确的mask，内部存的是True和False，但在masked_fill的时候把mask传给布尔值是False的位置，注意力分数全被设置成了负无穷，softmax之后变成均匀分布，和没训练一样。
排查了半天，发现是数据类型的问题：mask所有的元素都被自动转成了0和1，然后被当作布尔值解读。这个问题的根源在于PyTorch的布尔类型和长整型之间的隐式转换。解决方式是显式使用mask.bool()来转换，确保逻辑正确。
4.5 注意力可视化：模型到底在关注什么
在调试模型的过程中，我建议你养成一个习惯：把注意力权重可视化。当模型处理到某句话的时候，你可以把scores矩阵抽出来，画成热力图，看看每个词都在关注哪些词。有时候你会发现模型关注的对象和你的直觉认知完全不同，这往往能帮你快速定位到数据或者模型结构上的问题。
我在一次命名实体识别任务中就遇到过一个有趣的案例。模型在处理人名的时候，注意力异常集中到前一个标点符号上。模型确实学到了规律——人名的前面通常有标点，感受不到任何语义信息，但这个规律的有效性导致模型忽略了上下文。发现这一点后，我调整了数据预处理方式，在标点位置加入特殊标记，模型效果提升了不少。
5. 从基础到进阶：后注意力时代的一些个人体会
最近一两年，大模型领域又出现了不少新机制，比如线性注意力、膨胀注意力、混合注意力等。很多人开始讨论多头自注意力是否已经被淘汰了。从我个人的项目经验来看，这种说法还是过于武断了。
有一个关键点在于，很多高效的替代方案在长文本场景下确实优于标准多头注意力，但在中短文本和需要强语义建模的任务中，标准多头注意力依然展示了极强的竞争力。而且，许多新机制本质上是在标准多头注意力基础上做的变形和优化，它们解决的核心问题仍然是“如何让序列中的每个元素高效地获取全局信息”。
我把多头自注意力比作是深度学习领域的九九乘法表：它足够底层，出现在所有主流的预训练语言模型中；它足够基础，大模型、机器翻译、文本摘要全都靠它起家；它也足够巧妙，是理解后续所有注意力变体的必备前置知识。它能成为技术圈讨论的焦点，除了效果好之外，还有一个重要的原因：它在数学上非常优雅，将一个复杂的信息交互过程，拆解成了几个简单的矩阵运算的组合。
如果你正在学习或者正在实现相关模型，我建议你用“理解原理 -> 手写代码 -> 项目实战”这个路径来巩固。先把公式推导搞清楚，然后亲手实现一遍，最后把它用在一个真实的任务中去验证效果。这个过程走下来，那些看起来让人望而生畏的复杂模型，就只是一个你能够掌控的工程模块了。
最后再分享一个小技巧：调试注意力模块的时候，先跑一个只有一两个样本的小batch，把每一步的中间变量打印出来，观察维度是否正确。我基本上每次写新的模块都会这么做，省下来的调试时间相当可观。等你把这些细节都吃透了，再看那些Tokenizer怎么处理、位置编码用什么方式这些话题，都会觉得轻松很多。
