专栏首页AI科技大本营的专栏通俗易懂:8大步骤图解注意力机制

通俗易懂:8大步骤图解注意力机制

作者 | Raimi Karim

译者 | 夕颜

出品 | AI科技大本营(ID:rgznai100)

【导读】这是一份用图片和代码详解自注意力机制的指南,请收好。

BERT、RoBERTa、ALBERT、SpanBERT、DistilBERT、SesameBERT、SemBERT、MobileBERT、TinyBERT和CamemBERT的共同点是什么?答案并不是“ BERT”?。

而是“自注意力”?。我们不仅在讨论承载“ BERT” 的架构,更准确地说是基于 Transformer 的架构。基于 Transformer 的架构主要用于对语言理解任务进行建模,避免使用神经网络中的递归,而是完全信任自注意力在输入和输出之间绘制全局依赖性的机制。但是,这背后的数学原理是什么?

这就是我们今天要探讨的。这篇文章的主要内容是带你了解自注意力模块中涉及的数学运算。读完这篇文章,你应该就能够从零开始编写一个自注意力模块了。

本文的目的不是要解释自注意力模块中的不同数字表示形式和数学运算,也不是为了证明Transfomer 中自注意的原因和精确程度(我相信已经有很多相关资料了)。请注意,本文也没有详细介绍注意力和自注意力之间的区别。

内容大纲

  1. 图解
  2. 代码
  3. 拓展到 Transformer

现在开始吧!

0.什么是自注意力?

你可能会想,自注意力是否类似于注意力,答案是肯定的!它们从根本上来说概念和数学运算很多都是相通的。

自注意模块接收 n 个输入,并返回 n 个输出。这个模块会发生什么?用外行的话说,自关注机制允许输入之间彼此交互(“自我”)并找出它们应该给哪些对象更多注意力(“关注”)。输出是这些交互作用和注意力得分的聚合。

1.图解

图解分为以下步骤:

  1. 准备输入
  2. 初始化权重
  3. 派生密钥,查询和值
  4. 计算输入 1 的注意力得分
  5. 计算 softmax
  6. 将分数与值相乘
  7. 总和加权值以获得输出 1
  8. 对输入 2 和输入 3 重复步骤4–7

注意:实际上,数学运算是矢量化的,即所有输入都经过数学运算。我们稍后会在“代码”部分中看到这一点。

步骤1:准备输入

图 1.1:准备输入

在本教程中,我们从 3 个输入开始,每个输入的尺寸为 4。

输入1:[1,0,1,0]输入2:[0,2,0,2]输入3:[1,1,1,1] 

步骤2:初始化权重

每个输入必须具有三个表示形式(请参见下图)。这些表示形式称为键(橙色),查询(红色)和值(紫色)。对于此示例,让我们假设这些表示的尺寸为 3。因为每个输入的尺寸为 4,这意味着每组权重都必须为 4×3。

注意:我们稍后将看到值的维数也是输出的维数。

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

为了获得这些表示形式,每个输入(绿色)都将与一组键的权重,一组查询的权重(我知道这不是正确的拼写)和一组值的权重相乘。在我们的示例中,我们如下“初始化”三组权重。

键的权重:

[[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分布)随机初始化。

步骤3:派生键、查询和值

现在我们有了三组权重,让我们实际获取每个输入的键、查询和值表示形式。

输入 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.3c:从每个输入中派生查询表示

注意:实际上,可以将偏差向量添加到矩阵乘法的乘积中。

步骤4:计算输入 1 的注意力得分

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

为了获得注意力得分,我们首先在输入 1 的查询(红色)与所有键(橙色)(包括其自身)之间取一个点积。由于有 3 个关键表示(因为我们有3个输入),因此我们获得 3 个注意力得分(蓝色)。

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

注意,我们仅使用输入 1 的查询。稍后,我们将对其他查询重复相同的步骤。

注意:以上操作被称为点产品注意,它是几种评分功能其中之一。其他评分功能包括缩放点积和添加/合并数组。

步骤 5:计算 softmax

图 1.5:Softmax 注意分数(蓝色)

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

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

步骤6:将分数乘以值

图 1.6:从乘数值(紫色)和分数(蓝色)得出的加权值表示(黄色)

每个经过 softmax 的输入的最大注意力得分(蓝色)乘以其相应的值(紫色),得到 3 个对齐向量(黄色)。在本教程中,我们将它们称为加权值。

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]

步骤7:求和加权值以获得输出 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与所有其他键(包括其自身)交互的查询表示形式。

