Learning Longer-term Dependencies via Grouped Distributor Unit

TL;DR

This paper introduces a novel gated RNN called Grouped Distributor Unit (GDU) that effectively captures long-term dependencies by partitioning hidden states into groups with adaptive update rates, outperforming LSTM and GRU.

Contribution

The paper proposes a simpler gated RNN structure with grouped hidden states and adaptive memory updates, enhancing long-term dependency learning.

Findings

GDU outperforms LSTM and GRU on various tasks.

GDU has a simpler structure with only one gate.

Flexible grouping helps in capturing long-term dependencies.

Abstract

Learning long-term dependencies still remains difficult for recurrent neural networks (RNNs) despite their success in sequence modeling recently. In this paper, we propose a novel gated RNN structure, which contains only one gate. Hidden states in the proposed grouped distributor unit (GDU) are partitioned into groups. For each group, the proportion of memory to be overwritten in each state transition is limited to a constant and is adaptively distributed to each group member. In other word, every separate group has a fixed overall update rate, yet all units are allowed to have different paces. Information is therefore forced to be latched in a flexible way, which helps the model to capture long-term dependencies in data. Besides having a simpler structure, GDU is demonstrated experimentally to outperform LSTM and GRU on tasks including both pathological problems and natural data set.

Tables

Table 1. Table 1: Results for permuted pixel-by-pixel MNIST. Best result in each model set are bold.

Model	# parameters ($\approx$, $K$)	Test Accuracy
LSTM(128)	67.9	91.2
GRU(128)	51.2	90.6
GDU(4x32)	34.6	93.5
GDU(5x25)	33.0	93.0
LSTM(256)	266.8	91.8
GRU(256)	200.7	92.6
GDU(4x62)	134.7	94.7
GDU(5x51)	133.6	94.8

Equations

$${\mathbf{s}}_t=T({\mathbf{x}}_t,{\mathbf{s}}_{t-1})$$

$${\mathbf{s}}_t={\varphi }_s({\mathbf{W}}_s{\mathbf{x}}_t+{\mathbf{U}}_s{\mathbf{s}}_{t-1}+{\mathbf{b}}_s)$$

$${\mathbf{\epsilon }}_{\tau \leftarrow t}={\mathbf{\epsilon }}_{t\leftarrow t}\prod _{t\ge i>\tau }\frac{\partial {\mathbf{s}}_i}{\partial {\mathbf{s}}_{i-1}}$$

$$\Vert {\mathbf{\epsilon }}_{\tau \leftarrow t}\Vert =\Vert {\mathbf{\epsilon }}_{t\leftarrow t}\prod _{t\ge i>\tau }\frac{\partial {\mathbf{s}}_i}{\partial {\mathbf{s}}_{i-1}}\Vert \le {\xi }^{t-\tau }\Vert {\mathbf{\epsilon }}_{t\leftarrow t}\Vert$$

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

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

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

$${\bar{\mathbf{s}}}_t$$

$${\mathbf{s}}_t$$

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

$${\mathbf{r}}_t$$

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

$${\bar{\mathbf{s}}}_t$$

$${\mathbf{s}}_t$$

$${\bar{\mathbf{s}}}_t$$

$${\mathbf{s}}_t$$

$${\gamma }_t({\mathbf{s}}_{t-1})$$

$${\beta }_t({\mathbf{s}}_{t-1})$$

$${\alpha }_t({\bar{\mathbf{s}}}_t)$$

$${\gamma }_t({\mathbf{s}}_{t-1})$$

$${\beta }_t({\mathbf{s}}_{t-1})$$

$${\alpha }_t({\bar{\mathbf{s}}}_t)$$

$$T_t(\mathbf{s})={\mathcal{G}}_{T_t}\odot \mathbf{s}$$

$$\frac{\partial {\mathbf{s}}_t}{\partial {\mathbf{s}}_{t-1}}=J_{{\mathbf{s}}_{t-1}}+J_{{\bar{\mathbf{s}}}_t}+J_{{\mathcal{G}}_{{\alpha }_t}}+J_{{\mathcal{G}}_{{\beta }_t}}$$

$$J_{{\mathbf{s}}_{t-1}}$$

$$J_{{\bar{\mathbf{s}}}_t}$$

