这篇论文实现了一个基于维基百科的开放域问答系统，其实可以归类到机器阅读理解里面。相应的，这篇论文有配套的开源代码（见 facebookresearch/DrQA），这个系统的工程部分还是蛮实在的。

论文地址：https://arxiv.org/abs/1704.00051

三位来自 Google 的作者在这篇论文中提出了一种以两个 RNN 组合方式构成的网络结构，用来处理英语到法语的翻译问题，并且认为对于传统的深度神经网络(Deep Neural Network, DNN)不能处理的输入和输出都是变长序列的问题，这种模型都能很好地进行处理。

自 2006 年 Hinton 掀起深度学习这股浪潮，联结主义强势回归到现在已经有 10 年了，这 10 年里，深度学习已经在图像和语音两大领域取得了卓越的成就。然而大部分的深度神经网络仍然需要输入和输出的大小固定不变，并将一层一层不同类型的网络层组合在一起，通过巨量的数据、更有效的优化方法和训练技巧来达到目的，而这里的 "输入和输出的大小固定不变" 是一个很大的限制，比如说我们的语言、文字，天然就是变长的序列，这些网络结构要处理的话就必须要在核心模型之外在加上一些额外的处理。举个例子，图像识别中的图像一般也不是固定大小的，输入前一般都需要进行预处理将图像规整到同一尺寸。

面对这一问题，一个很自然的方法就是使用循环神经网络(Recurrent Neural Network, RNN)，这是一种在空间结构上非常简单的模型，在一些不太复杂的问题上，甚至只需要三层结构就足够了，如下图所示(配图来自 Elman 的 《Find Structure in Time》)

相比传统的前馈神经网络(Feedforward Neural Network, FNN)，RNN 的独特之处在于其隐藏层的一个环状结构，这个结构相当于能够缓存当前的输入，并用之参与下一次的计算，这样就隐式地将 时间信息 包含到模型中去了，在输入变长序列时，可以序列中的最小单元逐个输入。RNN 虽然在空间结构上可以很简单，但在进行训练时通常需要在 时间维度 上展开(unroll)，所以可以认为它是一个在时间维度上的 DNN，于是 DNN 训练中会出现的 gradient vanish (梯度消失)也会出现，直观上可以将其理解为 "记忆的衰退"，换句话说， RNN 只能 "记住" 短期的信息。1997 年 "长短期记忆单元(Long Short-Term Memory, LSTM)" 被提出来解决这个问题，而本文提出的模型就是利用了 LSTM 的优点。

虽说 RNN 能用于处理变长序列，但具体要怎么做呢？最早提出 RNN 之一的 Elman 做过的一些实验是这样的: 将序列中的元素逐个输入网络，并预测下一时刻的输入，比如一条句子逐个字符输入网络，并在输入第 n 个字符时预测第 n+1 个字符。这种方式虽然能处理变长的输入序列，但得到的输出序列却是和输入序列长度一样的，限制仍然还在。

一种办法是在输出时增加一个 "空白" 的输出候选，然后在每次输出时取每一种可能输出结果的概率，得到一张路径网络后用类似 beam search 的方法来组装起真正的输出，由于 "空白" 输出的存在，最后得到的非空白输出序列的长度就变成可变的了。语音识别和一些 OCR、手写识别是这么做的，效果也还不错。

而作者提出的方法是将两个 RNN 组合起来，以更加灵活地处理变长输入序列和变长输出序列。其模型结构如下(注意，这是一个已经 unroll 的网络结构)

模型的左侧(到输入为 <EOS> 为止)是一个 RNN 在输入序列 "ABC<EOS>" 上的展开，右侧是在输出序列 "wxyz<EOS>" 上的展开，其中 <EOS> 是一个表示序列结束的特殊符号。功能上，第一个 RNN 用来将输入序列映射成一个固定长度的向量，这个 "固定长度的向量" 即是 RNN 中间隐藏层所缓存的对整个输入序列的 "记忆"，我们可以说它表示了输入序列的语义；然后用第二个 RNN ，来从这个向量中得到期望的输出序列。

除了这个特殊的模型结构之外，再就是用 LSTM 来保留 一定程度 的长期记忆信息，并且作者表示复杂的网络结构(更多的参数)具有更强的表达能力，因此每个 RNN 用的都是 4 层的 LSTM, 参数两多达 380M, 也就是 38 亿 —— Google 的朋友们你们真是站着说话不腰疼啊，38 亿参数的模型，一般人哪来这么多数据喂饱这个大胃王，哪来那么强劲的机器来训练……

再就是，作者说将输入序列倒序后，效果得到了显著地改善，BLEU 从使用该方法之前的 25.9 上升到 30.6，然而自己也对其原因表示不太清楚，只作出了一些猜想(也就是说，并无明确的理论依据)。

原文中，作者对这个技巧的解释如下

While we do not have a complete explanation to this phenomenon, we believe that it is caused by the introduction of many short term dependencies to the dataset

以及

By reversing the words in the source sentence, the average distance between corresponding words in the source and target language is unchanged. However, the first few words in the source language are now very close to the first few words in the target language, so the problem's minimal time lag is greatly reduced.

模型训练时，以最大化条件概率为目标，也就是说，其目标函数为

\[\frac{1}{|S|}\sum \log P(T|S)\]

而在模型训练好后，用于实际的预测时，则也采用了简单的 beam search 方法，即在模型参数确定的情况下，对输入序列 \(S\) ，按下面的式子求解输出序列

\[\hat{T} = \arg\max_{T}P(T|S)\]

下表是与其他模型在机器翻上的的效果对比，其中上面两行是其他模型的效果，下面六行是作者模型在不同参数设置时的结果。

此外作者还尝试将自己的模型与传统的 SMT 系统进行结合，效果显著, BLEU 最好的达到了 37，超过 baseline system 4 个点。

