企业官网建设流程全解析

Self-Attention这个名字，这几年只要碰过Transformer、大模型或者序列建模相关的东西，基本都绕不开它。我最早接触它是在读那篇经典论文的时候，当时第一反应是：这个东西真的能替代RNN和CNN来处理序列吗？后来跟着复现、调参、应用到自己的任务里，才慢慢理解它为什么能成为几乎所有主流大模型的基础组件。这篇内容不打算从头科普Transformer全家桶，而是把Self-Attention这个核心机制单独拎出来，从数学直觉、设计动机、代码实现到实际踩坑，一层层掰开讲清楚。

如果你正准备深入Transformer的内部原理，或者已经在用预训练模型但总感觉对注意力机制的理解停留在“会用接口”的层面，这篇内容应该能帮你补上那块关键的拼图。我会尽量用直白的话讲明白每个“为什么”，同时附上可以直接跑起来的PyTorch实现，方便你边看边验证。

1. 从固定窗口到动态加权：Self-Attention到底解决了什么问题

1.1 传统序列模型的瓶颈在哪里

在Self-Attention被广泛应用之前，处理序列数据的主流方案是RNN（循环神经网络）和CNN（卷积神经网络）。RNN的思路是逐个时间步读取输入，靠隐藏状态把信息“接力”传下去。这个设计天然是顺序的，还伴随着长距离依赖问题——序列太长时，早期的信息传到后面要么衰减、要么被新信息淹没。CNN虽然可以并行处理，但它依赖卷积核的固定感受野，想要捕捉远距离关系就得堆很多层，或者用更大的卷积核，效率不太划算。

说白了，这两种老思路都有一个共同的隐含假设：词与词之间的相关性主要来自空间上的邻近性，或者时间上的先后顺序。但这个假设在真实语言里站不住脚。举个简单例子，“我在那个街角看到了小时候常去的那家书店，它还在那里”，这里的“它”和“书店”隔了十几个词，但它们语义上强相关。RNN要跨越这么长的距离去建立联系很吃力，CNN的感受野也覆盖不到。

1.2 Self-Attention的设计思路：让每个词自己去找该关注谁

Self-Attention的思路完全换了一个方向。它不再依赖距离来定义相关性，而是让序列里的每一个元素，都直接对序列里的所有其他元素计算一个“关联强度”，然后按这个强度去聚合信息。也就是说，任意两个位置之间都可以直接交互，无论它们在序列里隔了多远。

这种设计的优势在长距离依赖问题上几乎是降维打击。模型不再需要“一点点传”，而是所有位置两两直接建立通路。从计算图上看，任意两个token之间的路径长度都是1，这天然缓解了信息衰减和梯度消失的问题。而且这个结构对计算高度友好——所有位置之间的打分可以一次矩阵乘法算完，完全并行，训练效率远超RNN。

还有一点值得注意：Self-Attention学出来的“关联强度”不是固定的，而是根据输入内容动态变化的。同一对位置在不同句子里可能有着完全不同的关联强度。这种动态加权的特性，才是它名字里“Self”（自）的真正含义——权重不是外部指定的，而是序列自己根据内部元素之间的关系算出来的。

2. QKV三个角色：把注意力机制拆成信息检索的过程

2.1 查询、键、值的直观类比

要理解Self-Attention，最有效的捷径是先理解Q、K、V这三个字母。很多初学者一看QKV就头晕，其实它背后的逻辑非常直观，可以类比成一个信息检索系统。

想象你在一个资料库里找资料。你手里有一张“需求描述”，这就是查询（Query）；资料库里的每一份档案都贴着一个“标签”，这就是键（Key）；档案的正文内容，就是值（Value）。你的检索过程是：拿着查询去和每个键做匹配，算出相似度，然后按相似度高低去取对应的值，加权汇总成最终结果。

Self-Attention做的事情几乎一模一样。一个序列经过处理后，每个位置都会生成三个向量：q、k、v。当前这个token的q，会去和序列里所有token的k做点积，得到注意力分数；分数经过归一化变成权重；最后用权重对所有token的v做加权平均。从信息流动的角度看，Self-Attention就是让序列里的每个位置，按照自己的“查询意图”去其他位置“检索”信息，并带回来。

2.2 从输入到QKV：线性变换背后的维度逻辑

