tensorflow实现seq2seq:完整部分

72 阅读 0 评论 48 点赞

我是靠谱客的博主欣慰鞋垫，最近开发中收集的这篇文章主要介绍tensorflow实现seq2seq:完整部分，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

完整源码地址：https://github.com/colin0000007/seq2seq

源码中我将实现封装为了2个类，一个BasicSeq2SeqModel，一个AttentionSeq2SeqModel。前者包含了bi-rnn，beam search等特效，后者只是多了attention。下面详细讲讲BasicSeq2SeqModel。

1.训练数据

seq2seq数据分为源序列，目标序列。

这里的测试数据源序列是字母序列，目标序列是字母序列的倒序。

例如:

source:
ozi
dzrkwam
cuemir
krmwaes
target:
izo
mawkrzd
rimeuc
seawmrk

训练好模型后，输入一个字母序列，期望得到这个序列的倒序。

2.输入和数据

source:就是源序列

target：就是目标序列

比如seq2seq的机器翻译中，source就是被翻译的句子。

Target就是翻译到的句子。

第一步首先定义输入的tensor。包括：

source的tensor，shape=[batchsize,src_max_len]

target的tensor，shape=[batchsize,max_len]

这里有一个问题是，最终的标签（y）是什么？实际上就是target

序列生成的过程。

比如：

Source： abcd

Target：dcba

如果统计后知道src_max_len = 5,tgt_max_len=6

需要对tgt_max_len+1，因为target_x和target_y中分别包含了<s>和</s>

对于不足长度的样本补充<pad>

其次还需在target中添加<s></s>表示序列的开始和结尾。

那么最后的数据应该是这样：

source：

a b c d <pad>

target_x:

target_y:

d c b a </s> <pad>

也就是用<s>加上source上下文向量预测a

用a加上source 上下文向量预测b

生成时遇到</s>或者达到最大生成序列长度就结束。

一般都需要对source和target做embeding。至于是否需要单独为target_x和target_y声明2个tensor完全取决你自己。因为decoder最终使用的embedding后的tensor，此时对原来的target tensor处理一下就可以作为target_y。另外在实现时使用的tf.contrib.seq2seq.sequence_loss，并不要求把target_y变成one-hot向量。

对应代码部分：

#定义encoder的输入tensor，加入了词嵌入
def input_tensor():
#这里设置位None，意思是不指定batch_size用到多少就是多少
source_batch = tf.placeholder(tf.int32,[None,None],name="source_batch")
#对source做词嵌入，词向量矩阵的shape为[source的词库大小,嵌入维度]
#嵌入矩阵中每一行就是一个词向量
source_embedding = tf.get_variable(shape=[source_vocab_size,source_embedding_size],name='source_embedding')
#使用embedding_lookup从embedding矩阵中查询词向量从而将X的每一个单词的index转换一个词向量
embedded_source_batch = tf.nn.embedding_lookup(source_embedding,source_batch)
#最后返回的embedded_X.shape = [batch_size,time_step,embedding_size]
#target类似
target_batch_x = tf.placeholder(tf.int32,[None,None])
target_batch_y = tf.placeholder(tf.int32,[None,None])
target_embedding = tf.get_variable(shape=[target_vocab_size,source_embedding_size],name='target_embedding')
embedded_target_batch_x = tf.nn.embedding_lookup(target_embedding,target_batch_x)
source_batch_seq_len = tf.placeholder(tf.int32,[None],name="source_batch_seq_len")
target_batch_seq_len = tf.placeholder(tf.int32,[None],name="target_batch_seq_len")
#保存当前batch的最长序列值，mask的时候需要用到
tgt_batch_max_len = tf.placeholder(tf.int32,[],name="target_batch_max_len")
return embedded_source_batch,embedded_target_batch_x,source_batch,target_batch_x,target_batch_y,source_batch_seq_len,target_batch_seq_len,target_embedding,tgt_batch_max_len

3.encoder

encoder比较简单，就是堆叠几层rnn cell就行了，关于encoder我以前一直有个错误的想法，以为需要单独训练encoder，实际上并不是，encoder是和decoder连接到一起的，做梯度下降时参数一并更新。

#参照tensorflow/nmt的官方教程
def build_encoder(embedded_source_batch,source_batch_seq_len):
#定义rnn cell的获取
def get_rnn_cell():
return tf.nn.rnn_cell.LSTMCell(num_units=rnn_num_units)
#定义encoder的rnn_layer
rnn_layer = tf.nn.rnn_cell.MultiRNNCell([get_rnn_cell() for _ in range(rnn_cell_size)])
#将rnn沿时间序列展开
#
encoder_outputs: 返回了每一个序列节点的output，shape为[batch_size,max_time, num_units]
#
encoder_state: 返回了每个cell最后一个序列节点的state输出，shape为cell个数*[batch_size, num_units]
#
sequence_length:传入一个list保存每个样本的序列的真实长度，教程中说这样做有助于提高效率
encoder_outputs, encoder_state = tf.nn.dynamic_rnn(
rnn_layer, embedded_source_batch,
sequence_length=source_batch_seq_len, time_major=False,dtype=tf.float32)
return encoder_outputs, encoder_state

4.decoder

