先看看seq2seq原理：
encoder通过学习将输入embedding后传入rnn网络形成一个固定大小的状态向量S，并将S传给Decoder, Decoder一样通过学习embedding后传入RNN网络，并输出预测结果。
优缺点：
这样可以解决输入和输出不等长的问题，如文本翻译。但是因为encoder到decoder都依赖一个固定大小的状态向量S，所以咱们可以想象一下，信息越大，转化成为的S损失越大，随着序列长度增加，S损失的信息会越来越大。这个是Seq2seq的缺陷，所以要引入attention及Bi-directional encoder layer等。
1.Encoder分两步：
1.1 首先把输入进行embedding完成对输入序列数据嵌入工作，这里用到tf.contrib.layers.embed_sequence。
假如我们有一个batch=2，sequence_length=5的样本，features = [[1,2,3,4,5],[6,7,8,9,10]]，使用tf.contrib.layers.embed_sequence(features,vocab_size=n_words, embed_dim=10)
那么我们会得到一个2 x 5 x 10的输出，其中features中的每个数字都被embed成了一个10维向量。
encoder_embed_input = tf.contrib.layers.embed_sequence(input_data, source_vocab_size, encoding_embedding_size)
1.2 然后embedding完的向量传入RNN进行处理，返回encoder_output, encoder_state
def get_lstm_cell(rnn_size):
lstm_cell = tf.contrib.rnn.LSTMCell(rnn_size, initializer=tf.random_uniform_initializer(-0.1, 0.1, seed=2))
return lstm_cell
cell = tf.contrib.rnn.MultiRNNCell([get_lstm_cell(rnn_size) for _ in range(num_layers)])
encoder_output, encoder_state = tf.nn.dynamic_rnn(cell, encoder_embed_input,
sequence_length=source_sequence_length, dtype=tf.float32)
2.Decoder分三步
2.1 对target数据进行预处理
为什么这一步要做预处理？
- 左边encoder红框很简单，A,B,C融汇成一个输出
- 右边decoder红框接受一个输出后，传给每个RNN进行解码
- <GO>为解码开始符 <EOS>为解码结束符
我们预处理就要对encoder传过来的输出（添加<GO>，去掉<EOS>），用tf.strided_slice()
def process_decoder_input(data, vocab_to_int, batch_size):
'''
补充<GO>，并移除最后一个字符
'''
# cut掉最后一个字符
ending = tf.strided_slice(data, [0, 0], [batch_size, -1], [1, 1])
decoder_input = tf.concat([tf.fill([batch_size, 1], vocab_to_int['<GO>']), ending], 1)
return decoder_input
2.2 对target数据进行embedding
target_vocab_size = len(target_letter_to_int)
decoder_embeddings = tf.Variable(tf.random_uniform([target_vocab_size, decoding_embedding_size]))
decoder_embed_input = tf.nn.embedding_lookup(decoder_embeddings, decoder_input)
2.3 处理完的数据传入RNN，返回训练和预测的output
def get_decoder_cell(rnn_size):
decoder_cell = tf.contrib.rnn.LSTMCell(rnn_size,
initializer=tf.random_uniform_initializer(-0.1, 0.1, seed=2))
return decoder_cell
cell = tf.contrib.rnn.MultiRNNCell([get_decoder_cell(rnn_size) for _ in range(num_layers)])
output_layer = Dense(target_vocab_size,
kernel_initializer = tf.truncated_normal_initializer(mean = 0.0, stddev=0.1))
Training Decoder
with tf.variable_scope("decode"):
# 得到help对象
training_helper = tf.contrib.seq2seq.TrainingHelper(inputs=decoder_embed_input,
sequence_length=target_sequence_length,
time_major=False)
# 构造decoder
training_decoder = tf.contrib.seq2seq.BasicDecoder(cell,
training_helper,
encoder_state,
output_layer)
training_decoder_output, _ = tf.contrib.seq2seq.dynamic_decode(training_decoder,
impute_finished=True,
maximum_iterations=max_target_sequence_length)
Prediction decoder
# 与training共享参数
with tf.variable_scope("decode", reuse=True):
# 创建一个常量tensor并复制为batch_size的大小
start_tokens = tf.tile(tf.constant([target_letter_to_int['<GO>']], dtype=tf.int32), [batch_size],
name='start_tokens')
predicting_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(decoder_embeddings,
start_tokens,
target_letter_to_int['<EOS>'])
predicting_decoder = tf.contrib.seq2seq.BasicDecoder(cell,
predicting_helper,
encoder_state,
output_layer)
predicting_decoder_output, _ = tf.contrib.seq2seq.dynamic_decode(predicting_decoder,
impute_finished=True,
maximum_iterations=max_target_sequence_length)
return training_decoder_output, predicting_decoder_output
3.完成了encoder和decoder之后，再把两者连接起来形成seq2seq模型
def seq2seq_model(input_data, targets, lr, target_sequence_length,
max_target_sequence_length, source_sequence_length,
source_vocab_size, target_vocab_size,
encoder_embedding_size, decoder_embedding_size,
rnn_size, num_layers):
# 获取encoder的状态输出
_, encoder_state = get_encoder_layer(input_data,
rnn_size,
num_layers,
source_sequence_length,
source_vocab_size,
encoding_embedding_size)
# 预处理后的decoder输入
decoder_input = process_decoder_input(targets, target_letter_to_int, batch_size)
# 将状态向量与输入传递给decoder
training_decoder_output, predicting_decoder_output = decoding_layer(target_letter_to_int,
decoding_embedding_size,
num_layers,
rnn_size,
target_sequence_length,
max_target_sequence_length,
encoder_state,
decoder_input)
return training_decoder_output, predicting_decoder_output
这是个简单的seq2seq模型，只是对单词的字母进行简单的排序，数据处理部分也比较简单，符合本篇的宗旨：讲清楚什么是seq2seq模型。下一篇将应用seq2seq模型进行英法两种语言的文本翻译实战。
