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

通俗易懂：8⼤步骤图解注意⼒机制
【导读】这是⼀份⽤图⽚和代码详解⾃注意⼒机制的指南，请收好。

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
注意：我们稍后将看到值的维数也是输出的维数。

图 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 是流⾏的 Python 深度学习框架。

为了⽅便使⽤在以下代码段中索引中的@operator API、.T 和 None，请确保你使⽤的是Python≥3.6 和 PyTorch 1.3.1。

只需将它们步骤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, 步骤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.],
步骤4：计算注意⼒分数
attn_scores=*************#tensor([[2.,4.,4.],#attentionscoresfromQuery1#[4.,16.,12.],#attentionscoresfromQuery2#[4.,12.,10.]])#attentionscoresfromQuery3
步骤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, appr 步骤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.80步骤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
⾃注意⼒模块的输⼊：
嵌⼊模块
位置编码
截断
掩蔽
添加更多的⾃注意模块：
多头
层堆叠
⾃注意模块之间的模块：
线性变换
层范数
就是这些了朋友们！希望这篇⽂章对你来说简单易懂。

如果还想看到更多内容，请评论区告诉我！
参考⽂献
原⽂链接：
https:///illustrated-self-attention-2d627e33b20a#9abf
（*本⽂为AI科技⼤本营翻译⽂章，转载请微信联系1092722531）
◆。