decoder要麻烦一些，首选定义rnn cell，还需要定义projection layer，映射层。它的作用是将decoder的rnn输出映射为大小target词库大小，这样可以做分类。训练用到trainingHelper，测试阶段可以使用GreedyEmbeddingHelper或者beamSearch来解码。inference定义的decoder需要用到训练定义的decoder，这样可以共享rnn参数，projection layer的参数。具体看代码：

训练encoder：

def build_decoder(encoder_outputs, encoder_state,embedded_target_batch_x,target_batch_seq_len,target_embedding):
def get_rnn_cell():
return tf.nn.rnn_cell.LSTMCell(num_units=rnn_num_units)
rnn_layer = tf.nn.rnn_cell.MultiRNNCell([get_rnn_cell() for _ in range(rnn_cell_size)])
#decoder：需要helper，rnn cell，helper被分离开可以使用不同的解码策略，比如预测时beam search，贪婪算法
#这里projection_layer就是一个全连接层，encoder_state连接到encoder_embede后的向量维度不能和target词汇数量一致所以需要映射层
#这里使用tensorflow.python.keras.layers.core.Dense一直报错
#换成tf.layers.Dense后解决 但是我在另一份能够运行的seq2seq代码中发现使用上面的Dense并不会报错
projection_layer = tf.layers.Dense(units=target_vocab_size,kernel_initializer = tf.truncated_normal_initializer(mean = 0.0, stddev=0.1))
training_helper = tf.contrib.seq2seq.TrainingHelper(
embedded_target_batch_x, target_batch_seq_len, time_major=False)
decoder = tf.contrib.seq2seq.BasicDecoder(
rnn_layer, training_helper, encoder_state,
output_layer=projection_layer)
#将序列展开
decoder_output,_,_ = tf.contrib.seq2seq.dynamic_decode(decoder,output_time_major=False,maximum_iterations=target_max_len)
#decoder_output的shape:[batch_size,序列长度,target_vocab_size]
return decoder_output,rnn_layer,projection_layer

inference阶段的decoder：

#推理阶段，也就是预测阶段
def inference(target_embedding,encoder_state,decoder_rnn_layer,decoder_projection_layer):
inuput_batch = tf.placeholder(dtype=tf.int32, shape=[1],name="input_batch")
start_tokens = tf.tile(tf.constant(value=start_token_id, dtype=tf.int32,shape=[1]), multiples = inuput_batch, name="start_tokens_2")
predicting_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(target_embedding,start_tokens,end_token_id)
predicting_decoder = tf.contrib.seq2seq.BasicDecoder(
decoder_rnn_layer, predicting_helper, encoder_state,
output_layer=decoder_projection_layer)
predicting_decoder_output, _ ,_= tf.contrib.seq2seq.dynamic_decode(predicting_decoder,output_time_major=False,maximum_iterations=target_max_len)
tf.identity(predicting_decoder_output.sample_id, name='predictions2')

4.loss构建，训练计算图构建等

直接贴代码，更多细节问题参考前几篇说细节的文章。

def seq2seq_model(embedded_source_batch,source_batch_seq_len,embedded_target_batch_x,target_batch_seq_len,target_embedding):
encoder_outputs, encoder_state = build_encoder(embedded_source_batch, source_batch_seq_len)
decoder_output,rnn_layer,projection_layer = build_decoder(encoder_outputs, encoder_state, embedded_target_batch_x, target_batch_seq_len, target_embedding)
inference(target_embedding, encoder_state, rnn_layer, projection_layer)
print("encoder_outputs:",encoder_outputs)
print("encoder_state:",encoder_state)
print("decoder_output:",decoder_output)
return decoder_output
def build_graph():
#构造计算图
train_graph = tf.Graph()
with train_graph.as_default():
#1.tensor声明
embedded_source_batch,embedded_target_batch_x,source_batch,target_batch_x,target_batch_y,source_batch_seq_len,target_batch_seq_len,target_embedding,tgt_batch_max_len = input_tensor()
#2.构造seq2seq产生的output tensor
decoder_output = seq2seq_model(embedded_source_batch, source_batch_seq_len, embedded_target_batch_x, target_batch_seq_len,target_embedding)
#1和2这个步骤必须在同一个graph下声明
#对这2个decoder的输出获取不同的tensor并且取名字
training_logits = tf.identity(decoder_output.rnn_output, 'logits')
print("training_logits.shape:",training_logits.shape)
#尝试是否能成功
#mask的作用是：计算loss时忽略pad的部分，这部分的loss不需要算，提升性能，
masks = tf.sequence_mask(target_batch_seq_len, tgt_batch_max_len, dtype=tf.float32, name='masks')
with tf.name_scope("optimization"):
#loss
#这里尝试使用下tensorflow-nmt官方教程中的tf.nn.sparse_softmax_cross_entropy_with_logits
#不测试了，不能使用mask
loss = tf.contrib.seq2seq.sequence_loss(
training_logits,
target_batch_y,
masks)
optimizer = tf.train.AdamOptimizer(lr)
# Gradient Clipping
gradients = optimizer.compute_gradients(loss)
capped_gradients = [(tf.clip_by_value(grad, -5., 5.), var) for grad, var in gradients if grad is not None]
train_op = optimizer.apply_gradients(capped_gradients)
return train_graph,loss,train_op,source_batch,target_batch_x,target_batch_y,source_batch_seq_len,target_batch_seq_len,tgt_batch_max_len

这篇本来打算连着前面几个一起写完的，一期末就忙忘了，很多东西也有点不熟悉了，写得很水。