Partially Non-Recurrent Controllers for Memory-Augmented Neural Networks

TL;DR

This paper introduces a partially non-recurrent controller for Memory-Augmented Neural Networks that improves external memory utilization and enhances task performance compared to traditional RNN controllers.

Contribution

It proposes a novel controller design that reduces internal memory reliance, enabling better external memory use in MANNs.

Findings

Significantly better results on Toy and bAbI tasks

Improved external memory utilization over standard RNN controllers

Enhanced task-solving capabilities in MANNs

Abstract

Memory-Augmented Neural Networks (MANNs) are a class of neural networks equipped with an external memory, and are reported to be effective for tasks requiring a large long-term memory and its selective use. The core module of a MANN is called a controller, which is usually implemented as a recurrent neural network (RNN) (e.g., LSTM) to enable the use of contextual information in controlling the other modules. However, such an RNN-based controller often allows a MANN to directly solve the given task by using the (small) internal memory of the controller, and prevents the MANN from making the best use of the external memory, thereby resulting in a suboptimally trained model. To address this problem, we present a novel type of RNN-based controller that is partially non-recurrent and avoids the direct use of its internal memory for solving the task, while keeping the ability of using contextual information in controlling the other modules. Our empirical experiments using Neural Turing Machines and Differentiable Neural Computers on the Toy and bAbI tasks demonstrate that the proposed controllers give substantially better results than standard RNN-based controllers.

Tables

Table 1. Table  1: Details of the Toy tasks. The superscripts in Priority Sort is the priorities defined on the dataset, and implicitly attached to each kind of vectors.

	Input	Output
Copy	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_T$	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_T$
Reverse	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_T$	${𝒂}_T{𝒂}_{T-1}{𝒂}_{T-2}{𝒂}_{T-3}\dots {𝒂}_1$
Bigram Flip	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_T$	${𝒂}_2{𝒂}_1{𝒂}_4{𝒂}_3\dots {𝒂}_T$
Odd First	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_T$	${𝒂}_1{𝒂}_3\dots {𝒂}_2{𝒂}_4\dots$
Repeat Copy	${𝒂}_1{𝒂}_2{𝒂}_3{𝒂}_4\dots {𝒂}_{T}M$	${𝒂}_1\dots {𝒂}_T\dots {𝒂}_1\dots {𝒂}_T\left(Mtimes\right)$
Priority Sort	${𝒂}_1^5{𝒂}_2^{10}{𝒂}_3^1{𝒂}_4^T\dots {𝒂}_T^4$	${𝒂}_3^1{𝒂}_7^2{𝒂}_8^3{𝒂}_T^4\dots {𝒂}_4^T$

Table 2. Table  2: Average bit error rates on the Toy tasks. Bold results are the best ones for each task. The bracketed numbers are the number of the individual models of the ten which completely solved (achieved 0.0% of bit error rate) the tasks.

	EN	LSTM	NTM					DNC
			FNN	EN	proposed EN	LSTM	proposed LSTM	FNN	EN	proposed EN	LSTM	proposed LSTM
Copy	37.5 (0)	21.8 (0)	0.0 (10)	0.0 (9)	0.0 (10)	11.0 (3)	0.0 (10)	2.8 (9)	0.0 (9)	0.0 (10)	13.2 (3)	3.3 (7)
Reverse	25.8 (0)	13.2 (0)	10.0 (6)	2.0 (8)	15.2 (2)	8.9 (2)	7.8 (3)	2.2 (9)	7.4 (5)	0.0 (10)	7.7 (1)	13.5 (3)
Bigram Flip	37.1 (0)	23.2 (0)	4.5 (3)	2.0 (8)	0.0 (10)	9.6 (5)	0.0 (10)	2.8 (5)	0.8 (8)	1.7 (8)	9.6 (3)	7.0 (6)
Odd First	36.0 (0)	13.1 (0)	3.2 (1)	2.9 (6)	0.2 (7)	5.7 (3)	0.0 (10)	18.0 (0)	4.7 (2)	2.7 (6)	10.1 (1)	10.6 (1)
Repeat Copy	15.6 (0)	7.7 (0)	1.0 (8)	0.0 (10)	0.0 (10)	0.9 (5)	0.0 (10)	1.5 (8)	0.3 (9)	0.0 (10)	0.0 (10)	0.0 (10)
Priority Sort	30.0 (0)	14.7 (0)	11.2 (0)	7.4 (0)	9.3 (0)	7.5 (0)	8.2 (0)	12.1 (0)	6.7 (0)	9.0 (0)	8.3 (0)	4.4 (0)

Equations

$${\mathbf{M}}_t={\mathbf{M}}_{t-1}\odot (\mathbf{E}-{\mathbf{w}}_t^w{\mathbf{e}}_t^T)+{\mathbf{w}}_t^w{\mathbf{v}}_t^T,$$

$${\mathbf{r}}_t^i={\mathbf{M}}_t^T{\mathbf{w}}_t^{r,i},$$

$${\mathbf{h}}_t=\phi ({\mathbf{W}}_{xh}{\mathbf{x}}_t+{\mathbf{W}}_{rh}{\mathbf{r}}_{t-1}+\mathbf{b}),$$

$${\mathbf{h}}_t=\phi ({\mathbf{W}}_{xh}{\mathbf{x}}_t+{\mathbf{W}}_{rh}{\mathbf{r}}_{t-1}+{\mathbf{W}}_{hh}{\mathbf{h}}_{t-1}+\mathbf{b}).$$

$${\mathbf{z}}_t$$

$${\mathbf{i}}_t$$

$${\mathbf{f}}_t$$

$${\mathbf{o}}_t$$

$${\mathbf{c}}_t$$

$${\mathbf{h}}_t$$

$$\begin{array}{rl}{\mathbf{c}}_t& =C(\mathbf{M},{\mathbf{k}}_t,{\beta }_t)[i]=\frac{{\beta }_t\exp (\mathcal{K}({\mathbf{k}}_t,\mathbf{M}[i]))}{{\sum }_j{\beta }_t\exp (\mathcal{K}({\mathbf{k}}_t,\mathbf{M}[j]))},\end{array}$$

$$\begin{array}{rl}\mathcal{K}(\mathbf{a},\mathbf{b})& =\frac{\mathbf{a}\cdot \mathbf{b}}{|\mathbf{a}||\mathbf{b}|}.\end{array}$$

$$\begin{array}{r}{\mathbf{w}}_t^g=g_t{\mathbf{c}}_t+(1-g_t){\mathbf{w}}_{t-1},\end{array}$$

$$\begin{array}{rl}\widetilde{{\mathbf{w}}_t}[i]& =\sum _{j=0}^{N-1}{\mathbf{w}}_t^g[j]{\mathbf{s}}_t[i-j],\end{array}$$

$$\begin{array}{rl}{\mathbf{w}}_t[i]& =\frac{\widetilde{{\mathbf{w}}_t}[i{]}^{{\gamma }_t}}{{\sum }_j\widetilde{{\mathbf{w}}_t}[j{]}^{{\gamma }_t}},\end{array}$$

$${\mathbf{\psi }}_t=\prod _{i=1}^R(1-f_t^i{\mathbf{w}}_{t-1}^{r,i}),$$

$${\mathbf{u}}_t=({\mathbf{u}}_{t-1}+{\mathbf{w}}_{t-1}^w-{\mathbf{u}}_{t-1}\odot {\mathbf{w}}_{t-1}^w)\odot {\mathbf{\psi }}_t,$$

$${\mathbf{a}}_t[{\mathbf{\varphi }}_t[j]]=(1-{\mathbf{u}}_t[{\mathbf{\varphi }}_t[j]])\prod _{i=1}^{j-1}{\mathbf{u}}_t[{\mathbf{\varphi }}_t[i]].$$

$${\mathbf{w}}_t^w=g_t^w[g_t^a{\mathbf{a}}_t+(1-g_t^a){\mathbf{c}}_t^w],$$

$${\mathbf{p}}_t=(1-\sum _i{\mathbf{w}}_t^w[i]){\mathbf{p}}_{t-1}+{\mathbf{w}}_t^w,$$

$${\mathbf{L}}_t[i,j]=(1-{\mathbf{w}}_t^w[i]-{\mathbf{w}}_t^w[j]){\mathbf{L}}_{t-1}[i,j]+{\mathbf{w}}_t^w[i]{\mathbf{p}}_{t-1}[j],$$

$${\mathbf{f}}_t^i$$

$${\mathbf{b}}_t^i$$

$${\mathbf{w}}_t^{r,i}={\mathbf{\pi }}_t^i[1]{\mathbf{b}}_t^i+{\mathbf{\pi }}_t^i[2]{\mathbf{c}}_t^{r,i}+{\mathbf{\pi }}_t^i[3]{\mathbf{f}}_t^i,$$

$$\overline{{\mathbf{h}}_t^{\prime }}$$

$${\mathbf{h}}_t^{\prime }$$

$${\mathbf{h}}_t=\phi ({\mathbf{W}}_{hh}{\mathbf{h}}_{t-1}+\overline{{\mathbf{h}}_t^{\prime }}).$$

$$\overline{{\mathbf{h}}_t^{\prime }}={\mathbf{W}}_{xz}{\mathbf{x}}_t+{\mathbf{W}}_{rz}{\mathbf{r}}_{t-1}+{\mathbf{b}}_z.$$

$${\mathbf{z}}_t=\tanh ({\mathbf{W}}_{hz}{\mathbf{h}}_{t-1}+\overline{{\mathbf{h}}_t^{\prime }}).$$

Full text

Introduction

Recurrent Neural Networks (RNNs) are widely used in applications that require sequential data processing such as natural language processing and speech recognition (?; ?). In particular, RNNs equipped with a long-term memory such as Long Short-Term Memory (LSTM) (?) have proven highly effective and achieved state-of-the-art performance in many tasks (?; ?). Nevertheless, those RNNs are not without limitation; since they implement their memory using a fixed-size vector, the capacity of their memory is severely restricted and it is hard to have a compartmentalized memory to accurately remember facts about the past (?).

To address the limitation of RNNs, researchers have proposed models called Memory-Augmented Neural Networks (MANNs). MANNs are a class of networks equipped with an external memory (?), and they are capable of using individual facts from the past selectively. While MANNs have shown promising results in some (relatively small-scale) experiments, they are not yet practical enough to be widely used in many real-world applications.

While there are various types of MANNs, we focus on the MANNs that are based on the Neural Turing Machine (NTM) (?). As shown in Figure 1, a NTM-based MANN consists of a memory and three types of modules implemented using neural networks (NNs), namely, a controller, read heads, and a write head. Among these modules, we focus on the controller, which is the core module that controls how a MANN operates. In most of the previous work on the NTM, the controller is implemented using an LSTM-based RNN because it enables the controller to operate using contextual information. However, it has recently been pointed out that using RNNs for the controller can have negative effects in training the whole model (?; ?). This is mainly because the RNN-based controller has its own memory, and it allows the model to partially solve the given task without using the large external memory, thereby resulting in a suboptimally trained model.

To address the abovementioned problem, we present a novel type of RNN-based controller that can avoid suboptimal solutions while keeping the ability of using contextual information. Experiments on the Toy tasks (?; ?; ?) and the bAbI task (?) demonstrate that our approach substantially improves the performance of MANNs. The main contributions of our work are as follows:

• •

Introducing a novel type of RNN-based controller for MANNs. This controller utilizes contextual information for controlling the other modules while avoiding its direct use for the outputs of the model.

• •

Demonstrating the effectiveness of the proposed controllers by the experiments on the Toy and bAbI tasks. The experimental results show that the proposed controllers significantly outperform conventional controllers in both tasks.

Memory-Augmented Neural Networks

Model Outline

MANNs are a class of neural networks equipped with an external memory, which is implemented as a set of vectors. Each of the vectors is associated with an address of its memory, and each operation of reading from or writing to the memory is performed with respect to each address. This design of memory use enables a MANN to use a large memory and deal with facts from the past selectively. In this paper, we focus on the NTM-based MANNs, and use the term MANNs to refer to the NTM-based MANNs in what follows.

As shown in Figure 1, a MANN consists of a memory and three kinds of modules implemented using NNs, namely, a controller, read heads, and a write head. At each time step $t$, these modules follow the procedures from (i) to (iv) as below.