那么q、k、v具体是怎么来的？以标准Transformer为例：输入向量先经过一个输入嵌入层，得到维度为d_model的向量（经典配置是512维）。然后这个向量分别和三组可学习的权重矩阵W_q、W_k、W_v相乘，得到三个向量。

这里有个关键细节：这三个权重矩阵的输入维度都是d_model，但输出维度不一定等于d_model。在多头注意力里，它们通常输出d_k和d_v，而d_k一般等于d_model // num_heads。比如d_model=512、num_heads=8时，每个头的d_k=d_v=64。为什么要把维度压到64？因为如果8个头全在512维空间里做注意力，每个头很可能学到高度相似的模式，分头后降维能强制让每个头在不同子空间里提取信息。

我在实际实现中觉得最好记的方式是：Q和K的维度必须一致，因为要做内积；V的维度可以和它们不一样，因为V只是被加权求和的对象。但在标准多头实现里，三者通常取同样的维度，原因是为了简洁和参数平衡，并不是数学上强制的要求。

2.3 几个容易混淆的名词辨析

很多资料把“QKV”和“注意力权重”混着说，容易把人绕晕。这里捋清楚几个概念：

• Q（Query）：表示当前这个位置“想找什么”。
• K（Key）：表示其他位置“能提供什么”的标签。
• V（Value）：表示其他位置“实际提供的内容”。
• 注意力分数：q和k的内积结果，一个标量，表示两者之间的匹配程度。
• 注意力权重：对所有分数做softmax归一化后的结果，所有位置权重之和为1。
• 输出：对所有v按注意力权重进行加权求和。

我自己在调试时，习惯把注意力权重矩阵打印出来看看。形状是[batch_size, num_heads, seq_len, seq_len]，每一行表示某个查询位置对序列里所有键位置的注意力分布。观察权重分布能很快发现模型学歪了还是学对了，比如某些位置始终只关注自己，或者对特殊token过度关注，这些都是常见问题，后面我会专门讲排查方法。

3. 注意力分数的计算与缩放：为什么公式里非要除以根号dk

3.1 点积、缩放、Softmax三步走

标准Transformer采用的注意力函数叫“缩放点积注意力”（Scaled Dot-Product Attention），数学形式极其简洁：

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

整个计算过程可以拆成三步。第一步：把Q和K做矩阵乘法，得到[seq_len, seq_len]的分数矩阵，第i行第j列表示位置i对位置j的原始关联分数。第二步：对整个分数矩阵除以sqrt(d_k)。第三步：在最后一个维度上做softmax归一化，让每一行的权重加起来等于1。最后用归一化后的权重矩阵去乘V，得到加权求和结果。

为什么要先除再softmax，而不是直接softmax？这个sqrt(d_k)看着不起眼，但它同时关系到梯度的稳定性和softmax的“软化程度”。我在刚学的时候没太在意这个细节，直到有一次自己实现注意力时把缩放因子漏了，结果训练直接崩了，loss震荡到飞起，才真正意识到这个除法有多重要。

3.2 缩放因子背后的数学直觉：防止内积落入Softmax饱和区

假设q和k都是d_k维的向量，且每个分量独立服从均值为0、方差为1的分布。那么它们的点积q · k的均值是0，但方差会随着d_k增大而线性增长，变成d_k。换句话说，d_k越大，点积结果的绝对值就越有可能偏大。

这带来的问题是：当点积分数很大时，softmax输入端的分布会非常尖锐。比如[1, 2, 10, 3]和[1, 2, 10, 3]除以sqrt(64)=8后变成[0.125, 0.25, 1.25, 0.375]，softmax结果明显更平滑。这里的关键不是“平滑好看”，而是极端尖锐的softmax分布会导致大部分位置的梯度接近于0，模型几乎学不到东西。除以sqrt(d_k)相当于把点积方差重新拉回1附近，保持softmax区间的梯度流动。

如果你用过一些实现库，可能会注意到有的代码写的是math.sqrt(d_k)，有的写成d_k ** 0.5，本质一样。还有人会把缩放因子直接乘到Q上而不是除分数矩阵，效果等价，比如Q * (d_k ** -0.5)之后再和K做乘法，这样省一次张量除法操作。

3.3 Softmax的温度与注意力分布的“锐度”

