本文内容
本文基于李宏毅老师对 Self-Attention 的讲解，进行理解和补充，并结合Pytorch代码，最终目的是使得自己和各位读者更好的理解Self-Attention
李宏毅Self-Attention链接: https://www.youtube.com/watch?v=hYdO9CscNes
PPT链接见视频下方
通过本文的阅读，你可以获得以下知识：
- 什么是Self-Attention，为什么要用Self-Attention
- Self-Attention是如何做的
- Self-Attention是如何设计的
- Self-Attention公式的细节
- MultiHead Attention
- Masked Attention
一、Self-Attention
1.1. 为什么要使用Self-Attention
假设现在一有个词性标注(POS Tags)的任务，例如：输入I saw a saw（我看到了一个锯子）这句话，目标是将每个单词的词性标注出来，最终输出为N, V, DET, N(名词、动词、定冠词、名词)。
这句话中，第一个saw为动词，第二个saw(锯子)为名词。如果想做到这一点，就需要保证机器在看到一个向量(单词)时，要同时考虑其上下文，并且，要能判断出上下文中每一个元素应该考虑多少。例如，对于第一个saw，要更多的关注I，而第二个saw，就应该多关注a。
这个时候，就要Attention机制来提取这种关系：如果一个任务的输入是一个Sequence（一排向量），而且各向量之间有一定关系，那么就要利用Attention机制来提取这种关系。
1.2. 直观的感受下Self-Attention
在经过Self-Attention层之后，可能就变成了这样：
对于第一个saw，它除了自身外，还要考虑 个
I；对于第二个saw，它要考虑个
a。
1.3. Self-Attenion是如何考虑上下文的
对于上图，需要与
分别计算相关性分数
（需要和自己也计算一下）,
的分数越高，表示两个向量的相关度越高。
计算好 后，就可以求出新的包含上下文信息的向量
，假设
，则：
同理，对于 ，首先计算权重
, 然后进行加权求和
如果按照上面这个式子做，还有两个问题：
之和不为1，这样会将输入向量放大或缩小
- 直接用输入向量
去乘的话，拟合能力不够好
对于问题1，通常的做法是将 过一个Softmax（当然也可以选择其他的方式）
对于问题2，通常是将 乘个矩阵（该矩阵是训练出来的），然后生成
，然后用
去乘
1.4. 如何计算相关性分数
首先，复习下向量相乘。两个向量相乘（做内积），公式为： ， 通过公式可以很容易得出结论：
- 两个向量夹角越小（越接近），其内积越大，相关性越高。反之，两个向量夹角越大，相关性越差，如果夹角为90°，两向量垂直，内积为0，无相关性
通过上面的结论，很容易想到，要计算 和
的相关性，直接做内积即可，即
。 但如果直接这样，显然不好，例如，句子
I saw a saw的saw和saw相关性一定很高(两个一样的向量夹角为0)，这样不就错了嘛。
为了解决上面这个问题，Self-Attention又额外“训练”了两个矩阵 和
负责对“主角”进行线性变化，将其变换为
，称为query，
负责对“配角”进行线性变化，将其变换为
，称为key
有了，我们就可以计算
和
的相关分数
了，即：
上面这些内容可以汇总成如下图：
- 通过
- 通过
- 通过
上图并没有把
画出来，但实际计算的时候，需要计算
，即需要计算
和其自身的相关分数。
1.5. 将 归一化
还记得上面提到的，之和不为1，所以，在上面得到了
后，还需要过一下Softmax，将
进行归一化。如下图：
最终，会将归一化后的 作为
与其它向量的相关分数。 同理，
向量与其他向量的相关分数也这么求。
不一定非要用Softmax，你开心想用什么都行，说不定效果还不错，也不一定非要归一化。 只是通常是这么做的
1.6. 整合上述内容
求出了相关分数 ，就可以进行加权求和计算出包含上下文信息的向量
了。还记得上面提到过，如果直接用
与
进行加权求和，泛化性不够好，所以需要对
进行线性变换，得到向量
，所以Self-Attention还需要训练一个矩阵
用于对
进行线性变化，即：
然后就可用 与
进行加权求和，得到
了。
将求 的整个过程可以归纳为下图：
有一组输入序列 ，其中
为向量， 将序列
通过Self-Attention，可以将其转化为另外一个序列
，其中向量
是由向量
结合其上下文得出的，
的求解过程如下：
- 求出查询向量
， 公式为
- 求出
，公式为
- 求出
， 公式为
- 将
，公式为
- 求出向量
， 公式为：
- 求出
， 公式为
其中，
都是训练出来的
到这里Self-Attention的面纱已经揭开，但还没有结束，因为上面的步骤如果写成代码，需要大量的for循环，显然效率太低，所以需要进行向量化，能合并成向量的合成向量，能合并成矩阵的合成矩阵。
1.7. 向量化
向量 的矩阵化，假设列向量
维度为
，显然可以将输入转化为矩阵
，公式为：
接下来定义 矩阵，其中
和
的矩阵维度必须一致，为
，而
的矩阵维度为
，其中 $d_k $和
都是需要调的超参数（一般与词向量的维度
保持一致）。
只影响过程，但
会影响结果，即
是Attention的输出向量
的维度。 定义好
的维度后，就可以将
矩阵化了，
向量 的矩阵化，公式为：
同理，向量k的矩阵化，公式为：
同理，向量v的矩阵化，公式为：
得到了矩阵和
，那么就很容易得出相关分数
的矩阵了，
相关分数 的矩阵为：
我的定义
是列向量，所以要转置一下
进一步， 的矩阵为：
有了，
有了，那就可以对输出向量
进行矩阵化了，
输出向量b的矩阵化，公式为：
将上面全部整合起来，就可以的到，整合后的公式为
如果你看过其他文章，你应该会看到真正的最终公式如下：
其实我们的公式和这个公式只差了一个转置和 。转置不比多说，就是表示方式不同。
原公式的
以及输出
，对应我们公式的
和
1.8. 
是什么，为什么要除以 
首先，是Q和K矩阵的行维度，也就是上面的
中的
。而矩阵相乘会放大原有矩阵的标准差，放大的倍数约为
，为了将标准差缩放回原来的大小，所以要除以
。
例如，假设 和
的均值为0，标准差为1。则矩阵
的均值为0，标准差为
，矩阵相乘使得其标准差放大了
倍
矩阵的均值就是把所有的元素加起来除以元素数量，方差同理。
可以通过以下代码验证这个结论（数学不好，只能通过实验验证结论了，哭）：
Q = np.random.normal(size=(123, 456)) # 生成均值为0，标准差为1的 Q和K
K = np.random.normal(size=(123, 456))
print("Q.std=%s, K.std=%s, \nQ·K^T.std=%s, Q·K^T/√d.std=%s"
% (Q.std(), K.std(),
Q.dot(K.T).std(), Q.dot(K.T).std() / np.sqrt(456)))
Q.std=0.9977961671085275, K.std=1.0000574599289282,
Q·K^T.std=21.240017020263437, Q·K^T/√d.std=0.9946549289466212
通过输出可以看到，Q和K的标准差都为1，但是两矩阵相乘后，标准差却变为了 21.24, 通过除以 ，标准差又重新变为了 1
再看另一个例子，该例子Q和K的标准差是随机的，更符合真实的情况：
Q = np.random.normal(loc=1.56, scale=0.36, size=(123, 456)) # 生成均值为随机，标准差为随机的 Q和K
K = np.random.normal(loc=-0.34, scale=1.2, size=(123, 456))
print("Q.std=%s, K.std=%s, \nQ·K^T.std=%s, Q·K^T/√d.std=%s"
% (Q.std(), K.std(),
Q.dot(K.T).std(), Q.dot(K.T).std() / np.sqrt(456)))
Q.std=0.357460640868945, K.std=1.204536717914841,
Q·K^T.std=37.78368871510589, Q·K^T/√d.std=1.769383337989377
可以看到，最开始Q的标准差为 , K的标准差为
，结果矩阵相乘后标准差达到了
， 经过缩放后，标准差又回到了
。
1.9. 代码实战：Pytorch定义SelfAttention模型
接下来使用Pytorch来定义SelfAttention模型，这里使用原论文中的公式：
这里为了使代码定义逻辑更清晰，下面我将各个部分的维度标记出来：
其中，各个变量定义为：
：input_num，输入向量的数量，例如，你一句话包含20个单词，则该值为20
一致即可），该值决定了线性层的宽度。
：dimension of V，V矩阵的行维度，该值为输出向量的维度（超参数，需要自己调，一般取值和输入向量维度
上述公式中，是通过矩阵
和输入向量
计算出来的，而一般对于要训练的矩阵，代码中一般使用线性层来表示，详情可参考：Pytorch nn.Linear的基本用法，所以最终
矩阵的计算公式为：
矩阵同理。其中
有了公式(1)和(2)，就可以定义SelfAttention模型了，代码如下：
class SelfAttention(nn.Module):
def __init__(self, input_vector_dim: int, dim_k=None, dim_v=None):
"""
初始化SelfAttention，包含如下关键参数：
input_vector_dim: 输入向量的维度，对应上述公式中的d，例如你将单词编码为了10维的向量，则该值为10
dim_k: 矩阵W^k和W^q的维度
dim_v: 输出向量的维度，即b的维度，例如，经过Attention后的输出向量b，如果你想让他的维度为15，则该值为15，若不填，则取input_vector_dim
"""
super(SelfAttention, self).__init__()
self.input_vector_dim = input_vector_dim
# 如果 dim_k 和 dim_v 为 None，则取输入向量的维度
if dim_k is None:
dim_k = input_vector_dim
if dim_v is None:
dim_v = input_vector_dim
"""
实际写代码时，常用线性层来表示需要训练的矩阵，方便反向传播和参数更新
"""
self.W_q = nn.Linear(input_vector_dim, dim_k, bias=False)
self.W_k = nn.Linear(input_vector_dim, dim_k, bias=False)
self.W_v = nn.Linear(input_vector_dim, dim_v, bias=False)
# 这个是根号下d_k
self._norm_fact = 1 / np.sqrt(dim_k)
def forward(self, x):
"""
进行前向传播：
x: 输入向量，size为(batch_size, input_num, input_vector_dim)
"""
# 通过W_q, W_k, W_v矩阵计算出，Q,K,V
# Q,K,V矩阵的size为 (batch_size, input_num, output_vector_dim)
Q = self.W_q(x)
K = self.W_k(x)
V = self.W_v(x)
# permute用于变换矩阵的size中对应元素的位置，
# 即，将K的size由(batch_size, input_num, output_vector_dim)，变为(batch_size, output_vector_dim，input_num)
# 0,1,2 代表各个元素的下标，即变换前，batch_size所在的位置是0，input_num所在的位置是1
K_T = K.permute(0, 2, 1)
# bmm是batch matrix-matrix product，即对一批矩阵进行矩阵相乘
# bmm详情参见：https://pytorch.org/docs/stable/generated/torch.bmm.html
atten = nn.Softmax(dim=-1)(torch.bmm(Q, K_T) * self._norm_fact）
# 最后再乘以 V
output = torch.bmm(atten, V)
return output
接下来使用一下，定义50个为一批(batch_size=50)，输入向量维度为3， 一次输入5个向量，欲经过Attention层后，编码成5个4维的向量：
model = SelfAttention(3, 5, 4)
model(torch.Tensor(50,5,3)).size()
torch.Size([50, 5, 4])
Attention模型一般作为整体模型的一部分，是套在其他模型中使用的，最经典的莫过于Transformer
二. MultiHead Attention
2.1 MultiHead Attention理论讲解
在Transformer中使用的是MultiHead Attention，其实这玩意和Self Attention区别并不是很大。先明确以下几点，然后再开始讲解：
- MultiHead的head不管有几个，参数量都是一样的。并不是head多，参数就多。
- 当MultiHead的head为1时，并不等价于Self Attetnion，MultiHead Attention和Self Attention是不一样的东西
- MultiHead Attention使用的也是Self Attention的公式
- MultiHead除了
。
好了，知道上面几点，我们就可以开始讲解MultiHeadAttention了。
MultiHead Attention大部分逻辑和Self Attention是一致的，是从求出Q,K,V后开始改变的，所以我们就从这里开始讲解。
现在我们求出了Q, K, V矩阵，对于Self-Attention，我们已经可以带入公式了，用图像表示则为：
为了简单起见，该图忽略了Softmax和
而MultiHead Attention在带入公式前做了一件事情，就是拆，它按照“词向量维度”这个方向，将Q,K,V拆成了多个头，如图所示：
这里我的head数为4。既然拆成了多个head，那么之后的计算，也是各自的head进行计算，如图所示：
但这样拆开来计算的Attention使用Concat进行合并效果并不太好，所以最后需要再采用一个额外的矩阵，对Attention再进行一次线性变换，如图所示：
2.2. Pytorch实现MultiHead Attention
该代码参考项目annotated-transformer。
首先定义一个通用的Attention函数：
def attention(query, key, value):
"""
计算Attention的结果。
这里其实传入的是Q,K,V，而Q,K,V的计算是放在模型中的，请参考后续的MultiHeadedAttention类。
这里的Q,K,V有两种Shape，如果是Self-Attention，Shape为(batch, 词数, d_model)，
例如(1, 7, 128)，即batch_size为1，一句7个单词，每个单词128维
但如果是Multi-Head Attention，则Shape为(batch, head数, 词数，d_model/head数)，
例如(1, 8, 7, 16)，即Batch_size为1，8个head，一句7个单词，128/8=16。
这样其实也能看出来，所谓的MultiHead其实就是将128拆开了。
在Transformer中，由于使用的是MultiHead Attention，所以Q,K,V的Shape只会是第二种。
"""
# 获取d_model的值。之所以这样可以获取，是因为query和输入的shape相同，
# 若为Self-Attention，则最后一维都是词向量的维度，也就是d_model的值。
# 若为MultiHead Attention，则最后一维是 d_model / h，h为head数
d_k = query.size(-1)
# 执行QK^T / √d_k
scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
# 执行公式中的Softmax
# 这里的p_attn是一个方阵
# 若是Self Attention，则shape为(batch, 词数, 次数)，例如(1, 7, 7)
# 若是MultiHead Attention，则shape为(batch, head数, 词数，词数)
p_attn = scores.softmax(dim=-1)
# 最后再乘以 V。
# 对于Self Attention来说，结果Shape为(batch, 词数, d_model)，这也就是最终的结果了。
# 但对于MultiHead Attention来说，结果Shape为(batch, head数, 词数，d_model/head数)
# 而这不是最终结果，后续还要将head合并，变为(batch, 词数, d_model)。不过这是MultiHeadAttention
# 该做的事情。
return torch.matmul(p_attn, value)
class MultiHeadedAttention(nn.Module):
def __init__(self, h, d_model):
"""
h: head的数量
"""
super(MultiHeadedAttention, self).__init__()
assert d_model % h == 0
# We assume d_v always equals d_k
self.d_k = d_model // h
self.h = h
# 定义W^q, W^k, W^v和W^o矩阵。
# 如果你不知道为什么用nn.Linear定义矩阵，可以参考该文章：
# https://blog.csdn.net/zhaohongfei_358/article/details/122797190
self.linears = [
nn.Linear(d_model, d_model),
nn.Linear(d_model, d_model),
nn.Linear(d_model, d_model),
nn.Linear(d_model, d_model),
]
def forward(self, x):
# 获取Batch Size
nbatches = x.size(0)
"""
1. 求出Q, K, V，这里是求MultiHead的Q,K,V，所以Shape为(batch, head数, 词数，d_model/head数)
1.1 首先，通过定义的W^q,W^k,W^v求出SelfAttention的Q,K,V，此时Q,K,V的Shape为(batch, 词数, d_model)
对应代码为 `linear(x)`
1.2 分成多头，即将Shape由(batch, 词数, d_model)变为(batch, 词数, head数，d_model/head数)。
对应代码为 `view(nbatches, -1, self.h, self.d_k)`
1.3 最终交换“词数”和“head数”这两个维度，将head数放在前面，最终shape变为(batch, head数, 词数，d_model/head数)。
对应代码为 `transpose(1, 2)`
"""
query, key, value = [
linear(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
for linear, x in zip(self.linears, (x, x, x))
]
"""
2. 求出Q,K,V后，通过attention函数计算出Attention结果，
这里x的shape为(batch, head数, 词数，d_model/head数)
self.attn的shape为(batch, head数, 词数，词数)
"""
x = attention(
query, key, value
)
"""
3. 将多个head再合并起来，即将x的shape由(batch, head数, 词数，d_model/head数)
再变为 (batch, 词数，d_model)
3.1 首先，交换“head数”和“词数”，这两个维度，结果为(batch, 词数, head数, d_model/head数)
对应代码为：`x.transpose(1, 2).contiguous()`
3.2 然后将“head数”和“d_model/head数”这两个维度合并，结果为(batch, 词数，d_model)
"""
x = (
x.transpose(1, 2)
.contiguous()
.view(nbatches, -1, self.h * self.d_k)
)
# 最终通过W^o矩阵再执行一次线性变换，得到最终结果。
return self.linears[-1](x)
接下来尝试使用一下：
# 定义8个head，词向量维度为512
model = MultiHeadedAttention(8, 512)
# 传入一个batch_size为2， 7个单词，每个单词为512维度
x = torch.rand(2, 7, 512)
# 输出Attention后的结果
print(model(x).size())
输出为：
torch.Size([2, 7, 512])
三. Masked Attention
3.1 为什么要使用Mask掩码
在Transformer中的Decoder中有一个Masked MultiHead Attention。本节来对其进行一个详细的讲解。
首先我们来复习一下Attention的公式：
其中：
假设 对应着
。那么
就对应着
。 其中
包含着
到
的所有注意力信息。而计算
时的
这些字的权重就是
的第一行的
。
如果上面的回忆起来了，那么接下来看一下Transformer的用法，假设我们是要用Transformer翻译“Machine learning is fun”这句话。
首先，我们会将“Machine learning is fun” 送给Encoder，输出一个名叫Memory的Tensor，如图所示：
之后我们会将该Memory作为Decoder的一个输入，使用Decoder预测。Decoder并不是一下子就能把“机器学习真好玩”说出来，而是一个词一个词说（或一个字一个字，这取决于你的分词方式），如图所示：
紧接着，我们会再次调用Decoder，这次是传入“<bos> 机”：
到这里我们就会发现，对于Decoder来说是一个字一个字预测的，所以假设我们Decoder的输入是“机器学习”时，“习”字只能看到前面的“机器学”三个字，所以此时对于“习”字只有“机器学习”四个字的注意力信息。
但是，例如最后一步传的是“<bos>机器学习真好玩”，还是不能让“习”字看到后面“真好玩”三个字，所以要使用mask将其盖住，这又是为什么呢？原因是：如果让“习”看到了后面的字，那么“习”字的编码就会发生变化。
我们不妨来分析一下：
一开始我们只传入了“机”（忽略bos），此时使用attention机制，将“机”字编码为了
第二次，我们传入了“机器”，此时使用attention机制，如果我们不将“器”字盖住的话，那“机”字的编码就会发生变化，它就不再是是了，也许就变成了
。
这就会导致第一次“机”字的编码是，第二次却变成了
，这样就可能会让网络有问题。所以我们为了不让“机”字的编码产生变化，所以我们要使用mask，掩盖住“机”字后面的字，也就是即使他能attention后面的字，也不让他attention。
3.2 如何进行mask掩码
要进行掩码，只需要对scores动手就行了，也就是 。直接上例子：
第一次，我们只有 变量，所以是：
第二次，我们有 两个变量：
此时如果我们不对 进行掩码的话，
的值就会发生变化（第一次是
，第二次却变成了
）。那这样看，我们只需要将
盖住即可，这样就能保证两次的
一致了。
所以第二次实际就为：
依次类推，如果我们执行到第次时，就应该变成：
3.3 为什么是负无穷而不是0
按照上面的说法，mask掩码是0，但为什么源码中的掩码是 （负无穷）。Attention部分源码如下：
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
p_attn = scores.softmax(dim=-1)
你仔细看，我们上面说的 是什么，是softmax之后的。而源码中呢， 源码是在softmax之前进行掩码，所以才是负无穷，因为将负无穷softmax后就会变成0了。
3.4. 训练时的掩码
通常我们在网上看Masked Attention相关的文章时，会说mask的目的是为了防止网络看到不该看到的内容。本节主要来解释一下这句话。
首先，我们需要了解一下Transformer的训练过程。
在Transformer推理时，我们是一个词一个词的输出，但在训练时这样做效率太低了，所以我们会将target一次性给到Transformer（当然，你也可以按照推理过程做），如图所示：
从图上可以看出，Transformer的训练过程和推理过程主要有以下几点异同：
- 源输入src相同：对于Transformer的inputs部分(src参数)一样，都是要被翻译的句子。
- 目标输入tgt不同：在Transformer推理时，tgt是从
<bos>开始，然后每次加入上一次的输出（第二次输入为<bos> 我）。但在训练时是一次将“完整”的结果给到Transformer，这样其实和一个一个给结果上一致。这里还有一个细节，就是tgt比src少了一位，src是7个token，而tgt是6个token。这是因为我们在最后一次推理时，只会传入前n-1个token。举个例子：假设我们要预测<bos> 我 爱 你 <eos>（这里忽略pad），我们最后一次的输入tgt是<bos> 我 爱 你（没有<eos>），因此我们的输入tgt一定不会出现目标的最后一个token，所以一般tgt处理时会将目标句子删掉最后一个token。 - 输出数量变多：在训练时，transformer会一次输出多个概率分布。例如上图，
我就的等价于是tgt为<bos>时的输出，爱就等价于tgt为<bos> 我时的输出，依次类推。当然在训练时，得到输出概率分布后就可以计算loss了，并不需要将概率分布再转成对应的文字。注意这里也有个细节，我们的输出数量是6，对应到token就是我 爱 你 <eos> <pad> <pad>，这里少的是<bos>，因为<bos>不需要预测。计算loss时，我们也是要和的这几个token进行计算，所以我们的label不包含<bos>。代码中通常命名为tgt_y。
其实总结一下就一句话：Transformer推理时是一个一个词预测，而训练时会把所有的结果一次性给到Transformer，但效果等同于一个一个词给，而之所以可以达到该效果，就是因为对tgt进行了掩码，防止其看到后面的信息，也就是不要让前面的字具备后面字的上下文信息。
可能看了这句总结还是很难理解，所以我们接下来来做个实验，我们的实验内容为：首先模拟Transformer的推理过程，然后再模拟Transformer的训练过程，看看训练时一次性给到所有的tgt和推理时一个一个给的结果是否一致。
这里我们要用到Pytorch中的nn.Transformer，用法可参考这篇文章。
首先我们来定义模型：
# 词典数为10， 词向量维度为8
embedding = nn.Embedding(10, 8)
# 定义Transformer，注意一定要改成eval模型，否则每次输出结果不一样
transformer = nn.Transformer(d_model=8, batch_first=True).eval()
接下来定义我们的src和tgt：
# Encoder的输入
src = torch.LongTensor([[0, 1, 2, 3, 4]])
# Decoder的输入
tgt = torch.LongTensor([[4, 3, 2, 1, 0]])
然后我们将[4]送给Transformer进行预测，模拟推理时的第一步：
transformer(embedding(src), embedding(tgt[:, :1]),
# 这个就是用来生成阶梯式的mask的
tgt_mask=nn.Transformer.generate_square_subsequent_mask(1))
tensor([[[ 1.4053, -0.4680, 0.8110, 0.1218, 0.9668, -1.4539, -1.4427,
0.0598]]], grad_fn=<NativeLayerNormBackward0>)
然后我们将[4, 3]送给Transformer，模拟推理时的第二步：
transformer(embedding(src), embedding(tgt[:, :2]), tgt_mask=nn.Transformer.generate_square_subsequent_mask(2))
tensor([[[ 1.4053, -0.4680, 0.8110, 0.1218, 0.9668, -1.4539, -1.4427,
0.0598],
[ 1.2726, -0.3516, 0.6584, 0.3297, 1.1161, -1.4204, -1.5652,
-0.0396]]], grad_fn=<NativeLayerNormBackward0>)
这个时候你有没有发现，输出的第一个向量和上面那个一模一样。
最后我们再将tgt一次性送给transformer，模拟训练过程：
transformer(embedding(src), embedding(tgt), tgt_mask=nn.Transformer.generate_square_subsequent_mask(5))
tensor([[[ 1.4053, -0.4680, 0.8110, 0.1218, 0.9668, -1.4539, -1.4427,
0.0598],
[ 1.2726, -0.3516, 0.6584, 0.3297, 1.1161, -1.4204, -1.5652,
-0.0396],
[ 1.4799, -0.3575, 0.8310, 0.1642, 0.8811, -1.3140, -1.5643,
-0.1204],
[ 1.4359, -0.6524, 0.8377, 0.1742, 1.0521, -1.3222, -1.3799,
-0.1454],
[ 1.3465, -0.3771, 0.9107, 0.1636, 0.8627, -1.5061, -1.4732,
0.0729]]], grad_fn=<NativeLayerNormBackward0>)
看到没，前两个tensor和模拟推理时的输出结果一模一样。所以使用mask时，我们可以保证前面的词不会具备后面词的信息，这样就可以保证Transformer的输出不会因为传入词的多少而改变，从而我们就可以做到在训练时一次将tgt全部给到Transformer，却不会出现问题。这也就是人们常说的，防止网络训练时看到不该看到的内容。
可以尝试思考下为什么输出不会变，原因其实就是因为神经网络的本质就是不断的进行矩阵相乘，例如：
，
为输入，
，但我们通过mask可以保证
的第二个行向量不要影响到第一个行向量。这里就不展开讲解了，可以尝试用纸笔算一下。
完结，如果有什么地方有错误，欢迎大家指出来。
参考资料
李宏毅Self-Attention: https://www.youtube.com/watch?v=hYdO9CscNes
超详细图解Self-Attention: https://zhuanlan.zhihu.com/p/410776234
Pytorch nn.Linear的基本用法：https://blog.csdn.net/zhaohongfei_358/article/details/122797190
极简翻译模型Demo，彻底理解Transformer：https://zhuanlan.zhihu.com/p/360343417
annotated-transformer：https://github.com/harvardnlp/annotated-transformer/
文章出处登录后可见！