步骤 8:重复输入 2 和输入 3

既然我们已经完成了输出 1,我们将对输出 2 和输出 3 重复步骤 4 至 7。我相信你自己就可以操作??。

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

注意:由于点积分数功能,查询和键的维必须始终相同。但是,值的维数可能不同于 查询和键。结果输出将遵循值的维度。

2.代码

这是PyTorch?代码(https://pytorch.org/),PyTorch?是流行的 Python 深度学习框架。为了方便使用在以下代码段中索引中的@operator API、.T 和 None,请确保你使用的是Python≥3.6 和 PyTorch 1.3.1。只需将它们复制并粘贴到 Python / IPython REPL 或 Jupyter Notebook 中即可。

步骤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

注意:PyTorch 为此提供了一个 API nn.MultiheadAttention。但是,此 API 要求你输入键、查询并估算 PyTorch 张量。此外,该模块的输出经过线性变换。

3.扩展到 Transfomers

至此,我们接下来怎么做?Transfomers!确实,我们生活在深度学习研究和高计算资源令人兴奋的时代。Transfomers 是论文《Attention Is All You Need》的成果,最初是为了进行神经机器翻译而生。自此,研究人员开始进行组装、切割、添加和扩展,并将其用途扩展到更多的语言任务中。

在这里,我将简单提一下如何将自注意力扩展到 Transformer 架构中。

在自注意力模块中:

  • 尺寸
  • Bias

自注意力模块的输入:

  • 嵌入模块
  • 位置编码
  • 截断
  • 掩蔽

添加更多的自注意模块:

  • 多头
  • 层堆叠

自注意模块之间的模块:

  • 线性变换
  • 层范数

就是这些了朋友们!希望这篇文章对你来说简单易懂。如果还想看到更多内容,请评论区告诉我!

参考文献

Attention Is All You Need https://arxiv.org/abs/1706.03762

Transfomer 图解:https://jalammar.github.io/illustrated-transformer/(jalammar.github.io)

原文链接:

https://towardsdatascience.com/illustrated-self-attention-2d627e33b20a#9abf

(*本文为AI科技大本营翻译文章,转载请微信联系1092722531)

本文分享自微信公众号 - AI科技大本营(rgznai100)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-11-25

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 学网络编程前的计算机知识普及

    可能有朋友会好奇,前两天刚发布了数据结构,现在突然又发布网络编程,那此刻的我到底在学些神马?哈哈,我这学期的目标就是学数据结构和网络编程,至于学的先后,我想你应...

    泰斗贤若如
  • Pytest脚本中用例运行方式

    橙子探索测试
  • 在zabbix中实现发送带有图片的邮件和微信告警

    可以手动触发一个报警测试效果,手机上就可以收到带图的报警了,点击消息之后的页面也可以看到历史的图片

    没有故事的陈师傅
  • jenkins 凭证(Credentials)修改

    Jenkins是一个开源软件项目,是基于Java开发的一种[持续集成]工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能

    Anymarvel
  • R&Python Data Science 系列:数据处理(3)

    排序函数,按照某(几)个指定的列按照升(降)序排列重新排列数据集,参数ascending = False,降序排列,ascending = True,升...

    1480
  • Pytest全局用例共用之conftest.py详解

    1、可以跨.py文件调用,有多个.py文件调用时,可让conftest.py只调用了一次fixture,或调用多次fixture

    橙子探索测试
  • 计算机技术|我的第一个Flask程序

    Flask是目前十分流行的web框架,采用Python编程语言来实现相关功能。它被称为微框架(microframework),“微”并不是意味着把整个Web应用...

    算法与编程之美
  • 别找了,这是 Pandas 最详细教程了

    Python 是开源的,它很棒,但是也无法避免开源的一些固有问题:很多包都在做(或者在尝试做)同样的事情。如果你是 Python 新手,那么你很难知道某个特定任...

    昱良
  • 炒鸡简单,带你快速撸一遍Numpy代码!

    我们一起来学习Python数据分析的工具学习阶段,包括Numpy,Pandas以及Matplotlib,它们是python进行科学计算,数据处理以及可视化的重要...

    小小詹同学
  • dump和load怎么用?

    在写代码的时候,有的时候不知道什么时候用何种格式,字符串跟对象转换的时候,到底是用dump还是load.dumps或者loads, 每次都是蒙的,要么就去查,一...

    赵云龙龙

扫码关注云+社区

领取腾讯云代金券