此分类模型是来自序列模型Convolutional Sequence to Sequence Learning，整体构架如上图所示。
原论文是用来做语言翻译，这里我将稍微修改用来做问答中的slot filling和intent detection联合建模。
本项目中的图片和原始代码是改自https://github.com/bentrevett/pytorch-seq2seq 在此非常感谢作者实现了这么通俗易懂的代码架构，可以让其它人在上面进行修改。
Encoder:
1.句子token和其对应的position经过embedding后，逐元素加和作为source embedding。
2.source embedding经过： 线性层 -> 卷积块后得到的特征 -> 线性层。
3.以上的输出和source embedding进行残差连接。
4.以上的输出，我这里加了一个平均池化后进入线性层，预测输出intent概率。（这时是用来做intent detection，即意图识别）
5.原模型的encoder的输出包含两部分，一个是卷积输出；一个是卷积输出 + source embedding -> 这两个输出将用于deocder中的卷积块中计算相应attention context。Encoder-conv(encoder中的卷积块):
1.卷积块的初始输入是 source embedding加一个线性层，padding后输入卷积。
2.卷积后经过glu激活函数
3.激活后的输出和padding后的输入进行残差连接，进入下一个卷积块。
4.最终输出卷积特征。Decoder:
1.target标签的token和其对应的position经过embedding后，逐元素加和作为target embedding。
2.target embedding经过线性层的输出和target embedding -> 卷积块后得到的特征 -> 线性层。
3.再一次经过线性层输出预测slot标签概率。
注：可以到deocder的卷积块的输入还包含还来encoder的两个输出conved,combinedDecoder-conv(decoder中的卷积块):
1.卷积块的初始输入包含4个部分，分别是：target embedding; 经过一个线性层的target embedding; encoder的卷积块输出conved； encoder联合了source embedding和卷积块的输出conved的联合输出combined。
2.与encoder的卷积块类似，卷积后经过glu激活函数
3.激活后的输出和target embedding; encoder conved; encoder combined一起计算attention。
4.经过以上计算的输出，和padding后的输入进行残差连接。
5.以上的输出进入下一个卷积块。
程序(完整项目见：https://github.com/jiangnanboy/intent_detection_and_slot_filling/blob/master/model4/train.ipynb):
'''
编码器Encoder的实现
'''
class Encoder(nn.Module):
def __init__(self, input_dim, emb_dim, intent_dim, hid_dim, n_layers, kernel_size, dropout, max_length=50):
super(Encoder, self).__init__()
assert kernel_size % 2 == 1,'kernel size must be odd!' # 卷积核size为奇数，方便序列两边pad处理
self.scale = torch.sqrt(torch.FloatTensor([0.5])).to(device) # 确保整个网络的方差不会发生显著变化
self.tok_embedding = nn.Embedding(input_dim, emb_dim) # token编码
self.pos_embedding = nn.Embedding(max_length, emb_dim) # token的位置编码
self.emb2hid = nn.Linear(emb_dim, hid_dim) # 线性层，从emb_dim转为hid_dim
self.hid2emb = nn.Linear(hid_dim, emb_dim) # 线性层，从hid_dim转为emb_dim
# 卷积块
self.convs = nn.ModuleList([nn.Conv1d(in_channels=hid_dim,
out_channels=2*hid_dim, # 卷积后输出的维度，这里2*hid_dim是为了后面的glu激活函数
kernel_size=kernel_size,
padding=(kernel_size - 1)//2) # 序列两边补0个数，保持维度不变
for _ in range(n_layers)])
self.dropout = nn.Dropout(dropout)
# intent detection 意图识别
self.intent_output = nn.Linear(emb_dim, intent_dim)
def forward(self, src):
# src: [batch_size, src_len]
batch_size = src.shape[0]
src_len = src.shape[1]
# 创建token位置信息
pos = torch.arange(src_len).unsqueeze(0).repeat(batch_size, 1).to(device) # [batch_size, src_len]
# 对token与其位置进行编码
tok_embedded = self.tok_embedding(src) # [batch_size, src_len, emb_dim]
pos_embedded = self.pos_embedding(pos.long()) # [batch_size, src_len, emb_dim]
# 对token embedded和pos_embedded逐元素加和
embedded = self.dropout(tok_embedded + pos_embedded) # [batch_size, src_len, emb_dim]
# embedded经过一线性层，将emb_dim转为hid_dim，作为卷积块的输入
conv_input = self.emb2hid(embedded) # [batch_size, src_len, hid_dim]
# 转变维度，卷积在输入数据的最后一维进行
conv_input = conv_input.permute(0, 2, 1) # [batch_size, hid_dim, src_len]
# 以下进行卷积块
for i, conv in enumerate(self.convs):
# 进行卷积
conved = conv(self.dropout(conv_input)) # [batch_size, 2*hid_dim, src_len]
# 进行激活glu
conved = F.glu(conved, dim=1) # [batch_size, hid_dim, src_len]
# 进行残差连接
conved = (conved + conv_input) * self.scale # [batch_size, hid_dim, src_len]
# 作为下一个卷积块的输入
conv_input = conved
# 经过一线性层，将hid_dim转为emb_dim，作为enocder的卷积输出的特征
conved = self.hid2emb(conved.permute(0, 2, 1)) # [batch_size, src_len, emb_dim]
# 又是一个残差连接，逐元素加和输出，作为encoder的联合输出特征
combined = (conved + embedded) * self.scale # [batch_size, src_len, emb_dim]
# 意图识别,加一个平均池化,池化后的维度是：[batch_size, emb_dim]
intent_output = self.intent_output(F.avg_pool1d(combined.permute(0, 2, 1), combined.shape[1]).squeeze()) # [batch_size, intent_dim]
return conved, combined, intent_output
'''
解码器Decoder实现
'''
class Decoder(nn.Module):
def __init__(self, output_dim, emb_dim, hid_dim, n_layers,kernel_size, dropout, trg_pad_idx, max_length=50):
super(Decoder, self).__init__()
self.kernel_size = kernel_size
self.trg_pad_idx = trg_pad_idx
self.scale = torch.sqrt(torch.FloatTensor([0.5])).to(device)
self.tok_embedding = nn.Embedding(output_dim, emb_dim)
self.pos_embedding = nn.Embedding(max_length, emb_dim)
self.emb2hid = nn.Linear(emb_dim, hid_dim)
self.hid2emb = nn.Linear(hid_dim, emb_dim)
self.attn_hid2emb = nn.Linear(hid_dim, emb_dim)
self.attn_emb2hid = nn.Linear(emb_dim, hid_dim)
# slot filling，槽填充
self.slot_out = nn.Linear(emb_dim, output_dim)
self.convs = nn.ModuleList([nn.Conv1d(in_channels=hid_dim,
out_channels=2*hid_dim,
kernel_size=kernel_size)
for _ in range(n_layers)])
self.dropout = nn.Dropout(dropout)
def calculate_attention(self, embedded, conved, encoder_conved, encoder_combined):
'''
embedded:[batch_size, trg_Len, emb_dim]
conved:[batch_size, hid_dim, trg_len]
encoder_conved:[batch_size, src_len, emb_dim]
encoder_combined:[batch_size, src_len, emb_dim]
'''
# 经过一线性层，将hid_dim转为emb_dim，作为deocder的卷积输出的特征
conved_emb = self.attn_hid2emb(conved.permute(0, 2, 1)) # [batch_size, trg_len, emb_dim]
# 一个残差连接，逐元素加和输出，作为decoder的联合输出特征
combined = (conved_emb + embedded) * self.scale # [batch_size, trg_len, emb_dim]
# decoder的联合特征combined与encoder的卷积输出进行矩阵相乘
energy = torch.matmul(combined, encoder_conved.permute(0, 2, 1)) # [batch_size, trg_len, src_len]
attention = F.softmax(energy, dim=2) # [batch_size, trg_len, src_len]
attention_encoding = torch.matmul(attention, encoder_combined) # [batch_size, trg_len, emb_dim]
# 经过一线性层，将emb_dim转为hid_dim
attended_encoding = self.attn_emb2hid(attention_encoding) # [batch_size, trg_len, hid_dim]
# 一个残差连接，逐元素加和输出
attended_combined = (conved + attended_encoding.permute(0, 2, 1)) * self.scale # [batch_size, hid_dim, trg_len]
return attention, attended_combined
def forward(self, trg, encoder_conved, encoder_combined):
'''
trg:[batch_size, trg_len]
encoder_conved:[batch_size, src_len, emb_dim]
encoder_combined:[batch_size, src_len, emb_dim]
'''
batch_size = trg.shape[0]
trg_len = trg.shape[1]
# 位置编码
pos = torch.arange(trg_len).unsqueeze(0).repeat(batch_size, 1).to(device) # [batch_size, trg_len]
# 对token和pos进行embedding
tok_embedded = self.tok_embedding(trg) # [batch_size, trg_len, emb_dim]
pos_embedded = self.pos_embedding(pos.long()) # [batch_size, trg_len, emb_dim]
# 对token embedded和pos_embedded逐元素加和
embedded = self.dropout(tok_embedded + pos_embedded) # [batch_size, trg_len, emb_dim]
# 经过一线性层，将emb_dim转为hid_dim，作为卷积的输入
conv_input = self.emb2hid(embedded) # [batch_size, trg_len, hid_dim]
# 转变维度，卷积在输入数据的最后一维进行
conv_input = conv_input.permute(0, 2, 1) # [batch_size, hid_dim, trg_len]
batch_size = conv_input.shape[0]
hid_dim = conv_input.shape[1]
# 卷积块
for i, conv in enumerate(self.convs):
conv_input = self.dropout(conv_input)
# 在序列的一端进行pad
padding = torch.zeros(batch_size, hid_dim, self.kernel_size - 1).fill_(self.trg_pad_idx).to(device)
padded_conv_input = torch.cat((padding, conv_input), dim=2) # [batch_size, hid_dim, trg_len + kernel_size - 1]
# 进行卷积
conved = conv(padded_conv_input) # [batch_size, 2 * hid_dim, trg_len]
# 经过glu激活，会将原hidden_dim分成两部分
conved = F.glu(conved, dim=1) # [batch_size, hid_dim, trg_len]
# 计算attention
attention, conved = self.calculate_attention(embedded, conved, encoder_conved, encoder_combined) # [batch_size, trg_len, src_len], [batch_size, hid_dim, trg_len]
# 残差连接
conved = (conved + conv_input) * self.scale # [batch_size, hid_dim, trg_len]
# 作为下一层卷积的输入
conv_input = conved
conved = self.hid2emb(conved.permute(0, 2, 1)) # [batch_size, trg_len, emb_dim]
# 预测输出
output = self.slot_out(self.dropout(conved)) # [batch_size, trg_len, output_dim]
return output, attention
# 包装Encoder与Decoer
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
# 编码器
self.encoder = encoder
# 解码器用于slot槽识别
self.decoder = decoder
def forward(self, src, trg):
'''
src:[batch_size, src_len]
trg:[batch_size, trg_Len-1] # decoder的输入去除了<eos>
encoder_conved是encoder中最后一个卷积层的输出
encoder_combined是encoder_conved + (src_embedding + postional_embedding)
'''
encoder_conved, encoder_combined, intent_output = self.encoder(src) # [batch_size, src_len, emb_dim]; [batch_size, src_len, emb_dim]
# decoder是对一批数据进行预测输出
slot_output, attention = self.decoder(trg, encoder_conved, encoder_combined) # [batch_size, trg_len-1, output_dim]; [batch_size, trg_len-1, src_len]
return intent_output, slot_output, attention