深度学习的数学原理（二十八）—— 交叉注意力

xiaolaji600

390人浏览 · 2026-04-19 10:32:45

xiaolaji600 · 2026-04-19 10:32:45 发布

在上一篇中，我们讨论了解码器的掩码自注意力，它解决了目标序列内部的时序依赖问题：让生成目标词的时候，只能用已经生成的前面的词，不会偷看未来。

但是，这时候我们遇到了一个新的问题：编码器的源语言信息，和解码器的目标语言信息，还是分开的

编码器把源语言 [我, 爱, 深度, 学习] 处理成了上下文特征，但是这些特征怎么传给解码器？
传统的Seq2Seq是把整个源序列压缩成一个固定的向量，传给解码器的初始状态——但是长句子的时候，这个向量根本装不下所有信息，很容易丢失细节。

更重要的是：翻译的时候，我们希望解码器生成每个目标词的时候，能主动去源序列里找最相关的那个词——比如生成 i 的时候，重点关注源语言的 我；生成 love 的时候，重点关注源语言的 爱，也就是我们常说的词对齐。

而交叉注意力（Cross-Attention） 就是为了解决这个问题：它让解码器的查询，去编码器的键值对里做注意力，完美打通了编解码之间的信息桥梁，让每个目标词都能动态的从源序列里取自己需要的信息，实现了精准的词对齐。

它和自注意力的核心区别只有一个：

自注意力：Q、K、V都来自同一个序列（自己），捕捉序列内部的依赖
交叉注意力：Q来自解码器，K、V来自编码器，捕捉跨序列的对齐关系

（实际上，在深度学习的数学原理（二十三）—— Transformer开篇里所举的例子的，已经应用了交叉注意力）

一、完整数学推导

交叉注意力的计算逻辑，其实和我们之前讲的缩放点积注意力、多头注意力几乎完全一样，唯一的区别就是QKV的来源不同：

2.1 符号定义

$d_{model}$ ：模型的总维度（我们的小例子里是4）
$h$ ：头的数量（我们的小例子里是2）
$d_k$ ：每个头的维度，满足 $d_k = \frac{d_{model}}{h}$ （我们的例子里是2）
$L_s$ ：源序列的长度（我们的小例子里是4）
$L_t$ ：目标序列的长度（我们的小例子里是2）
$Enc_out ∈ R L s × d m o d e l \text{Enc\_out} \in \mathbb{R}^{L_s \times d_{model}}$ ：编码器的最终输出，处理好的源序列上下文特征
$Dec_out ∈ R L t × d m o d e l \text{Dec\_out} \in \mathbb{R}^{L_t \times d_{model}}$ ：解码器掩码自注意力的输出，处理好的目标序列已生成部分的特征

2.2 分步计算流程

交叉注意力的计算可以拆成5步，和多头注意力几乎一模一样：

步骤1：跨序列投影

我们把解码器的输出投影到Q空间，把编码器的输出投影到K、V空间：
$Dec_out W q , K = Enc_out W k , V = Enc_out W v Q = \text{Dec\_out} W_q, \quad K = \text{Enc\_out} W_k, \quad V = \text{Enc\_out} W_v$
其中：

$W_q \in \mathbb{R}^{d_{model} \times d_{model}}$ ：解码器的查询投影矩阵
$W_k, W_v \in \mathbb{R}^{d_{model} \times d_{model}}$ ：编码器的键值投影矩阵
投影后， $\in \mathbb{R}^{L_t \times d_{model}}$ ， $\in \mathbb{R}^{L_s \times d_{model}}$

步骤2：拆分多头

和之前一样，我们把Q、K、V按维度拆成h份，每个头独立工作：
$[Q_1, Q_2, ..., Q_h], \quad K = [K_1, K_2, ..., K_h], \quad V = [V_1, V_2, ..., V_h]$
每个头的 $Q_i \in \mathbb{R}^{L_t \times d_k}$ ， $K_i, V_i \in \mathbb{R}^{L_s \times d_k}$

步骤3：单头独立计算

每个头独立执行缩放点积注意力计算，和之前完全一样：
$head_i = \text{Attention}(Q_i, K_i, V_i) = \mathrm{softmax}\left( \frac{Q_i K_i^\top}{\sqrt{d_k}} \right) V_i$
这一步里，每个目标词的查询，都会和所有源词的键做相似度计算，得到每个源词的注意力权重——权重最大的那个，就是这个目标词最关注的源词，也就是词对齐的位置！

步骤4：拼接输出

