1. 核心思路拆解：为什么自注意力能成为序列建模的新范式

先把话说在前面：自注意力机制不是天上掉下来的，它是在解决一个非常实际的问题——如何处理序列中任意两个元素之间的关系。做NLP和序列建模的人都知道，在Transformer出现之前，处理序列信息最主流的手段是RNN和它的变体LSTM、GRU。这些模型的核心思路是“逐步递归”，也就是说，要把序列的第i个位置的语义信息带到第i+1个位置，必须经过一次前向传播的迭代。这就带来两个老生常谈的痛点：一是长距离依赖问题，两个相隔几十步的元素要建立联系，信息要在时间维度上传递很多次，中间稍有问题梯度就散了；二是不能并行，因为每一步计算强依赖前一步的输出，GPU再强也只能看着。

自注意力机制的核心思想就一句话：让序列里的每一个元素，直接与序列中所有其他元素计算关联程度，再用这个关联程度去聚合信息。它把“顺序传递”变成了“直接建立连接”。打个比方，RNN像是传话游戏，信息要一个一个传过去，传了几手之后就变样了；自注意力则像开全体会议，每个人都直接听所有人发言，然后根据议题相关性自己决定重点参考谁的说法。这种机制天然解决了长距离依赖问题，因为任意两个位置之间的路径长度都是1，不存在“距离”这个概念。

我在实际项目里第一次感受到这种差异是在处理一段长文本的情感判断时。用BiLSTM那会儿，文本超过200字，精度就开始往下掉，模型对关键信息的位置不敏感，你把它放在开头和放在第150个字的位置，效果天差地别。换成Transformer之后，同样的语料，模型对位置开始不那么挑剔了，因为每个词都可以直接“看到”所有其他词。这就引出自注意力的第一个关键结论：它的优势不是某个数学技巧，而是改变了信息交互的基本路径。

1.1 从全局视野到并行计算

自注意力带来的第二个红利是并行性。因为任意位置的输出只依赖于整个序列的输入矩阵，不存在递归般的时序依赖，所以整个序列可以一次喂给GPU做矩阵运算。矩阵乘法是硬件最擅长的事，能跑满算力。这也是Transformer能够把模型规模做到亿级、千亿级的基础——如果还是递归结构，哪怕数据量足够，训练时间也完全不现实。

不过这里我要提醒一句：自注意力不是完全不需要顺序信息，它只是把“顺序建模”这个任务从结构里剥离出来了，单独交给位置编码去处理。这一点很多初学者会搞混。网络结构本身对序列顺序是不敏感的，你把所有token换个顺序，注意力分数的矩阵依然成立，因为它是集合内部的相互计算。未加位置编码的Transformer，本质是在处理一个词袋集合，只是这个集合里的每个词都带上了一堆上下文。所以后面会有单独的位置编码模块，来弥补这个先天缺陷。

1.2 自注意力的三个组成部分

完整的自注意力计算包含三个输入：Query（查询）、Key（键）、Value（值）。这三个概念最容易劝退新手，但其实用搜索引擎类比就很好理解。

你在搜索引擎里输入一句话，这句话会被编码成Query；后台每个网页都有对应的标签，那些标签就是Key；网页本身的内容就是Value。搜索引擎先计算你的Query和每个网页Key之间的匹配度，这个匹配度就是注意力分数，然后按分数高低把相应的Value内容加权汇总，返回给你。自注意力机制做的就是同一件事：每个token同时充当Query、Key、Value三个角色，它拿自己的Query去和序列里所有（包含自己）的Key做匹配，再用匹配分数去加权求和对应的Value。

这就要建立一个最重要的直觉：注意力机制的本质是“软寻址”，就是不是非此即彼地只取某一个位置的Value，而是按照相关性权重把所有位置的Value都取一点儿，取多少由Query和Key的匹配程度决定。理解这一点，后面看公式就不会发怵。

2. 核心公式逐项拆解：从Q、K、V到缩放点积

自注意力公式长这样：

Attention(Q, K, V) = softmax( QK^T / sqrt(d_k) ) V

