@@ -53,11 +55,12 @@
当然，我们也可以仅仅通过扩大 $h$ 或 $c$的维度来扩大信息带宽，然而，这样的扩展是以 $O(n^2)$ 的存储（状态-状态转移矩阵）和计算复杂度为代价。而基于神经图灵机的记忆扩展的代价是 $O(n)$的，因为寻址是以记忆槽（Memory Slot）为单位，而控制器的参数结构仅仅是和 $m$（记忆槽的大小）有关。值得注意的是，尽管矩阵拉长了也是向量，但基于状态单向量的记忆读取和写入机制，本质上是**全局**的，而 NTM 的机制是局部的，即读取和写入本质上只在部分记忆槽（尽管实际上是全局写入，但是寻址强度的分布是很锐利的，即真正大的强度仅分布于部分记忆槽），因而可以认为是**局部**的。局部的特性让记忆的存取更干净。
-所以，在该实现中，RNNs 原有的状态向量 $h$ 或 $c$、 Seq2Seq 常见的注意力机制，被保留；同时，类似 NTM （简化版，无基于位置的寻址） 的有界外部记忆网络被以补充 $h$ 的形式加入。整体的模型实现则类似于论文\[[2](#references)\]，但有少量差异。同时参考该模型的另外一份基于V1 APIs [配置](https://github.com/lcy-seso/paddle_confs_v1/blob/master/mt_with_external_memory/gru_attention_with_external_memory.conf)， 同样有少量差异。具体讨论于 [Further Discussion](#discussions) 一章。
+所以，在该实现中，RNNs 原有的状态向量 $h$ 或 $c$、 Seq2Seq 常见的注意力机制，被保留；同时，类似 NTM （简化版，无基于位置的寻址） 的有界外部记忆网络被以补充 $h$ 的形式加入。整体的模型实现则类似于论文\[[2](#references)\]（网络结构见 [Architecture](#architecture)一章），但有少量差异。同时参考该模型的另外一份基于V1 APIs [配置](https://github.com/lcy-seso/paddle_confs_v1/blob/master/mt_with_external_memory/gru_attention_with_external_memory.conf)， 同样有少量差异。具体讨论于 [Discussions](#discussions) 一章。
注意到，在我们的实现中，注意力机制（或无界外部存储）和神经图灵机（或有界外部存储）被实现成相同的 ExternalMemory 类。只是前者是**只读**的， 后者**可读可写**。这样处理仅仅是为了便于统一我们对 “记忆机制” 的理解和认识，同时也提供更简洁和统一的实现版本。
### Architecture
+
网络总体结构基于传统的 Seq2Seq 结构，即RNNsearch\[[3](#references)\] 结构基础上叠加简化版 NTM\[[1](#references)\]。
- 编码器（encoder）采用标准**双向GRU结构**（非 stack），不再赘述。
@@ -72,29 +75,110 @@
1. $M_{t-1}^B$ 和 $M_t^B$ 为有界外部存储矩阵，前者为上一时间步存储矩阵的状态，后者为当前时间步的状态。$\textrm{read}^B$ 和 $\textrm{write}$ 为对应的读写头（包含其控制器）。$r_t$ 为对应的读出向量。
2. $M^S$ 为无界外部存储矩阵，$\textrm{read}^S$ 为对应的读头（无 写头），二者配合即实现传统的注意力机制。$c_t$ 为对应的读出向量（即 attention context)。
-3. 虚线框内（除$M^S$外），整体可视为有界外部存储模块。可以看到，除去该部分，网络结构和 RNNsearch\[[3](#references)\] 基本一致。
+3. $y_{t-1}$ 为解码器上一步的输出字符并做词嵌入（Word Embedding)，作为当前步的输入，$y_t$ 为解码器当前步的解码符号的概率分布。
+4. 虚线框内（除$M^S$外），整体可视为有界外部存储模块。可以看到，除去该部分，网络结构和 RNNsearch\[[3](#references)\] 基本一致（略有不一致之处为：用于 attention 的 decoder state 被改进，即叠加了一 Tanh 隐层并引入了 $y_{t-1}$）。
+
## Implementation
-TBD
+整体实现的关键部分在辅助模型类`ExternalMemory` 和模型配置函数 `memory_enhanced_seq2seq`。
+
+### `ExternalMemory` Class
+
+`ExternalMemory` 类实现通用的简化版**神经图灵机**。相比完整版神经图灵机，该类仅实现了基于内容的寻址（Content Addressing, Interpolation），不包括基于位置的寻址（ Convolutional Shift, Sharpening)。读者可以自行将其补充成为一个完整的神经图灵机。
+
+类结构如下：
+
+```
+class ExternalMemory(object):
+ __init__(self, name, mem_slot_size, boot_layer, readonly, enable_projection)
+ __content_addressing__(self, key_vector)
+ __interpolation__(self, head_name, key_vector, addressing_weight)
+ __get_adressing_weight__(self, head_name, key_vector)
+ write(self, write_key)
+ read(self, read_key)
+```
+
+神经图灵机的 “外部存储” 采用 `Paddle.layer.memory`实现，注意这里的`is_seq`需要设成`True`, 该序列的长度表示记忆槽的数量（$n$), `size` 表示记忆槽（向量）的大小。同时依赖一个外部层作为初始化， $n$ 取决于该层输出序列的长度。因此，该类不仅可用来实现有界记忆（Bounded Memory)，同时可用来实现无界记忆 (Unbounded Memory，即记忆槽数量可变)。
+
+`ExternalMemory`类的寻址逻辑通过 `__content_addressing__` 和 `__interpolation__` 两个私有函数实现。读和写操作通过 `read` 和 `write` 两个函数实现。并且读和写的寻址独立进行，不同于 \[[2](#references)\] 中的二者共享同一个寻址强度，目的是为了使得该类更通用。
+
+为了简单起见，控制器（Controller）未被专门模块化，而是分散在各个寻址和读写函数中，并且采用简单的前馈网络。读者可尝试剥离控制器逻辑并模块化，同时可尝试循环神经网络做控制器。
+
+`ExternalMemory` 类具有只读模式，同时差值寻址操作可关闭。便于用该类等价实现传统的注意力机制。
+
+注意， `ExternalMemory` 仅可用于和 `paddle.layer.recurrent_group`配合使用（使用在其用户自定义的 `step` 函数中）。它不可以单独存在。
+
+### `memory_enhanced_seq2seq` Related Functions
+
+涉及三个主要函数：
+
+```
+memory_enhanced_seq2seq(...)
+bidirectional_gru_encoder(...)
+memory_enhanced_decoder(...)
+```
+
+`memory_enhanced_seq2seq` 函数定义整个带外部存储增强的序列到序列模型，是模型定义的主调函数。`memory_enhanced_seq2seq` 首先调用`bidirectional_gru_encoder` 对源语言进行编码，然后通过 `memory_enhanced_decoder` 进行解码。
+
+`bidirectional_gru_encoder` 函数实现双向单层 GRU（Gated Recurrent Unit） 编码器。返回两组（均为`LayerOutput`）结果：一组为向量序列（包含所有字符的前后向编码结果），一组为整个源语句的最终编码向量（仅包含后向结果）。前者用于解码器的注意力机制，后者用于初始化解码器的状态向量。
+
+`memory_enhanced_decoder` 函数实现通过外部记忆增强的 GRU 解码器。它利用同一个`ExternalMemory` 类实现两种外部记忆模块：
+
+- 无界外部记忆：即传统的注意力机制（Attention）。利用`ExternalMemory`，打开只读开关，关闭插值寻址。并利用解码器的第一组输出作为 `ExternalMemory` 的`boot_layer`（用作存储矩阵的初始化）。因此，该存储的记忆槽数目是动态可变的，取决于编码器的字符（token）数。
+- 有界外部记忆：利用`ExternalMemory`，关闭只读开关，打开插值寻址。并利用解码器的第一组输出，取均值 Pooling 后并扩展为指定序列长度后，作为 `ExternalMemory` 的`boot_layer`。因此，该存储的记忆槽数目是固定的，并且其所有记忆槽的初始化内容均相同。
+
+注意，注意力机制也可以通过 `paddle.networks.simple_attention` 实现。
+
+此外，在该实现中，将 `ExternalMemory` 的 `write` 操作提前至 `read` 之前，以避开潜在的拓扑连接局限，详见 [Issue](https://github.com/PaddlePaddle/Paddle/issues/2061)。我们可以看到，本质上他们是等价的。
## Getting Started
### Prepare the Training Data
-TBD
+数据是通过无参的 `reader()` 函数，进入训练过程。因此我们需要为训练数据和测试数据分别构造 `reader()` 函数。`reader()` 函数使用 `yield` 来保证可迭代性（iterable，即可以 `for instance in reader()` 方式迭代运行）, 例如
+
+```
+def data_reader():
+ for instance in data_list:
+ yield instance
+```
+
+`yield` 返回的每条样本需为三元组，分别包含编码器输入字符ID列表（即源语言序列），解码器输入字符ID列表（即目标语言序列，且序列右移一位），解码器输出字符ID列表（即目标语言序列）。
+
+用户需自行完成字符的切分 (tokenize) ，并构建字典完成 ID 化。
-### Training a Model
+PaddlePaddle 的接口 paddle.paddle.wmt14 ([wmt14.py](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/dataset/wmt14.py))， 默认提供了一个经过预处理的[较小规模的 wmt14 子集](http://paddlepaddle.bj.bcebos.com/demo/wmt_shrinked_data/wmt14.tgz)。并提供了两个reader creator函数如下：
-TBD
+```
+paddle.dataset.wmt14.train(dict_size)
+paddle.dataset.wmt14.test(dict_size)
+```
-### Generating Sequences
+这两个函数被调用时即返回相应的`reader()`函数，供`paddle.traner.SGD.train`使用。
-TBD
+当我们需要使用其他数据时，可参考 paddle.paddle.wmt14 ([wmt14.py](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/dataset/wmt14.py)) 构造相应的 data creator，并替换 `paddle.dataset.wmt14.train` 和 `paddle.dataset.wmt14.train` 成相应函数名。
+
+### Running the script
+
+命令行输入：
+
+```Python mt_with_external_memory.py```
+
+即可运行训练脚本（默认训练一轮），训练模型将被定期保存于本地 `params.tar.gz`。训练完成后，将为少量样本生成翻译结果，详见 `infer` 函数。
+
+## Experiments
+
+To Be Added.
## Discussions
-TBD
+#### 和论文\[[2](#references)\]实现的差异
+
+差异如下：
+
+1. 基于内容的寻址公式不同，原文为 $a = v^T(WM^B + Us)$, 本实现为 $a = v^T \textrm{tanh}(WM^B + Us)$，以保持和 \[[3](#references)\] 中的注意力机制寻址方式一致。
+2. 有界外部存储的初始化方式不同，原文为：$M^B = \sigma(W\sum_{i=0}^{i=n}h_i)/n + V$, $V_{i,j}~\in \mathcal{N}(0, 0.1)$。本实现暂为 $M^B = \sigma(\frac{1}{n}W\sum_{i=0}^{i=n}h_i) + V$。
## References
diff --git a/mt_with_external_memory/mt_with_external_memory.py b/mt_with_external_memory/mt_with_external_memory.py
index aee73e2e470019464f53c12daadd668f00ea3780..22f96a72ceff8dba71be7d5e8ee4fa2781b389b5 100644
--- a/mt_with_external_memory/mt_with_external_memory.py
+++ b/mt_with_external_memory/mt_with_external_memory.py
@@ -20,6 +20,7 @@
import paddle.v2 as paddle
import sys
import gzip
+import random
dict_size = 30000
word_vec_dim = 512
@@ -28,6 +29,7 @@ batch_size = 5
memory_slot_num = 8
beam_size = 3
infer_data_num = 3
+memory_perturb_stddev = 0.1
class ExternalMemory(object):
@@ -46,6 +48,10 @@ class ExternalMemory(object):
handling. Besides, some existing mechanism can be realized directly with
the ExternalMemory class, e.g. the attention mechanism in Seq2Seq (i.e. an
unbounded external memory).
+
+ Besides, the ExternalMemory class must be used together with
+ paddle.layer.recurrent_group (within its step function). It can never be
+ used in a standalone manner.
For more details, please refer to
`Neural Turing Machines
`_.
@@ -289,11 +295,17 @@ def memory_enhanced_decoder(input, target, initial_state, source_context, size,
input=source_context, pooling_type=paddle.pooling.Avg()),
size=size,
act=paddle.activation.Sigmoid())
- bounded_memory_init = paddle.layer.expand(
- input=bounded_memory_slot_init,
- expand_as=paddle.layer.data(
- name='bounded_memory_template',
- type=paddle.data_type.integer_value_sequence(0)))
+ bounded_memory_perturbation = paddle.layer.data(
+ name='bounded_memory_perturbation',
+ type=paddle.data_type.dense_vector_sequence(size))
+ bounded_memory_init = paddle.layer.addto(
+ input=[
+ paddle.layer.expand(
+ input=bounded_memory_slot_init,
+ expand_as=bounded_memory_perturbation),
+ bounded_memory_perturbation
+ ],
+ act=paddle.activation.Linear())
unbounded_memory_init = source_context
# prepare step function for reccurent group
@@ -477,17 +489,22 @@ def train(num_passes):
"source_words": 0,
"target_words": 1,
"target_next_words": 2,
- "bounded_memory_template": 3
+ "bounded_memory_perturbation": 3
}
+ random.seed(0) # for keeping consitancy for multiple runs
+ bounded_memory_perturbation = [
+ [random.gauss(0, memory_perturb_stddev) for i in xrange(hidden_size)]
+ for j in xrange(memory_slot_num)
+ ]
train_append_reader = reader_append_wrapper(
reader=paddle.dataset.wmt14.train(dict_size),
- append_tuple=([0] * memory_slot_num, ))
+ append_tuple=(bounded_memory_perturbation, ))
train_batch_reader = paddle.batch(
reader=paddle.reader.shuffle(reader=train_append_reader, buf_size=8192),
batch_size=batch_size)
test_append_reader = reader_append_wrapper(
reader=paddle.dataset.wmt14.test(dict_size),
- append_tuple=([0] * memory_slot_num, ))
+ append_tuple=(bounded_memory_perturbation, ))
test_batch_reader = paddle.batch(
reader=paddle.reader.shuffle(reader=test_append_reader, buf_size=8192),
batch_size=batch_size)
@@ -524,7 +541,7 @@ def infer():
source_words = paddle.layer.data(
name="source_words",
type=paddle.data_type.integer_value_sequence(dict_size))
- beam_gen = seq2seq(
+ beam_gen = memory_enhanced_seq2seq(
encoder_input=source_words,
decoder_input=None,
decoder_target=None,
@@ -540,9 +557,14 @@ def infer():
# prepare infer data
infer_data = []
+ random.seed(0) # for keeping consitancy for multiple runs
+ bounded_memory_perturbation = [
+ [random.gauss(0, memory_perturb_stddev) for i in xrange(hidden_size)]
+ for j in xrange(memory_slot_num)
+ ]
test_append_reader = reader_append_wrapper(
reader=paddle.dataset.wmt14.test(dict_size),
- append_tuple=([0] * memory_slot_num, ))
+ append_tuple=(bounded_memory_perturbation, ))
for i, item in enumerate(test_append_reader()):
if i < infer_data_num:
infer_data.append((item[0], item[3], ))
