返回专栏
· 17 分钟阅读

Self-Attention 的工作原理:深入理解 Query、Key、Value 与注意力计算


一、什么是 Self-Attention?

Self-Attention(自注意力机制)是 Transformer 中用于建立序列内部不同 Token 之间信息关联的核心计算机制。

它的基本思想是:

在处理一个 Token 时,根据当前 Token 与其他 Token 的关联程度,动态聚合序列中其他位置的信息。

传统序列模型通常通过固定的计算顺序逐步传递信息,而 Self-Attention 可以直接计算序列中不同位置之间的关联。

例如:

输入:
小明把书放在桌子上,因为它很稳固。

问题:
"它" 指的是什么?

模型需要结合上下文判断代词与其他词语之间的关系。

Self-Attention 可以让当前位置的表示关注序列中的其他位置,从而融合相关上下文信息。

需要注意,Attention 权重表示模型在当前计算层中对不同位置的信息分配情况,并不等同于人类语言学意义上的真实指代关系,也不能简单视为模型的完整解释。

二、Self-Attention 的核心计算思想

Self-Attention 的输入是一组 Token 向量,输出仍然是一组向量,但每个位置的输出都融合了序列中其他位置的信息。

假设输入序列包含三个 Token:

Token 1:我
Token 2:喜欢
Token 3:AI

对应的输入向量:

X= \begin{bmatrix} x_1\\ x_2\\ x_3 \end{bmatrix}

其中:

X\in\mathbb{R}^{n\times d_{model}}

Self-Attention 会为每个 Token 计算三个不同的向量:

  • Query(Q):当前 Token 想要获取什么信息。
  • Key(K):当前 Token 可以提供什么信息。
  • Value(V):当前 Token 实际提供的内容表示。

随后,通过 Query 与所有 Key 计算相关性分数,再根据分数对 Value 进行加权聚合。