sequence to sequence 模型被提出后，由于其灵活性，受到了广泛的关注，我个人是很喜欢这个模型中的想法的。然而现在流行的几个开源库对 sequence to sequence 模型的支持仍然不太理想，它们都要求在模型定义时就将输入序列的最大长度和输出序列的最大长度确定，对于长度不足的，则要用特殊符号进行填充，并在模型内部或外部做一些特殊处理。比如用 Python 的深度学习框架 Keras 来实现一个弱化版的 sequence to sequence 模型，可以这样:

# coding: utf-8
"""Sequence to Sequence with Keras 1.0"""

from keras.models import Sequential
from keras.layers.core import Dense, RepeatVector
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import TimeDistributed

def build_model(input_size, max_output_seq_len, hidden_size):
    """建立一个 sequence to sequence 模型"""
    model = Sequential()
    model.add(LSTM(input_dim=input_size, output_dim=hidden_size, return_sequences=False))
    model.add(Dense(hidden_size, activation="relu"))
    # 下面这里将输入序列的向量表示复制 max_output_seq_len 份作为第二个 LSTM 的输入序列
    model.add(RepeatVector(max_output_seq_len))
    model.add(LSTM(hidden_size, return_sequences=True))
    model.add(TimeDistributed(Dense(output_dim=input_size, activation="linear")))
    model.compile(loss="mse", optimizer='adam')

    return model

上面这段代码，从模型定义上，只对输出序列做了最大限制，但训练数据集中 不允许出现不同长度的输入序列 ，实际上不同长度的目标输出序列也不被允许。希望这种情况在将来能够有所改善，当然啦，不行的话可以自己用 Theano 写嘛～

作者在这篇论文中提出了一种新的模型，并用来进行机器翻译和比较不同语言的短语/词组(phrase)之间的语义近似程度。这个模型由两个 RNN 组成，其中一个(Encoder)用来将输入的序列表示成一个固定长度的向量，另一个(Decoder)则使用这个向量重建出目标序列 —— 在机器翻译任务里，可以认为 Encoder 产生的向量是输入文本的 语义表达 ，而 Decoder 则根据这个语义表达产生目标语言的文本。

模型结构如下图所示

这个结构其实和 "Sequence to Sequence Learning with Neural Networks" (后面简称 "Sequence to Sequence")里提出的结构是非常相似的，见下图:

"Sequence to Sequence" 这篇论文的作者自己也表示 "Our approach is very similar to Cho et al" 。

两种结构的不同之处在于，Encoder 输出的向量，在后者这里只用来作 Decoder 的第一个 time step 的输入，而在 Cho 的这篇论文里，它是要在 Decoder 的每一个 time step 中都参与计算的。即在 "Sequence to Sequence" 中，Decoder 中第 t 个 time step 时计算输出的式子为

\[P(y_{t})=f(h_{t}, y_{t-1})\]

而在 Cho 的论文中，则是

\[P(y_{t})=f(h_{t}, y_{t-1}, c)\]

其中 \(h_{t}\) 表示第 t 个 time step 时 Decoder 的内部状态(RNN 单元的 "memory")，\(c\) 表示 Encoder 输出的向量。

再有一点不同是，Cho 在这篇论文中提出了 GRU 这种 LSTM 的简化版本单元结构，使用的 RNN 也是以 GRU 而非 LSTM 组成的。对 LSTM、GRU 的细节这里就不深入了，反正 Cho 自己还有一篇论文就是比较 LSTM 和 GRU 的各自优缺点的，到时候也读一读记录一下笔记什么的。

Cho 的 Encoder-Decoder 模型中，Encoder 的行为比较简单，重点在 Decoder 上。

Decoder 中 t 时刻的内部状态的 \(h_{t}\) 为:

\[h_{t}=g(h_{t-1}, y_{t-1}, c)\]

该时刻的输出概率则为:

\[P(y_{t}|y_{t-1}, y_{t-2},...,y_{1}, c)=f(h_{t}, y_{t-1}, c)\]

模型训练时则去最大化给定输入序列 x 时输出序列为 y 的条件概率:

\[\arg\max_{\theta}\frac{1}{N}\sum_{n=1}^{N}logP_{\theta}(Y_{n}|X_{n})\]

这个模型用来做机器翻译是很自然的，除了机器翻译外，作者还用这个模型来得到英语 phrase 和法语 phrase 之间的语义近似值(或说相似性)，方法是用大量的英语和法语的 phrase pair 进行训练，每个 pair 在训练时最后都会有概率输出，就用这个概率值作为这个 pair 对的 score ，并在整个训练过程中更新，最后得到一张记录很多 phare pair 近似值的表，这个表可以在其他的统计机器翻译(Statistical Machine Translation, SMT)系统中使用 —— 比如要将某个英语 phrase 翻译成法语 phrase 时，可以从表中找到与该英语 phrase 最接近的 K 个法语 phrase 作为候选。

在机器翻译上，作者用 Moses (一个 SMT 系统) 建立了一个 phrase based 的翻译模型作为 baseline system ，然后对比了以下四个模型的 BLEU 值

1. Baseline configuration
2. Baseline + RNN
3. Baseline + CSLM + RNN
4. Baseline + CSLM + RNN + Word penalty

所谓 BLEU 呢，是 BiLingual Evaluation Understudy 的缩写，是业界用来评估一个机器翻译系统水平的基准，如果遇到做机器翻译的上去问问 “你们的系统 BLEU 是多少” ，绝对会被认为你是专业人士，所以不妨记一下这个词 :) 。不过实际上 BLEU 和人工评价相差甚远，而且对于一些小的错误非常敏感，Yvette Graham 等人在 NAACL 2016 上专门有一篇长论文(Achieving Accurate conclusions in Evaluation of Automatic Machine Translation Metrics)讨论这个事情，这篇论文受到了很大的重视。

回归正题，四种不同的模型的 BLEU 值如下表所示：

