Transformer整体结构

下面的Transformer的整体结构，下图是Transformer用与中英文翻译的整体结构：

[!notice]
可以看到==Transformer==由==Encoder==和==Decoder==两个部分组成，Encoder和Decoder都包含6个==block==。

  • Transformer的工作流程大体如下:
    • 第一步：获取输入句子的每一个单词的表示向量X,X由单词的 Embedding(Embedding就是从原始数据提取出来的Feature)和单词位置的 Embedding相加得到。
    • 第二步：将得到的单词表示向量矩阵（如上图所示，每一行是一个单词的表示）传入 Encoder中，经过6个Encoder block(后可以得到句子所有单词的编码信息矩阵C,如下图。单词向量矩阵用表示，n是句子中单词个数，d是表示向量的维度( d=512)。每一个Encoder block输出的矩阵维度与输入完全一致。
      300
    • 第三步：将Encoder输出的编码信息矩阵C传递到Decoder中，Decoder依次会根据当前翻译过的单词1~i翻译下一个单词i+1，如下图所示。在使用的过程中，翻译到单词i+1的时候需要通过Mask(掩盖)操作遮盖住i+1之后的单词。

      [!note]
      上图Decoder接收了 Encoder的编码矩阵C,然后首先输入一个翻译开始符”<Begin>”,预测第一个单词”I”;然后输入翻译开始符”<Begin>”和单词”I”预测单词”have”,以此类推。这是Transformer使用时候的大致流程，接下来是里面各个部分的细节。

Transformer的输入

[!note]
Transformer中单词的输入表示x由单词Embedding和位置Embedding(Positional Encoding)相加得到。

单词Embedding

单词的Embedding有很多种方式可以获取，例如可以采用Word2Vec、Glove等算法预训练得到，也可以在Transformer中训练得到。

位置Embedding

[!notice]
Transformer中除了单词的Embedding,还需要使用位置Embedding表示单词出现在句子中的位置。因为Transformer==不采用RNN的结构==，而是使用全局信息，不能利用单词的顺序信息，而这部分信息对于NLP来说非常重要。所以Transformer中使用位置 Embedding保存单词在序列中的相对或绝对位置。

位置Embedding用PE表示，PE的维度与单词Embedding是一样的。PE可以通过训练得到，也可以使用某种公式计算得到。在Transformer中采用了后者
计算公式如下：


其中，pos表示单词在句子中的位置，d表示PE的维度（与词Embedding一样），2i表示偶数的维度，2i+1表示奇数维度（即21≤d,21+1≤d)。使用这种公式计算PE有以下的好处：

[!note]

  • 使PE能够适应比训练集里面所有句子更长的句子，假设训练集里面最长的句子是有20个单词，突然来了一个长度为21的句子，则使用公式计算的方法可以计算出第21位的 Embedding。
  • 可以让模型容易地计算出相对位置，对于固定长度的间距k,PE(pos+k)**可以用PE(pos)计算得到。 因为
  • Sin(A+B)=Sin(A)Cos(B)+Cos(A)Sin(B),
  • Cos(A+B)= Cos(A)Cos(B)-Sin(A)Sin(B)。

Self-Attention(自注意力机制)