如果你对“温度”这个说法有印象，softmax本质上就带一个温度参数。softmax(x/T)，T越小分布越尖锐，T越大分布越均匀。sqrt(d_k)的缩放本质就是在调节这个温度。缩放越大，等效温度越高，注意力权重越均匀；缩放越小，等效温度越低，注意力越集中于少数位置。

实际任务里，注意力分布的“锐度”会影响模型行为。比如机器翻译任务里，注意力通常需要相对精准地对齐源语言和目标语言的词；但在一些预训练任务里，过于尖锐的注意力反而可能导致模型只关注局部信息，忽略全局上下文。我在自己的实验里观察到，把缩放因子从sqrt(d_k)改成sqrt(d_k) * 0.5这类做法，通常不是明智的选择——它本质上是在改温度，而注意力机制对温度很敏感，一不小心就会让训练不稳定。所以除非你有明确的实验证据，否则不要轻易动这个缩放因子。

4. 多头注意力：让模型同时从多个视角观察序列

4.1 为什么需要多个头：不只要一种关联方式

单一注意力头能捕捉到一种词与词之间的关联模式，但这种模式往往不够丰富。语言里的关系是多样的：有的词对存在语法依赖（比如主谓一致），有的存在语义关联（比如“猫”和“宠物”），有的存在指代关系（比如“它”指向前文某个名词）。如果只有一个头，模型被逼着把所有这些关系模式压缩进一组权重矩阵里，表达能力会受限。

多头注意力就是为解决这个限制而设计的。它把d_model维的输入投影到h个不同的子空间，每个子空间独立计算注意力，然后把结果拼接起来再投影回去。每个头相当于一个独立的“观察视角”，有的头可能主要负责语法关系，有的头可能更关注语义相似性，有的头甚至可能学会关注特殊的位置模式。

我常跟人这样解释多头注意力：它就像做决策时找了一群不同背景的顾问，有人关注财务数据，有人关注市场情绪，有人关注政策风向，这些人单独看都有偏科，但把他们的意见汇总起来，决策就会更全面。

4.2 多头注意力的维度分配与拼接投影

标准多头注意力的维度规则如下：输入维度是d_model，头数是h，每个头的键/查询维度d_k = d_model // h，值维度d_v = d_model // h（经典配置里二者相等）。每个头在自己的64维空间里做缩放点积注意力，得到形状为[batch_size, seq_len, 64]的输出。把所有头的输出在最后一个维度上拼接，恢复成[batch_size, seq_len, d_model]，再经过一个输出投影矩阵W_o做线性变换。

这里有三个细节值得注意。

第一，d_model必须能被h整除。这是标准实现里的硬性前提，否则拼接时维度对不上。比如d_model=512、h=7就不行，实际使用中一般选h=8或h=16这种能被整除的数值。

第二，每个头确实拥有自己独立的W_q、W_k、W_v权重。如果把它们拼成一个大矩阵，等价于把所有头统一做一次大矩阵乘法再拆分。实际代码为了效率，往往只建立三组d_model × d_model的全量线性层，然后通过view操作切出头来。

第三，输出投影W_o是必要的，不能省。每个头在自己的子空间里提取的信息，需要经过这个线性变换融合回完整的d_model空间，才能被后续的前馈网络使用。如果省略输出投影，就相当于把多个子空间的信息简单叠加，缺少交叉融合，表达能力会打折。

4.3 不同头真的学到不同模式吗：一些现实观察

论文里展示过不同头关注不同语法结构的可视化，非常直观。但在真实训练中，头与头之间的差异化程度不一定总是很理想。我在实验里观察过一些预训练模型的注意力图，有的头非常明显地关注相邻词（局部注意力），有的头则关注句首的特殊token（可能是全局信息聚合器），但也确实存在一些头的行为高度相似，退化成了冗余计算。

这种情况不必太焦虑。多头注意力本身是一个带冗余的设计，即使某些头学得相似，整体效果依然能优于单头。但如果你的任务对可解释性要求高，想靠注意力权重做分析，那就得小心了——注意力权重不等于模型决策的全部理由，它只是模型内部状态的一部分，用它来直接解释模型的“想法”要谨慎。这是很多初学者容易掉进去的误区。

5. 位置编码：Self-Attention天生“无序”，怎么让它感知顺序

5.1 自注意力对位置不敏感的缺陷