其实也不见得比传统方法要好多少。当然据我所知， Encoder-Decoder 这个模型还是挺受重视的，如果我没记错的话，上次在 QCon 上看到阿里的跨境电商翻译系统应该是用上了 Encoder-Decoder 结构(不想误导，他们还有专业团队进行人工翻译)。

phrase pair 打分的结果如下:

其中第一栏是输入的英语 phrase ，第二栏是用传统的模型得到的最近似的三个法语 phrase，第三栏是用 Encoder-Decoder 模型得到的最近似的三个 phrase。

就我对这篇论文的理解来说，应该是这样的。结尾再对计算两个序列之间的相似性这件事情说说自己的想法，在这件事情上，作者只是在训练过程中得到这样一个额外的、静态的结果，最后得到的那张表，其中包含的 phrase 是确定的、有限的，姑且认为其中的 phrase 都是粒度比 sentence 更细的合法单元，但实际上可以把 Decoder 的输出看成一个搜索空间，在给定 任意 输入序列的时候，用输出序列在这个空间里确定搜索路径，这条路径上每一条边都是有置信度(概率)的，这样就可以直接得到一个条件概率来表征连个序列之间的相似程度，好处是可以处理任意的 sequence pair，这对实际问题应该会有帮助。当然这个想法可行性有待验证就是了。

这篇论文是第一篇提出 Memory Network 的论文，和神经元图灵机(Neural Turing Machine)的论文在同一年。不过说实话，我觉得这篇论文的质量很一般，是比不上 NTM 那篇论文的，只不过其中提出来的一些观点和思想在后面逐渐被补充和完善，才有了现在 Memory Network 的名声。

论文的出发点有这么几个:

1. 大部分 ML 方法都缺乏建立长期记忆(long term memory)的能力以及基于长期记忆的推理和处理 —— RNN 虽然能一定程度上做到，但由于 gradient vanish 的问题，实际上长期记忆在 RNN 中会衰退为短期记忆，LSTM 的提出对此问题有所改善，但效果有限
2. 作者主要是想进行基于知识库(Knowledge Base，或称知识图谱)的问答，但希望知识库可以作为模型的一部分并在此基础上进行 QA
3. NTM 的结构很好，但是它能使用的 memory 还是太小了

首先明确一下这里的「Memory」也就是「记忆」的概念。在不同的领域，比如脑科学、认知科学、物理学，对记忆的定义和理解都不一样，我对这些学科不太懂，不知道该对应到其中的哪部分上去。在机器学习/深度学习里，所谓的记忆，只是指「处理过的数据中会对目前的处理过程造成影响的信息」，也就是说，是和时序存在关联的。图像识别里用大量的图片来训练模型，最后能识别出新的图像的类别，这算不算「记忆」呢？按照我们的观点，其实也算，但这种我们更多认为是从大量同类图片中提取出了「模式」，本文讨论的「记忆」并不是这样的，除了有时序关系，还要有一定的因果关系，比如说我前 1 分钟给我看一张搞笑图片，现在给我一张根据这个搞笑图片 PS 过的川普和希拉里的图片，我会 get 到笑点然后拍桌狂笑。

总结一下的话是两点:

1. 时序性: 信息的输入是时序的，有先有后
2. 因果性: 先输入的信息对后输入的信息会产生影响，如果将两者调换，那么结果会不一样

看到时序性，很自然会想到 RNN，而它也满足第二点，只不过在它里面，「记忆」是隐式存在的，也就是它里面的 hidden state。但众所周知，RNN 因为 gradient vanish 的问题没法对长期记忆进行建模，LSTM 的提出倒是神来之笔，大大提高了 vanilla RNN 这方面的能力，后来 residual network 里的 skip connection 和 LSTM 里的 constant error flow 是很相似的。

对概念的讨论就这样，先来看看论文的模型，大致如下：

整个模型分成五个模块，分别是:

1. 输入模块 I: 用来对输入进行特征提取
2. 泛化模块 G: 用来将输入根据一定的机制写入到 memory 中去
3. 记忆模块 memory: 用来存储信息，供后面的处理使用
4. 响应模块 R: 对特定的问题，用来从 memory 中提取信息并进行推理，得到输出信息
5. 输出模块 O: 对模块 R 的输出进行处理，表达成自然语言

如果读过神经元图灵机那篇论文，应该能一眼看出来模块 G 和模块 R 其实就是 NTM 里面的 write heads 和 read heads，在读写的时候计算 memory 里所有成分和当前数据的相似度，其实就是类似现在的 attention 机制了。然而有一个问题是，如果 memory 超级大，比如像作者说的一样，要将整个 freebase 作为 memory，别说计算 softmax 了，就是遍历 memory 都会是难以承受的，这问题该怎么解决呢？

Consequently, for efficiency at scale, G(and O) need not operate on all memories: they can operate on only a retrieved subset of candidates(only operating on memories that are on the right topic). We explore a simple variant of this in our experiments.

如上，作者的办法是，建立 word 到 memory 的哈希，然后根据 question 来去检索出关联的 memory，只对这部分 memory 进行推理 —— 这其实就是一个倒排索引了……

在这个模型中，模块 G 和模块 R 是核心所在，真的如作者所说要存储大规模的 memory 并在其基础上进行推理时，模块 G 和模块 R 的具体设计是很重要的，然后作者在后面描述基于 freebase 的 QA 任务时，模块 G 只是填充「下一个空白的 memory cell」，模块 R 则是「根据倒排索引去检索相关的 memory cell」，完全就是一套检索系统，整个训练过程也完全不是端到端的，臭不要脸 :)。直到 15 年 Sukhbaatar 提出了端到端的模型后， Memory Network 才算是真正意义上的完成了，我是这样认为的。

总之我个人对这篇论文评价不高，虽然它提出的 Memory Network 这个模型的思想是不错的，某种意义上来说，它其实是一个框架而不是一个具体的模型，因为其中的 I/G/R/O 四个模块都是可以用不同 NN 来实现，扩展性很好，这也是后来持续地有 Memory Network 相关的工作的原因， NIPS 2015 还专门有一个 RAM workshop —— 所谓「RAM」是 "RNN-Attention-Memory" 的缩写。