flowchart TB
    A["输入 Token 向量 X"] --> B["线性投影"]
    B --> C["生成 Query、Key、Value"]
    C --> D["Query 与 Key 计算相似度"]
    D --> E["缩放注意力分数"]
    E --> F["Softmax 转换为权重"]
    F --> G["对 Value 加权求和"]
    G --> H["输出上下文表示"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49

整个过程可以概括为:

Output=Softmax\left( \frac{QK^T}{\sqrt{d_k}} \right)V

这是 Scaled Dot-Product Attention 的基本公式。

下面逐步拆解。

三、Query、Key、Value 的生成机制

Q、K、V 是 Self-Attention 最重要的三个概念。

它们不是直接从原始文本中提取的三个固定属性,而是由输入隐藏表示经过三个不同的可学习线性变换得到。

3.1 输入向量

设输入序列的隐藏表示为:

X\in\mathbb{R}^{n\times d_{model}}

其中:

  • n:序列长度。
  • d_{model}:模型隐藏维度。

例如:

n=4,\quad d_{model}=512

则:

X\in\mathbb{R}^{4\times512}

表示序列包含 4 个 Token,每个 Token 对应一个 512 维向量。

这些向量通常已经包含 Token Embedding、位置信息,以及之前网络层提取的特征。

3.2 通过线性变换生成 Q、K、V

模型使用三个不同的权重矩阵:

W_Q\in\mathbb{R}^{d_{model}\times d_k}
W_K\in\mathbb{R}^{d_{model}\times d_k}
W_V\in\mathbb{R}^{d_{model}\times d_v}

分别计算:

Q=XW_Q
K=XW_K
V=XW_V

因此:

Q\in\mathbb{R}^{n\times d_k}
K\in\mathbb{R}^{n\times d_k}
V\in\mathbb{R}^{n\times d_v}

实际模型通常还包含可学习偏置,但为了简化公式,这里省略偏置项。

3.3 为什么需要三个不同的投影矩阵?

因为它们承担不同的计算职责。

向量 作用 计算含义
Query 发起信息查询 当前 Token 需要什么信息
Key 提供匹配依据 当前 Token 如何与 Query 匹配
Value 提供实际内容 当前 Token 可以贡献什么信息

可以通过一个检索系统来理解:

  • Query:查询条件。
  • Key:索引特征。
  • Value:实际检索内容。

模型通过 Query 和 Key 计算匹配程度,再根据匹配程度聚合 Value。

需要强调:Q、K、V 是模型训练得到的连续向量表示,并不对应人类能够直接理解的固定语义字段。

3.4 Q、K、V 并不是三份独立输入

一个容易产生的误解是,认为 Q、K、V 来自三组不同的原始数据。

在 Self-Attention 中:

Q=XW_Q,\quad K=XW_K,\quad V=XW_V

三者都来自同一个输入 X,只是使用不同的投影矩阵。

这也是 Self-Attention 中 Self 的含义:注意力计算所使用的 Query、Key、Value 都来自同一序列的表示。

而在 Cross-Attention 中,Query 与 Key、Value 通常来自不同的序列或不同的网络模块。

四、计算 Attention Score:建立 Token 之间的关联

生成 Q、K、V 后,下一步是计算 Query 和 Key 之间的匹配程度。

4.1 点积计算

对于第 i 个 Token 的 Query:

q_i

以及第 j 个 Token 的 Key:

k_j

计算它们的点积:

s_{ij}=q_i k_j^T

点积结果用于衡量两个向量在当前表示空间中的匹配程度。

一般而言,点积越大,Softmax 之前的注意力分数越高。

不过,点积不是经过归一化的概率,也不一定处于固定范围内。

4.2 矩阵形式

对整个序列同时计算:

S=QK^T

假设:

Q\in\mathbb{R}^{n\times d_k}
K^T\in\mathbb{R}^{d_k\times n}

那么:

S\in\mathbb{R}^{n\times n}

其中:

S_{ij}=q_i k_j^T

表示第 i 个位置的 Query 与第 j 个位置的 Key 之间的匹配分数。

因此,Attention Score 矩阵具有以下结构:

  • 行:Query 所在的位置。
  • 列:Key 所在的位置。
  • 元素:两个位置之间的匹配分数。

例如,序列长度为 4:

S= \begin{bmatrix} s_{11}&s_{12}&s_{13}&s_{14}\\ s_{21}&s_{22}&s_{23}&s_{24}\\ s_{31}&s_{32}&s_{33}&s_{34}\\ s_{41}&s_{42}&s_{43}&s_{44} \end{bmatrix}

每一行对应一个 Token 对整个序列的注意力分数。

4.3 为什么需要计算所有位置之间的关系?

因为一个 Token 的语义表示往往依赖其他 Token。

例如:

句子 A:
苹果发布了新的手机。

句子 B:
我买了一些苹果。

同一个词语在不同上下文中可能具有不同含义。

Self-Attention 允许模型根据当前上下文动态聚合其他位置的信息,使相同 Token 在不同上下文中形成不同的隐藏表示。

这也是 Transformer 能够处理复杂上下文关系的重要原因。

五、Scaled Dot-Product:为什么要除以平方根?

标准 Self-Attention 并不是直接对 QK^T 进行 Softmax,而是先除以 \sqrt{d_k}。

公式:

S=\frac{QK^T}{\sqrt{d_k}}

这个操作称为 Scaled Dot-Product。

5.1 点积为什么会随着维度增大?

假设 Query 和 Key 的每个分量都是均值为 0、方差为 1 的独立随机变量。

点积为:

q\cdot k=\sum_{i=1}^{d_k}q_i k_i

在上述独立性假设下:

E[q\cdot k]=0

其方差约为:

Var(q\cdot k)=d_k

因此,点积的标准差约为:

\sqrt{d_k}

当向量维度增加时,点积数值的波动范围也会增大。

5.2 为什么过大的分数会影响 Softmax?

Softmax 公式:

Softmax(x_i)= \frac{e^{x_i}}{\sum_j e^{x_j}}

当输入分数差异过大时,Softmax 容易产生高度集中的概率分布。

例如:

Softmax([1,2,3])

与:

Softmax([10,20,30])

相比,第二组输入产生的概率分布会更加尖锐。

当概率高度集中时,非最大值位置的梯度可能变得很小,进而影响训练过程中的梯度传播。

5.3 缩放的作用

通过除以:

\sqrt{d_k}

可以在一定程度上控制点积的数值尺度,使 Softmax 的输入分布更加稳定。

例如:

d_k=64

则缩放因子为:

\sqrt{64}=8

最终:

AttentionScore=\frac{QK^T}{8}

需要注意,这一推导依赖于简化的统计假设。实际训练中,Q 和 K 的分布会随着模型参数、归一化方式和训练状态变化。

六、Softmax:将注意力分数转换为权重

完成缩放后,需要将每个 Query 对应的一行分数转换为权重分布。

6.1 Softmax 计算

假设某个 Query 对应三个 Key,其缩放后的分数为:

S=[1,2,3]

Softmax:

\alpha_i= \frac{e^{s_i}}{\sum_j e^{s_j}}

计算结果约为:

\alpha=[0.0900,0.2447,0.6652]

这表示当前 Query 对三个 Value 的加权比例分别约为:

  • 第一个位置:9.00%。
  • 第二个位置:24.47%。
  • 第三个位置:66.52%。

注意力权重满足:

\sum_j\alpha_j=1

并且:

0\leq\alpha_j\leq1

因此,可以将一行注意力权重理解为一个概率分布。

但它不是模型对某个事实正确性的概率,而是当前注意力计算中的归一化权重。

6.2 按行执行 Softmax

对于:

S\in\mathbb{R}^{n\times n}

Softmax 沿着最后一个维度计算。

也就是说:

  • 每一行对应一个 Query。
  • 每一行单独归一化。
  • 每一行的权重之和为 1。

得到:

A=Softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)

