NLP:Transformer之self-attention（特别分享3）

本文目录：

• 一、核心思想：一句话概括
• 二、计算流程的直观比喻
• 三、分步计算详解（附数字例子）
• • [第 1 步：创建 Query, Key, Value 向量](#第 1 步：创建 Query, Key, Value 向量)
  • [第 2 步：计算注意力分数](#第 2 步：计算注意力分数)
  • [第 3 步：缩放并应用 Softmax](#第 3 步：缩放并应用 Softmax)
  • [第 4 步：与 Value 向量加权求和，得到输出](#第 4 步：与 Value 向量加权求和，得到输出)
• 四、矩阵运算：实际是如何计算的
• [五、为什么 Self-Attention 如此强大？](#五、为什么 Self-Attention 如此强大？)
• • • 总结

前言 ：之前讲解了Transformer各部分作用、残差等，本文分享self-attention。

一、核心思想：一句话概括

Self-Attention 的核心思想是：让序列中的每一个词（元素）都能够"关注"到序列中的所有其他词（包括它自己），并根据相关性动态地聚合所有词的信息，从而得到一个新的、融入了全局上下文信息的表示。

简单比喻：

读一句话时，为了理解某个词的含义，你的大脑会自动地回顾句子中的其他词，并赋予它们不同的重要性。Self-Attention 就是让机器模拟这个过程。

• 理解"它"这个词时，你会更关注句子前面提到的某个名词（比如"苹果"）。
• 理解"好吃"这个词时，你会更关注"苹果"而不是"石头"。

二、计算流程的直观比喻

我们把 Self-Attention 想象成一个信息检索系统：

1. 准备阶段（Input Processing） ：每个词都把自己改造成三份身份：查询（Query） 、键（Key） 、值（Value）。
2. 检索阶段（Attention Scoring） ：
   • 一个词（通过它的 Query ）去"询问"序列中的所有词（它们的 Key）："我和你们每个人的相关度是多少？"
   • 通过计算 Q·K 得到一组相关度分数（Attention Scores）。
3. 加权求和阶段（Output） ：
   • 将这些相关度分数作为权重，对所有词的 Value（实际携带的信息）进行加权求和。
   • 最终输出：一个融合了全局信息的、新的词表示。

最终效果 ：每个词的新表示，不再是它孤立的嵌入向量，而是一个深知全局上下文的"社交达人"。

---

三、分步计算详解（附数字例子）

假设我们有一个简单的序列："Thinking Machines"，两个词。它们的初始嵌入向量（假设维度为 4）为：
x₁ = [1, 0, 1, 0] (代表 "Thinking")
x₂ = [0, 2, 0, 2] (代表 "Machines")

第 1 步：创建 Query, Key, Value 向量

每个输入向量 x_i 会分别乘以三个可训练的权重矩阵 W^Q, W^K, W^V，从而产生对应的 Q, K, V 向量。

假设我们的权重矩阵是：

W^Q = [[1, 0, 1, 0],
       [0, 1, 0, 1],
       [1, 0, 0, 1],
       [0, 1, 1, 0]]

W^K = [[0, 1, 1, 0],
       [1, 0, 0, 1],
       [0, 0, 1, 1],
       [1, 1, 0, 0]]

W^V = [[1, 1, 0, 0],
       [0, 1, 1, 0],
       [0, 0, 1, 1],
       [1, 0, 0, 1]]

计算第一个词 "Thinking" 的 Q, K, V：
q₁ = x₁ · W^Q = [1,0,1,0] · W^Q = [2, 0, 2, 0]
k₁ = x₁ · W^K = [1,0,1,0] · W^K = [0, 2, 2, 0]
v₁ = x₁ · W^V = [1,0,1,0] · W^V = [1, 1, 1, 1]

同理，计算 "Machines" 的 Q, K, V：
q₂ = x₂ · W^Q = [0,2,0,2] · W^Q = [0, 4, 0, 4]
k₂ = x₂ · W^K = [0,2,0,2] · W^K = [4, 0, 4, 0]
v₂ = x₂ · W^V = [0,2,0,2] · W^V = [2, 2, 2, 2]

关键 ：W^Q, W^K, W^V 是模型需要学习的参数，它们决定了如何从原始输入中解读出"要查询什么"、"用什么来被查询"、"实际信息是什么"。

第 2 步：计算注意力分数

我们现在计算 "Thinking" （Query）对序列中每个词（Key）的注意力分数。分数通过 Query 和 Key 的点积计算。

score₁₁ = q₁ · k₁ = [2,0,2,0] · [0,2,2,0] = 0*2 + 2*0 + 2*2 + 0*0 = 4 (Thinking 与自身的相关性)
score₁₂ = q₁ · k₂ = [2,0,2,0] · [4,0,4,0] = 2*4 + 0*0 + 2*4 + 0*0 = 16 (Thinking 与 Machines 的相关性)

第 3 步：缩放并应用 Softmax

1. 缩放（Scale） ：点积的结果可能很大，导致 Softmax 梯度变小。因此除以 Key 向量维度（d_k）的平方根进行缩放。这里 d_k=4，平方根是 2。
   scale_score₁₁ = 4 / 2 = 2
scale_score₁₂ = 16 / 2 = 8

2. Softmax ：将分数转换为概率分布（总和为1），使得大的分数更大，小的分数更小。
   softmax([2, 8]) ≈ [0.012, 0.988]

   解读：对于 "Thinking" 这个词来说，它认为 "Machines" 的信息（0.988）远比它自己的信息（0.012）重要得多！

第 4 步：与 Value 向量加权求和，得到输出

将 Softmax 得到的权重作用在所有词的 Value 向量上，并求和，得到 "Thinking" 位置的新表示 z₁。

z₁ = 0.012 * v₁ + 0.988 * v₂ ≈ 0.012*[1,1,1,1] + 0.988*[2,2,2,2] ≈ [1.97, 1.97, 1.97, 1.97]

这个新的 z₁ 向量就是 "Thinking" 经过自注意力机制处理后的输出。它几乎完全由 "Machines" 的信息构成，这非常合理，因为 "Thinking Machines" 是一个整体概念。

对 "Machines" 重复步骤 2-4，可以计算出 z₂。

---

四、矩阵运算：实际是如何计算的

上述过程是为了理解，实际代码中是用矩阵一次算完的，极其高效。

1. 将所有输入词向量堆叠成矩阵 X。
2. 计算 Q, K, V 矩阵：
   Q = X · W^Q
K = X · W^K
V = X · W^V
3. 计算注意力分数矩阵：Scores = Q · K^T / sqrt(d_k)
4. 对 Scores 矩阵的每一行应用 Softmax。
5. 计算输出矩阵 Z：Z = Softmax(Scores) · V

整个过程可以封装为一个漂亮的公式：
Attention(Q, K, V) = softmax(QK^T / √dₖ) V

---

五、为什么 Self-Attention 如此强大？

1. 全局依赖性：一步直接捕获序列中任意两个位置之间的关系，不受距离限制。解决了 RNN 的长程依赖问题。
2. 并行化：巨大的矩阵乘法可以完全并行计算，训练速度远快于必须顺序计算的 RNN。
3. 可解释性 ：通过分析注意力权重（softmax(QK^T)），我们可以直观地看到模型在做决策时关注了哪些词，如图：

总结

Self-Attention 是一个精巧的"信息检索与聚合"系统。它通过 Query、Key、Value 的抽象，让模型能够动态地、有选择地融合序列的全局信息，从而为每个位置生成一个上下文感知的强大表示。它是 Transformer 能够统治 NLP 乃至整个深度学习领域的基石。

本文分享到此结束。