Selfattention(自注意力机制)

作者: CBlair

self-attention是什么?

  一个 self-attention 模块接收 n 个输入,然后返回 n 个输出。自注意力机制让每个输入都会彼此交互(自),然后找到它们应该更加关注的输入(注意力)。自注意力模块的输出是这些交互的聚合和注意力分数。

  self-attention模块包括以下步骤:

  1. 准备输入
  2. 初始化权重
  3. 推导key, query 和 value
  4. 计算输入1 的注意力得分
  5. 计算 softmax
  6. 将分数与值相乘
  7. 将权重值相加,得到输出 1
  8. 对输入 2 和输入 3 重复步骤 4-7

第一步:准备输入

    

                    图1.1: 准备输入

  假设有 3 个输入,每个输入的维度为 4.

```
  Input 1: [1, 0, 1, 0] 
  Input 2: [0, 2, 0, 2]
  Input 3: [1, 1, 1, 1]

第二步:初始化权重

  每个输入必须有 3 个表征,分别被称为键(key,橙色)、查询(query,红色)和值(value,紫色)。在此示例中,们设这些表征的维度为 3。因为每个输入的维度为 4,所以这意味着每组权重的形状为 4×3。

    

        图1.2:从每个输入得出键、查询和值的表示

  为了得到这些表征,每个输入(绿色)都要与一组键的权重、一组查询的权重、一组值的权重相乘。在这个示例中,们按如下方式初始化这三个权重:{1632641978360}

  键的权重:

```
`[[0, 0, 1],  [1, 1, 0],  [0, 1, 0],  [1, 1, 0]]`

  查询的权重:

```
`[[1, 0, 1],  [1, 0, 0],  [0, 0, 1],  [0, 1, 1]]`

  值的权重:

```
`[[0, 2, 0],  [0, 3, 0],  [1, 0, 3],  [1, 1, 0]]`

  备注:在神经网络设置中,这些权重通常是较小的数值,初始化也是使用合适的随机分布来实现,比如高斯分布、Xavier 分布、Kaiming 分布。

第三步:推导键、查询和值

  现在们有三组权重了,们来实际求取每个输入的键、查询和值的表征:

  输入 1 的键表征:

```
`               [0, 0, 1] [1, 0, 1, 0] x [1, 1, 0] = [0, 1, 1]                [0, 1, 0]                [1, 1, 0]`

   使用同样一组权重求取输入 2 的键表征:

```
`    [0, 0, 1] [0, 2, 0, 2] x [1, 1, 0] = [4, 4, 0]                [0, 1, 0]                [1, 1, 0]`

  使用同样一组权重求取输入 3 的键表征:

```
`  [0, 0, 1] [1, 1, 1, 1] x [1, 1, 0] = [2, 3, 1]                [0, 1, 0]                [1, 1, 0]`

  向量化以上运算能实现更快的速度:

```
`               [0, 0, 1] [1, 0, 1, 0]   [1, 1, 0]   [0, 1, 1] [0, 2, 0, 2] x [0, 1, 0] = [4, 4, 0] [1, 1, 1, 1]   [1, 1, 0]   [2, 3, 1]`

    

              图1.3a:从每个输入推导出键表示

  通过类似的方式,们求取每个输入的值表征:

```
`               [0, 2, 0] [1, 0, 1, 0]   [0, 3, 0]   [1, 2, 3]  [0, 2, 0, 2] x [1, 0, 3] = [2, 8, 0] [1, 1, 1, 1]   [1, 1, 0]   [2, 6, 3]`

    

              图1.3b:从每个输入推导出值表示

  最后还有查询表征:

```
`               [1, 0, 1] [1, 0, 1, 0]   [1, 0, 0]   [1, 0, 2] [0, 2, 0, 2] x [0, 0, 1] = [2, 2, 2] [1, 1, 1, 1]   [0, 1, 1]   [2, 1, 3]`

    

            图1.3b:从每个输入推导出查询表示

第四步:计算输入1 的 attention scores

    

             图1.4:从查询1中计算注意力得分(蓝色)

  为了获得注意力得分,们首先在输入1的查询(红色)和所有键(橙色)之间取一个点积。因为有3个键表示(因为有3个输入),们得到3个注意力得分(蓝色)。{1632645771613}