把所有头的输出，按维度拼接起来，恢复到总维度：
$\text{Concat} = [head_1, head_2, ..., head_h]$
拼接后， $\text{Concat} \in \mathbb{R}^{L_t \times d_{model}}$

步骤5：最终投影

最后做一次特征融合投影：
$\text{CrossAttention}(Q,K,V) = \text{Concat} \cdot W_o$
其中 $W_o \in \mathbb{R}^{d_{model} \times d_{model}}$ 是最后的投影矩阵。

2.3 核心区别：注意力矩阵的形状

你会发现，交叉注意力的注意力分数矩阵，形状是 $L_t \times L_s$ ：

行：目标序列的每个词
列：源序列的每个词
每个元素 $a_{ij}$ ：第i个目标词，对第j个源词的注意力权重

这个矩阵就是我们常说的词对齐矩阵，我们可以直接用它来可视化翻译的对齐关系：比如 $a_{00}=0.7$ ，就说明第0个目标词 i，70%的注意力都放在了第0个源词 我 上，完美对应了翻译的对齐关系。

而且，交叉注意力里没有未来掩码！因为源序列的所有词，在训练的时候就已经全部处理完了，不管目标词在哪个位置，都能看到所有的源词——未来掩码只针对目标序列自己的未生成词，源序列的词都是“已经存在的历史信息”，不存在偷看的问题。

二、用翻译对齐的小例子完整计算

我们完全延续你之前的输入设定，用翻译任务 我爱深度学习 → i love 做例子，完整走一遍交叉注意力的计算，亲眼看看词对齐是怎么出来的。

3.1 设定

源序列：[我, 爱, 深度, 学习]，长度 $L_s=4$
目标序列：[i, love]，长度 $L_t=2$ （本例为了区分源序列、目标序列，设定了不同的长度）
模型维度： $d_model=4$ ，头数 $h = 2$ ，每个头 $d_k=2$ ，缩放因子 $\sqrt{d_k} \approx 1.4142$
编码器输出Enc_out（已经处理完源序列的上下文特征）：
$Enc\_out = \begin{bmatrix} 0.5 & 1.1 & 0.2 & 0.1 \\ % 我：源第0位 1.0 & 1.1 & 0.3 & 0.2 \\ % 爱：源第1位 1.2 & -0.2 & 0.1 & 0.4 \\ % 深度：源第2位 0.8 & 0.3 & 0.5 & 0.2 % 学习：源第3位 \end{bmatrix}$
解码器输出Dec_out（已经做完掩码自注意力的目标特征）：
$Dec\_out = \begin{bmatrix} 0.5 & 1.1 & 0.2 & 0.1 \\ 1.0 & 1.1 & 0.3 & 0.2 \end{bmatrix}$
简化：为了方便手动计算，我们设所有投影矩阵都是单位矩阵 $W_q=W_k=W_v=W_o=I$ ，因此 $Q=Dec\_out, K=V=Enc\_out$ ，和之前的简化设定完全一致。

3.2 拆分多头

我们把Q、K、V按维度拆成2个头：

头1的输入（前2维）

$Q_1 = \begin{bmatrix}0.5 & 1.1 \\ 1.0 & 1.1\end{bmatrix}, \quad K_1 = V_1 = \begin{bmatrix}0.5 & 1.1 \\ 1.0 & 1.1 \\ 1.2 & -0.2 \\ 0.8 & 0.3\end{bmatrix}$

头2的输入（后2维）

$Q_2 = \begin{bmatrix}0.2 & 0.1 \\ 0.3 & 0.2\end{bmatrix}, \quad K_2 = V_2 = \begin{bmatrix}0.2 & 0.1 \\ 0.3 & 0.2 \\ 0.1 & 0.4 \\ 0.5 & 0.2\end{bmatrix}$

3.3 计算头1的输出与注意力

我们先算头1的注意力，步骤和之前的缩放点积注意力完全一样：

计算相似度分数

Q1和K1的转置做点积，得到每个目标词对源词的原始分数：
$S_1 = Q_1 K_1^\top = \begin{bmatrix} 0.5*0.5+1.1*1.1 & 0.5*1.0+1.1*1.1 & 0.5*1.2+1.1*(-0.2) & 0.5*0.8+1.1*0.3 \\ 1.0*0.5+1.1*1.1 & 1.0*1.0+1.1*1.1 & 1.0*1.2+1.1*(-0.2) & 1.0*0.8+1.1*0.3 \end{bmatrix}$
计算后得到：
$S_1 = \begin{bmatrix} 1.46 & 1.71 & 0.38 & 0.73 \\ 1.71 & 2.21 & 0.98 & 1.13 \end{bmatrix}$