$$J_{{\mathcal{G}}_{{\beta }_t}}$$

$$J_{{\mathcal{G}}_{{\alpha }_t}}$$

$${\mathcal{P}}_{{\alpha }_t}=\frac{1}{K}\sum _{k=1}^K{\mathcal{G}}_{{\alpha }_t}^k$$

$${\mathcal{P}}_{{\beta }_t}=\frac{1}{K}\sum _{k=1}^K{\mathcal{G}}_{{\beta }_t}^k=1-{\mathcal{P}}_{{\alpha }_t}$$

$${\mathbf{s}}_t={\left\{{\left\{s_t^{i,j}\right\}}_{j=1}^{M_i}\right\}}_{i=1}^N$$

$$\sum _{j=1}^{M_i}{\mathcal{G}}_{{\alpha }_t}^{i,j}={\delta }_i,i=1,2,\cdots ,N$$

$${\mathcal{P}}_{{\alpha }_t}=\frac{{\sum }_{i=1}^N{\delta }_i}{{\sum }_{i=1}^N{M}_i}=\frac{1}{K}\sum _{i=1}^N{\delta }_i\in (0,1)$$

$${\mathbf{\vartheta }}_t$$

$$d_t^{i,j}$$

$${\mathcal{G}}_{{\alpha }_t}^{i,j}$$

$${\mathbf{a}}_t$$

$${\mathbf{s}}_t$$

$${\mathcal{P}}_{{\alpha }_t}=\frac{N}{{\sum }_{i=1}^N{M}_i}=\frac{N}{K}$$

Full text

1 Introduction

Recurrent Neural Networks (RNNs, [1, 2]) are powerful dynamic systems for tasks that involve sequential inputs, such as audio classification, machine translation and speech generation. As they process a sequence one element at a time, internal states are maintained to store information computed from the past inputs which makes RNNs capable of modeling temporal correlations between elements from any distance in theory.

In practice, however, it is difficult for RNNs to learn long-term dependencies in data by using back-propagation through time (BPTT, [1]) due to the well known vanishing and exploding gradient problem [3]. Besides, training RNNs suffers from gradient conflicts (e.g. input conflict and output conflict [4]) which make it challenging to latch long-term information while keeping mid- and short-term memory simultaneously. Various attempts have been made to increase the temporal range that credit assignment takes effect for recurrent models during training, including adopting a much more sophisticated Hessian-Free optimization method instead of stochastic gradient descent [5, 6], using orthogonal weight matrices to assist optimization [7, 8] and allowing direct connections to model inputs or states from the distant past [9, 10, 11]. Long short-term memory (LSTM, [4]) and its variant, known as gated recurrent units (GRU, [12]) mitigate gradient conflicts by using multiplicative gate units. Moreover, the vanishing gradient problem is alleviated by the additivity in their state transition operator. Simplified gated units have been proposed [13, 14] yet the ability of capturing long-term dependencies has not been improved. Recent work also supports the idea of partitioning the hidden units in an RNN into separate modules with different processing periods [15].

In this paper, we introduce Grouped Distributor Unit (GDU), a new gated recurrent architecture with additive state transition and only one gate unit. Hidden states inside a GDU are partitioned into groups, each of which keeps a constant proportion of previous memory at each time step, forcing information to be latched. The vanishing gradient problem, together with the issue of gradient conflict, which impede the extraction of long-term dependencies are thus alleviated.

We empirically evaluated the proposed model against LSTM and GRU on both synthetic problems which are designed to be pathologically difficult and natural dataset containing long-term components. Results reveal that our proposed model outperforms LSTM and GRU on these tasks with a simpler structure and less parameters.

2 Background and related work

An RNN is able to encode sequences of arbitrary length into a fixed-length representation by folding a new observation $\mathbf{x}_{t}$ into its hidden state $\mathbf{s}_{t}$ using a transition operator $T$ at each time step $t$:

[TABLE]

Simple recurrent networks (SRN, [16]), known as one of the earliest variants, make $T$ as the composition of an element-wise nonlinearity with an affine transformation of both $\mathbf{x}_{t}$ and $\mathbf{s}_{t-1}$:

[TABLE]

