原来聊天机器人是这么做出来的

seq2seq模型原理

主要参考《Sequence to Sequence Learning with Neural Networks》这篇论文，核心思想如下图：

ABC是输入语句，WXYZ是输出语句，EOS是标识一句话结束，图中的训练单元是lstm，lstm的特点是有长短时记忆，所以能够根据输入的多个字来确定后面的多个字，有关lstm的知识可以参考《http://deeplearning.net/tutorial/lstm.html》

上面的模型中编码器和解码器共用了同一个lstm层，也就是共享了参数，牛人们尝试把他们分开像https://github.com/farizrahman4u/seq2seq中提到的样子：

其中绿色是编码器，黄色是解码器，橙色的箭头传递的是lstm层的状态信息也就是记忆信息，编码器唯一传给解码器的就是这个状态信息

我们看到解码器每一时序的输入都是前一个时序的输出，从整体上来看就是：我通过不同时序输入“How are you <EOL>”，模型就能自动一个字一个字的输出“W I am fine <EOL>”，这里的W是一个特殊的标识，它既是编码器最后的输出，同时又是解码器的一个触发信号

那么我们训练的时候输入的X,Y应该是什么呢？X="How are you <EOL>"，Y="W I am fine <EOL>"?

这是不行的，因为在解码器还没有训练出靠谱的参数之前，我们无法保证第一个时序的输出就是“I”，那么传给第二个时序的输入就不一定是I，同样第三、四个时序的输入就无法保证是am和fine，那么是无法训练出想要的模型的

我们要这样来做：我们直接把解码器中每一时序的输入强制改为"W I am fine"，也就是把这部分从我们训练样本的输入X中传过来，而Y依然是预测输出的"W I am fine <EOL>"，这样训练出来的模型就是我们设计的编码器解码器模型了

那么在使用训练好的模型做预测的时候，我们改变处理方式：在解码时以前一时序的输出为输入做预测，这样就能输出我们希望输出的"W I am fine <EOL>"了

基于以上的原理，下面开始我们的工程实践

语料准备工作

准备至少300w的聊天语料用于词向量的训练和seq2seq模型的训练，语料越丰富训练出来的词向量质量越好，如果想通过影视剧字幕来获取语料可以参考《自己动手做聊天机器人 二十九-重磅：近1GB的三千万聊天语料供出》

获取到原始语料后需要做一些加工处理，首先需要做切词，方法如下：

python word_segment.py ./corpus.raw ./corpus.segment

其中word_segment.py是我写的切词工具，仅供参考

之后要把切词好的文件转成“|”分隔的问答对，如下：

cat ./corpus.segment | awk '{if(last!="")print last"|"$0;last=$0}' | sed 's/| /|/g' > ./corpus.segment.pair

这样语料准备工作就齐全了

训练词向量

我们直接利用google的word2vec来训练词向量，如下：

word2vec -train ./corpus.segment -output vectors.bin -cbow 1 -size 200 -window 8 -negative 25 -hs 0 -sample 1e-5 -threads 20 -binary 1 -iter 15

其中corpus.raw是原始语料数据，vectors.bin是生成的词向量二进制文件

了解word2vec的原理请见《自己动手做聊天机器人 二十五-google的文本挖掘深度学习工具word2vec的实现原理》

生成的词向量二进制加载方法可以参考我写的：word_vectors_loader.py

创建模型

下面就是重点的模型创建过程，这里面我们直接使用tensorflow+tflearn库来实现：