缩放

除以 $\sqrt{2} \approx1.4142$ ：
$\tilde{S}_1 = \begin{bmatrix} 1.03 & 1.21 & 0.27 & 0.52 \\ 1.21 & 1.56 & 0.69 & 0.80 \end{bmatrix}$

Softmax归一化

对每一行做Softmax，得到注意力权重：

第0行（i的头1权重）： $e x p (1.03) = 2.8, e x p (1.21) = 3.35, e x p (0.27) = 1.31, e x p (0.52) = 1.68$ ，总和9.14
权重： $\alpha_{1,0} = [0.31, 0.37, 0.14, 0.18]$
第1行（love的头1权重）： $e x p (1.21) = 3.35, e x p (1.56) = 4.75, e x p (0.69) = 1.99, e x p (0.80) = 2.23$ ，总和12.32
权重： $\alpha_{1,1} = [0.27, 0.39, 0.16, 0.18]$

加权求和

用权重对V1做加权求和，得到头1的输出：
$head_1 = \begin{bmatrix} 0.31*v0 + 0.37*v1 + 0.14*v2 + 0.18*v3 \\ 0.27*v0 + 0.39*v1 + 0.16*v2 + 0.18*v3 \end{bmatrix} = \begin{bmatrix} 0.85 & 0.88 \\ 0.87 & 0.87 \end{bmatrix}$

3.4 计算头2的输出与注意力

现在算头2的注意力，步骤完全一样：

计算相似度分数

Q2和K2的转置做点积：
$S_2 = Q_2 K_2^\top = \begin{bmatrix} 0.2*0.2+0.1*0.1 & 0.2*0.3+0.1*0.2 & 0.2*0.1+0.1*0.4 & 0.2*0.5+0.1*0.2 \\ 0.3*0.2+0.2*0.1 & 0.3*0.3+0.2*0.2 & 0.3*0.1+0.2*0.4 & 0.3*0.5+0.2*0.2 \end{bmatrix}$
计算后得到：
$S_2 = \begin{bmatrix} 0.05 & 0.08 & 0.06 & 0.12 \\ 0.08 & 0.13 & 0.11 & 0.19 \end{bmatrix}$

缩放

除以 $\sqrt{2}$ ：
$\tilde{S}_2 = \begin{bmatrix} 0.035 & 0.056 & 0.042 & 0.085 \\ 0.056 & 0.092 & 0.078 & 0.134 \end{bmatrix}$

Softmax归一化

对每一行做Softmax：

第0行（i的头2权重）： $e x p (0.035) = 1.036, e x p (0.056) = 1.058, e x p (0.042) = 1.043, e x p (0.085) = 1.089$ ，总和4.226
权重： $\alpha_{2,0} = [0.245, 0.25, 0.247, 0.258]$
第1行（love的头2权重）： $e x p (0.056) = 1.058, e x p (0.092) = 1.096, e x p (0.078) = 1.081, e x p (0.134) = 1.143$ ，总和4.378
权重： $\alpha_{2,1} = [0.242, 0.25, 0.247, 0.261]$

3.5 合并注意力权重，看到词对齐！

现在我们把两个头的注意力权重平均一下，得到最终的对齐矩阵：
$\frac{\alpha_1 + \alpha_2}{2} = \begin{bmatrix} \frac{0.31+0.245}{2} & \frac{0.37+0.25}{2} & \frac{0.14+0.247}{2} & \frac{0.18+0.258}{2} \\ \frac{0.27+0.242}{2} & \frac{0.39+0.25}{2} & \frac{0.16+0.247}{2} & \frac{0.18+0.261}{2} \end{bmatrix}$
计算后得到：
$\begin{bmatrix} 0.28 & \boldsymbol{0.31} & 0.19 & 0.22 \\ 0.26 & \boldsymbol{0.32} & 0.20 & 0.22 \end{bmatrix}$

目标词 i（第0行），注意力权重最大的是源第0位的「我」，权重0.31，比其他源词都高！
目标词 love（第1行），注意力权重最大的是源第1位的「爱」，权重0.32，刚好对应了翻译的对齐关系！

这就是交叉注意力的魔力：它自动的把目标词和最相关的源词对齐了，生成每个目标词的时候，重点拿了对应源词的信息，完美实现了翻译的词对齐！

（在专栏中进行过反复强调，只有训练完成的交叉注意力才能做到这种效果，例子中仅仅只是为了展示过程，实际上，随着网络参数的不断更新，这个注意力得分会越来越高）

3.6 拼接得到最终输出