where $\mathbf{W}_{s}$ is the input-to-state weight matrix, $\mathbf{U}_{s}$ is the state-to-state recurrent weight matrix, $\mathbf{b_{s}}$ is the bias and $\phi_{s}$ is the nonlinear activation function. For the convenience of the following descriptions, we denote this kind of operators as $\eta(\cdot,\cdot,\phi)$, and a subscript can be added to distinguish different network components. Thus in SRN, $\mathbf{s}_{t}=\eta_{s}(\mathbf{x}_{t},\mathbf{s}_{t-1},\phi_{s})$.

During training via BPTT, the error obtained from the output of an RNN at time step t (denoted as $\mathcal{L}_{t}$) travels backward through each state unit. The corresponding error signal propagated back to time step $\tau$ (denoted as $\bm{\varepsilon}_{\tau\leftarrow t}=\frac{\partial\mathcal{L}_{t}}{\partial\mathbf{s}_{\tau}}$222 $\frac{\partial\mathcal{L}_{t}}{\partial\mathbf{s}_{\tau}}=(\frac{\partial\mathcal{L}_{t}}{\partial s_{\tau}^{1}},\frac{\partial\mathcal{L}_{t}}{\partial s_{\tau}^{1}},\cdots,\frac{\partial\mathcal{L}_{t}}{\partial s_{\tau}^{M}})^{T}$, in which $M$ is the state size and the $k$-th component $\frac{\partial\mathcal{L}_{t}}{\partial s_{\tau}^{k}}$ represents the sensitivity of $\mathcal{L}_{t}$ to small perturbations in the $k$-th state unit at time step $\tau$. , $\tau<t$) contains a product of $t-\tau$ Jacobian matrices:

[TABLE]

From Eq. (3) we can easily find a sufficient condition for the vanishing gradient problem to occur, i.e. $\forall\tau<i\leq t,\left\lVert\frac{\partial\mathbf{s}_{i}}{\partial\mathbf{s}_{i-1}}\right\lVert<1$. Under this condition, a bound $\xi\in\mathcal{R}$ can be found such that $\forall i,\left\lVert\frac{\partial\mathbf{s}_{i}}{\partial\mathbf{s}_{i-1}}\right\lVert\leq\xi<1$, and

[TABLE]

As $\xi<1$, long term contributions (for which $t-\tau$ is large) go to [math] exponentially fast with $t-\tau$.

In SRN, $\frac{\partial\mathbf{s}_{i}}{\partial\mathbf{s}_{i-1}}$ is given by $\mathbf{U}_{s}^{T}diag({\phi^{\prime}_{s}(\mathbf{W}_{s}\mathbf{x}_{t}+\mathbf{U}_{s}\mathbf{s}_{t-1}+\mathbf{b}_{s})})$. As a result, if the derivative of the nonlinear function is bounded in SRN, namely, $\exists\kappa\in\mathcal{R}$, s.t. $|\phi^{\prime}_{s}(x)|\leq\kappa$, it will be sufficient for $\lambda_{1}<\frac{1}{\kappa}$, where $\lambda_{1}$ is the largest singular value of the recurrent weight matrix $\mathbf{U}_{s}$, for $\bm{\varepsilon}_{\tau\leftarrow t}$ to vanish (as $t\to\infty$)[17].

Any RNN architecture with a long-term memory ability should at least be designed to make sure the norm of its transition Jacobian will not easily be bounded by $1$ for a long time span as it goes through a sequence.

2.1 Gated additive state transition (GAST)

Long short-term memory (LSTM, [4]) introduced a memory unit with self-connected structure which can maintain its state over time, and non-linear gating units (originally input and output gates) which control the information flow into and out of it. Since the initial proposal in 1997, many improvements have been made to the LSTM architecture [18, 19]. In this paper, we refer to the variant with forget gate and without peephole connections, which has a comparable performance with more complex variants [20]:

[TABLE]

Here $\sigma$ denotes the sigmoid activation and $\odot$ denotes element-wise multiplication. Note that $\mathbf{h}_{t}$ should also be considered as hidden state besides $\mathbf{s}_{t}$.

Cho et al. [12] proposed a similar architecture with gating units called gated recurrent unit (GRU). Different from LSTM, GRU exposes all its states to the output and use a linear interpolation between the previous state $\mathbf{s}_{t-1}$ and the candidate state $\bar{\mathbf{s}}_{t}$:

[TABLE]

Previous work has clearly indicated the advantages of the gating units over the more traditional recurrent units [21]. Both LSTM and GRU perform well in tasks that require capturing long-term dependencies. However, the choice of these two structures may depend heavily on the dataset and corresponding task.

It is easy to notice that the most prominent feature shared between these units is the additivity in their state transition operators. In another word, both LSTM and GRU keep the existing states and add the new states on top of it instead of replacing previous states directly, as it did in traditional recurrent units like SRN. Another important ingredient in their transition operator is the gating mechanism, which regulates the information flow and enables the network to form skip connections adaptively. In this paper we refer to this kind of transition operators as the Gated Additive State Transition (GAST) with a general formula:

[TABLE]

where $\alpha_{t}$, $\beta_{t}$ and $\gamma_{t}$ are called gate operators with subscript $t$ indicating that values of the corresponding gating units change over time (see Fig. 1 (left)). In LSTM:

[TABLE]

whilst in GRU:

[TABLE]

We denote the gate vector used in a gate operator $T$ at time step $t$ as $\mathcal{G}_{T_{t}}$. Note that except Eq. (8a), gate operators $T_{t}$ have a common form 333In the following part of this paper, gate operators are referred to as being in this form.:

[TABLE]

where $\mathbf{s}$ is a state vector to be gated. We use $\beta_{t}=1-\alpha_{t}$ to indicate $\mathcal{G}_{\beta_{t}}=1-\mathcal{G}_{\alpha_{t}}$ as in the case of GRU. According to Eq. (7b), the transition Jacobian of a GAST can be resolved into 4 parts:

[TABLE]

in which

[TABLE]

The gradient property of GAST is much better than that of SRN since it can easily prevent its transition Jacobian norm to be bounded within $1$ by saturating part of units in $\mathcal{G}_{\beta_{t}}$ nearly at 1. Intuitively, when this happens, the corresponding components of error signal are allowed to be back-propagated easily through the shortcut created by the additive character of GAST without vanishing too quickly.

The original LSTM [4] uses full gate recurrence [22], which means that all neurons receive recurrent inputs from all gate activations at the previous time step besides the block outputs. Nevertheless, it still follows Eqs. (7). Another difference is that the original LSTM does not use forget gate, i.e. $\beta_{t}(\mathbf{s}_{t-1})=\mathbf{s}_{t-1}$, thus in Eq. (12a), $J_{\mathbf{s}_{t-1}}$ is a unit diagonal matrix $\mathcal{I}$. In addition, gradients are truncated by replacing the other components in its transition Jacobian, i.e. Eqs. (12b), (12c) and (12d), by zero, forming a constant error carrousel (CEC) where $\frac{\partial\mathbf{s}_{t}}{\partial\mathbf{s}_{t-1}}=\mathcal{I}$. It is noticeable, however, that if the gradients are not truncated, Eq. (3) does not hold for LSTMs since the gate vector $\mathbf{o}_{t-1}$ used in $\gamma_{t}$ is calculated at the previous time step, see Eq. (8a). In this condition, a concatenation of $\mathbf{s}_{t}$ and $\mathbf{h}_{t}=\gamma_{t}(\mathbf{s}_{t})$ should be used in analysis of its transition Jacobian, as in Fig. 7.

Simplifying GAST has drawn interest of researchers recently. GRU itself reduces the gate units to $2$ compared to LSTM which has $3$ gate units by coupling forget gate and input gate into one update gate, namely making the gate operator $\beta_{t}$ equals to $1-\alpha_{t}$. In this paper we denote this kind of GAST as cGAST, with the prefix c short for coupled. Based on GRU, the Minimal Gated Unit (MGU, [14]) reduced the gate number further to only 1 by letting $\gamma_{t}=\beta_{t}=1-\alpha_{t}$ without losing GRU’s accuracy benefits. The Update Gate RNN (UGRNN, [13]) entirely removed $\gamma_{t}$ operator. However, none of these models has shown superiority over LSTM and GRU on long-term tasks with single-layer hidden states.

2.2 Units partitioning

Although the capacity of capturing long-term dependencies in sequences is of crucial importance of RNNs, it is worthwhile to notice that the flowing data is usually embedded with both slow-moving and fast-moving information, of which the former corresponds to long-term dependencies. Along with the existence of both long- and short-term information in sequences, the training process always has gradient conflict existing. Here gradient conflict mainly refers to the contradiction between error signals back-propagated to a same time step, but injected at different time steps during training via BPTT. This issue may hinder the establish of long-term memory even without the gradient vanishing problem.

Consider a task in which a GRU is given one data point at a time and assigned to predict the next, e.g. $m$ERG (see Section 4.3). If the correct prediction at time step $t_{1}$ is heavily depending on the data point appeared at time step $t_{0}$, namely $x_{t_{0}}$, where $t_{0}\ll t_{1}$, we can say a long-term dependency exists between $x_{t_{0}}$ and $x_{t_{1}+1}$. GRU can capture this kind of dependency by learning to encode $x_{t_{0}}$ into some state units and latch it until $t_{1}$. For simplicity, let us focus on a single state unit $s^{k}$ and assume that the information of $x_{t_{0}}$ has been stored in $s_{t_{0}}^{k}$. At time step $t$ ($t_{0}<t<t_{1}$), state unit $s_{t}^{k}$ will often receive conflicting error signals. The error signal $\varepsilon^{k}_{t\leftarrow t_{1}}$ injected at time step $t_{1}$ may attempt to make $s_{t}^{k}$ keep its value until $t_{1}$. While other error signals injected before $t_{1}$, say, $t_{2}$, may hope that $s_{t_{2}}^{k}$ helps to do the prediction at time step $t_{2}$, thus it may attempt to make $s_{t}^{k}$ to be overwritten by a new value. This conflict makes the GRU model hesitate to shut the update gate for $s^{k}$ by setting $\mathcal{G}_{\alpha_{t}}^{k}$ to [math]. In GRU, we also observed that state units latching long-term memories (with corresponding neurons in $\mathcal{G}_{\beta_{t}}$ staying active for a long time) are usually sparse (see Fig. 6 (left)), which impedes the back-propagation of effective long-term error signals, since short-term error signals dominate. As a result, learning can be slow.

El Hihi and Bengio first showed that RNNs can learn both long- and short-term dependencies more easily and efficiently if state units are partitioned into groups with different timescales [23]. The clockwork RNN (CW-RNN) [15] implemented this by assigning each state unit a fixed temporal granularity, making state transition happens only at its prescribed clock rate. It can also be seen as a member of cGAST family. More specifically, a UGRNN with a special gate operator $\beta_{t}$ in which each gate vector value $\mathcal{G}_{\beta_{t}}^{k}$ is explicitly scheduled to saturate at either [math] or $1$. CW-RNN does not suffer from gradient conflict for it inherently has the ability to latch information. However, the clock rate schedule should be tuned for each task.

3 Grouped Distributor Unit

As introduced in Section 2, a network combining the advantages of GAST and the idea to partition state units into groups seems promising. Further, we argue that a dynamic system with memory does not need to overwrite the vast majority of its memory based on relatively little input data. For cGAST models whose $\beta_{t}=1-\alpha_{t}$, we define the proportion of states to be overwritten at time step $t$ as:

[TABLE]

where $K$ is the state size. On the other hand, the proportion of previous states to be kept is:

[TABLE]

Hence in our view, if a model input $\mathbf{x}_{t}$ contains small amount of information compared to system memory $\mathbf{s}_{t-1}$, $\mathcal{P}_{\alpha_{t}}$ should be kept low to protect the previous states. For cGAST family members, a lower $\mathcal{P}_{\alpha_{t}}$ leads to more active units in $\mathcal{G}_{\beta_{t}}$ (see Fig.6 (right)) and thus less prone to be affected by gradient conflict.

To put a limit on $\mathcal{P}_{\alpha_{t}}$, we start by a plain UGRNN and partition its state units into $N$ groups:

[TABLE]

where the $i$-th group contains $M_{i}$ units. At each time step, for each $i$, we let a positive constant $\delta_{i}<M_{i}$ to be distributed to the corresponding components in $\mathcal{G}_{\alpha_{t}}$, namely

[TABLE]

Thus $\mathcal{P}_{\alpha_{t}}$ becomes a constant given by

[TABLE]

See Fig.1 (right), the distribution work in each group is done by a distributor, hence the proposed structure is called Grouped Distributor Unit (GDU). The distributor is implemented by utilizing the softmax activation over each group individually in calculating $\mathcal{G}_{\alpha_{t}}$:

[TABLE]

here $1\leq i\leq N,~{}1\leq j\leq M_{i}$ and $\bm{\vartheta}_{t}=(\vartheta_{t}^{1,1},\cdots,\vartheta_{t}^{1,M_{1}},\cdots,\vartheta_{t}^{N,1},\cdots,\vartheta_{t}^{N,M_{N}})^{T}$. 444The permutation of $\left\{\left\{\vartheta_{t}^{i,j}\right\}_{j=1}^{M_{i}}\right\}_{i=1}^{N}$ can be arbitrary. Note that $\mathcal{G}_{\alpha_{t}}^{i,j}\in[0,\delta_{i})$ when $\delta_{i}\in(0,1]$ and $\mathcal{G}_{\alpha_{t}}^{i,j}\in(\frac{\delta_{i}-1}{M_{i}-1},1]$ when $\delta_{i}\in(1,M_{i})$. The resulting GDU is given by

[TABLE]

where $\zeta(\cdot,\{\delta_{i},M_{i}\}_{i=1}^{N})$ denotes distributor operator with group configuration $\{\delta_{i},M_{i}\}_{i=1}^{N}$ as is detailed in Eqs. (18).

In this paper, we let $\delta_{i}=1,i=1,2,\cdots,N$. As a consequence,

[TABLE]

If the size of each state group is set to a constant $M$, $\mathcal{P}_{\alpha_{t}}$ will be further reduced to $\frac{1}{M}$.

GDU has an inherent strength to keep a long-term memory since any saturated state unit $s^{i,j}$ will force all other group members to latch information. As a result, “bandwidth” is wider for long-term information to travel forward and error signals to back-propagate (see Fig.6 (right)).

Like CW-RNN, we set an explicit rate $\delta_{i}$ for each group. However, instead of making all group members act in the same way, we allow each unit to find its own rate by learning.

4 Experiments

We evaluated the proposed GDU on both pathological synthetic tasks and natural data set in comparison with LSTM and GRU. It is important to point out that although LSTM and GRU have similar performance in nature data set [21], one model may outperform another by a huge gap in different pathological tasks like the adding problem (see 4.1) at which GRU is good and the temporal order problem (see 4.2) in which LSTM performs better.

If not otherwise specified, all networks have one hidden layer with a same state size. Weight variables were initialized via Xavier uniform initializer [24], and the initial values of all internal state variable were set to [math]. All networks were trained using Adam optimization method [25] via BPTT, and the models were implemented using Tensorflow [26]. In GDU models, $\delta_{i}=1$ apply to all groups.

4.1 The adding problem

The adding problem is a sequence regression problem which was originally proposed in [4] to examine the ability of recurrent models to capture long-term dependencies. Two sequences of length $L$ are taken as input. The first one consists of real numbers sampled from a uniform distribution in $[0,1]$. While the second sequence serves as indicators with exactly two entries being 1 and the remaining being 0. We followed the settings in [27] where $L$ is a constant and the first 1 entry is located uniformly at random in the first half of the indicator sequence, whilst the second 1 entry is located uniformly at random in another half. The target of this problem is to add up the two entries in the first sequence whose corresponding indicator in the second sequence is 1. A naive strategy of outputting $1$ regardless of the inputs yields a mean squared error of $0.167$, which is the variance of the sum of two independent uniform distributions over $[0,1]$. We took it as the baseline.

Four different lengths of sequences, $L\in\{200,1000,5000,10000\}$ were used in this experiment. For each length, $500$ sequences were generated for testing, while a batch of $20$ sequences were randomly generated at each training step. Four models, an LSTM with $100$ hidden states, a GRU with $100$ hidden states, a GDU with $10$ groups of size $10$ and a GDU with only $1$ group of size $10$ were compared, with the corresponding parameter number $41.3K$, $31.0K$, $20.7K$ and $271$. A simple linear layer without activation is stacked on top of the recurrent layer in each model.

The results are shown in Fig. 2. Obviously GRU outperforms LSTM in these trials. LSTM fails to converge within $10000$ training steps when $L$ is $1000$ while GRU can learn this task within $1300$ steps even trained with sequences of length $10000$. Our GDU models perform slightly better than GRU with less parameters. As $L$ increases, this advantage becomes more obvious. Note that a GDU with only one group of size $10$ has comparable performance with a much bigger one, which indicates that GDU can efficiently capture simple long-term dependencies even with a tiny model.

4.2 The 3-bit temporal order problem

The 3-bit temporal order problem is a sequence classification problem to examine the ability of recurrent models to extract information conveyed by the temporal order of widely separated inputs of recurrent models [4]. The input sequence consists of randomly chosen symbols from the set $\{a,b,c,d\}$ except for three elements at position $t_{1}$, $t_{2}$ and $t_{3}$ that are either $X$ or $Y$. Position $t_{k}$ is randomly chosen between $\lfloor\frac{(k-1)\cdot L}{3}\rfloor$ and $\lfloor\frac{(k-1)\cdot L}{3}\rfloor+10$, where $k=1,2,3$ and $L$ is the sequence length. The target is to classify the order (either XXX, XXY, XYX, XYY, YXX, YXY, YYX, YYY) which is represented locally using $8$ units, as well as the input symbol (represented using $6$ units).

Four different lengths of sequences, $L\in\{100,200,500,1000\}$ were used in this experiment. Same with the settings in 4.1, we generated $500$ testing sequences for each length, and randomly generated a batch of $20$ sequences for each training step. Accuracy is used as the metric on testing set, and the baseline is $0.125$. We compared an LSTM model with $100$ hidden states, a GRU model with $100$ hidden states and a GDU with $10$ groups of size $10$ on these data sets. The parameter numbers are $43.6K$, $32.9K$ and $22.2K$ respectively.

The results are shown in Fig.3. In contrast to the results of the adding problem, LSTM outperforms GRU on this task. However, both LSTM and GRU fail in learning to distinguish the temporal order when the sequence length increases to $500$. The GDU model with $\mathcal{P}_{\alpha_{t}}=0.1$ always starts learning earlier. When trained with relatively longer sequences, GDU outperforms these $2$ models by a large margin with much less parameters.

4.3 Multi-embedded Reber grammar

Embeded Reber grammar (ERG) [28, 4] is a good example containing dependencies with different time scales. This task needs RNNs to read strings, one symbol at a time, and to predict the next symbol (error signals occur at every time step). To correctly predict the symbol before last, a model has to remember the second symbol. However, since it allows for training sequences with short time lags (of as few as $9$ steps), using it to evaluate a model’s ability to learn long-term dependency is not appropriate. In order to make the training sequences longer, we modified the ERG by having multiple Reber strings embedded between the second and the last but one symbols (See Fig.4).

We refer to this variant as the multi-embedded Reber grammar (mERG) and simply use the prefix $m$ to indicate the number of embedded Reber strings. For example, “BT(BPVVE)(BTSXSE)(BTXXVVE)TE” is a 3ERG sequence. Since each Reber string has a minimal length $5$, the shortest $m$ERG sequence has a length of $5m+4$.

Learning $m$ERG requires a recurrent model to have the ability to latch long-term memory while keeping mid- and short-term memory (provided $m$ is big) in the meantime. Further, there may be two legal successors from a given symbol and the model will never be able to do a perfect job of prediction. During training, the rules defining the grammar are never presented. Thus the model will see contradictory examples, sometimes with one successor and sometimes the other, which requires it to learn to activate both legal outputs. What’s more, a model must remember how many Reber strings it has read to make a correct prediction of the next symbol if the current symbol is an E. In other words, models must learn to count.

We set $m$ to be $10$, $20$ and $40$ for this task, with the minimal sequence length $54$, $104$ and $204$ respectively. One sequence is given at a time. As for the symbols with $2$ legal successors, a prediction is considered correct if the two desired outputs are the two with the largest values. For each $m$ we generated $1000$ sequences for training and $256$ sequences for testing. The sequences in testing set are unique and have never appeared in training set. The same training and testing sets are used for comparing all models.

We also defined two criteria to test the model’s ability to capture long- and short-term dependencies separately. The one for short-term dependency is $SC$ (short for short-term criterion) defined as the percentages of testing sequences each symbol of which is predicted correctly by the model except for the one before last. The other is $LC$ (short for long-term criterion) defined as the percentages of testing sequences whose last but one symbol is predicted correctly. We stopped the training when both $SC$ and $LC$ are satisfied (reach to $1$), namely all symbols in all testing sequences are predicted correctly. A naive strategy of predicting the symbol before last as T or P gives an expected $LC$ of $0.5$, which serves as the baseline.

An LSTM model and a GRU model both with 100 hidden states were chosen to be compared as previous, with corresponding parameter numbers $43.9K$ and $33.1K$. As for GDU, we chose a model with $35$ groups of size $2$ and $3$ groups of size $10$ (denoted as GDU(2x35+10x3)), totally $100$ hidden units and $22.3K$ parameters.

From the results presented in Fig. 5, we can see for $m$ERG, models always learn to capture the short-term dependencies first. While the long-term dependency is much more difficult to learn. GRU outperforms LSTM this time, no matter from the aspect of which criterion. GDU is slightly inferior to LSTM and GRU in terms of $SC$. However, on aspect of $LC$, it has an obvious advantage.

As discussed in Section 2, learning to latch long-term information in the presence of short-term dependencies is difficult for a traditional GAST model due to the gradient conflict. GDU greatly alleviate this problem by limiting $\mathcal{P}_{\alpha_{t}}$ in cGAST, namely the proportion of states to be overwritten, which results in a broader “bandwidth” for long-term information flow. Fig. 6 illustrates this by visualizing the $\mathcal{G}_{\beta_{t}}$ activation of GAST models on a same $10$ERG sequence after the $LC$ has been satisfied.

4.4 Sequential pMNIST classification

The sequential MNIST task [8] can be seen as a sequence classification task in which $28\times 28$ MNIST images [29] of $10$ digits are read pixel by pixel from left to right, top to bottom. While the sequential $p$MNIST [8] is a challenging variant where the pixels are permuted by a same randomly generated permutation matrix. This creates many longer term dependencies across pixels than in the original pixel ordering, which makes it necessary for a model to learn and remember more complicated dependencies embedded in varying time scales.

All models are trained with batch size of $100$ and the learning rate is set to $0.001$. No tricks, such as dropout [30], gradient clipping [17], recurrent batch normalization [31], etc., are used since we are not focusing on achieving absolute high accuracy. We trained two sets of models with $128$ and $256$ hidden states respectively. Again, GDU outperforms LSTM and GRU with less parameters in this task as shown in Table 1.

As discussed in Section 2, controlling $\left\lVert\frac{\mathcal{L}}{\mathbf{s}_{t}}\right\lVert$ is the key to avoid the vanishing gradient issue, so that long-term dependencies can be learned. We explored how each model propagated gradients by examining $\left\lVert\frac{\mathcal{L}}{\mathbf{s}_{t}}\right\lVert$ as a function of $t$, where $\mathcal{L}$ is the prediction loss. Gradient norms were computed after $5$ and $50$ epochs and the normalized curves are plotted in Fig. 7. For LSTM and GRU, we can see that error signals have trouble in reaching far from where they are injected at the early stage. This problem is reduced after training for dozens of epochs. GDU models have better gradient properties than LSTM and GRU because of the distributor mechanism in Eqs. (18).

5 Conclusions and future work

We proposed a novel RNN architecture with gated additive state transition which contains only one gate unit. The issues of gradient vanishing and conflict are mitigated by explicitly limiting the proportion of states to be overwritten at each time step. Our experiments mainly focused on challenging pathological problems. The results were consistent over different tasks and clearly demonstrated that the proposed grouped distributor architecture is helpful to extract long-term dependencies embedded in data.

A plethora of further ideas can be explored based on our findings. For example, various combinations of groups with different sizes and overwrite proportions can be explored. Further, the overwrite proportion $\delta$ can be trained. What’s more interesting is that the grouped distributor structure can be used spatially to ease gradient-based training of very deep networks. To be more specific, this work can base on the highway network [32] in which the distributor operator can be used to calculate the transform gate. Testings of the stacked GDU on other data sets are also planned.