这个公式看起来简单，但每一部分都有讲究。我在带团队做模型时，发现大部分人能背下公式，却说不清每一步在干什么。下面拆开揉碎地讲。

2.1 输入从哪里来：三个线性投影

在说公式之前，先要弄明白Q、K、V是怎么得到的。自注意力的输入，就是上一层输出的向量序列，通常表示为矩阵X，形状是(seq_len, d_model)，seq_len是序列长度，d_model是特征维度。但是输入X不能直接拿来做注意力计算，需要分别做三次线性变换：

Q = X @ W_q K = X @ W_k V = X @ W_v

W_q、W_k、W_v是三个可学习的权重矩阵，形状是(d_model, d_k)或(d_model, d_v)。注意Q和K的维度是d_k，V的维度是d_v，两者不一定要一样。在标准Transformer里，通常d_k = d_v = d_model / h，h是多头注意力的头数。

为什么一定要加这一步线性变换？因为如果直接用X算注意力，那每个token的Query和Key都是它自己，灵活度太低。而且不同的语义关系可能需要不同的匹配模式，比如做句法关系时可能关注相邻词，做语义指代时可能要找到远处的名词，单一向量无法承载这么多匹配模式。引入可学习的线性投影，相当于给每个token生成了多个不同视角的“查询方式”和“被查询方式”。这也是多头注意力能工作的基础：每个头有一组独立的W_q、W_k、W_v，它们可以学到的匹配模式天然不同。

我见过有人在实现时偷懒，省掉这三个投影直接拿Embedding算注意力，效果确实会掉。原理上也能跑通，但模型学习的表达空间被砍掉了一大截，没有必要省这三步矩乘。

2.2 QK^T这一步到底在算什么

Q和K的形状分别是(seq_len, d_k)，QK^T得到的是一个(seq_len, seq_len)的矩阵，其中第i行第j列的元素等于Q_i和K_j的点积。点积在数学上的含义是向量的相似度：两个向量方向一致时结果大，方向相背时结果小。原始向量经过线性变换之后，方向已经改变，所以这个点积衡量的是“i位置的token用它的Query视角，与j位置token的Key视角之间的匹配程度”。

这里有个关键细节：点积结果的数值范围是不固定的，它受向量维度影响。假设Q和K的每个分量都是均值为0、方差为1的随机变量，那么两者点积的均值还是0，但方差是d_k。也就是说，维度越大，点积结果的波动范围就越大。如果直接进softmax，会出现什么情况？

说到这个问题，就正好接上。

2.3 为什么非要在softmax前面除以根号d_k

softmax函数有一个特性：当输入数值的绝对值偏大时，softmax输出会趋于“硬”，就是说最大的那个值对应的概率接近1，其他的接近0。这时候梯度会非常小，接近0，模型基本学不动。这就是梯度消失的一种表现。

点积方差是d_k，数值分布会随着维度增大而发散。除以根号d_k之后，方差被拉回到1左右，数值范围稳定，softmax的梯度就能保持健康。这是数学上的解释，我在实际训练中观察到的是：把缩放项去掉，模型在训练初期loss下降明显变慢，甚至出现NaN，因为注意力分布很快就饱和了，反向传播时梯度几乎传不动。加上缩放之后，训练曲线立刻变得平滑。

另一种理解方式：除以根号d_k，其实是把点积分值标准化到和维度无关的量级，相当于控制了softmax输入的温度。你可以把softmax里的温度看作一个超参数，缩放因子就是在帮我们选一个合理的初始温度。

2.4 softmax的作用与掩码的配合

对QK^T矩阵的每一行做softmax，得到的就是权重矩阵，每行的和为1，表示“第i个token对序列中所有token的注意力分配比例”。这组权重再乘上V矩阵，相当于按权重把所有位置的Value向量做加权平均，得到第i个token在这个注意力层的新表示。

