1.Sequence-to-sequence简介
前一章提到过，模型在处理文本或者语音的数据时，是输入一个序列，输出一个class或者一个序
列
Seq2seq表示的不是一个模型的名称而是一种模型的类型的统称（即输入序列输出也是序列），在有了self-attention后，通过self-attention的变体模型结构transformer，可以很好的应用到Seq2seq的各种模型应用中
在输入一个序列输出一个序列的模型应用，有如下几种：
语音识别，机器翻译，语音翻译
聊天机器人
在深度学习中还有很多的人类语言处理模型
Seq2seq也可以用于多标签分类
2.transformer结构
先从seq2seq的结构来看：
seq2seq这一类模型的结构，通常都是由一个编码器（Encoder）和一个解码器（Decode）组成。
那对应到transformer也是如此如下图所示：
下文将详细对transformer结构展开解释
2.1 transformer的Encoder
2.1.1 Encode结构
注意这里是由N个上图的结构组成的哦，N个组合的方式如下图：
这里Block就有N个，每一个Block就对应上图里的结构
2.1.2 Encoder具体结构分解
1.多头注意力+残差，再进行layer norm
具体计算过程
2.前馈神经网络+残差，进行layer norm
具体计算过程
3.layer norm
在神经网络中norm有不同的比如batch norm和layer norm具体区别
layer norm具体步骤，就是对每一蓝色层，一层层求解，先计算出这一层的平均值与标准差，在进行标准化，转换即可。
2.2 transformer的Decoder
2.2.1 Decode结构
这里详细介绍一下在self-attention使用mask的含义的，实现过程
2.2.2 Mask
在self-attention里mask是一个参数设置，mask有二个作用：
1. key_padding_mask
我们在输入文本的时候，每一个batch的每一个句子的长度一般是不可能完全相同的，所以我们会使用padding把一些空缺补上。而这里的这个key_padding_mask是用来“遮挡”这些padding的。
这个mask是二元(binary)的，也就是说，它是一个矩阵和我们key的大小是一样的，里面的值是1或0，我们先取得key中有padding的位置，然后把mask里相应位置的数字设置为1，这样attention就会把key相应的部分变为"-inf". (为什么变为-inf我们稍后再说)
保持输入文本的每个句子长度一致。用mask填充
2.attn_mask
这个mask经常是用来遮挡“正确答案”的：
假如你想要用这个模型每次预测下一个单词，我们每一个位置的attention输出是怎么得来的？是不是要看一遍整个序列，然后每一个单词都计算一个attention weight？那也就是说，你在预测第5个词的时候，你其实会看到整个序列，这样的话你在预测之前不就已经知道第5个单词是什么了，这就是作弊了。
我们不想让模型作弊，因为在真实使用这个模型去预测的时候，我们是没有整个序列的信息的。那么怎么办？那就让第5个单词的attention weight=0吧，即声明：我不想看这个单词，我的注意力一点也别分给它。
保持输出预测的文本句子长度一致
2.2.3 Cross attention
这里蓝色和绿色输入的部分，以及后续三者如何结合的过程如下图所示：
3.self-attention（pytorch实现）
import torch import torch.nn as nn import numpy as np import math class SelfAttention(nn.Module): def __init__(self, hidden_size, num_attention_heads, dropout_prob): """ 假设 hidden_size = 128, num_attention_heads = 8, dropout_prob = 0.2 即隐层维度为128，注意力头设置为8个 """ super(SelfAttention, self).__init__() if hidden_size % num_attention_heads != 0: # 整除 raise ValueError( "The hidden size (%d) is not a multiple of the number of attention " "heads (%d)" % (hidden_size, num_attention_heads)) # 参数定义 self.num_attention_heads = num_attention_heads # 8 self.attention_head_size = int(hidden_size / num_attention_heads) # 16 每个注意力头的维度 self.all_head_size = int(self.num_attention_heads * self.attention_head_size) # all_head_size = 128 即等于hidden_size, 一般自注意力输入输出前后维度不变 # query, key, value 的线性变换（上述公式2） self.query = nn.Linear(hidden_size, self.all_head_size) # 128, 128 self.key = nn.Linear(hidden_size, self.all_head_size) self.value = nn.Linear(hidden_size, self.all_head_size) # dropout self.dropout = nn.Dropout(dropout_prob) def transpose_for_scores(self, x): # INPUT: x'shape = [bs, seqlen, hid_size] 假设hid_size=128 new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size) # [bs, seqlen, 8, 16] x = x.view(*new_x_shape) # return x.permute(0, 2, 1, 3) # [bs, 8, seqlen, 16] def forward(self, hidden_states, attention_mask): # eg: attention_mask = torch.LongTensor([[1, 1, 1], [1, 1, 0]]) shape=[bs, seqlen] attention_mask = attention_mask.unsqueeze(1).unsqueeze(2) # [bs, 1, 1, seqlen] 增加维度 attention_mask = (1.0 - attention_mask) * -10000.0 # padding的token置为-10000，exp(-1w)=0 # 线性变换 mixed_query_layer = self.query(hidden_states) # [bs, seqlen, hid_size] mixed_key_layer = self.key(hidden_states) # [bs, seqlen, hid_size] mixed_value_layer = self.value(hidden_states) # [bs, seqlen, hid_size] query_layer = self.transpose_for_scores(mixed_query_layer) # [bs, 8, seqlen, 16] key_layer = self.transpose_for_scores(mixed_key_layer) value_layer = self.transpose_for_scores(mixed_value_layer) # [bs, 8, seqlen, 16] # Take the dot product between "query" and "key" to get the raw attention scores. # 计算query与title之间的点积注意力分数，还不是权重（个人认为权重应该是和为1的概率分布） attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2)) # [bs, 8, seqlen, 16]*[bs, 8, 16, seqlen] ==> [bs, 8, seqlen, seqlen] attention_scores = attention_scores / math.sqrt(self.attention_head_size) # [bs, 8, seqlen, seqlen] # 除以根号注意力头的数量，可看原论文公式，防止分数过大，过大会导致softmax之后非0即1 attention_scores = attention_scores + attention_mask # 加上mask，将padding所在的表示直接-10000 # 将注意力转化为概率分布，即注意力权重 attention_probs = nn.Softmax(dim=-1)(attention_scores) # [bs, 8, seqlen, seqlen] # This is actually dropping out entire tokens to attend to, which might # seem a bit unusual, but is taken from the original Transformer paper. attention_probs = self.dropout(attention_probs) # 矩阵相乘，[bs, 8, seqlen, seqlen]*[bs, 8, seqlen, 16] = [bs, 8, seqlen, 16] context_layer = torch.matmul(attention_probs, value_layer) # [bs, 8, seqlen, 16] context_layer = context_layer.permute(0, 2, 1, 3).contiguous() # [bs, seqlen, 8, 16] new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) # [bs, seqlen, 128] context_layer = context_layer.view(*new_context_layer_shape) return context_layer # [bs, seqlen, 128] 得到输出
attention=SelfAttention(4,2,0.2) x_in=torch.randn(3,5,4) x_mask=torch.Tensor([[1,1,1,0,0], [1,1,0,0,0], [1,1,1,1,1],]) print(x_mask.shape) x_out=attention(x_in,x_mask)
