seq2seq模型实现英文反义词翻译
一、seq2seq简介
seq2seq模型是自然语言处理任务中一个常见的模型，于2014年由Google团队提出，该模型的创新之处在于将encoder-decoder框架应用到了RNN/LSTM中，文章中输入序列通过多层LSTM组成的encoder被映射成一个固定维度的中间语义编码向量C，另一组多层LSTM组成的decoder将中间语义编码向量C映射成目标序列。
下面是论文中seq2seq的输入输出图形化解释：
说明：seq2seq模型的输入序列是A，B，C，输出序列是W，X，Y，Z，蓝色部分是encoder，红色部分是decoder。
注：seq2seq原文可以在这里下载。
二、训练样本的预处理
现在利用seq2seq模型实现一个简单的英文反义词翻译实验，模型的输入是一个词，输出是其对应的反义词，为了方便起见，我们的训练数据是很简单的，只有 6 组，并且每个英文单词的长度不会超过 5，训练数据的形式如下：
[['man', 'women'], ['black', 'white'], ['king', 'queen'], ['girl', 'boy'], ['up', 'down'], ['high', 'low']]
说明：原始训练样本是一个二维的矩阵，用 seq_data 表示，每一行表示一组训练样本，第一个元素表示原始序列，第二个元素表示目标序列。
由于英文单词的长度都不会超过 5，因此定义时间步 n_step = 5，隐藏层 n_hidden = 128。考虑到英文单词的字母总共有 26 个，于是字符列表 char_arr 中必须加入 26 个英文字符（默认是小写）。训练数据单词的长度往往不一致，因此需要将其 padding 成相同长度的序列，于是还要给字符列表 char_arr 中加入一个 padding 符 ‘P’，另外，还需要将起始符 ‘S’ 和终止符 ‘E’ 加入字符列表 char_arr。
之后对字符列表进行字典化，然后对训练样本目的是把英文的输入样本转换成序列化的表示形式。代码如下：
n_step = 5 # n_step表示输入单词的最大长度
n_hidden = 128
char_arr = [c for c in "SEPabcdefghijklmnopqrstuvwxyz"]
num_dic = {c: i for i, c in enumerate(char_arr)}
int_dic = {i: c for i, c in enumerate(char_arr)}
seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'],
['girl', 'boy'], ['up', 'down'], ['high', 'low']]
n_class = len(char_arr)
batch_size = len(seq_data)
# 深拷贝
seq_copy = copy.deepcopy(seq_data)
inp, out, tar = make_batch()
对于第一组训练样本 [‘man’, ‘women’] 而言，如何得到 ‘man’ 的序列化输入呢？
首先，由于’man’ 的长度 3 是小于 n_step 的，因此需要在 ‘man’ 的后面填充 n_step - 3 个长度的 ‘P’，然后对于 ‘manPP’ 可以根据字典 num_dic 得到对应的序列表示 [15, 3, 16, 2, 2]，之后获得 'manPP’中每个字母的 one-hot 表示，是一个 5 * 29维的稀疏矩阵。于是，'man’就转换成了网络可以识别的形式。‘woman’ 是 ‘man’ 的标签数据，预处理是类似的，不同之处在于，‘woman’ 需要给最前面加上起始符 ‘S’。全部样本的预处理代码如下：
def make_batch():
input_batch = []
output_batch = []
target_batch = []
for seq in seq_copy:
for i in range(2):
seq[i] = seq[i] + 'P' * (n_step - len(seq[i]))
inp = [num_dic[s] for s in seq[0]]
out = [num_dic[s] for s in ('S' + seq[1])]
tar = [num_dic[s] for s in (seq[1] + 'E')]
input_batch.append(np.eye(n_class)[inp]) # 训练样本的输入向量表示
output_batch.append(np.eye(n_class)[out]) # 训练样本的输出向量表示
target_batch.append(tar) # 用于计算损失函数的输出向量表示
return torch.FloatTensor(input_batch), torch.FloatTensor(output_batch), torch.LongTensor(target_batch)
三、模型训练
模型训练过程如下：
# 定义损失函数和优化器
model = seq2seq()
model.train()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(4000):
# 初始化隐藏层的状态
hidden = torch.zeros(1, batch_size, n_hidden)
output = model(inp, hidden)
output = output.transpose(0, 1) # output：[batch_size, num_step(n_step + 1), n_class]
# 计算损失
optimizer.zero_grad()
loss = 0
for i in range(output.shape[0]):
loss += criterion(output[i], tar[i])
# output[i]：[n_step+1, n_class], tar[i]：[n_step+1]
if epoch % 200 == 0:
print("epoch:{} loss:{:.6f}".format(epoch, loss))
loss.backward()
optimizer.step()
四、全部代码
最后给出了预测部分，测试的样本选取的是训练样本，这里仅仅是为了说明问题。
# !-*- coding:utf-8 -*-
# @author:zhangsa
# @file:.py
import numpy as np
import torch.nn as nn
import torch
import copy
def make_batch():
input_batch = []
output_batch = []
target_batch = []
for seq in seq_copy:
for i in range(2):
seq[i] = seq[i] + 'P' * (n_step - len(seq[i]))
inp = [num_dic[s] for s in seq[0]]
out = [num_dic[s] for s in ('S' + seq[1])]
tar = [num_dic[s] for s in (seq[1] + 'E')]
input_batch.append(np.eye(n_class)[inp]) # 训练样本的输入向量表示
output_batch.append(np.eye(n_class)[out]) # 训练样本的输出向量表示
target_batch.append(tar) # 用于计算损失函数的输出向量表示
return torch.FloatTensor(input_batch), torch.FloatTensor(output_batch), torch.LongTensor(target_batch)
class seq2seq(nn.Module):
def __init__(self):
super().__init__()
self.enc_cell = nn.RNN(input_size=n_class, hidden_size=n_hidden)
self.dec_cell = nn.RNN(input_size=n_class, hidden_size=n_hidden)
self.fc = nn.Linear(n_hidden, n_class)
def forward(self, enc_input, hidden):
batch_size = enc_input.shape[0]
enc_input = enc_input.transpose(0, 1) # enc_shape：[num_step(n_step), batch_size, n_class]
# dec_input = dec_input.transpose(0, 1) # dec_shape：[num_step(n_step + 1), batch_size, n_class]
# 编码器的输入时随机初始化
dec_input = torch.randint(n_class, (n_step + 1, batch_size, n_class)).type(dtype=torch.FloatTensor)
_, enc_state = self.enc_cell(enc_input, hidden) # enc_state：中间的语义编码 c
# enc_state：[1, batch_size, n_hidden]
dec_out, _ = self.dec_cell(dec_input, enc_state)
# dec_out：[num_step(n_step + 1), batch_size, n_hidden]
out = self.fc(dec_out) # out：[num_step(n_step + 1), batch_size, n_class]
return out
if __name__ == "__main__":
n_step = 5 # n_step表示输入单词的最大长度
n_hidden = 128
char_arr = [c for c in "SEPabcdefghijklmnopqrstuvwxyz"]
num_dic = {c: i for i, c in enumerate(char_arr)}
int_dic = {i: c for i, c in enumerate(char_arr)}
seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'],
['girl', 'boy'], ['up', 'down'], ['high', 'low']]
n_class = len(char_arr)
batch_size = len(seq_data)
# 深拷贝
seq_copy = copy.deepcopy(seq_data)
inp, out, tar = make_batch()
# 定义损失函数和优化器
model = seq2seq()
model.train()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(4000):
# 初始化隐藏层的状态
hidden = torch.zeros(1, batch_size, n_hidden)
output = model(inp, hidden)
output = output.transpose(0, 1) # output：[batch_size, num_step(n_step + 1), n_class]
# 计算损失
optimizer.zero_grad()
loss = 0
for i in range(output.shape[0]):
loss += criterion(output[i], tar[i])
# output[i]：[n_step+1, n_class], tar[i]：[n_step+1]
if epoch % 200 == 0:
print("epoch:{} loss:{:.6f}".format(epoch, loss))
loss.backward()
optimizer.step()
# 模型预测
def translation():
model.eval()
input_batch, output_batch, _ = make_batch()
hidden_state = torch.zeros(1, 6, n_hidden)
predict = model(input_batch, hidden_state) # predict：[num_step, batch_size, n_class]
predict = predict.transpose(0, 1) # predict：[batch_size, num_step, n_class]
predict_words = []
for i in range(predict.shape[0]):
_, pre_seq = torch.max(predict[i], dim=1)
pre_word = [int_dic[p] for p in pre_seq.detach().numpy()]
pre = ""
for p in pre_word:
if p == 'P' or p == 'E':
break
else:
pre += p
predict_words.append(pre)
return predict_words
print("test：")
for i in range(len(seq_data)):
print(seq_data[i][0], "-->", translation()[i])
五、参考文献
https://github.com/graykode/nlp-tutorial/blob/master/4-1.Seq2Seq/Seq2Seq.py
seq2seq原文