机器学习08-Transfomer注意力机制

机器学习08-Transfomer注意力机制

• Transformer业务处理图
  

• Transformer在视觉领域的应用
  

1-核心逻辑脉络

• 1）常见的有哪几种注意力机制
• 2）每种注意力是如何计算的->
• 3）K、Q、V是什么鬼？过程是如何计算的
• 4）RNN的什么痛点和改进产生了Transfomer
• 5）局部窗口稀疏注意力原理->我只关注我的邻居，其他人我管不了一点
• 6）稀疏注意力掩码如何构建？
• 7）Wq、Wk、Wv 的权重矩阵->大模型训练结束之后，每个词对应的权重是固定的
• 8）Q、K、V向量并不是在大模型训练之后就定死了，而是在训练过程中根据数据动态学习得到的

2-参考网址

• 2分钟让你搞懂4种注意力是怎么计算：https://www.bilibili.com/video/BV12X6hYuE1m
• Transformer原理-自底向上解析：https://zhuanlan.zhihu.com/p/98650532
• 图解Transformer李宏毅：https://zhuanlan.zhihu.com/p/349569097
• 视觉Transformer发展比较：https://blog.csdn.net/u014636245/article/details/116333223
• 从零详细解读Transformer模型：https://www.bilibili.com/video/BV1fa411J7uJ
• Excel操作矩阵参考：https://www.bilibili.com/video/BV1b2421F7Xt
• 个人excel实现Transformer代码仓库：https://gitee.com/enzoism/transformer_excel.git

3-注意力Q、K、V计算-简化版

此时暂不考虑[权重矩阵 Wq、Wk、Wv]等扰动信息

在注意力机制中，稀疏通常指的是在计算过程中只关注部分元素，以减少计算量和内存消耗。下面以“我就是爱音乐”为例，假设每个词简化为10维的词向量，来详细说明Q、K、V每个词向量的计算过程。

1. 初始化词向量

首先，假设我们已经通过某种方式（如预训练模型或随机初始化）得到了“我”“是”“就”“爱”“音乐”这5个词的10维词向量，如下所示（这里仅为示例，实际值会有所不同）：

• 我：[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

• 是：[0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]

• 就：[0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]

• 爱：[0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3]

• 音乐：[0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4]

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

在注意力机制中，输入的词向量会通过线性变换得到Q（Query）、K（Key）、V（Value）三个矩阵。假设我们使用相同的线性变换矩阵Wq、Wk、Wv来分别得到Q、K、V，且这些矩阵也是10×10的（实际应用中，Q、K、V的维度可以不同）。这里简化假设Wq、Wk、Wv为单位矩阵，即输入向量不变，那么Q、K、V就和原始词向量相同：

• Q（查询矩阵）：

  • 我：[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

  • 是：[0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]

  • 就：[0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]

  • 爱：[0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3]

  • 音乐：[0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4]

• **K（键矩阵）和V（值矩阵）**与Q相同。

3. 计算注意力分数

对于输入序列中的每个词，通过计算其Query与所有词的Key的点积得到注意力分数。以“我”为例，计算其与序列中每个词的注意力分数：

• “我”与“我”：

  [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]= 3.85

• “我”与“是”：

  [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]= 4.2

以此类推，得到“我”与序列中所有词的注意力分数。

4. 归一化注意力分数

将得到的注意力分数通过softmax函数进行归一化，得到注意力权重。仍以“我”为例，假设其与序列中所有词的注意力分数分别为a1、a2、a3、a4、a5，那么归一化后的注意力权重为：

$
\text{softmax}(a_i) = \frac{\exp(a_i)}{\sum_{j=1}^{5} \exp(a_j)}
$

5. 加权求和得到输出

最后，使用归一化后的注意力权重对Value向量进行加权求和，得到“我”的最终输出向量。假设归一化后的注意力权重分别为w1、w2、w3、w4、w5，那么“我”的输出向量为：

$
\text{输出} = w1 \times \text{“我”的V} + w2 \times \text{“是”的V} + w3 \times \text{“就”的V} + w4 \times \text{“爱”的V} + w5 \times \text{“音乐”的V}
$

以上就是“我就是爱音乐”中每个词在注意力机制中Q、K、V的计算过程。需要注意的是，实际应用中线性变换矩阵Wq、Wk、Wv通常不是单位矩阵，而是通过训练得到的，且Q、K、V的维度也可以根据需要进行设置。

4-注意力Q、K、V计算过程

注意力机制中的稀疏性指的是在计算注意力分数时，模型倾向于只关注输入序列中的一小部分元素，而不是均匀地分配注意力到所有元素上。这种机制可以模拟人类如何在大量信息中聚焦于关键点。下面我将解释Q、K、V向量在稀疏注意力机制中是如何计算的。

在标准的注意力机制（例如Transformer模型中的自注意力）中，Q（查询）、K（键）和V（值）是通过线性变换从输入的词嵌入或隐藏状态得到的。然后，使用这些向量来计算注意力分数，通常采用缩放点积注意力：

1. 计算Q、K、V：

   • 对于每个位置i的输入向量x_i，我们有三个权重矩阵W_Q, W_K, W_V。
   • 通过线性变换获得Q、K、V向量：Q = x_i * W_Q, K = x_i * W_K, V = x_i * W_V。

2. 计算注意力分数：

   • 注意力分数通常是Q和K之间的点积，之后会除以根号下K的维度大小以稳定梯度，并应用softmax函数得到概率分布：attention_scores = softmax(Q * K^T / sqrt(d_k))。

3. 应用注意力分数到V：

   • 使用上述的概率分布加权求和V向量，得到输出O：O = attention_scores * V。

当引入稀疏性时，注意力机制可能会采取以下几种方式之一：

• 局部窗口：限制Q只能与一定范围内的K和V交互，例如只考虑相邻的几个词。这可以通过修改Q与K相乘的方式实现，比如只让Q与特定索引范围内的K相乘。

• 稀疏激活函数：使用特殊设计的激活函数，使得大多数注意力分数接近于零，只有少数显著非零，这样就实现了稀疏化。

• 稀疏连接：直接在架构层面定义哪些Q-K对应该有连接，哪些不应该。例如，在某些结构中，可能只允许句子中的某些特定位置之间形成注意力关系。

• 阈值剪枝：在计算完注意力分数后，应用一个阈值，低于这个阈值的分数被设为零，从而强制实现稀疏性。

具体的稀疏注意力机制取决于所使用的模型及其设计选择。不同的方法可能会结合以上策略中的一个或多个来实现稀疏性，目的是提高计算效率和/或增强模型的表现力。

5-局部窗口稀疏注意力原理

为了提供一个具体的稀疏注意力机制的示例，我们可以考虑一个简化版本的局部窗口（Local Window）稀疏注意力。这个例子将展示在一个句子中，每个词只关注它周围的几个词，而不是整个句子中的所有词。

假设我们有一个输入序列，由5个单词组成：[W1, W2, W3, W4, W5]。我们将使用一个大小为3的局部窗口，这意味着对于任何给定的词Wi，它只能与自身以及其左右各一个位置上的词形成注意力关系。这里我们不讨论Q、K、V的具体计算方式，而是直接给出稀疏性如何影响注意力矩阵。

步骤1: 定义局部窗口

• 对于W1，它可以关注自己和右侧的一个词：[W1, W2]
• 对于W2，它可以关注左侧的一个词、自己和右侧的一个词：[W1, W2, W3]
• 对于W3，它可以关注左侧的一个词、自己和右侧的一个词：[W2, W3, W4]
• 对于W4，它可以关注左侧的一个词、自己和右侧的一个词：[W3, W4, W5]
• 对于W5，它可以关注左侧的一个词和自己：[W4, W5]

步骤2: 构建稀疏注意力掩码

接下来，我们需要构建一个掩码矩阵，用来指示哪些位置应该参与注意力计算，哪些不应该。在这个例子中，我们将创建一个5x5的掩码矩阵，其中1表示可以参与注意力计算，0表示不能：

Mask = 
[[1, 1, 0, 0, 0],
 [1, 1, 1, 0, 0],
 [0, 1, 1, 1, 0],
 [0, 0, 1, 1, 1],
 [0, 0, 0, 1, 1]]

步骤3: 应用掩码到注意力分数

在计算注意力分数时，我们会先计算出完整的注意力分数矩阵，然后应用上述的掩码矩阵。这可以通过简单的元素级乘法来实现，即只有当掩码为1的地方，注意力分数才保留；否则被设为负无穷或非常小的数，这样在经过softmax函数后，这些位置的权重就会接近于零。

步骤4: 计算输出

最后，使用处理后的注意力分数对V向量加权求和得到输出O。由于我们已经应用了掩码，所以实际上每个词只会受到局部窗口内其他词的影响。

这种局部窗口的方法不仅减少了计算复杂度（因为不是所有Q-K对都进行计算），还引入了一种形式的稀疏性，模拟了人类阅读文本时的局部上下文理解模式。请注意，实际实现可能会更复杂，并且可能结合其他技术如多头注意力等以增强模型性能。

6-局部窗口稀疏注意力计算

好的，让我们基于之前的局部窗口稀疏注意力机制的示例，具体化注意力分数的计算过程。为了简化说明，我们假设每个词向量Q、K、V已经通过线性变换得到，并且维度为d_k=2（实际应用中维度通常会更大）。我们将使用缩放点积注意力作为计算注意力分数的方法。

假设输入：

• 输入序列：[W1, W2, W3, W4, W5]
• 每个单词对应的Q、K、V向量（随机生成，用于演示）：
  • Q = [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8], [0.9, 1.0]]
  • K = [[0.2, 0.3], [0.4, 0.5], [0.6, 0.7], [0.8, 0.9], [1.0, 1.1]]
  • V = [[0.3, 0.4], [0.5, 0.6], [0.7, 0.8], [0.9, 1.0], [1.1, 1.2]]

步骤1: 计算Q与K的点积

首先，根据局部窗口规则，我们只计算特定位置之间的Q和K的点积。对于每个查询词Wi，我们只计算它能关注到的键Kj的点积。

例如，对于W1，我们只计算Q1与K1和K2的点积；对于W2，我们计算Q2与K1、K2和K3的点积，依此类推。

Q1·K1 = 0.1*0.2 + 0.2*0.3 = 0.1
Q1·K2 = 0.1*0.4 + 0.2*0.5 = 0.14
...
Q5·K4 = 0.9*0.8 + 1.0*0.9 = 1.62
Q5·K5 = 0.9*1.0 + 1.0*1.1 = 2.0

步骤2: 应用缩放因子

接下来，我们将点积结果除以根号下K的维度大小sqrt(d_k)，在这个例子中是sqrt(2)≈1.414。

scaled_Q1·K1 = 0.1 / 1.414 ≈ 0.0707
scaled_Q1·K2 = 0.14 / 1.414 ≈ 0.0990
...
scaled_Q5·K4 = 1.62 / 1.414 ≈ 1.1457
scaled_Q5·K5 = 2.0 / 1.414 ≈ 1.4142

步骤3: 应用掩码并计算softmax

然后，我们创建一个5x5的注意力分数矩阵，其中只有允许的位置被填入上述计算的结果，其他位置填充为负无穷(-inf)或非常小的数，这样在softmax之后这些位置的权重将接近于零。

Attention_scores_before_softmax =
[[0.0707, 0.0990, -inf, -inf, -inf],
 [0.2121, 0.3536, 0.4950, -inf, -inf],
 [-inf, 0.4330, 0.5745, 0.7160, -inf],
 [-inf, -inf, 0.6325, 0.7740, 0.9154],
 [-inf, -inf, -inf, 0.8285, 1.4142]]

现在对每一行应用softmax函数，这将使得每行的元素变成一个概率分布，表示该位置上的词对其他词的关注度。

Attention_scores_after_softmax =
[[exp(0.0707)/Z1, exp(0.0990)/Z1, 0, 0, 0],
 [exp(0.2121)/Z2, exp(0.3536)/Z2, exp(0.4950)/Z2, 0, 0],
 [0, exp(0.4330)/Z3, exp(0.5745)/Z3, exp(0.7160)/Z3, 0],
 [0, 0, exp(0.6325)/Z4, exp(0.7740)/Z4, exp(0.9154)/Z4],
 [0, 0, 0, exp(0.8285)/Z5, exp(1.4142)/Z5]]

这里Z1, Z2, …, Z5分别是各行元素的指数求和，确保每行加起来等于1。

步骤4: 计算输出

最后，我们使用上面得到的注意力分数来对V向量进行加权求和，从而得到最终的输出O。例如，对于W1来说：

O1 = Attention_scores_after_softmax[0][0]*V1 + Attention_scores_after_softmax[0][1]*V2

同样的方法可以应用于其他词的输出计算。这就是稀疏注意力机制中注意力分数的具体计算过程。请注意，在实际实现中，所有这些操作都会在矩阵运算中高效地执行，而不是逐个元素处理。

7-注意力Q、K、V计算-考虑权重

在注意力机制中，稀疏性并不直接与Q、K、V的计算方式相关，而是与注意力机制中的权重分布有关。注意力机制的基本流程包括查询（Q）、键（K）和值（V）的计算，以及通过这些向量来计算注意力分数和输出。下面我们将详细描述如何计算这些向量和注意力分数。

1. 初始化词向量

假设我们有一个句子 [我, 就, 是, 爱, 音, 乐]，每个词被表示为一个10维的向量。假设我们已经通过某种方式（如预训练模型或随机初始化）已经得到这些向量，如下所示：

核心就是调用embedding方法，每个字每次计算的结果都是相同的

我 = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
就 = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]
是 = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4]
爱 = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1]
音 = [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2]
乐 = [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3]

2. 计算Q、K、V

Q、K、V是通过词向量与权重矩阵 Wq、Wk、Wv 相乘得到的。假设 Wq、Wk、Wv 都是 10x10 的矩阵，我们可以随机初始化这些矩阵：

Wq = [
  [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
  [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1],
  [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4],
  [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1],
  [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2],
  [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3],
  [0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9, 0.8, 0.7],
  [0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
  [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9],
  [0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
]

Wk = [
  [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1],
  [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
  [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1],
  [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2],
  [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3],
  [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4],
  [0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9, 0.8, 0.7],
  [0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
  [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9],
  [0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
]

Wv = [
  [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
  [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1],
  [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1],
  [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2],
  [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.1, 0.2, 0.3, 0.4],
  [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4],
  [0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9, 0.8, 0.7],
  [0.7, 0.8, 0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
  [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1.0, 0.9],
  [0.9, 1.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
]

3. 计算Q、K、V

对于每个词向量，我们通过与 Wq、Wk、Wv 相乘来计算 Q、K、V 向量。例如，对于词“我”：

Q我 = 我 * Wq = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * Wq
K我 = 我 * Wk = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * Wk
V我 = 我 * Wv = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * Wv

4. 计算注意力分数

注意力分数通过计算 Q 和 K 的点积来得到。对于每个词，我们计算它与其他词的注意力分数：

注意力分数 = softmax(Q我 * K我^T / sqrt(d_k))

其中 d_k 是 Q 和 K 的维度（这里是10），softmax 用于归一化注意力分数。

5. 计算输出

最后，使用注意力分数对 V 向量进行加权求和，得到输出：

输出 = 注意力分数 * V我

6. Wq、Wk、Wv 的性质

Wq、Wk、Wv 是模型在训练过程中学习到的参数。在训练完成后，这些矩阵是固定的，不会在推理阶段改变。它们的值是通过反向传播算法优化得到的，用于在推理阶段生成 Q、K、V 向量。

总结

• Q、K、V 的计算是通过词向量与权重矩阵 Wq、Wk、Wv 相乘得到的。
• 注意力分数是通过 Q 和 K 的点积计算的。
• Wq、Wk、Wv 是在训练过程中学习到的参数，训练完成后是固定的。

通过上述步骤，我们可以得到每个词的 Q、K、V 向量，并计算出注意力机制的输出。

8-稀疏注意力掩码如何进行构建？

稀疏注意力机制通过减少计算注意力分数时的全连接操作，提高模型的计算效率和可扩展性。稀疏注意力掩码（Sparse Attention Mask）用于指导哪些位置之间需要计算注意力分数，哪些位置不需要计算。这可以通过多种方式实现，常见的稀疏注意力掩码构建方法包括局部注意力、轴向注意力和稀疏因子分解等。

1. 局部注意力（Local Attention）

局部注意力机制仅计算每个词与其附近的词之间的注意力分数，而不是所有词之间的注意力分数。这可以通过滑动窗口的方式实现。

构建过程

1. 定义窗口大小：假设窗口大小为 w，表示每个词仅与其前后 w 个词进行注意力计算。
2. 构建掩码矩阵：对于句子 [我, 就, 是, 爱, 音, 乐]，假设窗口大小为 2，构建掩码矩阵 mask，其中 1 表示需要计算注意力分数，0 表示不需要计算。

mask = [
  [1, 1, 0, 0, 0, 0],  # "我" 只与 "我" 和 "就" 计算
  [1, 1, 1, 0, 0, 0],  # "就" 只与 "我", "就", "是" 计算
  [0, 1, 1, 1, 0, 0],  # "是" 只与 "就", "是", "爱" 计算
  [0, 0, 1, 1, 1, 0],  # "爱" 只与 "是", "爱", "音" 计算
  [0, 0, 0, 1, 1, 1],  # "音" 只与 "爱", "音", "乐" 计算
  [0, 0, 0, 0, 1, 1]   # "乐" 只与 "音", "乐" 计算
]

2. 轴向注意力（Axial Attention）

轴向注意力机制将输入序列拆分为多个轴，并在每个轴上独立应用注意力机制。这可以减少计算复杂度，同时保持模型的表达能力。

构建过程

1. 定义轴：假设我们将句子 [我, 就, 是, 爱, 音, 乐] 拆分为两个轴，每个轴包含 3 个词。
2. 构建掩码矩阵：对于每个轴，构建局部注意力掩码，然后将这些掩码组合起来。

轴1: [我, 就, 是]
轴2: [爱, 音, 乐]

掩码1 = [
  [1, 1, 0],  # "我" 只与 "我" 和 "就" 计算
  [1, 1, 1],  # "就" 只与 "我", "就", "是" 计算
  [0, 1, 1]   # "是" 只与 "就", "是" 计算
]

掩码2 = [
  [1, 1, 0],  # "爱" 只与 "爱" 和 "音" 计算
  [1, 1, 1],  # "音" 只与 "爱", "音", "乐" 计算
  [0, 1, 1]   # "乐" 只与 "音", "乐" 计算
]

组合后的掩码 = [
  [1, 1, 0, 0, 0, 0],
  [1, 1, 1, 0, 0, 0],
  [0, 1, 1, 0, 0, 0],
  [0, 0, 0, 1, 1, 0],
  [0, 0, 0, 1, 1, 1],
  [0, 0, 0, 0, 1, 1]
]

3. 稀疏因子分解（Sparse Factorization）

稀疏因子分解将注意力机制分解为多个稀疏的子矩阵，每个子矩阵只计算部分位置之间的注意力分数。

构建过程

1. 定义因子分解：假设我们将注意力矩阵分解为两个稀疏矩阵 A 和 B，每个矩阵只计算部分位置之间的注意力分数。
2. 构建掩码矩阵：对于每个稀疏矩阵，定义其掩码矩阵，然后将这些掩码矩阵组合起来。

A = [
  [1, 1, 0, 0, 0, 0],
  [0, 1, 1, 0, 0, 0],
  [0, 0, 1, 1, 0, 0],
  [0, 0, 0, 1, 1, 0],
  [0, 0, 0, 0, 1, 1],
  [0, 0, 0, 0, 0, 1]
]

B = [
  [1, 0, 0, 0, 0, 0],
  [1, 1, 0, 0, 0, 0],
  [0, 1, 1, 0, 0, 0],
  [0, 0, 1, 1, 0, 0],
  [0, 0, 0, 1, 1, 0],
  [0, 0, 0, 0, 1, 1]
]

组合后的掩码 = A * B

总结

稀疏注意力掩码通过减少计算量来提高模型的效率。常见的稀疏注意力掩码构建方法包括局部注意力、轴向注意力和稀疏因子分解。选择哪种方法取决于具体的应用场景和模型需求。通过合理的稀疏掩码设计，可以在保持模型表现的同时，显著提高计算效率。

9-Q、K、V对应的权重矩阵 Wq、Wk、Wv，请问每个权重矩阵在大模型中针对每一个词是固定的吗？

在注意力机制中，Wq、Wk、Wv 是权重矩阵，用于将输入的词向量投影到查询（Query）、键（Key）和值（Value）空间。这些权重矩阵是模型参数，在训练过程中学习得到，并且在训练完成后是固定的。

对于所有词，Wq、Wk、Wv 是共享的，也就是说，这些权重矩阵是模型的一部分，不针对每一个词单独设定。具体来说：

• 共享参数：在标准的自注意力机制中，Wq、Wk、Wv 是全局共享的权重矩阵，适用于序列中的所有词。这意味着，对于序列中的每个词，都使用相同的Wq、Wk、Wv来计算其 Q、K、V 向量。

• 独立计算：尽管权重矩阵是共享的，但每个词的 Q、K、V 向量是独立计算的，因为它们是通过各自的词向量与权重矩阵相乘得到的。

例如，假设我们的输入序列有三个词：A、B、C，每个词有一个10维的词向量。权重矩阵Wq、Wk、Wv都是10x10的矩阵。

• 对于词A：

Q_A = 词向量A * Wq

K_A = 词向量A * Wk

V_A = 词向量A * Wv

• 对于词B：

Q_B = 词向量B * Wq

K_B = 词向量B * Wk

V_B = 词向量B * Wv

• 对于词C：

Q_C = 词向量C * Wq

K_C = 词向量C * Wk

V_C = 词向量C * Wv

在这个过程中，Wq、Wk、Wv 对于所有词都是相同的，只是与不同的词向量相乘，得到不同的 Q、K、V 向量。

总结

• Wq、Wk、Wv 是模型的参数，在训练过程中学习得到，并在训练完成后固定。
• 这些权重矩阵是共享的，适用于序列中的所有词。
• 每个词的 Q、K、V 向量是通过其词向量与这些共享权重矩阵相乘得到的。

10-Excel实现QKV计算过程

个人excel实现提交代码仓库：https://gitee.com/enzoism/transformer_excel.git

核心两步计算：【QKV矩阵乘积】+【注意力得分】

1-【QKV矩阵乘积】

2-【注意力得分】