陈敬雷-充电了么-CEO兼CTO

Seq2Seq端到端神经网络介绍

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

- Seq2Seq端到端神经网络介绍
前言
一、Seq2Seq原理介绍
二、Seq2Seq代码实战
获取encoder的状态输出
总结

前言

Seq2Seq技术，全称Sequence to Sequence，该技术突破了传统的固定大小输入问题框架，开通了将经典深度神经网络模型（DNNs）运用于翻译与智能问答这一类序列型（Sequence Based，项目间有固定的先后关系）任务的先河，并被证实在机器翻译、对话机器人、语音辨识的应用中有着不俗的表现。下面就详细讲一下其原理和实现。

提示：以下是本篇文章正文内容，下面案例可供参考

一、Seq2Seq原理介绍

传统的Seq2Seq是使用两个循环神经网络，将一个语言序列直接转换到另一个语言序列。是循环神经网络的升级版，其联合了两个循环神经网络。一个神经网络负责接收源句子；另一个循环神经网络负责将句子输出成翻译的语言。这两个过程分别称为编码和解码的过程，如图7.38所示：

1）编码过程

编码过程实际上使用了循环神经网络记忆的功能，通过上下文的序列关系，将词向量依次输入网络。对于循环神经网络，每一次网络都会输出一个结果，但是编码的不同之处在于，其只保留最后一个隐藏状态，相当于将整句话浓缩在一起，将其存为一个内容向量（context）供后面的解码器（decoder）使用。

2）解码过程

解码和编码网络结构几乎是一样的，唯一不同的是在解码过程中，是根据前面的结果来得到后面的结果。编码过程中输入一句话，这一句话就是一个序列，而且这个序列中的每个词都是已知的，而解码过程相当于什么也不知道，首先需要一个标识符表示一句话的开始，然后接着将其输入网络得到第一个输出作为这句话的第一个词，接着通过得到的第一个词作为网络的下一个输入，得到的输出作为第二个词，不断循环，通过这种方式来得到最后网络输出的一句话。

3）使用序列到序列网络结构的原因

翻译的每句话的输入长度和输出长度一般来讲都是不同的，而序列到序列的网络结构的优势在于不同长度的输入序列能够能到任意长度的输出序列。使用序列到序列的模型，首先将一句话的所有内容压缩成一个内容向量然后通过一个循环网络不断地将内容提取出来，形成一句新的话。

二、Seq2Seq代码实战

了解了Seq2Seq原理和介绍，我们来做一个实践应用,做一个单词的字母排序,比如输入单词是’acbd’,输出单词是’abcd’,要让机器学会这种排序算法,就可以使用seq2seq的模型来完成,接下来我们分析一下核心步骤,最后会给予一个能直接运行的完整代码给大家学习

1）数据集的准备

这里有两个文件分别是source.txt和target.txt,对应的分别是输入文件和输出文件，代码如下所示：

#读取输入文件

with open(‘data/letters_source.txt’, ‘r’, encoding=‘utf-8’) as f:

source_data = f.read()

#读取输出文件

with open(‘data/letters_target.txt’, ‘r’, encoding=‘utf-8’) as f:

target_data = f.read()

2）数据集的预处理

填充序列，序列字符和ID的转换，代码如下所示：

#数据预处理

def extract_character_vocab(data):

使用特定的字符进行序列的填充

special_words = [’’, ‘’, ‘’, ‘’]

set_words = list(set([character for line in data.split(’\n’) for character in line]))

#这里要把四个特殊字符添加进词典

int_to_vocab = {idx: word for idx, word in enumerate(special_words + set_words)}

vocab_to_int = {word: idx for idx, word in int_to_vocab.items()}

return int_to_vocab, vocab_to_int

source_int_to_letter, source_letter_to_int = extract_character_vocab(source_data)

target_int_to_letter, target_letter_to_int = extract_character_vocab(target_data)

#对字母进行转换

source_int = [[source_letter_to_int.get(letter, source_letter_to_int[’’])

for letter in line] for line in source_data.split(’\n’)]

target_int = [[target_letter_to_int.get(letter, target_letter_to_int[’’])

for letter in line] + [target_letter_to_int[’’]] for line in target_data.split(’\n’)]

print(‘source_int_head’,source_int[:10])

填充字符含义：

< PAD>: 补全字符。

< EOS>: 解码器端的句子结束标识符。

< UNK>: 低频词或者一些未遇到过的词等。

< GO>: 解码器端的句子起始标识符。

3）创建编码层

创建编码层代码如下所示：

#创建编码层

def get_encoder_layer(input_data, rnn_size, num_layers,source_sequence_length, source_vocab_size,encoding_embedding_size):

#Encoder embedding

encoder_embed_input = layer.embed_sequence(ids=input_data, vocab_size=source_vocab_size,embed_dim=encoding_embedding_size)

RNN cell

def get_lstm_cell(rnn_size):

lstm_cell = rnn.LSTMCell(rnn_size, initializer=tf.random_uniform_initializer(-0.1, 0.1, seed=2))

return lstm_cell

指定多个lstm

cell = rnn.MultiRNNCell([get_lstm_cell(rnn_size) for _ in range(num_layers)])

#返回output,state

encoder_output, encoder_state = tf.nn.dynamic_rnn(cell=cell, inputs=encoder_embed_input,sequence_length=source_sequence_length, dtype=tf.float32)

return encoder_output, encoder_state

参数变量含义：