其中:

A\in\mathbb{R}^{n\times n}

A 就是注意力权重矩阵。

七、加权聚合 Value:生成上下文表示

注意力权重计算完成后,模型还需要真正获取其他 Token 的信息。

这一步通过 Value 完成。

7.1 加权求和

对于第 i 个 Query,其输出为:

o_i=\sum_{j=1}^{n}\alpha_{ij}v_j

其中:

  • \alpha_{ij}:第 i 个 Query 对第 j 个 Value 的注意力权重。
  • v_j:第 j 个 Token 对应的 Value 向量。
  • o_i:第 i 个位置的输出向量。

因此,输出并不是简单选择一个最相关的 Token,而是根据权重对多个 Value 进行加权求和。

7.2 矩阵形式

将所有位置的计算合并:

O=AV

其中:

A\in\mathbb{R}^{n\times n}
V\in\mathbb{R}^{n\times d_v}

因此:

O\in\mathbb{R}^{n\times d_v}

最终得到的 O 就是上下文融合后的表示。

7.3 完整计算公式

将上述步骤合并:

\boxed{ Attention(Q,K,V)= Softmax\left( \frac{QK^T}{\sqrt{d_k}} \right)V }

整个过程可以拆解为:

flowchart TB
    A["输入 X"] --> B["Q = XWQ"]
    A --> C["K = XWK"]
    A --> D["V = XWV"]
    B --> E["QK 转置点积"]
    C --> E
    E --> F["除以 √dk"]
    F --> G["Softmax"]
    G --> H["注意力权重矩阵 A"]
    H --> I["A × V"]
    D --> I
    I --> J["上下文输出 O"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#E5F0E9,stroke:#83A995,color:#315D49

八、通过一个数值例子理解 Attention

为了更直观地理解计算过程,假设有三个 Token:

我 喜欢 AI

假设它们经过线性投影后得到以下简化向量:

Q= \begin{bmatrix} 1&0\\ 0&1\\ 1&1 \end{bmatrix}
K= \begin{bmatrix} 1&0\\ 0&1\\ 1&1 \end{bmatrix}
V= \begin{bmatrix} 1&0\\ 0&2\\ 2&1 \end{bmatrix}

这里为了方便手工计算,令:

d_k=2

8.1 计算 QK 的转置

QK^T= \begin{bmatrix} 1&0&1\\ 0&1&1\\ 1&1&2 \end{bmatrix}

8.2 缩放分数

S=\frac{QK^T}{\sqrt{2}}

得到:

S\approx \begin{bmatrix} 0.707&0&0.707\\ 0&0.707&0.707\\ 0.707&0.707&1.414 \end{bmatrix}

8.3 Softmax 归一化

逐行计算 Softmax,得到近似结果:

A\approx \begin{bmatrix} 0.401&0.198&0.401\\ 0.198&0.401&0.401\\ 0.248&0.248&0.504 \end{bmatrix}

每一行的权重之和约等于 1。

8.4 与 V 相乘

O=AV

得到:

O\approx \begin{bmatrix} 1.203&0.797\\ 1.000&1.203\\ 1.256&0.752 \end{bmatrix}

这意味着:

  • 第一个 Token 的输出融合了三个位置的 Value。
  • 第二个 Token 的输出融合了三个位置的 Value。
  • 第三个 Token 的输出也融合了三个位置的 Value。

三个位置虽然使用相同的输入序列,但由于各自的 Query 不同,得到的注意力权重也不同。

因此,每个 Token 最终获得不同的上下文表示。

这个例子中的 Q、K、V 是人为构造的数值,不代表真实语言模型的训练参数。

九、Self-Attention 为什么能够建模上下文?

Self-Attention 的核心价值不只是计算 Token 之间的相似度,而是通过动态权重实现上下文信息融合。

9.1 静态词向量与上下文表示

传统静态词向量通常为同一个词提供固定的向量表示。

例如:

苹果手机
我喜欢吃苹果

如果只使用一个固定词向量,难以直接体现同一个词在不同上下文中的含义差异。

Self-Attention 则可以根据当前输入上下文动态调整信息聚合结果。

同一个 Token 在不同句子中,可以产生不同的 Q、K、V 及注意力权重。

9.2 多层 Attention 的逐层建模

一个 Transformer 通常包含多个 Attention Layer。

每一层都会基于上一层的隐藏表示重新计算 Q、K、V。

因此:

  • 浅层可以学习局部关联和基础模式。
  • 中间层可以逐步融合更复杂的上下文信息。
  • 深层可以形成更加抽象的特征表示。

这只是常见的理解方式,并不意味着每一层都有固定且严格的语义职责。

十、Self-Attention 与 Cross-Attention 的区别

Self-Attention 和 Cross-Attention 都使用 Q、K、V 计算注意力,但三者的输入来源不同。

10.1 Self-Attention

在 Self-Attention 中:

Q=XW_Q
K=XW_K
V=XW_V

Q、K、V 来自同一组输入表示。

例如 Encoder 对输入序列执行 Self-Attention。

10.2 Cross-Attention

在 Cross-Attention 中,Query 来自一个序列,Key 和 Value 来自另一个序列。

例如:

Q=H_{dec}W_Q
K=H_{enc}W_K
V=H_{enc}W_V

其中:

  • H_{dec}:Decoder 隐藏表示。
  • H_{enc}:Encoder 输出。

10.3 对比

对比维度 Self-Attention Cross-Attention
Query 来源 当前序列 一个序列
Key 来源 当前序列 另一个序列
Value 来源 当前序列 另一个序列
主要作用 序列内部信息交互 不同序列之间信息交互
典型场景 Encoder、Decoder Encoder-Decoder Decoder

需要注意,Self-Attention 不意味着所有位置一定都能互相访问。具体可访问范围还受到 Padding Mask、Causal Mask 或其他注意力掩码的约束。

十一、Mask:控制注意力的可见范围

在实际 Transformer 中,Attention 不一定允许所有 Token 互相访问。

Mask 用于控制哪些位置可以参与注意力计算。

通常在 Softmax 之前,将不可访问位置的分数设置为负无穷。

S'=\frac{QK^T}{\sqrt{d_k}}+M

其中:

  • 可访问位置:Mask 值通常为 0。
  • 不可访问位置:Mask 值通常为负无穷。

随后:

A=Softmax(S')

不可访问位置的注意力权重就会变为 0。

11.1 Padding Mask

Padding Mask 用于屏蔽批次处理中补齐的无效 Token。

例如,不同输入序列长度不同,为了组成统一形状的 Batch,通常需要填充特殊 Token。

这些填充位置不应该作为有效内容被其他位置关注。

11.2 Causal Mask

Causal Mask 用于实现自回归注意力。

当前位置只能访问当前位置和之前的位置,不能访问未来 Token。

例如,序列长度为 4:

M= \begin{bmatrix} 0&-\infty&-\infty&-\infty\\ 0&0&-\infty&-\infty\\ 0&0&0&-\infty\\ 0&0&0&0 \end{bmatrix}

其可见关系如下:

flowchart TB
    A["位置 1"] --> B["只能访问位置 1"]
    C["位置 2"] --> D["可以访问位置 1、2"]
    E["位置 3"] --> F["可以访问位置 1、2、3"]
    G["位置 4"] --> H["可以访问位置 1、2、3、4"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49

11.3 不同 Mask 的用途

Mask 类型 主要目的 典型应用
Padding Mask 屏蔽填充位置 批量序列处理
Causal Mask 屏蔽未来位置 自回归语言模型
Attention Mask 泛指注意力可见性约束 各类 Transformer

实际框架中,Attention Mask 的具体数据格式可能不同。例如有的实现使用布尔掩码,有的使用加性掩码,不能仅凭变量名称判断其语义。

十二、Multi-Head Self-Attention:为什么需要多个头?

单个 Self-Attention 只能通过一组 Q、K、V 投影空间计算注意力。

为了增强模型表示能力,Transformer 引入 Multi-Head Attention(多头注意力)。

12.1 单头注意力的局限

单个 Attention Head 使用一组投影矩阵:

Q=XW_Q
K=XW_K
V=XW_V

然后计算:

head=Attention(Q,K,V)

这种结构只在一个投影子空间中执行注意力计算。

但 Token 之间可能存在多种关联模式,例如:

  • 语法关系。
  • 语义关系。
  • 指代关系。
  • 长距离依赖。
  • 位置关联。

使用多个注意力头,可以让模型在不同的表示子空间中学习不同的关联模式。

12.2 多头计算

第 i 个 Head:

head_i= Attention( XW_i^Q, XW_i^K, XW_i^V )

多个 Head 分别计算后进行拼接:

MultiHead(Q,K,V)= Concat(head_1,\ldots,head_h)W^O

其中:

  • h:注意力头数量。
  • W_i^Q:第 i 个头的 Query 投影矩阵。
  • W_i^K:第 i 个头的 Key 投影矩阵。
  • W_i^V:第 i 个头的 Value 投影矩阵。
  • W^O:输出投影矩阵。

12.3 多头结构示意

flowchart TB
    A["输入 X"] --> B["Head 1"]
    A --> C["Head 2"]
    A --> D["Head 3"]
    A --> E["Head h"]

    B --> F["Concat"]
    C --> F
    D --> F
    E --> F

    F --> G["输出线性投影"]
    G --> H["Multi-Head Attention 输出"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49

12.4 多头维度计算

假设:

d_{model}=768
h=12

则每个 Head 的维度通常为:

d_k=d_v=\frac{768}{12}=64

各个 Head 的输出:

head_i\in\mathbb{R}^{n\times64}

拼接后:

Concat(head_1,\ldots,head_{12}) \in\mathbb{R}^{n\times768}

经过输出投影后,通常仍保持:

O\in\mathbb{R}^{n\times768}