RNN聊天机器人与Beam Search [Tensorflow Seq2Seq]
本博客分析了一个Tensorflow实现的开源聊天机器人项目deepQA，首先从数据集上和一些重要代码上进行了说明和阐述，最后针对于测试的情况，在deepQA项目上实现了Beam Search的方法，让模型输出的句子更加准确。
DeepQA
DeepQA是一个Tensorflow实现的开源的seq2seq模型的聊天机器人( 传送们),出自谷歌的一篇关于对话模型的论文A Neural Conversational Model，训练的语料库包含电影台词的对话（Cornell和扩展版本的Cornell），Scotus对话库，以及Ubantu的对话。这些数据都能在项目的data里找到，但是目前好像只能针对某一个对话数据库进行训练，还没有支持混合对话的训练。目前实现的模型使用的是基础RNN中的seq2seq模型，主要针对的是比较短的对话。
1. Cornell数据集
DeepQA默认的是Cornell对话数据，一共两个文件：人物对话信息movie_conversations.txt和具体对话内容movie_lines.txt，+++$+++为分隔符，movie_conversations.txt里每一行的第一个数据代表对话人物1的ID，第二个数据代表对话人物2的ID，第三个数据代表电影ID，后面是对话的ID，而movie_lines.txt里每一行的第一个数据代表对话ID，第二个数据表示说话的人物ID，第三个数据电影ID，第四个是此人物的名字，最后是这句话的具体内容。
＃ movie_conversations.txt
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L194', 'L195', 'L196', 'L197']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L198', 'L199']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L200', 'L201', 'L202', 'L203']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L204', 'L205', 'L206']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L207', 'L208']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L271', 'L272', 'L273', 'L274', 'L275']
u0 +++$+++ u2 +++$+++ m0 +++$+++ ['L276', 'L277']
＃movie_lines.txt
L1045 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ They do not!
L1044 +++$+++ u2 +++$+++ m0 +++$+++ CAMERON +++$+++ They do to!
L985 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ I hope so.
L984 +++$+++ u2 +++$+++ m0 +++$+++ CAMERON +++$+++ She okay?
L925 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ Let's go.
L924 +++$+++ u2 +++$+++ m0 +++$+++ CAMERON +++$+++ Wow
L872 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ Okay -- you're gonna need to learn how to lie.
L871 +++$+++ u2 +++$+++ m0 +++$+++ CAMERON +++$+++ No
L870 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ I'm kidding. You know how sometimes you just become this "persona"? And you don't know how to quit?
L869 +++$+++ u0 +++$+++ m0 +++$+++ BIANCA +++$+++ Like my fear of wearing pastels?
L868 +++$+++ u2 +++$+++ m0 +++$+++ CAMERON +++$+++ The "real you".
通过解析这个两个文件，可以在data/samples路径生成dataset-cornell.pkl数据集以及dataset-cornel-length10-filter1-vocabSize40000.pkl词汇表，默认对话的长度一般最大为10，过滤词频小于1的词并用unk代替，词汇表最大40000；这些参数可以自行修改，生成过程具体由textdata.py实现
2. 重要代码分析
2.1 构建基础RNN网络结构
直接看一下构建模型的代码，首先定义单个LSTM cell，然后用Dropout包裹，最后用参数numLayers决定多少层Stack结构的RNN：
def create_rnn_cell():
encoDecoCell = tf.contrib.rnn.BasicLSTMCell( # Or GRUCell, LSTMCell(args.hiddenSize)
self.args.hiddenSize,
)
if not self.args.test: # TODO: Should use a placeholder instead
encoDecoCell = tf.contrib.rnn.DropoutWrapper(
encoDecoCell,
input_keep_prob=1.0,
output_keep_prob=self.args.dropout
)
return encoDecoCell
encoDecoCell = tf.contrib.rnn.MultiRNNCell(
[create_rnn_cell() for _ in range(self.args.numLayers)],
)
2.2 定义输入值
接着定义网络的输入值，根据标准的seq2seq模型，一共四个：
- encorder的输入：人物1说的一句话A，最大长度10
- decoder的输入：人物2回复的对话B，因为前后分别加上了go开始符和end结束符，最大长度为12
- decoder的target输入：decoder输入的目标输出，与decoder的输入一样但只有end标示符号，可以理解为decoder的输入在时序上的结果，比如说完这个词后的下个词的结果。
- decoder的weight输入：用来标记target中的非padding的位置，即实际句子的长度，因为不是所有的句子的长度都一样，在实际输入的过程中，各个句子的长度都会被用统一的标示符来填充（padding）至最大长度，weight用来标记实际词汇的位置，代表这个位置将会有梯度值回传。
with tf.name_scope('placeholder_encoder'):
self.encoderInputs = [tf.placeholder(tf.int32, [None, ]) for _ in
range(self.args.maxLengthEnco)] # Batch size * sequence length * input dim
with tf.name_scope('placeholder_decoder'):
self.decoderInputs = [tf.placeholder(tf.int32, [None, ], name='inputs') for _ in
range(self.args.maxLengthDeco)] # Same sentence length for input and output (Right ?)
self.decoderTargets = [tf.placeholder(tf.int32, [None, ], name='targets') for _ in
range(self.args.maxLengthDeco)]
self.decoderWeights = [tf.placeholder(tf.float32, [None, ], name='weights') for _ in
range(self.args.maxLengthDeco)]
其实，数据获取后的Batch的过程可以由Tensorflow标准的batch方法来实现，而这个项目自己Batch各个输入值，因此对于初学者来说，可以观察输入值的构造，对入门RNN还是很有帮助的
2.3 封装Embedding seq2seq模型
Tensorflow把常用的seq2seq模型都封装好了，比如embedding_rnn_seq2seq，这是seq2seq一个最简单的模型，一般的文本任务都会加上attention机制，但这里都用的短句子，所以attention并考虑，若想加上attention也很简单，直接修改模型名字为embedding_attention_seq2seq即可，这种封装虽然使用起来很方便，但是对于用户来说就是个黑匣子，想要自己去实现一些功能，还得去看代码。
decoderOutputs, states = tf.contrib.legacy_seq2seq.embedding_rnn_seq2seq(
self.encoderInputs, # List<[batch=?, inputDim=1]>, list of size args.maxLength
self.decoderInputs, # For training, we force the correct output (feed_previous=False)
encoDecoCell,
self.textData.getVocabularySize(),
self.textData.getVocabularySize(), # Both encoder and decoder have the same number of class
embedding_size=self.args.embeddingSize, # Dimension of each word
output_projection=outputProjection.getWeights() if outputProjection else None,
feed_previous=True if bool(self.args.test) and not bool(self.args.beam_search) else False
# When we test (self.args.test), we use previous output as next input (feed_previous)
)
RNN输出一个句子的过程，其实是对句子里的每一个词来做整个词汇表的softmax分类，取概率最大的词作为当前位置的输出词，但是若词汇表很大，计算量会很大，那么通常的解决方法是在词汇表里做一个下采样，采样的个数通常小于词汇表，例如词汇表有50000个，经过采样后得到4096个样本集，样本集里包含1个正样本（正确分类）和4095个负样本，然后对这4096个样本进行softmax计算作为原来词汇表的一种样本估计，这样计算量会小不少。
在这里，具体的操作是定义一个全映射outputProjection对象，把隐藏层的输出映射到整个词汇表，这种映射需要参数w和b，也就是out＝w＊h＋b，h是隐藏层的输出，out是整个词汇表的输出，可以理解为一个普通的全连接层。假设隐藏层的输出是512，那么w的shape就为50000＊512，我们采样词汇表的操作可以看作是对w和b参数的采样，也就是采样出来的w为4096＊512，用这个w带入上式计算，能得出4096个输出，然后计算softmax loss，这个sampled softmax loss是原词汇表softmax loss的一种近似。outputProjection的定义请看model.py。
outputProjection = ProjectionOp(
(self.textData.getVocabularySize(), self.args.hiddenSize),
scope='softmax_projection',
dtype=self.dtype
)
def sampledSoftmax(labels, inputs):
labels = tf.reshape(labels, [-1, 1]) # Add one dimension (nb of true classes, here 1)
# We need to compute the sampled_softmax_loss using 32bit floats to
# avoid numerical instabilities.
localWt = tf.cast(outputProjection.W_t, tf.float32)
localB = tf.cast(outputProjection.b, tf.float32)
localInputs = tf.cast(inputs, tf.float32)
return tf.cast(
tf.nn.sampled_softmax_loss(
localWt, # Should have shape [num_classes, dim]
localB,
labels,
localInputs,
self.args.softmaxSamples, # The number of classes to randomly sample per batch
self.textData.getVocabularySize()), # The number of classes
self.dtype)
2.4 定义损失函数和更新方法
下面定义seq2seq模型的损失函数sequence_loss，其中sequence_loss需要softmax_loss_function参数，这个参数若不指定，那么就是默认对整个词汇表的做softmax loss，若需要采样来加速计算，则要传入上面定义的sampledSoftmax方法，这个方法的返回值是TF定义的sampled_softmax_loss。更新方法采用默认参数的Adam。
# Finally, we define the loss function
self.lossFct = tf.contrib.legacy_seq2seq.sequence_loss(
decoderOutputs,
self.decoderTargets,
self.decoderWeights,
self.textData.getVocabularySize(),
softmax_loss_function=sampledSoftmax if outputProjection else None # If None, use default SoftMax
)
tf.summary.scalar('loss', self.lossFct) # Keep track of the cost
# Initialize the optimizer
opt = tf.train.AdamOptimizer(
learning_rate=self.args.learningRate,
beta1=0.9,
beta2=0.999,
epsilon=1e-08
)
self.optOp = opt.minimize(self.lossFct)
3. Beam Search
在测试模型的时候，比如我输入问一句话“How are you？“以及一个go开始符，那么模型就开始输出第一个词的候选集，这个候选集里的每一个词都有一个概率，一般采用贪婪的思想，就取概率最大的那个词作为当前输出，然后把这个词作为预测第二个词的输入再feed进网络，如此循环，直到模型输出end结束符，那么这句话就输出完毕。
这种把上一个时刻的输出当作下一个时刻的输入的过程在TF模型中由feed_previous参数决定：在训练模型的时候，我们是知道每一时刻的正确输入和输出的，并不需要这个过程，因此feed_previous＝False，而只有在测试的时候，才会需要这种过程feed_previous＝True
而Beam Search是这种贪婪的思想的扩展，前面是选择最大的Top 1概率的词作为当前输出，而Beam Search是选择当前Top k得分的词，当然这个得分也就是概率，那么采用这种思想，对一个问题，模型最后的输出就应该有好几种回答，这些回答根据得分排序，最终选择得分最高的句子作为最终输出。相对于前面贪婪的回答，这种搜索机制能让机器人选择更好的回答。
那么在DeepQA的基础上，我们来自己实现一下Beam Search（目前DeepQA并不支持），网上有很多实现的方法，大都是自己编写decoder，比较复杂。那么本文就采用一种非常直接的方法，依照Beam Search的思想：feed in上一时刻产生的Top k答案来产生本时刻的候选答案集，然后排序本时刻的候选答案集再选择Tok k作为本时刻的最终答案，并作为下一时刻输入，如此循环。每一时刻需要记录当前选择词的id，从第一个词到最后一个词，这些词的id构成一种选择路径。最后根据参数k，得出k条路径，每条路径有一个概率得分。这种情况下，我们是手动feed in各个候选答案，因此feed_previous=False
def beamSearchPredict(self, question, questionSeq=None):
# question为输入的句子，这里先把每个词转为id，再加上padding和go标示符构成一个batch，这个batch就包含一个句子
batch = self.textData.sentence2enco(question)
if not batch:
return None
if questionSeq is not None: # If the caller want to have the real input
questionSeq.extend(batch.encoderSeqs)
# feedDict为TF的placeholder变量以及对应的数据
# ops为TF的需要计算的网络图
ops, feedDict = self.model.step(batch)
# 定义softmax操作
def softmax(x):
return np.exp(x) / np.sum(np.exp(x), axis=0)
# path储存搜索的路径，probs里储存每个路径对应的得分（log概率）
# beam_size对应路径的个数，储存的位置越靠后，得分越高
beam_size = self.args.beam_size
path = [[] for _ in range(beam_size)]
probs = [[] for _ in range(beam_size)]
# 计算第一个词的output
output = self.sess.run(ops[0][0], feedDict)
for k in range(len(path)):
# 计算输出的softmax概率分布
prob = softmax(output[-1].reshape(-1, ))
# 用对数表示这些概率分布
log_probs = np.log(np.clip(a=prob, a_min=1e-5, a_max=1))
# 根据概率大小排序，取前Top－beam_size的词，记录log概率和词的id
top_k_indexs = np.argsort(log_probs)[-beam_size:]
path[k].extend([top_k_indexs[k]])
probs[k].extend([log_probs[top_k_indexs[k]]])
# 计算第二个词到最后一个词
for i in range(2, self.args.maxLengthDeco):
tmp = []
for k in range(len(path)):
for j in range(len(path[k])):
# feedDict种加入前面的词的id数据
feedDict[self.model.decoderInputs[j + 1]] = [path[k][j]]
# 输入feedDict至网络图，计算当前句子的output
output = self.sess.run(ops[0][0:i], feedDict)
# 取最后一个output（当前词的输出）做softmax和log
prob = softmax(output[-1].reshape(-1, ))
log_probs = np.log(np.clip(a=prob, a_min=1e-5, a_max=1))
# 计算概率得分：P(a,b)=P(a|b)*P(b)
# a为当前要选择的词，b为上一个已选择的词
# Log表示： log P(a,b)=log P(a|b)+ log P(b)
tmp.extend(list(log_probs + probs[k][-1]))
# 假设上一个词的候选集有三个元素a,b,c
# 那么分别把这个三个元素作为输入feed进网络里，会得出三个output的结果
# 将这些output的概率串联到一个tmp里排序，依然取出前Top-beam_size的词作为当前的词的候选集
top_k_indexs = np.argsort(tmp)[-beam_size:]
indexs = top_k_indexs % self.textData.getVocabularySize()
# 记录当前选择词的id和log概率得分
for k in range(len(path)):
probs[k].extend([tmp[top_k_indexs[k]]])
path[k].extend([indexs[k]])
return path
还有部分细节没有展出，详细请看chatbot.py
4.运行
使用python main来训练模型，使用python main --test interactive --beam-search --beam-size 3来实时测试对话，下面是loss的图，混乱度为以loss为自变量的e的指数函数
使用python main --test来生成对话，在save/model/model_predictions.txt中查看结果
5. 结果
deepQA是基于python 3.5的项目，用python 2.7也可以跑，但是需要稍微修改一些地方，另外项目还提供了训练好的参数，不想训练的可以直接导入训练好的模型。但是那些模型都是用python 3.5训练的，如果用python 2.7会导入不了这些预训练的模型。我用的是python 2.7，因此只能自己训练，由于显存的限制，训练的参数很小，效果不太好，这里给出官方的对话例子：
Q: Hi
A: Hi.
Q: What is your name ?
A: Laura.
Q: What does that mean ?
A: I dunno.
Q: How old are you ?
A: thirty-five.
Q: Will Google hire me ?
A: No.
Q: Tell me the alphabet
A: Fuck you.
Q: That's not nice
A: Yeah.
下面给出部分我用Beam Search做出来结果，beam_size=3，因此每个问题有三个答案，得分从高到低：
Q: Hi
A: Hi,
A: Hey, man,
A: Hello ... alright! what suicide!.?
Q: Luke, I am your father!
A: What?
A: Who?
A: We're!?!
Q: Are you ready ?
A: I'm
A: What?
A: Who? ready?
Q: When are you ready ?
A: Tomorrow.
A: Thursday.
A: I, uh., is
Q: How old are you ?
A: Eighteen.
A: Twenty.
A: I'm thirty-four.
Q: How is Laura ?
A: Fine.
A: Tolerable well
A: Good...
6. 分析
通过Beam search，有的问题能够举例多种回答，但是有的问题的后面的回答直接就失败了。有以下方面可以还可以提高：
- 更大的训练集：训练效果强烈依赖于训练集的质量，甚至可以把几个数据集在同一个RNN网络上训练，猜想可能效果会更好
- 一些参数的调整：如词频过滤的大小，词汇表大小，word embedding的维度大小，RNN的stack层数，输入输出句子最大长度，softmax的采样的大小，以及导入预训练的word2vec来加速训练过程等
- 增加attention机制，对于长句子
- 输入多个问题，只给出一个答案：这样能让网络稍微记住当前答案与前几个问题有关，目前是当前答案只与当前问题有关，问题与问题之间相互独立
- 更高级一点，增加记忆网络，显性将特征记忆到外部储存器，然后在记忆中搜索答案返回，这样可以使记忆长期保留，是目前比较火的研究方向
- 再高级就是增加知识图谱和一些启发函数，让模型自己去外部获取信息处理，然后返回答案，类似你问一个问题，即使机器人不知道，但是它可以去上网查资料然后返回你答案，这种level是最高级的。
LEAVE COMMENT ON: