RNN中的多头注意力

可视化演示

源头问题：长序列的瓶颈

故事要从最初的装配线讲起。老张是流水线末端的记录员，他的工作方式很特别：每经过一个零件，就把上一句话和当前零件的情况“挤”成最新的一句话，最后只把这句话交给质检台。句子一长，“挤”的过程就不断丢细节——前面工位的一次轻微划伤，早就被后来的信息冲得无影无踪。这就是传统 seq2seq 翻译模型的困境：编码器把整句源语言压缩进最后一个隐藏状态。

在神经网络里，编码器逐个读入单词，每一步更新隐藏状态 $\mathbf{h}_i$，最后用时刻 $T$ 的状态当作整句话的摘要。解码器只能依赖这个“一句话总结”生成翻译，句子越长、信息越挤，后面的单词几乎把前面的语义都覆盖掉了。更糟的是，RNN 在长距离反向传播时梯度会指数衰减，开头单词的信息根本走不到句尾。

回到工厂，老张这种“只记最后一句话”的做法让质检部门叫苦不迭。后来厂里想通了一个道理：为什么不让质检台直接回看每个工位自己的原始记录？这正是注意力的起点——不再把整条流水线压成一句话，而是让解码器随时翻阅每一站的台账。

RNN注意力：按需取用

于是质检流程改版了。解码器每生成一个新输出，不再是干等那一句总结，而是拉出一份“全流水线历史记录”：第 3 号工位的螺丝扭矩记录、第 7 号工位的喷漆色号记录……每份记录对应一个相关性分数，相关度高的记录就用粗线标出来，相关度低的就淡化成背景。这就是 Bahdanau 在 2015 年提出的注意力机制，它让解码器在每一步都动态地决定“该看哪些工位”。

技术上，编码器不再只保留最后一个状态，而是保存每一步的隐藏状态 $\mathbf{h}_1, \mathbf{h}_2, \ldots, \mathbf{h}_T$。解码器生成第 $j$ 个词时，先用解码器的上一状态 $\mathbf{s}_{j-1}$ 与每个 $\mathbf{h}_i$ 计算一个对齐分数 $e_{ij}$，表示“源位置 i 与当前输出位置 j 的相关程度”。

光有分数还不够，分数要先变成“权重”。把第 $j$ 步的所有 $e_{1j}, \ldots, e_{Tj}$ 做一遍 softmax 归一化，得到概率分布 $\alpha_{ij}$，再对全部 $\mathbf{h}_i$ 做加权求和，得到这一步的上下文向量 $\mathbf{c}_j$。于是每次翻译“看见”的源词重点都不一样，而不是永远盯着句末。

工厂里这套“按需回看”立刻见效，翻译质量大幅提升。可老张又发现一个问题：他自己再厉害，一双眼睛只能盯着一种指标——看了扭矩就顾不上漆面。能不能多请几位各有所长的质检员，让他们同时看、最后合议？这就是多头注意力登场的契机。

多头机制：多位专家各看一面

厂长请来三位质检专家：红镜师傅专注检查金属裂纹，绿镜师傅监督表面镀层，蓝镜师傅盯螺丝扭矩。他们把各自看到的重点写在三张不同的台账上，最后合到一起形成一份完整报告。多头注意力就是把这个“分工合议”过程公式化：不再用一套 Q、K、V 算一次注意力，而是用 $h$ 组权重矩阵，把输入投影到 $h$ 个子空间，每组独立计算注意力，最后拼接融合。

为什么这样做有效？语言里的关系往往是多重的：翻译一个代词时，既要知道它指代哪个名词（语法关系），又要知道它处于什么语境情绪（语义关系）。单一注意力头只能捕捉一种主要的关联模式，多个头则各管一类。在 RNN 场景里，编码器的隐藏状态序列就是“流水线台账”，多头注意力可以同时从句法、语义、位置等多个角度观察这段序列。

回到工厂，三位质检员各自只写“自己的重点”，最后把三份报告钉在一起成一份综合结论。解密器拿到的不再是单一视角的加权和，而是一份多维度融合的评估报告。