Transformer的内部结构图

  • 左侧为Encoder block
  • 右侧为Decoder block
  • 红色圈中的部分为Multi-Head Attention,是由多个Self-Attention组成的
    500
  1. 可以看到Encoder block包含一个`Multi- Head Attention
  2. 而Decoder block包含两个 Multi- Head Attention(其中有一个用到
  3. Multi--Head Attention上方还包括一个Add&Norm层
  4. Add表示残差连接(Residual Connection)用于防止网络退化，
  5. Norm表示Layer Normalization,用于对每一层的激活值进行归一化。

因为Self-Attention是Transformer的重点，所以我们重点关注Multi-Head Attention以及 Self-Attention,首先详细了解一下Self-Attention的内部逻辑。

self-Attention结构

300
上图是Self-Attention的结构，在计算的时候需要用到矩阵Q(查询)，K(键值)，V(值)。在实际中， Self-Attention接收的是输入（单词的表示向量x组成的矩阵）或者上一个Encoder block的输出。而 Q,K,V正是通过Self-Attention的输入进行线性变换得到的。

Q,K,V的计算

[!note]
Self-Attention的输入用矩阵X进行表示，则可以使用线性变阵矩阵==WQ,WK,WV==计算得到Q,K,V。计算如下图所示，注意X,Q,K,V的每一行都表示一个单词。

300

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# self attention实现  
  
import torch  
from torch import nn  
import numpy as np  
from math import sqrt  
  
  
class Self_Attention(nn.Module):  
    # input : batch_size * seq_len * input_dim  
    # q : batch_size * input_dim * dim_k    # k : batch_size * input_dim * dim_k    # v : batch_size * input_dim * dim_v  
    def __init__(self, input_dim, dim_k,dim_v):  
        super(Self_Attention, self).__init__()  
        self.q = nn.Linear(input_dim, dim_k)  
        self.k = nn.Linear(input_dim, dim_k)  
        self.v = nn.Linear(input_dim, dim_v)  
        self._norm_fact = 1/sqrt(dim_k)  
  
    def forward(self, x):  
        Q = self.q(x) # Q : batch_size * input_dim * dim_k  
        K = self.k(x) # K : batch_size * input_dim * dim_k  
        V = self.v(x) # V : batch_size * input_dim * dim_v  
  
        # Q * K.T() # batch_size * seq_len * seq_len        atten = nn.Softmax(  
            dim=-1)(torch.bmm(Q, K.permute(0, 2, 1)))*self._norm_fact  
          
        # Q * K.T() * V # batch_size * seq_len * dim_v  
        output = torch.bmm(atten, V)  
  
        return output  
  
X = torch.randn(4,3,2)  
print(X)  
self_attn = Self_Attention(2,4,5)  
res = self_attn(X)  
print(res.shape)

Self-Attention的输出

得到矩阵Q,K,V之后就可以计算出Self-Attention的输出了，计算的公式如下：


是Q，K矩阵的列数，即向量维度

[!note]
公式中计算矩阵Q和K每一行向量的内积，为了防止内积过大，因此除以的平方根。Q乘以K的转置后，得到的矩阵行列数都为n，n为句子单词数，这个矩阵可以表示单词之间的 attention强度。下图为Q乘以KT，1234表示的是句子中的单词。


得到之后，使用Softmax计算每一个单词对于其他单词的attention系数，公式中的 Softmax是对矩阵的每一行进行Softmax,即每一行的和都变为1.
500
得到Softmax矩阵之后可以和V相乘，得到最终的输出Z。
500
上图中Softmax矩阵的第1行表示单词1与其他所有单词的attention系数，最终单词1的输出 等于所有单词i的值根据attention系数的比例加在一起得到，如下图所示：
500

Muti-Head Attention

在上一步，我们已经知道怎么通过Self-Attention计算得到输出矩阵Z，而Multi-Head Attention是由多个Self-Attention组合形成的，下图是论文中Multi-HeadAttention的结构图。
500
从上图可以看到Multi-Head Attention包含多个Self-Attention层，首先将输入X分别传递到h个不同的Self-Attention中，计算得到h个输出矩阵Z。下图是h=8时候的情况，此时会得到8个输出矩阵Z。

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# Muti-head Attention 机制的实现  
  
from math import sqrt  
import torch  
import torch.nn as nn  
  
class Self_Attention_Muti_Head(nn.Module):  
    # input : batch_size * seq_len * input_dim  
    # q : batch_size * input_dim * dim_k    # k : batch_size  * input_dim * dim_k    # v : batch_size * input_dim * dim_v  
    def __init__(self,input_dim,dim_k,dim_v,nums_head):  
        super(Self_Attention_Muti_Head,self).__init__()  
        assert dim_k%nums_head==0  
        assert dim_v%nums_head==0  
        self.q = nn.Linear(input_dim,dim_k)  
        self.k = nn.Linear(input_dim,dim_k)  
        self.v = nn.Linear(input_dim,dim_v)  
  
        self.nums_head = nums_head  
        self.dim_k = dim_k  
        self.dim_v = dim_v  
        self._norm_fact = 1/sqrt(dim_k)  
  
  
    def forward(self,x):  
        Q=self.q(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.nums_head)  
        K=self.k(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.nums_head)  
        V=self.v(x).reshape(-1,x.shape[0],x.shape[1],self.dim_v // self.nums_head)  
  
        print(x.shape)  
        print(Q.size())  
  
        atten = nn.Softmax(dim=-1)(torch.matmul(Q,K.permute(0,1,3,2)))  
  
        output = torch.matmul(atten,V).reshape(x.shape[0],x.shape[1],-1)  
  
        return output  
  
x = torch.rand(1,3,4)  
print(x)  
  
atten = Self_Attention_Muti_Head(4,4,4,2)  
y = atten(x)  
print(y.shape)

400
得到8个输出矩阵到之后，Multi-Head Attention将它们拼接在一起(Concat),然后传入一个Linear层，得到Multi–Head Attention最终的输出Z。
500

可以看到Multi-Head Attention输出的矩阵Z与其输入的矩阵X的维度是一样的。

Encoder结构

红色部分是Transformer的Encoder block结构，可以看到是由Multi-Head Attention,Add&Norm,Feed Forward,Add&Norm组成的。刚刚已经了解了Multi- Head Attention的计算过程，现在了解一下Add&Norm和Feed Forward部分。
300

Add&Norm

Add&Norm层由Add和Norm两部分组成，其计算公式如下：


[!note]
其中X表示Multi-Head Attention或者Feed Forward的输入， MultiHeadAttention(X)何1FeedForward(X)表示输出（输出与输入X维度是一样的，所以可以相加)

Add指X+MultiHeadAttention(),是一种残差连接，通常用于解决多层网络训练的问题，可以让网络只关注当前差异的部分，在ResNet中经常用到：

500

[!note]
Norm指Layer Normalization,通常用于RNN结构，Layer Normalization会将每一层神经元的输入都转成均值方差都一样的，这样可以加快收敛。

Feed Forward

Feed Forward层比较简单，是一个两层的全连接层，第一层的激活函数为Relu,第二层不使用激活函数，对应的公式如下。


X是输入，Feed Forward最终得到的输出矩阵的维度与X一致。

组成Encoder

通过上面描述的Multi-Head Attention,Feed Forward,Add&Norm就可以构造出一个Encoder block,Encoder block接收输入矩阵,并输出一个矩阵。通过多个Encoder block叠加就可以组成Encoder。
300

  • 第一个Encoder block的输入为句子单词的表示向量矩阵，
  • 后续 Encoder block的输入是前一个 Encoder block的输出
  • 最后一个Encoder block输出的矩阵就是编码信息矩阵C,这一矩阵后续会用到 Decoder中。

Decoder结构

500
红色部分为Transformer的Decoder block结构，与Encoder block相似，但是存在一些区别：

  • 包含两个 Multi-Head Attention。
  • 第一个Multi-Head Attention层采用了Masked操作。
  • 第二个Multi-Head Attention层的K, V矩阵使用Encoder的编码信息矩阵C进行计算，而Q使用上一个Decoder block的输出计算。
  • 最后有一个Softmax层计算下一个翻译单词的概率。

第一个Multi-Head Attention

[!note]
Decoder block的第一个Multi–Head Attention采用了Masked操作，因为在翻译的过程中是顺序翻译的，即翻译完第i个单词，才可以翻译第i+1个单词。通过Masked操作可以防止第i个单词知道i+l个单词之后的信息。下面以”我有一只猫”翻译成”I have a cat”为例，了解一下Masked操作。

  • 在Decoder的时候，是需要根据之前的翻译，求解当前最有可能的翻译，如下图所示。首先根据输入”<Begin>”预测出第一个单词为”I”,然后根据输入”<Begin>I”预测下一个单词”have”

  • Decoder可以在训练的过程中使用Teacher Forcing并且并行化训练，即将正确的单词序列(<Begin>I have a cat))和对应输出(I have a cat<end>)传递到Decoder。那么在预测第讠个输出时，就要将第1+1之后的单词掩盖住，

  • 注意Mask操作是在Self-Attention的Softmax之前使用的，下面用012345分别表示<Begin>I have a cat <end>。

第一步：

[!note]
是Decoder的输入矩阵和Mask矩阵，输入矩阵包含”<Begin>I have a cat”(0,l,2,3, 4)五个单词的表示向量，Mask是一个5×5的矩阵。在Mask可以发现单词0只能使用单词0的信息，而单词1可以使用单词0,1的信息，即只能使用之前的信息。


第二步：

[!note]
‘接下来的操作和之前的Self-Attention一样，通过输入矩阵X计算得到Q,K,V矩阵。然后计算Q和的乘积

500

第三步：

[!note]
在得到之后需要进行Softmax,计算attention score,我们在Softmax之前需要使用Mask矩阵遮挡住每一个单词之后的信息，遮挡操作如下：


得到Mask 之后在Mask 上进行Softmax,.每一行的和都为1。但是单词0在单词 1,2,3,4上的attention score都为0。

第四步：
使用Mask 与矩阵V相乘，得到输出,则单词1的输出向量是只包含单词1信息的。

第五步：
通过上述步骤就可以得到一个Mask Self-Attention的输出矩阵，然后和Encoder类似，通过Multi-Head Attention拼接多个输出然后计算得到第一个Multi-Head Attention的输出Z,Z与输入X维度一样。

第二个Multi-Head Attention

  • Decoder block第二个Multi-Head Attention变化不大，主要的区别在于其中 SeLf-Attention的K,V矩阵不是使用上一个Decoder block的输出计算的，而是使用 Encoder的编码信息矩阵C计算的。
  • 根据Encoder的输出C计算得到K,V,根据上一个Decoder block的输出Z计算Q(如果是第一个Decoder block则使用输入矩阵X进行计算)，后续的计算方法与之前描述的一致。
  • 这样做的好处是在Decoder的时候，每一位单词都可以利用到Encoder所有单词的信息（这些信息无需Mask)。

Softmax预测输出单词

Decoder block最后的部分是利用Softmax预测下一个单词，在之前的网络层我们可以得到一个最终的输出Z,因为Mask的存在，使得单词0的输出Z0只包含单词0的信息，如下：
500
softmax根据输出矩阵的每一行预测下一个单词：
500

这就是 Decoder block的定义，与Encoder一样，Decoder是由多个 Decoder block组合而成。