以上。

这篇论文是中科院自动化研究所(CASIA)在 9 月份发表的一篇论文，收录于 COLING2016。该论文基于 Memmory Network 做了一些改进，使得模型在特定的 QA 任务中能更好地从 memory 中选择答案，并且能一定程度上处理低频词甚至未登录词(unknown words)。论文的数据集以及模型实现已经在 Github 上开源，如果对论文细节没有太多兴趣，可以直接去 项目地址 了解项目详情。

论文使用的数据集如下表所示

数据集包含机票预订和酒店预订两个领域，而且包含中文的数据集哦，这点很赞，虽然数据量看起来并不是很多。截取中文的机票预订数据中的片段如下:

1 下午 好 ， 我 是 机票 预订 服务 代理 ， 需要 什么 服务 ？
2 我要 预订 一张 机票 。
3 请问 先生 您 从 哪里 起飞 ？
4 由 BGI 起飞 的 飞机 。
5 去 到 哪里 ？
6 到 印第安纳 去 。
7 电话 号 ？
8 13228762221 ， 这 是 我 的 号码
9 时间 是 ？
10 2015年09月26日22点 之前 。
11 先生 ， 乘客 的 身份证 是 ？
12 我 的 身份证号 是 110100195352319154 。
13 麻烦 说 下 您 的 名字 ？ 谢谢 先生 。
14 好 的 ， 名字 是 袁磊 。
15 先生 ， 我们 已经 成功 为 您 预订 。
16 这么 快 ， 非常 感谢您
17 订票 人 的 姓名 叫 什么 ？ 袁磊 16
18 出发 城市 是 哪里 ？       BGI 16
19 到达 城市 是 哪里 ？       印第安纳 16
20 出发 时间 是 什么 时候 ？  2015年09月26日22点 16
21 证件号码 是 多少 ？        110100195352319154 16
22 联系电话 是 多少 ？        13228762221 16

数据集的情况似乎有点像多轮对话，但并不完全是，如上 22 轮对话，其中前 16 轮是客服和客户之间的对话，这段内容被作为 history 输入到模型中储存为 memory，而 17-22 则是问题和对应的答案，每个问题的答案都是一个单独的词，是从 memory 中挑选出来的。所以从数据集上来看，本文的方法适用于一些像机票预订、酒店预订这种流程比较明确的业务。

像这种数据集，如果要我做我会怎么做呢？粗暴点的思路是将 history 和 question 各自 encode，然后将两者一起用于计算来去预测输出，事实上之前不少 QA 方面的工作都是这种思路。论文开头就批评这种做法

the memory of these methods, such as Long Short-Term Memory(LSTM) (Hochreiter and Schmidhuber, 1997) and Gated Recurrent Unit (GRU) (Cho et al., 2014) compressing all the external sentences into a fixed-length vector, is typically too small to accurately rememberfacts from the past, and may lose important details for response generation

这个也是当前在 sentence representation 讨论得比较多的话题吧，将句子直接 encode 成一个固定长度的向量，是会丢失一些细节的。不过我觉得还是看应用场景，如果是那种一问一答且目的性不是非常强的 QA 场景，encoder-decoder 的框架问题不大，语义漂移(如万能回复)的问题可以在前期进行意图识别、情感分析来得到额外的特征输入到模型里。但像本文的这种数据集就不是简单的一问一答，而是先有了一部分历史信息，然后给定问题从历史信息里寻找答案，有点类似英语的阅读理解题目 —— 因此 PaperWeekly 在 教机器学习阅读 中介绍了《End-to-End Memory Networks》这一篇作为本篇论文基础的论文(好绕口呀)。

对于类似本文的 QA 任务，早先的一些相关工作也是可以用上的，比如 Sukhbaatar 提出的端到端的 Memory Networks，文中记为「MemNN」。但是 MemNN 的问题在于它单纯在句子级别进行 "推理"，具体一点是只使用了 sentence level 的 attention 机制，见之前写的笔记: End-to-End Memory Networks。如果能进一步地在词级别进行分析，结果应该会更好一点。事实上也有人这么做了，2015 年俞扬等人的《Empirical study on deep learningmodels for question answering》论文中就提出了一种 "Search-Response" 结构的模型，先使用 MemNN 从 history 中挑选出相关的句子(supporting sentences)，这一步称为 "Search"；然后用 NTM 或者 NMT(Neural Machine Translation) 来从这些 supporting sentences 中生成答案，这一步称为 "Response"。在 "Search-Response" 结构中，Search 和 Response 两个步骤是分别独立训练的，也就是说这其实是一个 pipeline 的方法。

所以本文的基本思想是: 结合 MemNN 和 "Search-Response" 的思想，得到一个端到端的系统。本文的模型结构如下图所示:

图中左侧是模型的整体结构，右边的两个小图是左图中两个模块的细节图示。整个模型大体上可以划分为四个部分，分别是:

1. sentence level memory and reasoning

   这部分将 history 信息转换成内部的 memory，并在 此基础上计算结果，同 MemNN，上图中右下块是这部分的图示，要注意的是这里为了简化画成了类似 RNN 的结构图，但并不是说 \(X\) 中的句子依次输入这个模型，然后更新自连接的 \(u_{r}{(S)}\)，这里的自连接只是表示多层结构(文中使用的层数为 3)，而这种多层结构和 RNN 的结构有共同之处。

   在这里，history 也就是 \(X\) 中的每个句子 \(x_{i}\) 和 question 也就是 \(q\) 都要表示成一个向量，使用的是《End-to-End Memory Networks》中的 position encoding 方法，即将句子中每个词的 embedding 加权求和，而这个权值和词在句子中的次序有关。

   总之这部分跟《End-to-End Memory Networks》中的内容基本一样，不赘述，详见 MemNN 的笔记。