在实现中有一个重要环节：softmax之前要先做掩码操作。在Decoder里，为了防止未来信息泄漏，需要把矩阵的右上三角位置的值替换为负无穷，这样softmax之后这些位置的权重就为0。实操中，负无穷通常用一个很大的负数代替，比如-1e9。这里我踩过坑：有人用-1e9，有人用-1e4，其实在一定量级内差别不大，关键是别因为精度问题搞成NaN。

还有一个经常被忽略的mask，是处理变长序列的padding mask。因为一个batch里的序列长度不同，短序列要补pad到最长长度，这些pad位不应该参与注意力计算，否则模型会把注意力分配到无意义的pad符号上。做法是把pad对应位置的值在softmax之前同样置为很大的负值。

3. 实操过程与核心环节实现：从零搭建一个单头自注意力

讲了这么多理论，下面我们直接动手写代码。我习惯用PyTorch做原型验证，所以用PyTorch风格展示。每行代码我都会解释它在干什么，方便还没熟练的人对照着看。

3.1 最小可运行的PyTorch实现

import torch import torch.nn as nn import math class SelfAttention(nn.Module): def __init__(self, d_model, d_k, d_v): super().__init__() self.d_k = d_k self.d_v = d_v self.W_q = nn.Linear(d_model, d_k, bias=False) self.W_k = nn.Linear(d_model, d_k, bias=False) self.W_v = nn.Linear(d_model, d_v, bias=False) self.scale = 1.0 / math.sqrt(d_k) def forward(self, x, mask=None): # x: (batch_size, seq_len, d_model) Q = self.W_q(x) # (batch_size, seq_len, d_k) K = self.W_k(x) # (batch_size, seq_len, d_k) V = self.W_v(x) # (batch_size, seq_len, d_v) scores = torch.matmul(Q, K.transpose(-2, -1)) * self.scale # scores: (batch_size, seq_len, seq_len) if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attn_weights = torch.softmax(scores, dim=-1) output = torch.matmul(attn_weights, V) return output, attn_weights

这段代码有几个值得说透的点。

第一，为什么用nn.Linear而不是自己定义权重矩阵再做矩阵乘法？因为nn.Linear会自动管理参数的初始化和梯度，还能顺便处理bias，省事。这里我设置bias=False，因为注意力计算里的线性投影在大多数实现中不带偏置，加了也没太大帮助，反而多一组参数。习惯上不带bias，但也有人加，实验差别很小。

第二，注意矩阵乘法维度的控制。Q是(batch_size, seq_len, d_k)，要转置K的最后两个维度变成(batch_size, d_k, seq_len)，matmul之后才能得到(batch_size, seq_len, seq_len)。新手最容易在这里栽跟头，报错信息基本都是维度不匹配。我的经验是：在写代码前先拿笔在纸上写出每个变量的shape，走一遍流程，比反复试错快得多。

第三，masked_fill是原地还是非原地？masked_fill会返回新tensor，不会修改原scores。在这个场景下没有影响，但如果你之后要复用scores，就要注意这一点。

3.2 多头注意力的实现：为什么切头而不是复制

多头注意力不是把单头注意力重复计算h次，而是把Q、K、V的维度拆成h份，分别计算注意力，最后拼接起来。

class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() assert d_model % num_heads == 0 self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads self.d_v = d_model // num_heads self.W_q = nn.Linear(d_model, d_model, bias=False) self.W_k = nn.Linear(d_model, d_model, bias=False) self.W_v = nn.Linear(d_model, d_model, bias=False) self.out_proj = nn.Linear(d_model, d_model, bias=False) def forward(self, x, mask=None): batch_size, seq_len, _ = x.size() Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.d_k) K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.d_k) V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.d_v) Q = Q.transpose(1, 2) # (batch, num_heads, seq_len, d_k) K = K.transpose(1, 2) V = V.transpose(1, 2) # 这里可以直接复用前面单头注意力的计算逻辑 scale = 1.0 / math.sqrt(self.d_k) scores = torch.matmul(Q, K.transpose(-2, -1)) * scale # 注意mask需要扩展出num_heads维度 if mask is not None: mask = mask.unsqueeze(1) # (batch, 1, 1, seq_len) scores = scores.masked_fill(mask == 0, float('-inf')) attn_weights = torch.softmax(scores, dim=-1) context = torch.matmul(attn_weights, V) # context: (batch, num_heads, seq_len, d_v) context = context.transpose(1, 2).contiguous().view( batch_size, seq_len, self.d_model ) output = self.out_proj(context) return output, attn_weights