input_data: 输入tensor
rnn_size: rnn隐层结点数量
num_layers: 堆叠的rnn cell数量
source_sequence_length: 源数据的序列长度
source_vocab_size: 源数据的词典大小
encoding_embedding_size: embedding的大小

4）创建解码层

对编码之后的字符串进行处理，去除最后一个没用的字符串，代码如下所示：

#对编码数据进行处理,移除最后一个字符

def process_decoder_input(data, vocab_to_int, batch_size):

‘’’

补充，并移除最后一个字符

‘’’

#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[’’]), ending], 1)

return decoder_input

创建解码层代码如下所示：

#创建解码层

def decoding_layer(target_letter_to_int,

decoding_embedding_size,

num_layers, rnn_size,

target_sequence_length,

max_target_sequence_length,

encoder_state, decoder_input):

#1 构建向量

#目标词汇的长度

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)

构造Decoder中的RNN单元

def get_decoder_cell(rnn_size):

decoder_cell = rnn.LSTMCell(num_units=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)])

#3. Output全连接层

output_layer = Dense(units=target_vocab_size,kernel_initializer=tf.truncated_normal_initializer(mean=0.0, stddev=0.1))

#4. Training decoder

with tf.variable_scope(“decode”):

#得到help对象

training_helper = seq2seq.TrainingHelper(inputs=decoder_embed_input,sequence_length=target_sequence_length,time_major=False)

#构造decoder

training_decoder = seq2seq.BasicDecoder(cell=cell,helper=training_helper,initial_state=encoder_state,output_layer=output_layer)

training_decoder_output, _ ,_= seq2seq.dynamic_decode(decoder=training_decoder,impute_finished=True,maximum_iterations=max_target_sequence_length)

Predicting decoder

#与training共享参数

with tf.variable_scope(“decode”, reuse=True):

#创建一个常量tensor并复制为batch_size的大小

start_tokens = tf.tile(tf.constant([target_letter_to_int[’’]], dtype=tf.int32), [batch_size],name=‘start_tokens’)

predicting_helper = seq2seq.GreedyEmbeddingHelper(decoder_embeddings,start_tokens,target_letter_to_int[’’])

predicting_decoder = seq2seq.BasicDecoder(cell=cell,helper=predicting_helper,initial_state=encoder_state,output_layer=output_layer)

predicting_decoder_output, _ ,_= seq2seq.dynamic_decode(decoder=predicting_decoder,impute_finished=True,maximum_iterations=max_target_sequence_length)

return training_decoder_output, predicting_decoder_output

在构建解码这一块使用到了，参数共享机制 tf.variable_scope("")，方法参数含义：

target_letter_to_int: target数据的映射表
decoding_embedding_size: embed向量大小
num_layers: 堆叠的RNN单元数量
rnn_size: RNN单元的隐层结点数量
target_sequence_length: target数据序列长度
max_target_sequence_length: target数据序列最大长度
encoder_state: encoder端编码的状态向
decoder_input: decoder端输入

5）构建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

6）创建模型输入参数

创建模型输入参数代码如下所示：

#创建模型输入参数

def get_inputs():

inputs = tf.placeholder(tf.int32, [None, None], name=‘inputs’)

targets = tf.placeholder(tf.int32, [None, None], name=‘targets’)

learning_rate = tf.placeholder(tf.float32, name=‘learning_rate’)

#定义target序列最大长度（之后target_sequence_length和source_sequence_length会作为feed_dict的参数）

target_sequence_length = tf.placeholder(tf.int32, (None,), name=‘target_sequence_length’)

max_target_sequence_length = tf.reduce_max(target_sequence_length, name=‘max_target_len’)

source_sequence_length = tf.placeholder(tf.int32, (None,), name=‘source_sequence_length’)

return inputs, targets, learning_rate, target_sequence_length, max_target_sequence_length, source_sequence_length

7）训练数据准备和生成

数据填充代码如下所示：

#对batch中的序列进行补全，保证batch中的每行都有相同的sequence_length

def pad_sentence_batch(sentence_batch, pad_int):

‘’’

参数：

sentence batch
pad_int: 对应索引号

‘’’

max_sentence = max([len(sentence) for sentence in sentence_batch])

return [sentence + [pad_int] * (max_sentence - len(sentence)) for sentence in sentence_batch]

批量数据获取代码如下所示：

#批量数据生成

def get_batches(targets, sources, batch_size, source_pad_int, target_pad_int):

‘’’

定义生成器，用来获取batch

‘’’

for batch_i in range(0, len(sources) // batch_size):

start_i = batch_i * batch_size

sources_batch = sources[start_i:start_i + batch_size]

targets_batch = targets[start_i:start_i + batch_size]

#补全序列

pad_sources_batch = np.array(pad_sentence_batch(sources_batch, source_pad_int))

pad_targets_batch = np.array(pad_sentence_batch(targets_batch, target_pad_int))

记录每条记录的长度

pad_targets_lengths = []

for target in pad_targets_batch:

pad_targets_lengths.append(len(target))

pad_source_lengths = []

for source in pad_sources_batch:

pad_source_lengths.append(len(source))

yield pad_targets_batch, pad_sources_batch, pad_targets_lengths, pad_source_lengths

到此核心步骤基本上就分析完了，最后还剩训练和预测，如代码7.3所示：

【代码7.3】 seq2seq.py

#-- coding: utf-8 --

#description train seq2seq model for sort word of key

from tensorflow.python.layers.core import Dense

import numpy as np

import time

import tensorflow as tf

import tensorflow.contrib.layers as layer

import tensorflow.contrib.rnn as rnn

import tensorflow.contrib.seq2seq as seq2seq