# 首先我们为输入的样本数据申请变量空间，如下。其中self.max_seq_len是指一个切好词的句子最多包含多少个词，self.word_vec_dim是词向量的维度，这里面shape指定了输入数据是不确定数量的样本，每个样本最多包含max_seq_len*2个词，每个词用word_vec_dim维浮点数表示。这里面用2倍的max_seq_len是因为我们训练是输入的X既要包含question句子又要包含answer句子
input_data = tflearn.input_data(shape=[None, self.max_seq_len*2, self.word_vec_dim], dtype=tf.float32, name = "XY")
# 然后我们将输入的所有样本数据的词序列切出前max_seq_len个，也就是question句子部分，作为编码器的输入
encoder_inputs = tf.slice(input_data, [0, 0, 0], [-1, self.max_seq_len, self.word_vec_dim], name="enc_in")
# 再取出后max_seq_len-1个，也就是answer句子部分，作为解码器的输入。注意，这里只取了max_seq_len-1个，是因为还要在前面拼上一组GO标识来告诉解码器我们要开始解码了，也就是下面加上go_inputs拼成最终的go_inputs
decoder_inputs_tmp = tf.slice(input_data, [0, self.max_seq_len, 0], [-1, self.max_seq_len-1, self.word_vec_dim], name="dec_in_tmp")
go_inputs = tf.ones_like(decoder_inputs_tmp)
go_inputs = tf.slice(go_inputs, [0, 0, 0], [-1, 1, self.word_vec_dim])
decoder_inputs = tf.concat(1, [go_inputs, decoder_inputs_tmp], name="dec_in")
# 之后开始编码过程，返回的encoder_output_tensor展开成tflearn.regression回归可以识别的形如(?, 1, 200)的向量；返回的states后面传入给解码器
(encoder_output_tensor, states) = tflearn.lstm(encoder_inputs, self.word_vec_dim, return_state=True, scope='encoder_lstm')
encoder_output_sequence = tf.pack([encoder_output_tensor], axis=1)
# 取出decoder_inputs的第一个词，也就是GO
first_dec_input = tf.slice(decoder_inputs, [0, 0, 0], [-1, 1, self.word_vec_dim])
# 将其输入到解码器中，如下，解码器的初始化状态为编码器生成的states，注意：这里的scope='decoder_lstm'是为了下面重用同一个解码器
decoder_output_tensor = tflearn.lstm(first_dec_input, self.word_vec_dim, initial_state=states, return_seq=False, reuse=False, scope='decoder_lstm')
# 暂时先将解码器的第一个输出存到decoder_output_sequence_list中供最后一起输出
decoder_output_sequence_single = tf.pack([decoder_output_tensor], axis=1)
decoder_output_sequence_list = [decoder_output_tensor]
# 接下来我们循环max_seq_len-1次，不断取decoder_inputs的一个个词向量作为下一轮解码器输入，并将结果添加到decoder_output_sequence_list中，这里面的reuse=True, scope='decoder_lstm'说明和上面第一次解码用的是同一个lstm层
for i in range(self.max_seq_len-1):
   next_dec_input = tf.slice(decoder_inputs, [0, i+1, 0], [-1, 1, self.word_vec_dim])
   decoder_output_tensor = tflearn.lstm(next_dec_input, self.word_vec_dim, return_seq=False, reuse=True, scope='decoder_lstm')
   decoder_output_sequence_single = tf.pack([decoder_output_tensor], axis=1)
   decoder_output_sequence_list.append(decoder_output_tensor)
# 下面我们把编码器第一个输出和解码器所有输出拼接起来，作为tflearn.regression回归的输入
decoder_output_sequence = tf.pack(decoder_output_sequence_list, axis=1)
real_output_sequence = tf.concat(1, [encoder_output_sequence, decoder_output_sequence])
net = tflearn.regression(real_output_sequence, optimizer='sgd', learning_rate=0.1, loss='mean_square')
model = tflearn.DNN(net)

至此模型创建完成，让我们汇总一下里面的思想：

1）训练输入的X、Y分别是编码器解码器的输入和预测的输出；

2）X切分两半，前一半是编码器输入，后一半是解码器输入；

3）编码解码器输出的预测值用Y做回归训练

4）训练时通过样本的真实值作为解码器输入，实际预测时将不会有上图中WXYZ部分，因此上一时序的输出将作为下一时序的输入(后面会详述预测的实现)

训练模型

下面我们来实例化模型并喂数据做训练，如下：

model = self.model()
model.fit(trainXY, trainY, n_epoch=1000, snapshot_epoch=False, batch_size=1)
model.load('./model/model')

这里的trainXY和trainY通过加载上面我们准备的语料来赋值

首先我们加载词向量并存到word_vector_dict中，然后读取语料文件并挨个词查word_vector_dict并赋值向量给question_seq和answer_seq，如下：

def init_seq(input_file):
    """读取切好词的文本文件，加载全部词序列
    """
    file_object = open(input_file, 'r')
    vocab_dict = {}
    while True:
        question_seq = []
        answer_seq = []
        line = file_object.readline()
        if line:
            line_pair = line.split('|')
            line_question = line_pair[0]
            line_answer = line_pair[1]
            for word in line_question.decode('utf-8').split(' '):
                if word_vector_dict.has_key(word):
                    question_seq.append(word_vector_dict[word])
            for word in line_answer.decode('utf-8').split(' '):
                if word_vector_dict.has_key(word):
                    answer_seq.append(word_vector_dict[word])
        else:
            break
        question_seqs.append(question_seq)
        answer_seqs.append(answer_seq)
    file_object.close()