(i) According to the input to the model $\bm{x}_{t}\in\mathbb{R}^{I}$ and the information read from the memory $\bm{r}_{t-1}\in\mathbb{R}^{W}$, the controller generates two vectors $\bm{\mathcal{H}}_{t}^{r}$ and $\bm{\mathcal{H}}_{t}^{w}$ to control the read heads and the write head. $I$ is the size of the input vectors, and $W$ is size of each vector in the memory. $\bm{r}_{t-1}$ is defined as $\bm{r}_{t-1}=[\bm{r}_{t-1}^{1};\,...;\,\bm{r}_{t-1}^{R}]$, where $\bm{r}_{t-1}^{i}$ is a vector read from the memory by the $i$th of the $R$ read heads at $t-1$, and the semicolons mean the concatenation of vectors.

(ii) According to $\bm{\mathcal{H}}_{t}^{w}$ and the memory at $t-1$, $\bm{M}_{t-1}\in\mathbb{R}^{N\times W}$, the write head updates $\bm{M}_{t-1}$ to $\bm{M}_{t}$, where $N$ is the number of addresses of the memory. The write operation is performed as follows:

[TABLE]

where all the elements of $\bm{E}\in\mathbb{R}^{N\times W}$ are $1$, and the vectors $\bm{e}_{t}\in[0,1]^{W}$ and $\bm{v}_{t}\in\mathbb{R}^{W}$ are used for erasing or adding information in the memory at $t$. $\bm{w}_{t}^{w}\in[0,1]^{N}$ is a vector which represents the weights for erasing and adding information at each address, where $\sum_{j}\bm{w}_{t}^{w}(j)\leq 1$. $\bm{e}_{t}$ and $\bm{v}_{t}$ are generated by a one-layer NN which uses $\bm{\mathcal{H}}_{t}^{w}$ as its input.

(iii) According to $\bm{\mathcal{H}}_{t}^{r}$ and $\bm{M}_{t}$, the read heads read information from the memory, and generate $\bm{r}_{t}$. The read operation of the $i$th read head is performed as follows:

[TABLE]

where $\bm{w}_{t}^{r,i}\in[0,1]^{N}$ is the weights of the $i$th read head for reading information from each address where $\sum_{j}\bm{w}_{t}^{r,i}(j)\leq 1$. After its generation, $\bm{r}_{t}$ is sent to the controller, and the controller saves it.

(iv) According to $\bm{x}_{t}$, $\bm{r}_{t-1}$, and $\bm{r}_{t}$, the controller generates $\bm{\mathcal{H}}_{t}^{o}$, which is the information used for the output of the model.

In the procedures from (i) to (iv), how to generate $\bm{\mathcal{H}}_{t}^{r}$, $\bm{\mathcal{H}}_{t}^{w}$, $\bm{\mathcal{H}}_{t}^{o}$, $\bm{w}_{t}^{w}$, and $\bm{w}_{t}^{r,1},\,...,\,\bm{w}_{t}^{r,R}$ depends on models and their implementations. In this paper, we use the NTM and the Differentiable Neural Computer (DNC) (?) for the models. First, we explain how to generate $\bm{\mathcal{H}}_{t}^{r}$, $\bm{\mathcal{H}}_{t}^{w}$, and $\bm{\mathcal{H}}_{t}^{o}$ for the two models in the next section. We then explain the mechanisms to generate $\bm{w}_{t}^{w}$ and $\bm{w}_{t}^{r,1},\,...,\,\bm{w}_{t}^{r,R}$ for each model in the following sections.

Controller

How to generate $\bm{\mathcal{H}}_{t}^{r}$, $\bm{\mathcal{H}}_{t}^{w}$, and $\bm{\mathcal{H}}_{t}^{o}$ is determined by the controller. In this paper, we assume that the baseline controllers for the NTM and the DNC are implemented as $\bm{\mathcal{H}}_{t}^{r}=\bm{\mathcal{H}}_{t}^{w}=\bm{h}_{t}$ and $\bm{\mathcal{H}}_{t}^{o}=[\bm{h}_{t}\,;\,\bm{r}_{t}]$, where $\bm{h}_{t}$ is a vector generated by a NN in the controller according to $\bm{x}_{t}$ and $\bm{r}_{t-1}$. The same design is used in the original paper of DNC (?).