拆头的逻辑怎么理解？你可以把每个头想象成一个“专家”，它的匹配模式可能各有侧重。代码上的核心是把最后一维d_model拆成num_heads份，比如d_model=512，num_heads=8，那么每份的d_k=d_v=64。每个头在不同子空间里计算注意力，最后把它们在特征维度上拼接回512维，再过一层线性投影融合。

为什么这个设计有效？单个头只能学一种Query、Key的匹配模式，但真实的语言关系是多种多样的：有的头可能专注于局部语法依赖，有的头可能擅长捕捉长距离指代，还有的头可能主要负责词汇共现。我训练过一个小模型，专门把8个头的注意力权重可视化过，确实能看到不同的头会有不同的关注模式，有的头对句法依存关系特别敏感，有的头把权重几乎全部分配给序列首尾。这种功能分化就是多头注意力的价值所在。

3.3 从单头到多头：参数量的账要算清楚

多头注意力看起来把参数乘了num_heads倍，但实际上总参数量基本不变。因为每个头的d_k和d_v都缩小了，三个投影矩阵加起来的参数量还是d_model × d_model的量级。比如d_model=512，单头时W_q是512×512，8个头时每个W_q是512×64，8个加一起还是512×512。参数量不变，但表达能力却因为“分工”而更强了，这是Transformer设计里很精巧的一笔。

唯一多出来的参数是最后的out_proj，那是用来融合多头的，参数量也是d_model×d_model。所以多头注意力的总参数是单头的约4倍布局：3个输入投影加1个输出投影，但每一维的语义表达更丰富。实操时，如果你把num_heads设得太少，比如2个头，模型对关系建模的多样性不足；设太多，比如64个头，每个头的维度太小，反而学不到有意义的模式。常见的经验是d_model=512配8个头，d_model=768配12个头，d_model=1024配16个头，这样每个头的d_k大约是64，这个数值已被大量实验验证比较稳。

4. 位置编码与掩码机制：自注意力缺的两块拼图

前面说了自注意力是无序的，所以必须把位置信息喂进去。标准的Transformer用的是三角函数位置编码，公式如下：

PE(pos, 2i) = sin(pos / 10000^(2i/d_model)) PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

其中pos是token在序列中的位置，i是特征维度索引。为什么要用三角函数而不是简单地把位置序号直接拼上去？有几个层面的考虑。

第一，这种编码是有界的，数值始终落在[-1, 1]区间，训练时稳定性好。第二，正弦和余弦的交替出现，让模型可以通过线性变换来捕捉相对位置关系。第三，这种编码具有一定的外推能力，虽然实际测试中超过训练长度效果会衰减，但比随机初始化的位置编码多了些泛化余地。

不过说实话，在我最近几年接触到的模型里，越来越多方案改用可学习位置编码，也就是初始化一个(seq_len, d_model)的Embedding跟着模型训练。它没有外推能力，训练到多长就只能处理多长，但在长度固定的场景下效果往往比三角函数编码还略好一点。这两种方案选哪个，取决于你的任务：如果序列长度比较固定，比如句子分类，用可学习编码就行；如果要做长文档生成，序列长度动态变化，带外推设计的编码方案会更合适。

掩码机制在前面已经提了一部分，这里再把padding mask和causal mask的区别讲透。padding mask针对的是“这个位置没有真实token”，数据层面负责，所以Encoder和Decoder都要用。causal mask针对的是“未来位置不该被看到”，逻辑层面负责，只有Decoder的自注意力才用。很多人在实现Decoder时只做causal mask，忘了padding mask，或者反过来，都会导致训练异常，常见现象是loss在某个值上震荡不下降，然后训练曲线突然跳NaN。

我把两个mask经常出现的bug整理成了一张表，方便排查：

