【小白学AI系列】NLP 核心知识点（八）多头自注意力机制

文章目录

- - [**多头自注意力机制（Multi-Head Self-Attention）**](#多头自注意力机制（Multi-Head Self-Attention）)
  - - **核心概念**
  - [**1. 自注意力机制（Self-Attention）**](#1. 自注意力机制（Self-Attention）)
  - [**2. 多头机制（Multi-Head Attention）**](#2. 多头机制（Multi-Head Attention）)
  - [**3. 为什么要用多头注意力机制？**](#3. 为什么要用多头注意力机制？)
  - [**4. 公式总结**](#4. 公式总结)
  - [**5. 例子：如何理解多头自注意力机制？**](#5. 例子：如何理解多头自注意力机制？)
  - **6.自注意力机制的前提**
  - - [**1. 输入的表示形式：词嵌入**](#1. 输入的表示形式：词嵌入)
    - [**2. 线性变换得到 Q, K, V**](#2. 线性变换得到 Q, K, V)
    - [**3. 计算注意力权重：Query 和 Key 的相似度**](#3. 计算注意力权重：Query 和 Key 的相似度)
    - [**4. Softmax 归一化**](#4. Softmax 归一化)
  - **自注意力机制的关键步骤和公式**
  - **为什么要进行点积和转置操作？**

多头自注意力机制（Multi-Head Self-Attention）

多头自注意力机制是 Transformer 中最核心的部分，它使得模型能够同时从不同的子空间捕捉输入序列的不同上下文信息，从而更好地理解和处理复杂的关系。这个机制是 Transformer 相比传统 RNN 和 LSTM 模型最大的创新之一。

核心概念

自注意力机制的核心思想是：对于输入的每一个词，我们都计算它与其他所有词之间的关系，并用这些关系加权来更新词的表示。

1. 自注意力机制（Self-Attention）

在自注意力机制中，我们会计算每个单词对其他所有单词的"注意力"分数，然后根据这些分数加权所有单词的表示，得到每个单词的上下文相关表示。

计算步骤：

对输入的每个单词生成三个向量：查询（Query） 、键（Key）和值（Value）。
计算查询和键之间的相似度（通常是点积），用来衡量一个单词对其他单词的"关注"程度。
将这些相似度值进行softmax操作，得到每个单词对其他单词的注意力权重。
使用这些注意力权重对值（Value）进行加权求和，从而得到加权后的输出表示。

公式：
Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dk QKT)V

其中：

Q Q Q：查询向量（Query）
K K K：键向量（Key）
V V V：值向量（Value）
d k d_k dk：向量的维度，用于缩放相似度（防止值过大）

解释：

通过计算 查询（Q） 和 键（K） 之间的相似度，得到了每个词对其他词的关注度。
softmax 操作使得关注度的值变得更易于解释，变成了概率分布。
最终将这些权重应用到 值（V） 上，得到加权后的输出。

2. 多头机制（Multi-Head Attention）

多头自注意力机制 进一步将多个不同的自注意力机制并行化，每个注意力头关注输入的不同方面。通过多头机制，模型能够从多个子空间中学习不同的上下文关系，从而捕捉到更多的信息。

步骤：

输入的查询（Q）、键（K）、值（V）分别通过多个不同的线性变换，得到多个"头"。
每个头都有自己的自注意力计算，得到多个输出。
最后将多个头的输出拼接起来，并通过一个线性变换，得到最终的输出表示。

公式：
Multi-Head Attention ( Q , K , V ) = Concat ( head 1 , head 2 , ... , head h ) W O \text{Multi-Head Attention}(Q, K, V) = \text{Concat}(\text{head}_1, \text{head}_2, \dots, \text{head}_h) W^O Multi-Head Attention(Q,K,V)=Concat(head1,head2,...,headh)WO

其中：

head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) headi=Attention(QWiQ,KWiK,VWiV)
W i Q , W i K , W i V W_i^Q, W_i^K, W_i^V WiQ,WiK,WiV 是每个头的线性变换矩阵。
W O W^O WO是输出的线性变换矩阵。

解释：

每个**头（head）**是一个独立的自注意力机制，每个头学习不同的上下文信息。
最终，将多个头的输出拼接在一起，再通过一个线性层生成最终的输出。

3. 为什么要用多头注意力机制？

捕捉多样化信息：每个注意力头在学习过程中关注不同的上下文信息，能够从不同的角度理解序列之间的关系。例如，一个头可以关注句子中的语法关系，另一个头可以关注句子的语义。
提高模型的表达能力：通过多个注意力头，模型能同时处理来自不同子空间的信息，这增强了模型的表征能力。
提高模型的灵活性和鲁棒性：在实际应用中，不同任务可能需要捕捉不同层次的信息，多头注意力可以灵活地组合各个头的不同特点，从而提升性能。

4. 公式总结

最终的多头自注意力机制的计算过程是：
Multi-Head Attention ( Q , K , V ) = Concat ( head 1 , head 2 , ... , head h ) W O \text{Multi-Head Attention}(Q, K, V) = \text{Concat}(\text{head}_1, \text{head}_2, \dots, \text{head}_h) W^O Multi-Head Attention(Q,K,V)=Concat(head1,head2,...,headh)WO

其中每个头的计算公式为：
head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) headi=Attention(QWiQ,KWiK,VWiV)

并且：
Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dk QKT)V

5. 例子：如何理解多头自注意力机制？

假设我们有一个句子："我爱机器学习 "，并且想要计算"爱"这个词的自注意力。

第一步：生成查询、键、值
- 对于每个词，都生成查询（Q）、键（K）和值（V）向量。
第二步：计算查询和键的相似度
- 计算"爱"这个词的查询向量 Q 爱 Q_{\text{爱}} Q爱与其他词的键向量的相似度，得到一个相似度矩阵。
第三步：注意力分配
- 对这个相似度矩阵进行 softmax 归一化，得到每个词的权重。
第四步：加权值向量
- 使用这些权重来加权其他词的值向量，得到"爱"这个词的上下文表示。
多头计算
- 在多头机制中，模型会同时进行多个这样的计算，每个头关注不同的上下文关系，最终将所有头的结果拼接起来，生成"爱"这个词的综合表示。

没问题！让我们再从头开始，拆解这个公式背后的前置条件，慢慢引导你理解每一步。

6.自注意力机制的前提

自注意力机制（Self-Attention）是深度学习中用于序列数据处理的核心机制之一，尤其在处理文本、语言模型、机器翻译等任务时非常常见。为了能理解自注意力机制中的公式，我们首先要理解以下几个关键的前置条件：

1. 输入的表示形式：词嵌入

在自然语言处理中，文本首先会被转换成数值形式，通常使用 词嵌入（Word Embedding） 技术将词语转换为高维向量。假设我们有一个句子："猫吃鱼"，它被转换成词向量后，可能变成这样的矩阵：

X = $猫的向量吃的向量鱼的向量$ \mathbf{X} = \begin{bmatrix} \text{猫的向量} \\ \text{吃的向量} \\ \text{鱼的向量} \end{bmatrix} X= 猫的向量吃的向量鱼的向量

这个矩阵 ( \mathbf{X} ) 是我们输入给模型的词向量表示。

2. 线性变换得到 Q, K, V

接下来，为了应用自注意力机制，我们会通过线性变换（矩阵乘法）将输入矩阵 X \mathbf{X} X 分别转换为 查询向量（Query，Q） 、键向量（Key，K） 和 值向量（Value，V）。

Query（Q）：表示当前元素对其他元素的关注点。它类似于"询问"某个问题。
Key（K）：表示每个元素的特征。它类似于"标签"，帮助我们决定当前元素对哪些其他元素重要。
Value（V）：表示每个元素的具体信息。它包含了我们想要从当前元素中提取的内容。

通过以下线性变换，得到这些向量：

Q = X W q , K = X W k , V = X W v \mathbf{Q} = \mathbf{X} \mathbf{W_q}, \quad \mathbf{K} = \mathbf{X} \mathbf{W_k}, \quad \mathbf{V} = \mathbf{X} \mathbf{W_v} Q=XWq,K=XWk,V=XWv

其中， W q \mathbf{W_q} Wq W k \mathbf{W_k} Wk W v \mathbf{W_v} Wv 是学习到的权重矩阵。

3. 计算注意力权重：Query 和 Key 的相似度

接下来的步骤是计算 Query（Q） 和 Key（K） 之间的相似度，这就涉及到一个关键的计算：点积（Dot Product）。

为什么要计算 Query 和 Key 的相似度呢？因为我们希望知道对于当前的查询（Q），它应该关注哪些键（K）。点积越大，表示查询和键之间的相似度越高，也就是说，这个位置就应该更"重要"地被考虑。

4. Softmax 归一化

因为我们要将计算出的相似度转化为概率分布，使得所有的注意力权重之和为 1，我们会用 Softmax 函数对相似度进行归一化处理。

自注意力机制的关键步骤和公式

计算 Query 和 Key 的点积：

计算 Query（Q） 和 Key（K） 的点积，得到一个矩阵，这个矩阵表示每个 Query 和每个 Key 之间的相似度：

Scores = Q K T \text{Scores} = \mathbf{Q} \mathbf{K}^T Scores=QKT

这里的 K T \mathbf{K}^T KT代表 Key 矩阵的转置 。为什么要转置呢？这是因为我们要计算的是每个查询（Q）和所有键（K）之间的相似度。为了进行点积， Q \mathbf{Q} Q 的行和 ( \mathbf{K} ) 的列必须匹配。因此， K \mathbf{K} K的转置让它们的维度对齐。

缩放（Scaling）操作：

由于点积可能会变得非常大，尤其是在高维空间中，所以我们会对点积结果进行缩放。这个缩放的因子是 d k \sqrt{d_k} dk ，其中 d k d_k dk是 Key 向量的维度。这个缩放操作可以帮助缓解梯度爆炸和数值不稳定的问题。

Scores scaled = Q K T d k \text{Scores}_{\text{scaled}} = \frac{\mathbf{Q} \mathbf{K}^T}{\sqrt{d_k}} Scoresscaled=dk QKT

Softmax 归一化：

对缩放后的点积结果应用 Softmax 函数，确保每一行的注意力权重和为 1，使得它们能够作为概率分布：

Attention Weights = Softmax ( Q K T d k ) \text{Attention Weights} = \text{Softmax}\left(\frac{\mathbf{Q} \mathbf{K}^T}{\sqrt{d_k}}\right) Attention Weights=Softmax(dk QKT)

加权求和：

最后，我们将计算出的注意力权重与 Value（V） 矩阵相乘，得到加权的输出。每个位置的输出都由它的注意力权重决定，权重越大，影响越大：

Output = Attention Weights ⋅ V \text{Output} = \text{Attention Weights} \cdot \mathbf{V} Output=Attention Weights⋅V

为什么要进行点积和转置操作？

点积计算相似度 ：

点积可以用来衡量两个向量的相似度。对于每一个查询向量 Q i \mathbf{Q}_i Qi，我们都需要衡量它与所有键向量 K j \mathbf{K}_j Kj之间的相似度。通过计算点积，我们可以得出每个查询与所有键的相对"重要性"。
转置的作用 ：

转置操作是为了使得 K \mathbf{K} K 的 列向量 能与 Q \mathbf{Q} Q的 行向量 对齐，确保它们能进行点积运算。转置后的矩阵 K T \mathbf{K}^T KT 让我们能够计算出查询与每个键之间的相似度。