14Seq2Seq原理(1)

先看看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数据进行预处理
为什么这一步要做预处理？

image.png

• 左边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模型进行英法两种语言的文本翻译实战。