单头局限与多头优势

如果只请一位质检员，会发生什么？他要么只能盯裂纹，要么只能盯扭矩，看多了眼睛就花。单头注意力也是如此：一整份 $\mathbf{Q}\mathbf{K}^\top$ 里的所有信息被压缩进一次 softmax 分布，模型只能学到一种占主导的对齐模式，其他关系被平均掉了。

多头注意力则不同。它把模型的表达能力拆成 $h$ 条更窄的通道，每条通道专注一种关联模式。比如一个头专门学习中英文的语序对应关系，另一个头专门学习名词和代词的同指关系，第三个头则捕捉长距离的修饰关系。正因为每个头的维度变窄，反而“被迫”学得更专一。

工厂里，三位质检员每人只看一项指标，不存在“看不全面”的问题，也不用担心请三倍的人会付三倍工资——因为他们每个人只做原来三分之一的工作量。数学模型上也正是如此：多头让“表达宽度”换成了“表达深度”，整体开销几乎持平。

自注意力：全员圆桌会议

故事在这里迎来转折。厂长发现，传送带式的 RNN 有个天生缺陷：信息必须一站一站往后传，第 1 站的信息传到第 20 站要拐 19 道弯，途中不断衰减。于是厂长决定开会——干脆把传送带拆了，所有人围坐一张圆桌，任何两个人之间可以直接对话。这就是 Self-Attention：句子里的每个词都跟所有其他词直接计算关联，不需要经过中间词的接力传递。

在公式上，Self-Attention 与普通注意力唯一的区别是 $\mathbf{Q}$、$\mathbf{K}$、$\mathbf{V}$ 都来自同一个序列 $\mathbf{X}$——也就是“自己和自己注意力”。RNN 里的源词序列是“别人的台账”，而 Self-Attention 里每个位置同时是查询方、被查询方和被聚合方。更妙的是，所有位置之间的计算可以写成一次矩阵乘法，整体并行完成，不再有循环依赖。

圆桌会议上，任何两个人之间的对话都是一步直达，不再有中间人传话的损耗。Self-Attention 也因为这个特性，后来被 Transformer 收为心脏，成为大语言模型的基石。

演进脉络：从传话到平行对话

把整个故事串起来看，是一条清晰的升级路径。最初 RNN + seq2seq 只有“一句话总结”（信息瓶颈）；接着 Bahdanau 引入注意力，让解码器按需回看所有源词；再后来把单头注意力扩展成多头，让多个子空间并行分工；最后 Self-Attention 彻底去掉循环，让所有位置直接互相通信。每一步都解决了上一步最痛的短板。

Transformer 之所以爆发，是因为它把这条路径推到了极致：编码器和解码器都不再用 RNN，而是层层堆叠 Multi-Head Self-Attention。在这里，$\mathbf{Q}$、$\mathbf{K}$、$\mathbf{V}$ 全部来自同一序列 $\mathbf{X}$，所以叫自注意力；每一层都用多头机制来扩展表达力。RNN 的时序依赖被彻底移除，带来了两个巨大红利：训练可以完整并行，长距离依赖不再衰减。

把时间线逆回去看，Transformer 的每一块砖都来自 RNN 时代：多头机制在 RNN 场景里已经显现优势，Self-Attention 只是把注意力从“解码器看源词”换成“每个位置看所有位置”。工厂从传送带升级为圆桌，成员没换，规则变了，效率却天翻地覆。

实践要点：别把流水线建歪了

圆桌会议虽好，布置会场也有讲究。第一个问题是请几位专家合适？实践中 $h=8$ 是最常用的选择，有时用 16；头数太少表达力不足，太多则每个头分到的维度太少、学不到位，还容易让训练数据量需求暴涨。第二个问题是维度要整除：$d_{\text{model}} = h \times d_k$，如果 $512$ 维配 $12$ 个头，分不干净就无法实现标准的子空间分解。