Self-Attention有个显著特点：它在计算注意力分数时，完全不在乎两个token在序列里的先后顺序。如果输入序列的顺序改变，只要每个token本身没变，注意力分数矩阵就完全一样。这是因为点积只计算q_i和k_j的内容相似度，没有任何位置信息参与。

这对语言处理来说是个大问题。有序的语言中，“张三打了李四”和“李四打了张三”完全是两码事。如果模型感知不到词序，它就无法区分施动者和受动者。因此，必须在输入里显式地注入位置信息。

5.2 正弦位置编码的原理与代码实现

经典Transformer用的是一个固定公式生成位置编码，不参与训练。对位置pos和维度索引i，编码值定义为：

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

也就是说，每个位置会生成一个和输入嵌入维度相同的向量，奇数维用正弦，偶数维用余弦，频率随维度从低到高递减。低维度上的编码变化较快，能区分相近的位置；高维度上的编码变化较慢，能提供长距离的位置区分。这种设计让模型通过线性变换就能表达相对位置关系。

对应的PyTorch实现非常简洁，我一般直接写成这样：

import torch import math def sinusoidal_position_encoding(seq_len, d_model): pe = torch.zeros(seq_len, d_model) position = torch.arange(0, seq_len).unsqueeze(1).float() div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe.unsqueeze(0)

这段代码里，div_term就是1 / 10000^(2i/d_model)的log域计算，这样写比直接算幂更快，也更稳定。实际使用时，把pe加到输入嵌入上就行：x = x + pe。

5.3 可学习位置编码与相对位置编码的取舍

正弦位置编码后来衍生出很多变体。最直接的替代方案是可学习位置编码（Learned Positional Embedding），也就是把位置编码当成一个可以训练的嵌入表，随机初始化，通过反向传播学习。这种方案在很多早期BERT类模型里用过，实现更简单，效果也不错。

但可学习位置编码有个明显的短板：训练时见过的最大序列长度，就是推理时能支持的最大长度。一旦输入超过训练长度，模型就无从处理。正弦位置编码虽然理论上也能外推到更长序列，但因为训练数据里没见过那么长的位置交互，实际效果通常也会退化。这引出了相对位置编码的思路——与其告诉模型“这是第5个位置”，不如告诉模型“这个token和那个token的偏移是3”。这类方法（如RoPE、ALiBi等）在长序列场景表现更好，也是当前大模型的主流选择。

选哪种位置编码，取决于你的任务。如果序列长度基本固定且不长，可学习位置编码完全够用；如果要做长文本泛化，优先考虑相对位置编码方案。

6. 从公式到现实：Mask机制和复杂度那些事

6.1 Padding Mask与因果Mask：自注意力中的两类“遮罩”

在实际训练里，一个batch里的序列长度通常参差不齐，需要把短序列pad到统一长度。但这些填充位是无效的，不能让模型关注它们，否则等于引入了噪声。于是就有了Padding Mask：一个形状和注意力分数矩阵相同（更准确说是[batch_size, 1, 1, seq_len]，会被广播到合适形状）的掩码矩阵，被填充的位置为0，有效位置为1。在计算注意力分数后，把掩码为0的位置替换成负无穷（比如-1e9），这样softmax之后对应位置的权重趋近于0。

另一个常见的Mask是因果Mask，也叫自回归Mask。它用在生成模型里，保证预测第t个token时只能看到第t个token及之前的信息，看不到未来内容。实现方式是把注意力分数矩阵的上三角部分全部设置为负无穷。注意，Padding Mask和因果Mask可以同时使用，但两者不是一回事，千万别搞混。

我在写代码时常用masked_fill来实现：scores = scores.masked_fill(mask == 0, -1e9)。这里有个小技巧：-1e9要选得足够“负”，但也不是负得越离谱越好。如果太接近float的上限，加了一些数值误差后可能溢出成NaN。-1e9在大多数情况下够用，如果d_k很大且分数也很大，可以考虑用-torch.finfo(scores.dtype).max这种更安全的下界。

6.2 复杂度瓶颈：为什么长序列上Self-Attention很吃力

Self-Attention的时间复杂度是O(n² · d)，其中n是序列长度，d是维度。这个二次复杂度在长序列上非常致命。n=512时还好，n=4096时注意力分数矩阵就有一千六百万个元素，显存直接爆炸。这也是为什么很长一段时间里，Transformer类模型处理长文本都靠截断，而不是直接全量输入。