2. k-max pooling

   这部分连接 1 和 3，利用 1 输出的 internel state 和 question 一起挑选出 history 中和 question 最相关的 k 个句子。

   所谓的 internel state，就是图中的 \(\alpha^{(S)}\)

   \[\alpha^{(S)}=softmax(M^{T}u_{1}^{(S)})\]

   上式中 \(M\) 为 sentence level memory，\(u_{1}\) 为问题 \(q\) 的 representation。

3. word level memory and attention: 使用 2 得到的 k 个句子，进行 word level 的 attention 来得到结果

   这部分使用 BiGRU 来得到 attention

   \[M^{(W)} = \{m_{t}\}_{t=(1,2,...)}\]

   \[m_{t}=\overrightarrow{h_{t}}+\overleftarrow{h_{t}}\]

   \[\alpha^{(W)}=softmax(v^{T}\tanh(Wu_{R}^{(S)}+U\hat{m}_{t}))\]

   这里的 \(alpha^{(W)}\) 就是 word level 得到的结果，但是这个结果是在 k 个句子中的词上的概率分布，没法直接用于第 4 步的计算，因此要做一次转换，将 \(\alpha^{(W)}\) 扩充为长度为 \(V\) 的向量，\(V\) 是词典的大小，方法是用 0 填充。

4. output: 综合 1 和 3 的输出来计算最后的结果

   第一步得到的输出记为 \(p^{(S)}\)，第三步得到的输出记为 \(p^{(W)}\)，将这两者直接相加作为最后的输出

   \[p = p^{(S)}+p^{(W)}\]

如上所述，因为在 sentence level memory network 的基础上加上了 word level memory，作者将这个模型称为「Hierarchical Memmory Networks」，这是一个能够进行端到端训练、能在更细粒度的语言成分上进行"推理"的 QA 模型。

下图是 HMN 和其他模型在给定的数据集上的对比结果

以及 HMN 模型使用不同的 word level encoder 时的效果对比

下面的图显示了模型回答一个问题时的过程

1. 表格第一列是 history，这些内容将会被 encode 后储存到 sentence level memory 中
2. 需要回答的问题是: When does the client depart，正确答案是 history 中第 14 条中的日期
3. 表格第二列是 sentense level reasoning 的过程，其中的值是每一个 reasoning 层的 internel state 也就是 \(u_{r}^{(S)}\)，可以看到进行三次 reasoning 后正确的 supporting sentence 也就是第 14 条的权重已经非常的高了
4. 第三列是 k-max pooling，这里的 k 取值为 4，得到的就是 8、10、13、14 这四个候选的句子
5. 第四列是 word level 部分，使用 attention 来得到每个候选句子中的词作为答案的概率，这里概率最大的就是第 14 条句子中的日期

以上就是本篇论文的主要内容，至于开头作者提到的未登录词问题的处理，作者就是指着上面的图说：你看， 10/13/2018 这样的词也被找出来了！总之，作者没有提出一种对未登录词的解决办法，我猜他的意思是，在构建 vocabulary 的时候，不要根据词频去除低词频的词，而是照单全收喂给模型，而这个模型是能够将这种词频非常低的词正确地找出来作为答案的。

我觉得这就有点标题党了哈……

这篇论文在指出基于检索方法(retrieval-based)和基于生成方法(generation-based)的两种对话系统的问题后，提出了一种结合检索方法和生成方法的对话系统，并在 700w 的中文对话数据(来自微博、百度知道、贴吧等)上获得了比两种方法都更好的结果。

检索方法在一些垂直领域的对话系统中比较常见，这是因为特定领域的对话系统中用户的目的性比较明确，多为查询信息或者提供信息(以完成某种「任务」)，通过检索和人工规则一般就能解决问题。而开放域的闲聊类场景下，如果有足够的数据，用生成方法会是一种比较好的选择。作者关注的开放域中的对话系统，这种场景下也可以应用一些检索方法和人工规则，但检索方法只能根据浅层语义来发现关联的回复，而尝试用人工规则覆盖开放域下的种种不同情况将会导致规则数量爆炸增长；生成方法固然可以生成知识库中没有的回答，但很容易抛出类似「呵呵」、「是吗」这种万能回复，这种语义漂移现象已经被很多将生成方法应用于对话系统的人发现并进行研究了。

文本的思路是将检索方法和生成方法结合起来，主要思想有两点:

1. 使用生成方法时，使用检索到的回复作为额外的信息
2. 对检索方法和生成方法给出的结果，在最后进行重新排序

具体一点的话，过程是这样的:

1. 对给定的 query \(q\)，首先从知识库中进行检索，得到候选的回复 \(r^{\ast}\)，这个 \(r^{\ast}\) 会有很多个
2. 将每个候选回复 \(r^{\ast}\) 和 \(q\) 一起输入到生成模型也就是图中的「multiseq2seq generator」中，后文又称之为「biseq2seq」
3. \(q\) 和 \(r^{\ast}\) 都是一个句子，它们在 biseq2seq 中经过 encoder 被各自编码成一个向量
4. 将 \(q\) 和 \(r^{\ast}\) 的向量 拼接 起来，decoder 以其作为输入，生成一个回复 \(r^{​+}\)
5. 将所有检索出的回复 \(r^{\ast}\) 和生成的回复 \(r^{​+}\) 混合起来，进行重排序，返回最优的一个

检索阶段没有太多好说的，就是搜索系统用的那一套东西，先根据 query 内容找到知识库中可能有关联的 "问-答" 对 \((q^{\ast}, r^{\ast})\)，然后进行排序，选出 1000 条最好的结果。需要注意的是，在排序时，\(q\) 和 \(q^{\ast}\) 的关联性、\(q\) 和 \(r^{\ast}\) 的关联性会一起被考虑。

生成阶段，其所谓的「biseq2seq」的结构如下图所示