第三个问题是遮罩。开会时如果要求“第 5 号工位不能偷看第 6 号工位已经写好的结论”，这就是 Mask。在解码器里，生成第 $j$ 个词时不允许看到未来词，所以要给注意力矩阵加一个上三角掩码，把未来位置的分数设成负无穷。这个技巧在 Transformer 中继承自 RNN 注意力的“只能看已生成内容”的天然约束。

第四个问题是工程上的“缩放因子 $\sqrt{d_k}$”。RNN 时代的注意力打分方式五花八门：有加法注意力（Bahdanau），也有点积注意力（Luong）。后来发现点积注意力在大维度上需要除以 $\sqrt{d_k}$ 来维持梯度稳定，这个细节被 Transformer 保留并沿用至今。工业界从机器翻译到语音识别，都在用这些经验配置。

| $d_{\text{model}}$ | 常用头数 $h$ | 每头维度 $d_k$ |

| :---: | :---: | :---: |

| 256 | 8 | 32 |

| 512 | 8 | 64 |

| 768 | 12 | 64 |

| 1024 | 16 | 64 |

回到工厂，会场布置得当，会议效率极高；布置不当——比如请一百位专家挤在一起、座位维度切分不匀、让工位偷看未来结论——会议再热闹也是空转。多头注意力也一样，真正决定效果的不是“头多”这个名头，而是对子空间、维度和遮罩这些细节的拿捏。

AI 应用场景

Python 演示

import numpy as np  def softmax(x):    e = np.exp(x - x.max(axis=-1, keepdims=True))    return e / e.sum(axis=-1, keepdims=True)  class MultiHeadAttention:    def __init__(self, d_model, h, seed=42):        assert d_model % h == 0, "d_model must be divisible by h"        rng = np.random.RandomState(seed)        self.d_model = d_model        self.h = h        self.d_k = d_model // h        self.wq = rng.randn(d_model, d_model) * 0.02        self.wk = rng.randn(d_model, d_model) * 0.02        self.wv = rng.randn(d_model, d_model) * 0.02        self.wo = rng.randn(d_model, d_model) * 0.02     def split(self, x):        T, d = x.shape        return x.reshape(T, self.h, self.d_k).transpose(1, 0, 2)     def attn(self, Q, K, V):        score = Q @ K.transpose(0, 2, 1) / np.sqrt(self.d_k)        weight = softmax(score)        return weight @ V     def forward(self, Q, K, V):        Q = self.split(Q @ self.wq)        K = self.split(K @ self.wk)        V = self.split(V @ self.wv)        heads = self.attn(Q, K, V)        T, _, dk = heads.shape        concat = heads.transpose(1, 0, 2).reshape(T, self.h * dk)        return concat @ self.wo  def fake_rnn_states(T=10, d=16):    rng = np.random.RandomState(0)    return np.tanh(rng.randn(T, d))  if __name__ == "__main__":    T, d_model, heads = 10, 16, 4    H = fake_rnn_states(T, d_model)    model = MultiHeadAttention(d_model, heads)    out = model.forward(H, H, H)    print("RNN hidden states shape:", H.shape)    print("Multi-Head attention output shape:", out.shape)    print("Each head dimension d_k =", model.d_k)

1. assert d_model % h == 0保证总维度能被头数整除，这是子空间均分的前提。
2. rng.randn(d_model, d_model) * 0.02初始化投影矩阵，小数值防止注意力分数过大。
3. x.reshape(T, self.h, self.d_k).transpose(1, 0, 2)把矩阵拆成 $h$ 个子空间，并换成“头在前”的维度排列。
4. score = Q @ K.transpose(0, 2, 1) / np.sqrt(self.d_k)缩放点积注意力：先算相似度矩阵，再除以 $\sqrt{d_k}$。
5. softmax(score)对每个查询位置做归一化，得到权重分布。
6. head.transpose(1, 0, 2).reshape(T, self.h * dk)把各头的输出从“按头分组”还原为“按位置排列”的拼接矩阵。
7. concat @ self.wo乘以输出投影矩阵，把多头信息融合回 $d_{\text{model}}$ 维。

常见误区

面试题