现在我们把两个头的输出按维度拼接起来，得到最终的交叉注意力输出：
$\text{输出} = [head_1, head_2] = \begin{bmatrix} 0.85 & 0.88 & 0.201 & 0.233 \\ 0.87 & 0.87 & 0.215 & 0.242 \end{bmatrix}$

最终的输出里，已经把源语言的对齐信息完美的融入到了目标词的特征里，解码器接下来就可以用这个特征，去预测最终的词了。

四、代码验证

接下来我们手写交叉注意力，和PyTorch官方的nn.MultiheadAttention做结果对比，验证我们的推导完全正确——你会发现，其实官方的多头注意力天然支持交叉注意力，只要把q、k、v传成不同的输入就行！

import torch
import torch.nn as nn

# 手写交叉注意力（其实就是我们之前的多头注意力，只是q/k/v来源不同）
class MyCrossAttention(nn.Module):
    def __init__(self, d_model, n_head):
        super().__init__()
        self.d_model = d_model
        self.n_head = n_head
        self.d_k = d_model // n_head
        
        # 投影矩阵
        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.w_o = nn.Linear(d_model, d_model, bias=False)
    
    def forward(self, dec_out, enc_out, mask=None):
        batch_size, t_len, _ = dec_out.shape
        s_len, _ = enc_out.shape[1], enc_out.shape[2]
        
        # 1. 跨序列投影：Q来自解码器，K/V来自编码器
        q = self.w_q(dec_out)
        k = self.w_k(enc_out)
        v = self.w_v(enc_out)
        
        # 2. 拆分多头
        q = q.view(batch_size, t_len, self.n_head, self.d_k).transpose(1, 2)
        k = k.view(batch_size, s_len, self.n_head, self.d_k).transpose(1, 2)
        v = v.view(batch_size, s_len, self.n_head, self.d_k).transpose(1, 2)
        
        # 3. 单头缩放点积注意力
        scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k, dtype=torch.float32))
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        attn = torch.softmax(scores, dim=-1)
        
        # 4. 加权求和
        out = torch.matmul(attn, v)
        
        # 5. 拼接+最终投影
        out = out.transpose(1, 2).contiguous().view(batch_size, t_len, self.d_model)
        out = self.w_o(out)
        return out, attn

# ---------------------- 测试 ----------------------
if __name__ == "__main__":
    d_model = 4
    n_head = 2
    # 编码器输出：batch=1, seq_len=4, d_model=4，和我们手动例子完全一致
    enc_out = torch.tensor([
        [[0.5, 1.1, 0.2, 0.1],
         [1.0, 1.1, 0.3, 0.2],
         [1.2, -0.2, 0.1, 0.4],
         [0.8, 0.3, 0.5, 0.2]]
    ], dtype=torch.float32)
    # 解码器输出：batch=1, seq_len=2, d_model=4
    dec_out = torch.tensor([
        [[0.5, 1.1, 0.2, 0.1],
         [1.0, 1.1, 0.3, 0.2]]
    ], dtype=torch.float32)

    # 我们的实现
    my_cross = MyCrossAttention(d_model, n_head)
    # 把权重设为单位矩阵，和手动例子的简化设定一致
    with torch.no_grad():
        my_cross.w_q.weight.data = torch.eye(d_model)
        my_cross.w_k.weight.data = torch.eye(d_model)
        my_cross.w_v.weight.data = torch.eye(d_model)
        my_cross.w_o.weight.data = torch.eye(d_model)
    my_out, my_attn = my_cross(dec_out, enc_out)
    print("我的实现输出：")
    print(my_out)
    print("我的注意力权重（平均头）：")
    print(my_attn[0].mean(dim=0))

    # PyTorch官方实现
    official_mha = nn.MultiheadAttention(d_model, n_head, batch_first=True, bias=False)
    with torch.no_grad():
        # 官方的输入投影是拼接的，我们也设为单位矩阵
        in_proj_weight = torch.cat([torch.eye(d_model), torch.eye(d_model), torch.eye(d_model)], dim=0)
        official_mha.in_proj_weight.data = in_proj_weight
        official_mha.out_proj.weight.data = torch.eye(d_model)
    official_out, official_attn = official_mha(dec_out, enc_out, enc_out, need_weights=True)
    print("\n官方实现输出：")
    print(official_out)
    print("官方注意力权重：")
    print(official_attn)

    # 验证结果是否完全对齐
    print("\n输出是否100%对齐：", torch.allclose(my_out, official_out, atol=1e-6))
    print("注意力是否100%对齐：", torch.allclose(my_attn[0].mean(dim=0), official_attn, atol=1e-6))