这个模型里有两个 encoder 和一个 decoder，一个 encoder 用来对 \(q\) 进行编码，另一个 encoder 用来对 \(r^{\ast}\) 进行编码。两个 encoder 输出会拼接成一个向量输入到 decoder 中。不过论文没有就 biseq2seq 的具体数学表示和训练做详细说明，从引用文献里看，biseq2seq 的想法是来自 Barret Zoph 和 Kevin Knight 的一篇论文《Multi-source neural translation》，是 2016 年发表的一篇论文，回头再去了解一下。

下表是论文中方法和其他一些方法的实验对比结果。

论文中还展示了 biseq2seq 和 seq2seq 在生成回复时的结果对比，从下表来看，biseq2sq 生成的结果确实更有意义一些。

这篇论文是在看 Hierarchical Memory Networks for Answer Selection on Unknown Words 时追过去的 —— 这篇论文里有些东西讲的不明不白，还好它里面说明一些思想来自哪里。

论文标题为 "End-to-End Memory Networks" ，很显然这篇论文是基于 Memory Networks 来做了一些工作，按照惯例，论文在开头说了一些原始的 Memory Networks 的缺点:

1. Memory Networks 难以进行 BP 训练
2. Memory Networks 需要更多的 supervision(这个没太懂，回头把 Memory Networks 再看一下)

模型的基本结构如下图所示。

模型的输入包含两部分，一个是图左端那个「Sentences」，即由多个句子组成的内容，这些句子会被输入到网络中并储存为「memory」，可以认为是在检索/问答时的历史信息或者说上下文；另一部分是 query 或说 question，就是图中下端那个 q，也是一个句子。模型最后的输出也是一个句子。

模型的输出，按照我对这张图的理解，应该是一个经过 softmax 的 d 维向量(d 是 vocabulary 的大小)，但是这样的话就只能输出一个词了？从后面的实验部分来看确实是这样的，总感觉这样的话并不是很适用于常规的 QA 任务了。

输入的 Sentences，首先通过 embedding 矩阵 A 得到 input memory。其实就是将每一个句子 encode 成一个向量，也就是图上的 \(m_{i}\)，这些 \(m_{i}\) 组合起来就得到 input memory，也就是涂上标为 Input 的那块矩形 M。问题 q 同样通过 embedding 矩阵 B 来 encode 成一个向量 u，然后用 u 和 M 內积得到一个权值向量:

\[p=softmax(u^{T}M)\]

接着，输入的 Sentences 通过另外一个 embedding 矩阵 C 得到另外一个 memory 表示，也就是图上标为 Output 的那块矩形 C，然后用上一步得到的权值向量来对 C 进行加权求和:

\[o=\sum_{i}p_{i}c_{i}\]

对于这部分，我的理解是，u 和 M 的內积相当于一个 attention，得到 attention 后，就用来在用于输出的 memory 也就是 C 中进行检索得到输出结果。不过还是有些地方不太明白，比如说反映在网络结构上，u 和 M 的內积是怎么体现的？输入连接两个 embedding 矩阵又是怎么体现的？

在得到输出向量 o 后，按理来说直接 softmax 就可以得到结果吧，但是这里却和 question 的向量 u 做了一个加法才进行 softmax，不是很懂，也许和 ResNet 的那个 residual connection 是同样的思想？但是 2015 年 3 月份(这篇论文的发表时间)的时候 ResNet 还没有正式发表吧。

以上就是单层时的情况，多层的时候就用前一层的(未经过 softmax 的)输出作为本层的输入向量 u，即

\[u^{k+1} = o^{k}+u^{k}\]

一图胜千言:

在多层结构的时候，作者又对 "weight typing" 做了不同的尝试 —— 不知道「weight typing」该怎么翻译，且看下文吧。

可以看到，在上面的多层网络结构中，每一层都有一个 A 和 C，对 A 和 C 的处理，有两种方式:

1. Adjacent: 将前一层的输出 embedding 矩阵 C 作为本层的输入 embedding 矩阵 A: \(A^{k+1}=C^{k}\)
2. Layer-wise: 像 RNN 一样，所有输入 embedding 矩阵 A 共享参数: \(A^{1}=A^{2}=...=A^{K}\)，输出矩阵 C 同理

在对句子的 encode 上，也有两种不同的处理方式:

1. BoW: 简单的将句子中每个词的 embedding 累加起来: \(m_{i}=\sum_{j}Ax_{ij}\)，u 和 \(c_{i}\) 的计算同理
2. position encoding: \(m_{i}=\sum_{j}l_{j}\cdot Ax_{ij}\)，这里的 \(l_{j}\) 就是所谓的反映了词序的 position encoding，它和后面的值进行 element-wise 的乘法而不是內积，而这个 position encoding 的计算方法是: \(l_{kj}=(1-j/J)-(k/d)(1-2j/J)\)，其中 j 是词在句子中的位置，J 是句子的长度，k 是这个词的 vocabulary id，d 是 vocabulary 的大小。

此外就是 Sentences 中的句子之间也是有次序的，为了反映这个次序，又在计算 \(m_{i}\) 和 \(c_{i}\) 时加了一个额外的叫做 temporal encoding 的东西，分别记为 \(T_{A}(i)\) 和 \(T_{C}(i)\):

\[m_{i}=\sum_{j}Axij + T_{A}(i)\]

但是并没有说 \(T_{A}(i)\) 和 \(T_{C}(i)\) 是如何表现的，只是带了一句: Both \(T_{A}\) and \(T_{C}\) are learnd during training。另外，在模型中，句子的次序对真实的次序而言是倒序的。

作者提出这个模型除了用在 QA 上外，还在语言模型上做了实验。在做语言模型时，是没有 question/query 的，所以 u 被设置为一个常量的向量(值都为 0.1)；然后每个 \(m_{i}\) 和 \(c_{i}\) 都是对应一个词而不是一个句子了，因为 LM 是 word-level 的问题嘛。