有了question_seq和answer_seq，我们来构造trainXY和trainY，如下：

    def generate_trainig_data(self):
        xy_data = []
        y_data = []
        for i in range(len(question_seqs)):
            question_seq = question_seqs[i]
            answer_seq = answer_seqs[i]
            if len(question_seq) < self.max_seq_len and len(answer_seq) < self.max_seq_len:
                sequence_xy = [np.zeros(self.word_vec_dim)] * (self.max_seq_len-len(question_seq)) + list(reversed(question_seq))
                sequence_y = answer_seq + [np.zeros(self.word_vec_dim)] * (self.max_seq_len-len(answer_seq))
                sequence_xy = sequence_xy + sequence_y
                sequence_y = [np.ones(self.word_vec_dim)] + sequence_y
                xy_data.append(sequence_xy)
                y_data.append(sequence_y)
        return np.array(xy_data), np.array(y_data)

构造了训练数据也创建好了模型，训练的效果如下：

[root@centos #] python my_seq2seq_v2.py train
begin load vectors
words = 70937
size = 200
load vectors finish
---------------------------------
Run id: 9PZWKM
Log directory: /tmp/tflearn_logs/
---------------------------------
Training samples: 368
Validation samples: 0
--
Training Step: 47  | total loss: 0.62260
| SGD | epoch: 001 | loss: 0.62260 -- iter: 047/368

最终会生成./model/model模型文件

效果预测

训练好模型，我们希望能输入一句话来预测一下回答，如下：

predict = model.predict(testXY)

因为我们只有question没有answer，所以testXY中是没有Y部分的，所以需要在程序中做一些改变，即用上一句的输出作为下一句的输入，如下：

for i in range(self.max_seq_len-1):
   # next_dec_input = tf.slice(decoder_inputs, [0, i+1, 0], [-1, 1, self.word_vec_dim])这里改成下面这句
   next_dec_input = decoder_output_sequence_single
   decoder_output_tensor = tflearn.lstm(next_dec_input, self.word_vec_dim, return_seq=False, reuse=True, scope='decoder_lstm')
   decoder_output_sequence_single = tf.pack([decoder_output_tensor], axis=1)
   decoder_output_sequence_list.append(decoder_output_tensor)

因为词向量是多维浮点数，预测出的词向量需要通过余弦相似度来匹配，余弦相似度匹配方法如下：

def vector2word(vector):
    max_cos = -10000
    match_word = ''
    for word in word_vector_dict:
        v = word_vector_dict[word]
        cosine = vector_cosine(vector, v)
        if cosine > max_cos:
            max_cos = cosine
            match_word = word
    return (match_word, max_cos)

其中的vector_cosine实现如下：

def vector_cosine(v1, v2):
    if len(v1) != len(v2):
        sys.exit(1)
    sqrtlen1 = vector_sqrtlen(v1)
    sqrtlen2 = vector_sqrtlen(v2)
    value = 0
    for item1, item2 in zip(v1, v2):
        value += item1 * item2
    return value / (sqrtlen1*sqrtlen2)

其中的vector_sqrtlen实现如下：

def vector_sqrtlen(vector):
    len = 0
    for item in vector:
        len += item * item
    len = math.sqrt(len)
    return len

预测效果如下：

输入是“真 讨厌”

预测结果：

[root@centos #] python my_seq2seq_v2.py test test.data
begin load vectors
words = 70937
size = 200
load vectors finish
predict answer
竟然 0.796628661264 8.13188244428
是 0.361905373571 4.72316883181
你 0.416023172832 3.78265507983
啊 0.454288467277 3.13229596833
不是 0.424590214456 2.90688231062
你 0.489174557107 2.62733802498
啊 0.501460288258 2.87990178439
你 0.560230783333 3.09066126524

输出的第一列是预测的每个时序产生的词，第二列是预测输出向量和最近的词向量的余弦相似度，第三列是预测向量的欧氏距离

因为我们设计的max_seq_len是定长8，所以输出的序列最后会多余一些字，可以根据余弦相似度或者其他指标设定一个阈值来截断

以上列出的是部分代码，全部代码分享在my_seq2seq_v2.py欢迎点击观看