针对这个问题，衍生出了大量优化方案。稀疏注意力（Sparse Attention）只让部分位置对之间计算注意力，把复杂度降到O(n log n)左右；线性注意力（Linear Attention）用核函数的思路把注意力计算重写成不需要显式构建n×n矩阵的形式；还有FlashAttention这类IO优化的实现，通过分块计算、减小显存读写来加速训练，同时仍然保持精确的注意力结果。

对于大多数常规任务，你不需要自己实现这些优化。成熟框架里已经有大量封装好的高效注意力算子，直接调用就行。但理解复杂度瓶颈还是很重要的，因为它决定了你的模型能处理多长的输入，也决定了训练时的batch size上限。我在这上面踩过一次坑：把输入长度从512增到1024，batch size减半后显存依然不够，后来才意识到问题在于n²矩阵占用的显存，而不是模型参数量。

6.3 推理阶段与训练阶段的复杂度差异

训练阶段Self-Attention可以一次性看到整个序列，所有位置的q、k、v可以并行计算。但在自回归生成时，情况不同。每生成一个token，如果要重新计算整个序列的注意力，代价会随着生成长度线性累积，总代价变成O(n³)，完全没法用。

实际推理框架的解法是KV Cache：把已经算好的历史token的k和v缓存在显存里，每次生成新token时只计算新token的q、k、v和新的注意力分数，然后追加到缓存里。这能把单步生成时间降到基本恒定，代价是多花显存来存缓存。你去看大模型推理的显存占用，很大一部分其实是KV Cache吃掉的。这也是近两年很火的MQA（Multi-Query Attention）和GQA（Grouped-Query Attention）诞生的原因——通过让多个头共享一部分K和V，大幅压缩KV Cache的显存开销，同时尽量保住模型质量。

7. 用PyTorch从零实现一个完整的缩放点积注意力

7.1 单头注意力的最小实现

理论讲了那么多，落到代码才算真正掌握。下面这个实现是我见过最清晰的单头注意力写法，每一行都有明确的作用：

import torch import torch.nn as nn import math def scaled_dot_product_attention(query, key, value, mask=None, dropout=None): d_k = query.size(-1) # [batch, heads, seq_len_q, seq_len_k] 的分数矩阵 scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k) if mask is not None: # 把mask为0的位置换成负无穷，softmax后权重趋近0 scores = scores.masked_fill(mask == 0, -1e9) # 对最后一维（Key维度）做softmax，得到归一化权重 weights = torch.softmax(scores, dim=-1) if dropout is not None: weights = dropout(weights) # 用权重对Value做加权求和 output = torch.matmul(weights, value) return output, weights

这段代码的核心都集中在三行：scores、weights、output。注意scores的维度是4维的[batch_size, num_heads, query_len, key_len]，这里的matmul会把batch和heads当作批量维度处理，所以Q和K的最后两个维度必须对齐。key.transpose(-2, -1)就是把K的最后两个维度转置，这样才能得到[query_len, key_len]。

还有一点值得注意：mask的形状要能广播到scores的形状。通常mask是[batch_size, 1, 1, key_len]，在处理多头时，num_heads维会被自动广播，不需要手动扩展。

7.2 多头注意力封装：切头、变换、拼接的完整流程

单头实现清楚以后，多头就是加一个切分和融合的过程。下面这个类我习惯当作模板直接用：

class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads, dropout=0.1): super().__init__() assert d_model % num_heads == 0, "d_model must be divisible by num_heads" self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_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, query, key, value, mask=None): batch_size = query.size(0) # 线性投影 -> 拆分为 [batch, seq_len, heads, d_k] -> 调轴为 [batch, heads, seq_len, d_k] Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) V = self.W_v(value).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) # 缩放点积注意力 scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) weights = torch.softmax(scores, dim=-1) weights = self.dropout(weights) context = torch.matmul(weights, V) # [batch, heads, seq_len, d_k] # 拼接所有头: 先调轴回 [batch, seq_len, heads, d_k]，再连续展开成 [batch, seq_len, d_model] context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) output = self.W_o(context) return output

这里有一个经常被忽略的细节：view之前必须做.contiguous()。原因在于transpose返回的张量在内存中并不是连续排布的，直接view会报错。很多新手在这里卡住，报错信息是RuntimeError: view size is not compatible with input tensor's size and stride，加了.contiguous()就好了。

另外，Q、K、V的线性层都是d_model → d_model的，也就是说每个头的维度并不是单独建立一层，而是在同一个大线性层里完成，再通过view切块。这么做的好处是能利用GEMM的高效实现，坏处是如果你想把每个头独立初始化或单独控制，就得多写一点逻辑。

7.3 数值稳定性与初始化建议

写注意力代码时，数值稳定性是绕不开的话题。最常见的问题出现在softmax之前，如果scores里出现了NaN或inf，softmax的输出会直接崩掉。我看到过的几种常见诱因包括：输入向量包含NaN、学习率过大导致梯度爆炸、masked_fill的负无穷值太小和scores相加时出现数值问题。

关于初始化：nn.Linear默认的初始化方式是均匀分布，在标准Transformer里，注意力层的权重通常还需要乘上一个额外的缩放因子（比如0.1或sqrt(0.1)），原论文也有类似的初始化技巧。如果从头训练又发现收敛慢，检查一下输出投影W_o的初始化方差是不是太大，往往是原因之一。

我习惯在实现里加一个快速自检：构造一个随机输入，前向跑一遍，检查输出形状是否正确、是否包含NaN。这个步骤只要花几十秒，能省掉大量debug的时间。下面这个自检代码我几乎每次调试都会用：

import torch torch.manual_seed(42) x = torch.randn(2, 32, 512) # [batch, seq_len, d_model] mha = MultiHeadAttention(d_model=512, num_heads=8) y = mha(x, x, x) assert y.shape == x.shape, f"shape mismatch: {y.shape}" assert torch.isfinite(y).all(), "NaN or Inf detected in output" print("shape:", y.shape)

如果你看到输出形状正确且没有NaN，基本可以认为实现没有问题。

8. 常见问题与排查技巧实录

8.1 为什么我的注意力输出全是同一个值

这是一个我在新手代码里经常见到的现象：多头注意力的输出在经过一段时间训练后，同一批次里所有token的输出几乎一样，序列的区分度消失了。原因通常出在softmax权重分布上——如果所有位置的注意力权重都均匀分布，加权求和的结果就近似于所有v的平均值，不同位置的输出自然变得相似。

排查思路分几步。先打印注意力权重矩阵，看分布是否均匀。如果均匀，检查是不是缩放因子被漏掉了；如果缩放因子正确，检查是不是d_k设置得过小，导致注意力分数差异不够大；还有一种常见原因是训练数据本身信息量不足，模型学到的最优策略就是“平均所有token”。最后这种情况不算bug，但确实会影响模型能力，需要从数据质量和训练目标上找原因。

8.2 注意力分数出现NaN或者训练发散怎么办

训练发散是Transformer训练的经典难题，注意力机制往往首当其冲。我在之前调试一个从头训练的中等规模Transformer时，遇到过loss在几百步后突然变成NaN的情况。最终定位下来，原因是学习率warmup策略设置不合适，加上注意力scores里出现了极大值，softmax的输入的梯度爆炸了。

几个实用的解决办法：

• 确保用了warmup学习率策略。Transformer训练初期参数还没稳定，直接用大学习率很容易走飞。建议前几千步线性升温，到达峰值后再用余弦退火或指数衰减。
• 检查输入数据里有没有异常值。文本任务里特别要注意是否把NaN当作某个token的向量输入了。
• 如果用了混合精度训练，检查masked_fill里的-1e9在fp16下是否仍然有效。fp16的最大有限值约为65504，-1e9会直接上溢成-inf，在某些情况下会导致softmax计算异常。更稳妥的方式是使用torch.finfo(torch.float16).min。

你可以把注意力分数的分布打印出来：如果训练早期分数动辄上百，多半是初始化或缩放出了问题。

8.3 训练时GPU显存爆掉，真的是因为模型太大吗

不一定。很多情况下显存瓶颈不在模型参数，而在注意力分数矩阵。一个[batch, heads, seq_len, seq_len]的张量，在batch=8、heads=8、seq_len=1024、fp16精度下，占用大约是8*8*1024*1024*2字节 = 128MB，这只是一个中间变量。如果把这个矩阵保留到反向传播阶段，还要再存一份用于梯度计算，显存开销直接翻倍。

解决办法有几个：减少batch size、减少头数、用梯度检查点（gradient checkpointing）来切换时间换空间、或者干脆换用FlashAttention这类不显式构建n×n矩阵的高效实现。FlashAttention之所以重要，不只是速度快，更关键的是它通过分块和重计算，让注意力分数矩阵不需要整体驻留显存。如果你在跑长序列任务，强烈建议优先考虑这个方案。

8.4 注意力权重总是集中在某个特殊token上，正常吗

不少人在分析注意力图时发现，模型对[CLS]、[SEP]这种特殊token投注了超高的注意力权重。这个现象在BERT类模型里尤其常见，它看似“不自然”，其实背后有合理的解释：特殊token在整个序列里始终存在，位置固定，模型把它们当作了一种“全局信息汇聚点”或者“任务适配标志”。简单说，模型不是只关注局部语义，而是在利用这些token来汇总全局信息。

这种现象通常不需要干预，除非你的下游任务对注意力分布有特殊的可解释性需求。但如果你希望注意力分布更分散一些，可以尝试在训练时加入注意力正则化（比如熵正则），或者调整特殊token的构造方式。不过这类改动往往是双刃剑，改之前先想清楚你到底需要注意力权重做什么。

8.5 位置编码在长序列推理时出现性能下降

我自己在很多场景遇到过一个现象：模型在训练长度范围内效果不错，一旦序列超过训练时的长度，性能就开始掉。这不一定全是位置编码的问题，也可能是训练分布和测试分布不一致。但如果确认是位置编码的外推问题，有几个方向可以尝试。

如果用的是可学习位置编码，可以试试改成相对位置编码方案，比如RoPE或ALiBi。这两种方案在长文本外推上的表现通常比绝对位置编码好很多，也是目前大模型的主流选择。如果暂时不想改模型结构，也可以用更笨但有效的方法：把长序列切段，每段分别编码并拼接，注意段边界处要适当重叠，否则会丢失上下文连续性。

8.6 注意力Dropout在训练和推理中的不同用法

注意力权重的Dropout是一个容易写错的地方。nn.Dropout在训练模式下会随机把一部分权重置零，同时做一个缩放来保持期望值不变。但在推理模式下，Dropout层是恒等映射，不会屏蔽任何信息。这本来没什么问题，但如果你显式地在模型里调用了model.eval()，Dropout会自动关闭；如果你忘了切换模型模式，推理时Dropout还会继续随机屏蔽信息，导致输出结果不稳定。

另外，注意力Dropout的比率一般设置在0.1附近。设得太高会让注意力权重过于稀疏，信息丢失严重；设得太低在数据量小时又容易过拟合。这个超参数对整体性能的影响不算特别大，但值得在调参的时候扫一遍。

9. 从理论到复现：我是怎么彻底学会Self-Attention的

如果让我给刚接触Self-Attention的人一个学习路径，我通常会建议三条线并行：先搞懂数学直觉，再亲自实现一遍，最后用现成框架在真实任务上跑一跑。

数学直觉这部分，重点不是背诵公式，而是理解三个问题：QKV的角色分工、缩放因子的动机、多头带来的表达能力扩展。你可以用自己的话把整个流程解释一遍，比如“每个token发出查询，和所有键做匹配，按匹配度取回值”。能这样流畅讲出来，说明真的懂了。

实现这部分，建议先照着前面那段代码手动敲一遍，改一改参数，打印每一层的形状和注意力权重。有一个我特别喜欢的小练习：把多头注意力的num_heads改成1，和改成8，对比一下在同一个任务上的收敛曲线差异。这能让你直观感受到多头的价值。

最后是真实任务。不用上来就追求超大模型，可以先在文本分类或者机器翻译小任务上试。找到一个自带Transformer的成熟框架，替换其中的注意力实现为手写版本，如果效果不掉点，就说明你的理解已经可以实战了。

我自己的经验是，写这篇笔记的过程中，最难的不是把代码跑通，而是把每个“为什么”都解释清楚。Self-Attention看起来只是一个公式，背后却凝聚了无数关于序列建模、表示学习、数值稳定的智慧。把它彻底想明白之后，再看其他基于注意力机制的变体（比如各种高效注意力、线性注意力），就能很快抓住它们的核心差异，而不只是记差异表的结论。