最后总结一下，本文的主要贡献是增强了原始的 Memory Networks，让其称为一个端到端的模型，能更方便地使用 BP 方法进行训练。

就酱！

这篇论文是 DeepMind 在 2016 年 8 月 18 日发布的，最初是在智能单元上看到这个消息的，觉得挺有趣的，就去读了一下。

这篇论文干了什么呢？它在现有的神经网络模型基础上，提出了一种称为 Decoupled Neural Interfaces(后面缩写为 DNI) 的网络层之间的交互方式，用来加速神经网络的训练速度。

作者在开篇指出，在神经网络模型训练中存在几个问题

• Forward Locking: 前一层没有用输入完成计算，后一层无法进行根据输入进行计算
• Update Locking: 如果一个网络层依赖的层没有完成前馈计算，该层无法进行更新
• Backward Locking: 如果一个网络层依赖的层没有完成反向传播，该层无法进行更新

刚看到这说不定会想你这不是废话吗，前一层没计算好后一层怎么计算怎么更新？哎，作者表示我就是不信这个邪我就是要上天和太阳肩并肩啊！为什么呢，因为在一些情况下，神经网络的这种计算模式会带来一些问题，这些情况包括:

• 由多个异步模块组成的复杂的系统(这个不懂……)
• 分布式模型，模型的一部分共享给多个下游客户端使用，最慢的客户端将会成为模型更新速度的短板

所以呢，作者就想办法把这种训练时层与层互相依赖的限制干掉咯。

第一个想法，是干掉 Update Locking 和 Backward Locking，让网络的每一层在完成前馈计算后能马上计算出残差，然后立即进行该层的参数更新，而不用等待后一层的前馈计算和误差反向传播。这个是怎么做到的呢？办法就是， 增加一个额外的模型 ，去根据当前网络层的输出去预测其残差，并用预测到的残差去计算梯度，这个实际梯度的估计值，被称为「合成梯度(synthetic gradients)」。

先来看看传统的误差反向传播(Backpropagation, BP)算法，我们假设一个有 N 层的神经网络，其第 i 层的激活值即输出为 \(h_{i}\) ，那么对第 i 层，其参数更新式子为:

\[\begin{array}{rcl} \theta_{i} &\leftarrow& \theta_{i} - \alpha\delta_{i}\frac{\partial h_{i}}{\partial \theta_{i}} \\ &\leftarrow& \theta_{i} - \alpha\delta_{N}\frac{\partial h_{i}}{\partial \theta_{i}}\cdot \prod_{j=0}^{N-i-1}\frac{\partial h_{N-j}}{\partial h_{N-j-1}}\end{array}\]

可以看到，需要依赖后面所有层的激活值的计算。作者的思路就是只利用当前层的激活值 \(h_{i}\) 去得到当前层的残差 \(\delta_{i}\) 的估计值 \(\hat{\delta_{i}}\):

\[\begin{array}{rcl} \delta_{i} &\sim& \hat{\delta_{i}} \\ &=& M_{i+1}(h_{i})\end{array}\]

但是可想而知，在初始的时候，这样一个「额外的模型 M」所给出的残差估计值肯定是与实际的残差有很大的偏差的，那么怎么办呢？办法就是用每一层的实际的残差去训练这个额外的模型 M —— 不过这样不就将 BP 的过程转移到另外一个模型里去了么，这不是耍流氓嘛！不过作者在这里又使用了一个技巧，将 BP 过程彻底干掉了。

我们都知道，所谓误差反向传播，是先计算出最后一层的残差，然后用最后一层的残差去计算倒数第二层的残差，依次类推，故称「误差反向传播」。如果在训练模型 M 时依然遵照这个流程，毫无疑问 Update Locking 和 Backward Locking 依然存在，所以作者在计算每一层的“实际残差”时，用的是后一层的“合成残差”，而合成残差的计算是可以立即计算的。这里实际上又做了一次近似，也就是:

\[\delta_{i} = \hat{\delta}_{i+1}\frac{\partial h_{i+1}}{\partial h_{i}}\]

这样用这个近似的 \(\delta_{i}\) ，去评估模型 M 给出的残差估计值 \(\hat{\delta_{i}}\) ，并用两者之间的误差去更新模型 M。由于最后一层是能得到真正的残差的，所以最后一层的模型 M 能较快得到训练，随着最后一层的模型 M 被训练的越来越好，它所估计出的 \(\hat{\delta_{i}}\) 也能越接近真实的 \(\delta_{i}\) 。如下图所示:

再进一步地，作者表示，利用 DNI 的思想，去预测每一层的输入也是可以的，这样就把 Forward Locking 也去掉了。基本思想和合成梯度是一样的，不同之处在于预测每一层的输入时只用到第一层也就是输入层的输入:

这样 Forward Locking、Update Locking 和 Backward Locking 都被去掉了，通过适当的设计，整个训练可以被很好地并行化、异步化了。

DNI 的思想除了用在前馈神经网络上，也可以用于循环神经网络(Recurrent Neural Network, RNN)的训练上面，因为 RNN 在时间维度上展开后，其实就相当于是一个前馈神经网络了。而且由于应用 DNI 的模型，最多只有两层的网络层依赖，那么在用于 RNN 训练时，可以不用将 RNN 完全展开，而是可以以两个 time step 为最小单元进行展开，即一次只展开两个 time step，这样在存储上的消耗也可以被降低。

来看看作者的牛皮

Although we have explicitly described the application of DNI for communication between layers in feedforward networks, and between recurrent cores in recurrent networks, thereis nothing to restrict the use of DNI for arbitrary network graphs. The same procedure can be applied toany network or collection of networks, any number of times.

以上就是 DNI 的理论部分，实际上还有很多东西没有讲清楚，比如:

• 那个额外的模型 M 的具体细节？
• 增加了额外的模型 M ，相当于增加了参数数量，是不是更容易过拟合了？