5. 常见问题与排查技巧实录：实际踩过的坑

这几年里，我在实现和调优Transformer时踩过很多坑，挑几个最典型的分享出来，希望能帮你少走弯路。

5.1 注意力权重全部趋同怎么办

训练初期如果发现注意力权重非常均匀，几乎每个位置的权重都差不多，这说明模型还没找到有用的匹配模式，这算正常现象，多训几轮就会分化。但如果跑了很久还是很均匀，就要检查是不是学习率设太高，导致Q、K参数一直在震荡。我遇到过一种更隐蔽的情况：初始化不当导致三个线性投影的参数几乎一样，Q、K、V成比例关系，注意力自然退化成均匀分布。解决办法是把线性层的初始化标准差调小，或者给Q、K的投影加上正交初始化。

5.2 推理时内存暴涨

自注意力复杂度的关键指标是QK^T那一步：它的复杂度是O(n²·d)，n是序列长度。做长文本推理时，比如1000个token，就是百万级别的矩阵，多头再乘上batch和head数，内存很快就爆了。实际项目里，序列长度翻倍，显存占用大概会翻4倍，这个增长曲线非常陡。

缓解手段无非几种：用窗口注意力，只让每个token关注附近k个token；或者在整个序列上分段，段内做全量注意力、段间做压缩；再或者用线性注意力替换，把复杂度降下来。训练时可以用梯度检查点来换显存，牺牲一点速度，但能撑住更大的batch。

5.3 训练速度慢，怀疑GPU利用率不够

先自查数据加载和预处理是不是瓶颈，很多时候慢的不是模型而是dataloader。排除了这个之后，看矩阵形状有没有做大。自注意力里最容易出现的问题是把单条样本的seq_len拉得很长，batch又太小，GPU的矩阵尺寸过小，无法充分利用硬件并行能力。一个有效做法是梯度累积，让小的batch等效于大的batch，保持训练稳定性的同时提升吞吐。

5.4 初学者最常见的理解偏差

每次有新人问我自注意力，我发现有三处地方几乎人人都会卡一下。

第一个是Q、K、V和输入X的关系。有人以为Q、K、V是三个不同的输入序列，其实它们是同一个X经过三个不同线性变换得到的。第二个是注意力分数的形状。它是方阵(seq_len, seq_len)，不是高维矩阵里随便找了个子矩阵。第三是输出向量的维度不变性。自注意力的输出和输入的序列长度、特征维度都保持一致，所以它可以被反复堆叠很多层，这为深层Transformer的堆叠提供了结构上的可行性。

6. 作者经验与扩展心得

最后分享一点我个人的实操体会。

调参时，我习惯先固定其他变量，单独观察注意力权重可视化。说个直观的案例：在训练一个文本匹配模型时，我把某一层的注意力图拉出来看，发现几乎所有注意力都集中在句首的几个token上，后面内容几乎不被关注。表面上看模型确实学出了“开头很重要”的规律，但测试集里包含了大量开头是套话、核心信息在后面的样本，模型在这些样本上分数偏低。后来我调整了位置编码的缩放方式，并给模型加了前馈层的强化，相当于把序列中段和后段的信息“抬”了一下优先级，注意力分布才变得合理。

还有一个值得试验的小方向：在自注意力之后加入层归一化时，放在残差连接之前还是之后，细节顺序会影响数值稳定性。标准的Transformer用Post-LN，最近很多方案趋向于Pre-LN，就是先归一化再进入子层。Pre-LN在深层的训练稳定性更好，收敛对学习率不那么敏感，这是我建议做实验时优先尝试的变体。

如果你已经理解了自注意力机制，下一步可以去看一些工程化的优化思路，比如稀疏注意力（让每个token只关注固定步长范围内的位置）、FlashAttention（在CUDA层面对Attention计算做内存优化）以及各种高效的注意力变体。这些优化的核心动机，都是在保留自注意力“全局建模”优势的同时，把计算和内存开销降下来。理解了底层原理之后，再看这些高阶工具，你会有一种“哦，原来是在这个环节上做了手术”的通透感。