```
`            [0, 4, 2] [1, 0, 2] x [1, 4, 3] = [2, 4, 4]             [1, 0, 1]`

  注意这里仅使用了输入 1 的查询。后面们会为其它查询重复同一步骤。

  备注:上面的运算也被称为点积注意力(dot product attention),这是众多评分函数中的一个,其它评分函数还包括扩展式点积和 additive/concat

第五步:计算 softmax

    

               图1.5:Softmax注意力评分(蓝色)

  在所有注意力得分中使用softmax(蓝色)。

```
`softmax([2, 4, 4]) = [0.0, 0.5, 0.5]`

第六步:将分数与值相乘

    

        图1.6:由值(紫色)和分数(蓝色)的相乘推导出加权值表示(黄色)

  每个输入的softmaxed attention 分数(蓝色)乘以相应的值(紫色)。结果得到3个对齐向量(黄色)。在本教程中,们将它们称为加权值。{1632646066044}

```
`1: 0.0 * [1, 2, 3] = [0.0, 0.0, 0.0] 2: 0.5 * [2, 8, 0] = [1.0, 4.0, 0.0] 3: 0.5 * [2, 6, 3] = [1.0, 3.0, 1.5]`

第七步:将加权值相加得到输出1

    

        图1.7:将所有加权值(黄色)相加,得到输出1(深绿色)

  将所有加权值(黄色)按元素指向求和:

```
`  [0.0, 0.0, 0.0] + [1.0, 4.0, 0.0] + [1.0, 3.0, 1.5] ----------------- = [2.0, 7.0, 1.5]`

  所得到的向量 [2.0, 7.0, 1.5](深绿色)是输出 1,这是基于输入 1 的查询表征与所有其它键(包括其自身的)的交互而得到的。

第八步:为输入 2 和 3 重复 4-7 步骤

  现在已经完成了对输出 1 的求解,们再为输出 2 和输出 3 重复步骤 4-7。

    

        图1.8:对输入2和输入3重复前面的步骤

代码

步骤1:准备输入

import torch
x = [
[1, 0, 1, 0], Input 1
[0, 2, 0, 2], Input 2
[1, 1, 1, 1] Input 3
]
x = torch.tensor(x, dtype=torch.float32)

步骤2:初始化权重

w_key = [
[0, 0, 1],
[1, 1, 0],
[0, 1, 0],
[1, 1, 0]
]
w_query = [
[1, 0, 1],
[1, 0, 0],
[0, 0, 1],
[0, 1, 1]
]
w_value = [
[0, 2, 0],
[0, 3, 0],
[1, 0, 3],
[1, 1, 0]
]
w_key = torch.tensor(w_key, dtype=torch.float32)
w_query = torch.tensor(w_query, dtype=torch.float32)
w_value = torch.tensor(w_value, dtype=torch.float32)

步骤3: 推导键、查询和值

keys = x @ w_key
querys = x @ w_query
values = x @ w_value

print(keys)
tensor([[0., 1., 1.],
[4., 4., 0.],
[2., 3., 1.]])

print(querys)
tensor([[1., 0., 2.],
[2., 2., 2.],
[2., 1., 3.]])

print(values)
tensor([[1., 2., 3.],
[2., 8., 0.],
[2., 6., 3.]])

步骤4:计算注意力得分

attn_scores = querys @ keys.T
tensor([[ 2., 4., 4.], attention scores from Query 1
[ 4., 16., 12.], attention scores from Query 2
[ 4., 12., 10.]]) attention scores from Query 3

步骤5:计算softmax

from torch.nn.functional import softmax
attn_scores_softmax = softmax(attn_scores, dim=-1)
tensor([[6.3379e-02, 4.6831e-01, 4.6831e-01],
[6.0337e-06, 9.8201e-01, 1.7986e-02],
[2.9539e-04, 8.8054e-01, 1.1917e-01]])

For readability, approximate the above as follows
attn_scores_softmax = [
[0.0, 0.5, 0.5],
[0.0, 1.0, 0.0],
[0.0, 0.9, 0.1]
]
attn_scores_softmax = torch.tensor(attn_scores_softmax)

步骤6:将得分和值相乘

weighted_values = values[:,None] * attn_scores_softmax.T[:,:,None]

tensor([[[0.0000, 0.0000, 0.0000],
[0.0000, 0.0000, 0.0000],
[0.0000, 0.0000, 0.0000]],

[[1.0000, 4.0000, 0.0000],
[2.0000, 8.0000, 0.0000],
[1.8000, 7.2000, 0.0000]],

[[1.0000, 3.0000, 1.5000],
[0.0000, 0.0000, 0.0000],
[0.2000, 0.6000, 0.3000]]])

步骤7:求和加权值

outputs = weighted_values.sum(dim=0)