作者首先在 MNIST 和 CIFAR-10 两个数据集上测试了 DNI 方法和 BP 方法之间的训练效果(只去除 Update Locking 和 Backward Locking)

需要说明的是，这里用的模型(FCN 和 CNN)层数都不多，实验分别使用了 3-6 的层数，见上图中右侧部分，从该图来看，使用 DNI 的训练方法在训练速度和训练效果上并没有什么优势。这个实验只是表明，使用 DNI ，模型 能够被训练 。

第二个实验是这样的：对一个四层的前馈网络，以随机的顺序来更新每一层，并且每一层在被选中都是有概率的。在这样的情况下，模型依然是可以被训练的。

不过明显能看出来，概率值越大，收敛是越快的，最后在迭代次数达到 50w 次时，不同的概率都达到了接近的精度(2% 的误差)，不过一个四层的网络，真的不是过拟合了么……

第三个实验在第二个实验的基础上，加上了 synthetic inputs ，也就是把 Forward Locking 去掉了，从结果上来看，和第二个实验差不多的样子。

最后在 RNN 上进行了三个实验，分别是:

• Copy: 读入 N 个字符，然后将这 N 个字符原样输出，有点类似 char-level language model 和 autoencoder。
• Repeat Copy: 读入 N 个字符，以及一个表示重复次数的数字 R，然后重复输出 R 次这 N 个字符构成的序列。
• char-level language modeling: (持续地)读取一个字符，并预测下一个字符。

结果如下图所示:

上图中 Copy 和 Repeat Copy 两栏中的值表示建模的最大序列长度，越大越好；Penn Treebank 一栏表示语言模型的困惑度(Perplexity，这里用 bits per word 进行度量)，越小越好。从实验结果上来看，在 Copy 和 Repeat Copy 任务上，使用 DNI 的模型能建模更长的序列。

这篇论文的作者来自一家 AI 公司 MetaMind，因此虽然用了「Memory Network」这个概念，但在思路上和 FAIR 提出 Memory Network 的几个人都很不一样。按我的观点，这篇论文里的模型与其说是 Memory Network，不如说是 encoder-decoder + attention。

这篇论文同样是用来处理 QA 任务的，用的是 FAIR 公开的 bAbI 数据集。这个数据集所描述的场景，其实和 reading comprehension 更接近一点，先会有一段话进行描述，然后给出若干个问题，要求根据前面的描述来寻找答案，下面是一个例子:

I: Jane went to the hallway.
I: Mary walked to the bathroom.
I: Sandra went to the garden.
I: Daniel went back to the garden.
I: Sandra took the milk there.
Q: Where is the milk?
A: garden
I: It started boring, but then it got interesting.
Q: What’s the sentiment?
A: positive
Q: POS tags?
A: PRP VBD JJ , CC RB PRP VBD JJ .

其中以 "I" 开头的句子就是描述性句子，被称为上下文（Context）；"Q" 开头的句子则是问题，"A" 开头的句子是回答。在这个场景下，context 有一定的长度，要比 RNN 能处理的信息长度更大，但又是有限的。

与 14 年那提出的 Memory Network 模型和 Neural Turing Maching 模型不同的是，DMN 里没有使用外部的存储空间，而是直接用一个 RNN 的 encoder 对 context 进行编码，将这个过程中输出的 hidden state 作为 memory —— 所以我会认为这个模型更接近 encoder-decoder + attention 而不是 Memory Network 了。

如上图所示，整个模型分为四个模块，和 Memory Network 里的 I/G/R/O 四个模块一一对应，但刚才也说了，其实这个模型和 Memory Network 并不是很像，所以作者为了对应上 Memory Network 的四个模块而作出类比，搞得有点不太好理解。图中的 Episodic Memory 模块并不对应 Memory Network 里的 memory 存储区域，非要说的话，应该是对应 Memory Network 里的 Response 模块，用来做结果的推理也就是 attention。

接下来我还是按我的理解来梳理这篇论文吧。

模型的 Input Module，其实就是一个 encoder，用来将 context 表示成 hidden state 形式的 "memory"。与 Memory Network 不同的是，各个 context 并不是分开处理的，而是串联成一个长的 sequence，然后喂给 RNN，然后只取每个 context 结束时输出的 hidden state。当然也有一些极端情况，比如说只有一个 context 的句子，这种情况下就直接输出每个 time step 的 hidden state 作为 memory。如下图所示：

然后同样用一个 RNN encoder 对 quesiton 进行处理，不过这时只取这个 encoder 最后一个 time step 的 hidden state，作为这个 question 的表示。

Episodic Memory Module 其实就是一个 attention 模块，用 question 在 Input Module 产生的 memory 上进行 attention。不过与普通的 attention 不同的是，这里的 attention 不是单纯地用 question 和 memory 进行內积算 softmax，而是再用一个 RNN encoder，将 Input Module 产生的 memory 依次输入到这个 encoder 中，并且每次都将 Question Module 的输出作为额外的信息参与计算，然后取这个 encoder 的最后一个 time step 的 hidden state 作为最后 Answer Module 里的 decoder 的 context vector。除了这点不同外，再就是这个过程可能会进行多遍，用每次计算出来的 context vector 输入到一个 decoder 里，用产生的 hidden state 再参与到 attention 中，这个迭代次数是认为设定的，在论文里作者就迭代了三次。如下图所示:

最后，将 Episodic Memory Module 的输出作为 context vector 输入到 Answer Module 的 decoder 里去，来生成最终的答案，这块比较简单，如下图所示。

比较有意思的是它里面那个 Episodic Memory Module 多遍迭代的结果，作者可视化后发现，第一遍的时候可能找到的是字面上相关的 context 句子，然后后面在迭代会慢慢定位到真正语义相关的 context 句子上，相当于是在做了推理。

此外，作者还把模型用在了情感分析上，对句子中词的 attention 结果，在迭代过程中的变化也展现出了类似的现象。

以上。