We consider three types of NNs for the baseline controller: Feedforward Neural Networks (FNNs), Elman Networks (ENs) (?), and LSTMs. We call each type of the controllers a FNN controller, an EN controller, and a LSTM controller. The FNN controller generates $\bm{h}_{t}$ as follows:

[TABLE]

where $\varphi$ is an activation function. Similarly, the EN controller generates $\bm{h}_{t}$ as follows:

[TABLE]

The LSTM controller generates $\bm{h}_{t}$ as follows:

[TABLE]

where $\sigma$ is an activation function for the gating mechanism. In Equations (1–7), we set $\bm{h}_{0}=\bm{c}_{0}=\bm{0}$.

Neural Turing Machine

For the NTM, $\bm{w}_{t}^{w}$ and all of $\bm{w}_{t}^{r,1},\,...,\,\bm{w}_{t}^{r,R}$ are generated by the same mechanism. Here we denote them by $\bm{w}_{t}$.

First, according to $\bm{\mathcal{H}}_{t}^{r}=\bm{\mathcal{H}}_{t}^{w}=\bm{h}_{t}$ generated by the controller, the following operation is conducted:

[TABLE]

where $\bm{k}_{t}$ and $\beta$ are generated from $\bm{h}_{t}$ using a one-layer NN. Note that we use the expression $\bm{M}$ because the write head uses $\bm{M}_{t-1}$, while the read heads use $\bm{M}_{t}$. $\mathcal{K}(\bm{a},\bm{b})$ is a function which measures the relatedness between two vectors, $\bm{a}$ and $\bm{b}$, and usually implemented by cosine similarity:

[TABLE]

Next, the NTM generates $\bm{w}_{t}^{g}$ as follows:

[TABLE]

where $g_{t}\in[0,1]$, and is generated by a one-layer NN. After that, the following circular convolution is applied to $\bm{w}_{t}^{g}$.

[TABLE]

where $\bm{s}_{t}\in[0,1]$ represents the amount of shift, and satisfies the condition $\sum_{j}\bm{s}_{t}[j]=1$. $\bm{s}_{t}$ is generated by a one-layer NN. Finally, $\bm{w}_{t}$ is generated as follows:

[TABLE]

where $\gamma_{t}$ satisfies the condition $\gamma_{t}\geq 1$, and is generated by a one-layer NN. $\gamma_{t}$ sharpens the element of $\bm{w}_{t}$.

Differentiable Neural Computer

In the DNC, $\bm{w}_{t}^{w}$ and $\bm{w}_{t}^{r,1},\,...,\,\bm{w}_{t}^{r,R}$ are generated by different mechanisms.

First, we explain the write operation. The following operation is conducted.

[TABLE]

where $f_{t}^{i}\in[0,1]$ is a scalar generated by a one-layer NN for each read head. $\bm{\psi}_{t}\in[0,1]^{N}$ represents how much each address will not be freed by the free gates, $f_{t}^{i}$. According to $\bm{\psi}_{t}$, the usage vector is defined as follows:

[TABLE]

where each element of $\bm{u}_{t}$ indicates the degree to which the address is used, and the nearer it is to $1$, the higher the degree is. After that, $\bm{\phi}_{t}\in\mathbb{Z}^{N}$ is defined. Each element of $\bm{\phi}_{t}$ represents an index, and they are sorted by ascending order of usage. By using $\bm{\phi}_{t}$, the allocation weighting, which is used to provide new addresses for writing is generated as follows:

[TABLE]

According to $\bm{a}_{t}$, the actual address used for the write operation is defined as follows:

[TABLE]

where $g_{t}^{w}\in[0,1]$ and $g_{t}^{a}\in[0,1]$ are scalars generated by a one-layer NN. $\bm{c}_{t}^{w}$ is a vector generated as $\bm{c}_{t}$ in Equation (8).

The read operation is conducted using a temporal link matrix, $\bm{L}_{t}\in[0,1]^{N\times N}$. This matrix holds the order of written addresses. In the DNC, the following operation is conducted according to $\bm{w}_{t}^{w}$:

[TABLE]

where $\bm{p}_{0}=\bm{0}$. $\bm{p}_{t}$ basically represents the addresses where the write operation is conducted at $t$, while it holds the recently written addresses when the write operation is not conducted. $\bm{L}_{t}$ tracks the write operation by the following operation:

[TABLE]

where $\bm{L}_{0}[i,j]=0,\forall i,j$ and $\bm{L}_{t}[i,i]=0$. By using this matrix, vectors $\bm{f}^{i}_{t}$ and $\bm{b}^{i}_{t}$ are defined as follows:

[TABLE]

The two vectors represent the addresses where the write operations are conducted before and after the location $\bm{w}_{t}^{r,i}$ is written. Finally, the addresses for the read operation is defined as follows:

[TABLE]

where $\bm{\pi}_{t}^{r,i}\in[0,1]^{3}$ is generated according to $\bm{h}_{t}$ using a one-layer NN which uses a softmax function for its activation function. We do not use the sparse link matrix for the DNC in this paper.

Partially Non-Recurrent Controllers

RNN-based controllers enable MANNs to utilize contextual information for controlling the other modules. This is usually beneficial for the models, and most of the studies on MANNs adopt a RNN-based controller for their models. However, the use of the memory in the RNN-based controller potentially has a negative effect for the training of the models because the output of the controller $\bm{h}_{t}$ is used for $\bm{\mathcal{H}}_{t}^{o}$, which allows the model to directly solve the given tasks using the (small) memory in the controller.

In this paper, we propose a novel type of RNN-based controller that is partially non-recurrent and avoids the direct use of its internal memory for solving the task, while keeping the ability of using contextual information in controlling the other modules. As shown in Figure 2, the outputs of the proposed RNN-based controller are $\bm{\mathcal{H}}_{t}^{r}=\bm{\mathcal{H}}_{t}^{w}=\bm{h}_{t}$ and $\bm{\mathcal{H}}_{t}^{o}=[\bm{h}^{\prime}_{t}\,;\,\bm{r}_{t}]$, where $\bm{h}_{t}$ is the vector generated in the same way as usual RNN-based controllers, and $\bm{h}^{\prime}_{t}$ is the vector generated without using the memory in the controllers. For the EN controller, $\bm{h}^{\prime}_{t}$ is generated as follows:

[TABLE]

Then, $\bm{h}_{t}$ is generated by using $\bar{\bm{h}^{\prime}_{t}}$ as follows:

[TABLE]

Note that the number of parameters used in Equation (9) and Equation (11) is same as that used in Equation (1).

Similarly, for the LSTM controller, $\bm{h}^{\prime}_{t}$ is generated in the same manner as Equation (10) by using the following $\bar{\bm{h}^{\prime}_{t}}$:

[TABLE]

Then, $\bm{h}_{t}$ is generated according to Equations (3–7) by using the following $\bm{z}_{t}$:

[TABLE]

Again, the number of parameters used in Equation (12) and Equation (13) is the same as that used in Equation (2).

Although in this paper we apply our proposal only to the EN and the LSTM controller, it can be applied to other types of RNN-based controllers such as the RNN-based controllers based on gated recurrent units (?).

Experiments

General Settings

To evaluate the performance of our proposed RNN-based controller, we carry out experiments on two sets of tasks, the Toy and bAbI tasks. On both tasks, we compare the performance of the NTM and the DNC with the FNN controller, the EN controller, the proposed EN controller, the LSTM controller, and the proposed LSTM controller. The network settings of the NTM and the DNC are described in the following sections separately because they are different on the two tasks, except for the upper bound of the shift operation of the NTM, which is $\pm 3$. We also carry out experiments on a one-layer EN and LSTM with $128$ hidden units to evaluate how well the RNNs in RNN-based controllers can solve the tasks. For parameter optimization, we use RMSProp (?) with a learning rate of 0.0001 and a momentum of 0.9. The training is performed in an online manner, and during backpropagation we clip all gradient values by the global norm with a threshold of 5. When evaluating the models, we use the best model parameters in terms of validation loss, and we report average scores of ten individual models with different parameter initializations for each experimental setting.

Toy Tasks

Settings. Following the previous work (?; ?; ?), we use six kinds of the Toy tasks described in Table 1. On each task, the models receive a sequence of nine-dimensional binary vectors, and they are required to output an appropriate sequence of vectors. The ninth element of each vector indicates the end of the input and output sequences. The number of the input vectors is indicated by $T$, and it is chosen randomly for each input sequence. We adopt $T\in[1,20]$ for all tasks except for Repeat Copy, for which we adopt $T\in[1,10]$ and $M\in[1,10]$, where $M$ is the randomly chosen number of repetitions. We use ten different training datasets, each of which consists of $1,000,000$ sequences for each individual model. The sizes of test and validation data are $10,000$ and $1,000$, respectively, and we validate the models for every $1,000$ training iterations. We use the unit size of $128$ for all of the controllers. The memory size of the NTM and the DNC is $128\times 20$, and the number of the read heads is set to one for all of the tasks except for Priority Sort, for which we use the models with four read heads. For evaluation, we use the average bit error rates of the output of the ten models.

Discussions on the test results. Table 3 shows the experimental results on the Toy tasks. As shown in Table 3, the NTM or the DNC with one of the proposed controllers achieves the lowest average bit error rates on all of the tasks. Figure 3 illustrates why the models with the proposed controllers achieve the best results. In Figure 3(a), some of the ten models converge insufficiently, while all of the models converge successfully in Figure 3(b). Also, we show examples of the output and the memory use of the NTM with the LSTM and the proposed LSTM controller on Copy in Figure 4. As seen in Figure 4(b), the NTM with the proposed LSTM controller predicts the perfect output, making an appropriate use of the external memory, while the output of the NTM with the LSTM controller (Figure 4(a)) is far from perfect. An interesting observation is that the output of the NTM with the LSTM controller is partially correct although it does not read from the address where it wrote the information in the past. This phenomenon occurs because the model solves the task using the small memory in the controller directly as we hypothesized, and the phenomenon is seen for all of the insufficiently converged NTMs with the LSTM controller as shown in Figure 3(a).

Nonetheless, there are situations where the proposed controllers perform worse than the other controllers. Among them, we focus on the results of the NTM with the proposed EN controller on Reverse because both of the average bit error rate and the number of trained models which completely solved the task are worse than those of the NTM with the conventional controller only for this case. We show failed and successful examples of output and memory use of the NTM with the proposed EN controller on Reverse. In the experiment, we find that the NTM with the proposed EN controller tends to converge to the solution shown in Figure 5(a) or similar ones. In Figure 5(a), the model predicts partially correct outputs although it does not read the written information reversely. Because the proposed EN controller cannot use the internal memory of the controller directly to solve tasks, the phenomenon that the model even partially solves the task cannot occur without using the external memory. In Figure 5(a), we can see that the write operation is conducted on multiple addresses at each time step, while the read operation is conducted on just one address. In addition, the read operation in the input phase is conducted only on one specific address. These observations suggest that the model converges to a local optimum where it holds the partial contextual information using the internal memory of the controller, and send it to the output using multiple memory locations. This type of local optimum tends to occur with the proposed controllers but not with the FNN controller and the standard RNN-based controllers. The FNN controller does not suffer from the second phenomenon because they do not have the internal memory of the controller, and the usual RNN-based controllers do not suffer from the two phenomena because they can directly use the internal memory of the controller for the output of the model.

Discussions on the average learning curves. Figure 6 shows the average learning curves of the NTM and the DNC with different controllers. In Figure 6, we can see that the learning curves of successful case of the NTM converge so fast (e.g. the NTM with the FNN, the proposed EN, and the proposed LSTM controller on Copy or Bigram Flip). The architecture of the NTM is simple but contains enough functions to solve basic tasks such as Copy, while that of the DNC is more general but more complex. The FNN controller and the proposed RNN-based controllers utilize the external memory and functions of the model to solve the tasks as much as possible, which results in the fast convergence.

On the other hand, the models with the FNN, the proposed EN, and the proposed LSTM controllers are less stable compared to those with the EN and the LSTM controllers. For example, the learning curve for Reverse Copy of the NTM with the proposed LSTM controller is basically worse than that of the NTM with the LSTM controller, while the test result with the proposed LSTM controller is better than that with the LSTM controller as seen in Table 3. This is because the learning curves of the NTM with the proposed LSTM controller has high volatility. Therefore, using appropriate early stopping is important to achieve good performance on the models with the FNN or the proposed RNN-based controllers.

bAbI Task

Settings. To evaluate the proposed controllers on more practical situations, we carry out experiments on the bAbI task, which is a set of $20$ simple question answering tasks. In each task, the models read stories followed by a few questions. Because the experiments using the full dataset were too computationally expensive, we only used Tasks $1,\,4,\,9,\,10,\,11,\,14$ of the $20$ task, following Hsin (?). In the experiment, we train the models using a joint dataset of these six tasks, and the evaluation is conducted for each task separately. We use the dataset provided by Facebook 111http://www.thespermwhale.com/jaseweston/babi/tasks_1-20_v1-2.tar.gz with 10k training examples for each task. We use NNs with $128$ units for the controller, $128\times 32$ for the memory, and $R=4$. The epoch size is $128$, and the other detailed settings are the same as Graves et al. (?).

Discussions. Table 3 shows the average error rates of the ten models on the bAbI task. Due to the difference of the settings about the experiment, the results are different from those in Graves et al. (?).

Table 3 shows that the DNC with the proposed LSTM controller performs the best in terms of the mean error rate. The proposed LSTM controller brings out the potential ability of the DNC (e.g. the DNC can benefit from its design of tracking the order of written addresses to solve Task 14, time reasoning) because our proposed controller is designed to utilize the external memory. In addition, the proposed LSTM controller performs the best in all of the six tasks on each of the NTM and the DNC. Another observation seen in Table 3 is that the scores of the models with the EN and the proposed EN controllers are worse than those of the other cases. We speculate the reason that the internal memory of the EN does not contribute to increasing the performance of the model while preventing it from converging to an appropriate solution.

Related Work

NTM-based MANNs have been actively studied since the advent of the NTM (?; ?; ?). Rae et al. (?) proposed Sparse Access Memory (SAM), which is a scalable end-to-end differentiable memory access scheme. One of the biggest restrictions of MANNs is that the capacity of memory depends on the size of the external memory, while larger external memory requires more computational cost. SAM enables efficient training of a MANN with a very large memory. Zaremba and Sutskever (?) used a reinforcement learning algorithm on the NTM to apply it for tasks that require discrete interfaces, which are not differentiable.

Gulcehre et al. (?) proposed a novel NTM-based MANN, Dynamic Neural Turing Machine (D-NTM). While the original NTM implements location-based addressing using shift operations with a fixed size, the D-NTM performs this operation using NNs directly. They also address the same problem as ours, but they tackle the problem by using a regularization approach where the addresses pointed by the read heads and the write head are forced to be consistent. Gulcehre et al. (?) proposed a novel MANN called TARDIS based on the concept that MANNs connect “time” discontinuously. Their work also addresses the problem which we focus on, but their approach is using $\bm{\mathcal{H}}_{t}^{o}=[\bm{x}_{t}\,;\,\bm{r}_{t}]$ for the output of the model. Our proposed controller uses $\bm{h}^{\prime}_{t}$ instead of $\bm{x}_{t}$ for $\bm{\mathcal{H}}_{t}^{o}$, which enables the output of the model and written information at $t$ to be more consistent.

There also exist models called MANNs which are not based on the NTM. In particular, the models based on Memory Networks (?) are actively studied (?; ?; ?). These MANNs are different from the NTM-based models in some respects (e.g. MANNs based on Memory Networks conduct the read operation multiple times in a time step). In addition, MANNs based on Memory Networks do not have a module corresponding to the controller, which controls all the other modules.

Conclusion and Future Work

In this paper, we have proposed a novel type of RNN-based controller for MANNs. Without increasing the number of training parameters, our proposed controller avoids using the memory in the controller for the output of the model and benefits from it for controlling the other modules. In the experiments on both of the Toy and bAbI tasks, the best scores are achieved by the models with our proposed controller, which demonstrates the effectiveness of our approach.

An interesting direction of future work is exploring other architectures based on the insights obtained in this work because there are more variations than the two proposed controllers we have used.