tensor([[2.0000, 7.0000, 1.5000], Output 1
[2.0000, 8.0000, 0.0000], Output 2
[2.0000, 7.8000, 0.3000]]) Output 3

原文创作:CBlair

原文链接:https://www.cnblogs.com/BlairGrowing/p/15338310.html

更多推荐

更多
  • AWS自动化机器学习-十一、MLSDLC 的持续集成、部署和训练 技术要求,编纂持续集成阶段,管理持续部署阶段,管理持续训练,延伸,构建集成工件,构建测试工件,构建生产工件,自动化持续集成流程,回顾构建阶段,回顾测试阶段,审查部署和维护阶段,回顾应用用户体验,创建新的鲍鱼调查数据,回顾持续训练流程,清
    Apache CN

  • AWS自动化机器学习-六、使用 AWS 步骤函数自动化机器学习过程 技术要求,介绍 AWS 步骤功能,使用 Step 函数 Data Science SDK for CI/CD,建立 CI/CD 渠道资源,创建状态机,解决状态机的复杂性,更新开发环境,创建管道工件库,构建管道应用构件,部署 CI/CD
    Apache CN

  • AWS自动化机器学习-第三部分:优化以源代码为中心的自动化机器学习方法 本节将向您介绍整体 CI/CD 流程的局限性,以及如何将 ML 从业者的角色进一步整合到管道构建流程中。本节还将介绍这种角色集成如何简化自动化过程,并通过向您介绍 AWS Step 函数向您展示一种优化的方法。本节包括以下章节:
    Apache CN

  • AWS自动化机器学习-一、AWS 上的自动化机器学习入门 技术要求,洗钱流程概述,洗钱过程的复杂性,端到端 ML 流程示例,AWS 如何使 ML 开发和部署过程更容易自动化,介绍 ACME 渔业物流,ML 的情况,从数据中获得洞察力,建立正确的模型,训练模型,评估训练好的模型,探索可能的后续步
    Apache CN

  • AWS自动化机器学习-二、使用 SageMaker 自动驾驶器自动化机器学习模型开发 技术要求,介绍 AWS AI 和 ML 前景,SageMaker 自动驾驶器概述,利用 SageMaker 自动驾驶器克服自动化挑战,使用 SageMaker SDK 自动化 ML 实验,SageMaker Studio 入门,准备实验
    Apache CN

  • AWS自动化机器学习-四、机器学习的持续集成和持续交(CI/CD) 四、机器学习的持续集成和持续交CI/CD技术要求,介绍 CI/CD 方法,通过 CI/CD 实现 ML 自动化,在 AWS 上创建 CI/CD 管道,介绍 CI/CD 的 CI 部分,介绍 CI/CD 的 CD 部分,结束循环,采取以部
    Apache CN

  • AWS自动化机器学习-九、使用 Amazon Managed Workflows 为 Apache AirFlow 构建 ML 工作流 技术要求,开发以数据为中心的工作流程,创建合成鲍鱼调查数据,执行以数据为中心的工作流程,构建和单元测试数据 ETL 工件,构建气流 DAG,清理, 在前面的年龄计算器示例中,我们了解了如何通过 ML 从业者和开发人员团队之间的跨职能
    Apache CN

  • AWS自动化机器学习-七、使用 AWS 步骤函数构建 ML 工作流 技术要求,构建状态机工作流,执行集成测试,监控管道进度,设置服务权限,创建 ML 工作流程, 在本章中,我们将从第六章中的 [处继续,使用 AWS 步骤函数自动化机器学习过程。您将从那一章中回忆起,我们正在努力实现的主要目标是简化
    Apache CN

  • AWS自动化机器学习-八、使用 Apache Airflow 实现机器学习过程的自动化 技术要求,介绍阿帕奇气流,介绍亚马逊 MWAA,利用气流处理鲍鱼数据集,配置 MWAA 系统的先决条件,配置 MWAA 环境, 当建立一个 ML 模型时,有一个所有 ML 从业者都知道的基本原则;也就是说,最大似然模型只有在数据被训练时
    Apache CN

  • AWS自动化机器学习-五、自动化 ML 模型的持续部署 技术要求,部署 CI/CD 管道,构建 ML 模型工件,执行自动化 ML 模型部署,整理管道结构,创建 CDK 应用,部署管道应用,查看建模文件,审查申请文件,查看模型服务文件,查看容器构建文件,提交 ML 工件,清理, 在 [第 4
    Apache CN

  • 近期文章

    更多
    文章目录

      推荐作者

      更多