前言
这个专栏我们开始学习transformer，自推出以来transformer在深度学习中占有重要地位，不仅在NLP领域，在CV领域中也被广泛应用，尤其是2021年，transformer在CV领域可谓大杀四方。
在论文的学习之前，我们先来介绍一些专业术语。本篇就让我们先来认识一下encoder和decoder吧！
🍀本人Transformer相关文章导航：
【Transformer系列（1）】encoder（编码器）和decoder（解码器）
【Transformer系列（2）】注意力机制、自注意力机制、多头注意力机制、通道注意力机制、空间注意力机制超详细讲解
【Transformer系列（3）】 《Attention Is All You Need》论文超详细解读（翻译＋精读）
【Transformer系列（4）】Transformer模型结构超详细解读
一、encoder
1.1 简介
encoder，也就是编码器，负责将输入序列压缩成指定长度的向量，这个向量就可以看成是这个序列的语义，然后进行编码，或进行特征提取（可以看做更复杂的编码）。
简单来说就是机器读取数据的过程，将现实问题转化成数学问题。如下图所示：
1.2 代码实现
在编码器接口中，我们只指定长度可变的序列作为编码器的输入X。 任何继承这个encoder 基类的模型将完成代码实现。
class encoder(nn.Module): def __init__(self): super(Encoder, self).__init__() self.positional_encoding = Positional_Encoding(config.d_model) self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads) self.feed_forward = Feed_Forward(config.d_model) self.add_norm = Add_Norm() def forward(self,x): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list x += self.positional_encoding(x.shape[1],config.d_model) # print("After positional_encoding: {}".format(x.size())) output = self.add_norm(x,self.muti_atten,y=x) output = self.add_norm(output,self.feed_forward) return output
Mutihead_Attention()：多头注意力机制：
class Mutihead_Attention(nn.Module): def __init__(self,d_model,dim_k,dim_v,n_heads): super(Mutihead_Attention, self).__init__() self.dim_v = dim_v self.dim_k = dim_k self.n_heads = n_heads self.q = nn.Linear(d_model,dim_k) self.k = nn.Linear(d_model,dim_k) self.v = nn.Linear(d_model,dim_v) self.o = nn.Linear(dim_v,d_model) self.norm_fact = 1 / math.sqrt(d_model) def generate_mask(self,dim): # 此处是 sequence mask ，防止 decoder窥视后面时间步的信息。 # padding mask 在数据输入模型之前完成。 matirx = np.ones((dim,dim)) mask = torch.Tensor(np.tril(matirx)) return mask==1 def forward(self,x,y,requires_mask=False): assert self.dim_k % self.n_heads == 0 and self.dim_v % self.n_heads == 0 # size of x : [batch_size * seq_len * batch_size] # 对 x 进行自注意力 Q = self.q(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k K = self.k(x).reshape(-1,x.shape[0],x.shape[1],self.dim_k // self.n_heads) # n_heads * batch_size * seq_len * dim_k V = self.v(y).reshape(-1,y.shape[0],y.shape[1],self.dim_v // self.n_heads) # n_heads * batch_size * seq_len * dim_v # print("Attention V shape : {}".format(V.shape)) attention_score = torch.matmul(Q,K.permute(0,1,3,2)) * self.norm_fact if requires_mask: mask = self.generate_mask(x.shape[1]) attention_score.masked_fill(mask,value=float("-inf")) # 注意这里的小Trick，不需要将Q,K,V 分别MASK,只MASKSoftmax之前的结果就好了 output = torch.matmul(attention_score,V).reshape(y.shape[0],y.shape[1],-1) # print("Attention output shape : {}".format(output.shape)) output = self.o(output) return output
Feed_Forward() : 两个Linear中连接Relu即可，目的是为模型增添非线性信息，提高模型的拟合能力。
class Feed_Forward(nn.Module): def __init__(self,input_dim,hidden_dim=2048): super(Feed_Forward, self).__init__() self.L1 = nn.Linear(input_dim,hidden_dim) self.L2 = nn.Linear(hidden_dim,input_dim) def forward(self,x): output = nn.ReLU()(self.L1(x)) output = self.L2(output) return output
Add_Norm（）：残差连接以及LayerNorm
class Add_Norm(nn.Module): def __init__(self): self.dropout = nn.Dropout(config.p) super(Add_Norm, self).__init__() def forward(self,x,sub_layer,**kwargs): sub_output = sub_layer(x,**kwargs) # print("{} output : {}".format(sub_layer,sub_output.size())) x = self.dropout(x + sub_output) layer_norm = nn.LayerNorm(x.size()[1:]) out = layer_norm(x) return out
1.3 transformer中的使用
1.3.1transformer中encoder的组成
transformer 中 encoder 由 6 个相同的层组成，每个层包含 2 个部分：
- Multi-Head Self-Attention
- Position-Wise Feed-Forward Network
1.3.2 每个Block的组成
自注意力机制 + 残差链接 + LayerNorm + FC + 残差链接 + layer Norm此时的输出 = 一个 Block 的输出；
1.3.3 每个Block 中的具体实现步骤
（1）原始的输入向量b 与输出向量a残差相加，得到向量a+b；
【注意】 b是原始的输入向量，下图中输出向量a是考虑整个序列的输入向量得到的结果
（2）将向量 a+b 通过 Layer Normation 得到向量c ;
也就是下图左边部分：
（3）将向量c 通过 FC layer 得到向量d ;
（4）向量c 与向量d 残差相加 ，得到向量e ；
（5）向量e 通过 Layer Norm 输出 向量f；
（6）此时得到的输出向量f 才是 encoder中每个Block中的一个输出向量；
以上步骤就是下图右边部分：
上述步骤，便是原始论文transformer中encoder的设计啦~
二、decoder
2.1 简介
decoder，也就是解码器，负责根据encoder部分输出的语义向量c来做解码工作。以翻译为例，就是生成相应的译文。
简单来说，就是就数学问题，并转换为现实世界的解决方案。
【注意】生成的序列是不定长的。而且上一时刻的输出通常要作为下一时刻的输入。
2.2 代码实现
在上面1.2encoder的代码实现中，我们已经实现了大部分decoder的模块。
但是encoder和decoder实现还是有区别的：
- decoder的Muti_head_Attention引入了Mask机制
- decoder与encoder中模块的拼接方式不同
class Decoder(nn.Module): def __init__(self): super(Decoder, self).__init__() self.positional_encoding = Positional_Encoding(config.d_model) self.muti_atten = Mutihead_Attention(config.d_model,config.dim_k,config.dim_v,config.n_heads) self.feed_forward = Feed_Forward(config.d_model) self.add_norm = Add_Norm() def forward(self,x,encoder_output): # batch_size * seq_len 并且 x 的类型不是tensor，是普通list # print(x.size()) x += self.positional_encoding(x.shape[1],config.d_model) # print(x.size()) # 第一个 sub_layer output = self.add_norm(x,self.muti_atten,y=x,requires_mask=True) # 第二个 sub_layer output = self.add_norm(output,self.muti_atten,y=encoder_output,requires_mask=True) # 第三个 sub_layer output = self.add_norm(output,self.feed_forward) return output
2.3 transformer中的使用
2.3.1transformer中decoder的组成
在transformer中decoder 也是由 6 个相同的层组成，每个层包含 3 个部分：
- Multi-Head Self-Attention
- Multi-Head Context-Attention
- Position-Wise Feed-Forward Network
2.3.2 transformer中encoder和decoder的区别
我们先来看看这个图
（1）第一级中： 将self attention 模块加入了Masked模块，变成了 Masked self-attention， 这样以来就只考虑解码器的当前输入和当前输入的左侧部分， 不考虑右侧部分； ( 注意，第一级decoder的key， query， value均来自前一层decoder的输出，但加入了Mask操作，即我们只能attend到前面已经翻译过的输出的词语，因为翻译过程我们当前还并不知道下一个输出词语，这是我们之后才会推测到的。)
（2）第二级中：引入了 Cross attention 交叉注意力模块， 在 masked self-attention 和全连接层 之间加入；
（3）Cross attention 交叉注意力模块的输入 Q，K，V 不是来自同一个模块，K,V 来自编码器的输出， Q来自解码器的输出；
【注意】 解码器的输出一个一个产生的
2.3.3 Masked self attention模块
举个栗子吧~以翻译为例：
- 输入：我是路人贾
- 输出： I am Jia
由上一节可知，输入“我是路人贾”这一步是在encoder中进行了编码，那么这里我们具体讨论decoder的操作，也就是加了 Masked self attention模块后如何得到输出（“I am Jia”）的过程。
第1步：
- 初始输入： 起始符 + Positional Encoding（位置编码）
- 中间输入：（我是路人贾）Encoder Embedding
- 最终输出：产生预测“I”
第2步：
- 初始输入：起始符 + “I”+ Positonal Encoding
- 中间输入：（我是路人贾）Encoder Embedding
- 最终输出：产生预测“am”
第3步：
- 初始输入：起始符 + “I”+ “Love”+ Positonal Encoding
- 中间输入：（我是路人贾）Encoder Embedding
- 最终输出：产生预测“Jia”
其实这个原理很简单，主要想表达的就是因为变成了Masked self attention ，所以只考虑输入向量本身， 和输入向量的之前的向量，即左侧向量，而不去考虑后边（右侧）向量。
另外，求相关性的分数时，q，k ，v 同样的也只会考虑当前输入向量的左侧向量部分，而不去考虑输入向量后面的右侧部分。
这里介绍一下论文在Decoder的输入上，对Outputs的Shifted Right操作。
Shifted Right 实质上是给输出添加起始符/结束符，方便预测第1个Token/结束预测过程。
还是看看我们上一个栗子~
正常的输出序列位置关系如下：
- 0-"I"
- 1-"am"
- 2-"Jia"
但在执行的过程中，我们在初始输出中添加了起始符，相当于将输出整体右移1位（Shifted Right），所以输出序列变成如下情况：
- 0-【起始符】
- 1-“I”
- 2-“am”
- 3-“Jia”
这样我们就可以通过起始符预测“I”，也就是通过起始符预测实际的第1个输出啦。
2.3.4 Cross attetion模块
Cross attetion模块称为交叉注意力模块，是因为向量 q , k , v 不是来自同一个模块。
而是将来自解码器的输出向量q 与来自编码器的输出向量 k , v运算。
具体讲来：
向量 q 与向量 k之间相乘求出注意力分数α1 '
注意力分数α1 '再与向量 v 相乘求和，得出向量 b (图中表示为向量 v ) ;
2.3.5 具体实现步骤
（1）经过 Masked self attention:
解码器之前的输出作为当前解码器的输入，并且训练过程中真实标签的也会输入到解码器中，此时这些输入， 通过一个Masked self-attention ，得到输出q向量，注意到这里的q是由解码器产生的；
（2）经过 Cross attention:
将向量q 与来自编码器的输出向量 k , v 运算。具体讲来就是向量 q 与向量 k之间相乘求出注意力分数α1 '，注意力分数α1 '再与向量 v 相乘求和，得出向量 b ;
（3）经过全连接层：
之后向量 b 便被输入到feed−forward 层， 也即全连接层， 得到最终输出；
上述步骤，便是原始论文transformer中decoder的设计啦~
三、encoder-decoder
刚才已经分别了解了encoder和decoder，接下来我们再来看看encoder-decoder这个框架吧。
3.1 简介
encoder-decoder 模型主要是 NLP 领域里的概念。它并不特值某种具体的算法，而是一类算法的统称。encoder-decoder 算是一个通用的框架，在这个框架下可以使用不同的算法来解决不同的任务。
其实整个过程我们可以看做是一个游戏——《你画我猜》。玩家1从系统中抽取拿到题卡，然后通过画画的方式描述该词。玩家2就通过画来猜出题目中的词是什么东东。我们拿目前应用最深入的机器翻译问题举个栗子：
（毕贾索已上线~）
就酱就酱~大家懂就行~
3.2 代码实现
encoder-decoder框架包含了一个编码器和一个解码器，并且还拥有可选的额外的参数。在前向传播中，编码器的输出用于生成编码状态，这个状态又被解码器作为其输入的一部分。
class EncoderDecoder(nn.Module): """ A standard Encoder-Decoder architecture. Base for this and many other models. """ def __init__(self, encoder, decoder, src_embed, tgt_embed, generator): super(EncoderDecoder, self).__init__() self.encoder = encoder self.decoder = decoder self.src_embed = src_embed self.tgt_embed = tgt_embed self.generator = generator def forward(self, src, tgt, src_mask, tgt_mask): "Take in and process masked src and target sequences." return self.decode(self.encode(src, src_mask), src_mask, tgt, tgt_mask) def encode(self, src, src_mask): return self.encoder(self.src_embed(src), src_mask) def decode(self, memory, src_mask, tgt, tgt_mask): return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)
3.3 注意问题
- 不论输入和输出的长度是什么，中间的“向量c”长度都是固定的（这是它的缺陷所在）。
- 根据不同的任务可以选择不同的编码器和解码器（例如，CNN、RNN、LSTM、GRU等）
- encoder-decoder的一个显著特征就是：它是一个end-to-end的学习算法。
- 只要符合这种框架结构的模型都可以统称为encoder-decoder模型。
本文参考：
李宏毅机器学习
