Understanding Feature Selection and Feature Memorization in Recurrent Neural Networks

TL;DR

This paper introduces the F1B test to analyze how recurrent neural networks handle feature selection and memorization, revealing a conflict that can be mitigated by gating mechanisms or increasing state dimensions.

Contribution

The paper proposes the F1B test and provides a comparative analysis of different RNN models' capabilities in feature selection and memorization.

Findings

Gated RNNs resolve the conflict via adaptive gating.

Vanilla RNNs assign different tasks to different state dimensions.

A fundamental conflict exists between feature selection and memorization.

Abstract

In this paper, we propose a test, called Flagged-1-Bit (F1B) test, to study the intrinsic capability of recurrent neural networks in sequence learning. Four different recurrent network models are studied both analytically and experimentally using this test. Our results suggest that in general there exists a conflict between feature selection and feature memorization in sequence learning. Such a conflict can be resolved either using a gating mechanism as in LSTM, or by increasing the state dimension as in Vanilla RNN. Gated models resolve this conflict by adaptively adjusting their state-update equations, whereas Vanilla RNN resolves this conflict by assigning different dimensions different tasks. Insights into feature selection and memorization in recurrent networks are given.

Tables

Table 1. Table 2 : Working mechanisms of Vanilla RNN ( K = 2 𝐾 2 K=2 ) with constructed parameters

Mechanism	Condition	Effect	Comments
Load Emptying	$X_t^F=0$	$S_t^2=-1$	Loading state is set to clean background (-1)
Feature Loading	$X_t^F=1$	$S_t^2=W_{21}{X}_t^I$	Feature $X_t^I$ is loaded into loading state
Memorization	$S_{t-1}^1\in (-1,1)$, $S_{t-1}^2=-1$	$S_t^1=S_{t-1}^1$	Memorization state keeps its previous value
State Mixing	$h(S_{t-1}^1,S_{t-1}^2)\in (-1,1)$, $S_{t-1}^2>-1$	$S_t^1=h(S_{t-1}^1,S_{t-1}^2)$	Linear mixing of loading and memorization states and storing it in memorization state

Equations

$$s_t$$

$$y_t$$

$$s_t$$

$$i_t$$

$$f_t$$

$$o_t$$

$${\tilde{c}}_t$$

$$c_t$$

$$d_t$$

$$r_t$$

$$z_t$$

$${\tilde{s}}_t$$

$$s_t$$

$$z_t$$

$${\tilde{s}}_t$$

$$s_t$$

$$C(s)=\left\{\begin{array}[]{ll}+1,&{\rm if}~{}\beta^{T}s+\gamma\geq 0.\\ -1,&{\rm otherwise}\end{array}\right.$$

$$g(x):=\left\{\begin{array}[]{ll}-1,&{\rm if}~{}x<-1\\ x,&{\rm if}~{}-1\leq x\leq 1\\ 1,&{\rm if}~{}x>1\end{array}\right.$$

$$S_t=\tanh \left(U{S}_{t-1}+W_1{X}_t^{\mathrm{I}}+W_2{X}_t^{\mathrm{F}}\right)$$

$$U:=\left[\begin{array}[]{cc}1&b_{1}\\ 0&0\end{array}\right],W:=\left[\begin{array}[]{cc}0&0\\ W_{21}&-b_{2}\end{array}\right]$$

$$S_t^1$$

$$S_t^2$$

$$h(S_{t-1}^1,S_{t-1}^2):=S_{t-1}^1+b_1{S}_{t-1}^2+b_1.$$

$$W^{\mathrm{r}}:=[0,0];W^{\mathrm{z}}:=[0,a];W^{\tilde{\mathrm{s}}}:=[b,0]$$

$$U^{\mathrm{r}},U^{\mathrm{z}},U^{\tilde{\mathrm{s}}}:=0;b^{\mathrm{r}},b^{\mathrm{z}},b^{\tilde{\mathrm{s}}}:=0$$

$$S_t$$

Full text

Machine Learning, ICML

1 Introduction

Over the past decade, the revival of neural networks has revolutionized the field of machine learning, in which deep learning(LeCun et al., 2015) now prevails. Despite the stunning power demonstrated by the deep neural networks, fundamental understanding concerning how these networks work remains nearly vacuous. As a consequence, designing deep network models in practice primarily relies on experience, heuristics and intuition. At present, deep neural networks are still regarded as “black boxes”. Understanding and theorizing the working of these networks are seen, by many, as the utmost important topic in the research of deep learning(Shwartz-Ziv & Tishby, 2017).

Among various frameworks in deep learning, recurrent neural networks (RNNs) (Elman, 1990; Hochreiter & Schmidhuber, 1997; Cho et al., 2014a) have been shown particularly suited for modelling sequences, natural languages, and time-series data(Sundermeyer et al., 2012; Mikolov et al., 2010; Wu & King, 2016). Their success in sequence learning has been demonstrated in a large variety of practical applications (Cho et al., 2014b; Kalchbrenner et al., 2016; Cho et al., 2014b; Cheng & Lapata, 2016; Cao et al., 2015; Nallapati et al., 2016; Wen et al., 2015; Lewis et al., 2017; Geiger et al., 2014; Zeyer et al., 2017). But, in line with the overall development of deep learning, very limited understanding is available to date regarding how RNNs really work. For example, the following questions yet await for answers: How does an RNN effectively detect and continuously extract the relevant temporal structure as the input sequence is feeding through the network? How does the network maintain the extracted feature in its memory so that it survives in the incoming stream of noise or disturbances? Investigating these questions is the primary interest of this paper.

In this work, we construct a particular test, referred to the “Flagged-1-Bit” (F1B) test to answer these questions. In this test, we feed a random sequence of “bit pairs”, $(X_{t}^{\rm I},X_{t}^{\rm F})$ to a recurrent network. The $X^{\rm F}$-components of the sequence contain a single flag ($+1$) at a random time $L$; the $X^{\rm I}$-components of the sequence are independent bits ($\pm 1$’s), among which only the value at time $L$ carries the desired feature. The objective of the test is to check if an RNN, irrespective of the training algorithm, is able to select the feature and memorize it until the entire bit-pair sequence is fed to the network.

The F1B test has obviously a simplified setting. However, the feature selection and memorization challenges designed in this test are important aspects of learning with RNN. Specifically, detecting the desired temporal structure and maintaining it throughout the sequence duration must both be carried out through effectively using the network’s size-limited memory, or dimension-limited state. Such challenges arguably exist nearly universally.

We study the behaviour of several RNNs in this test. The studied models include Vanilla RNN(Elman, 1990), LSTM(Hochreiter & Schmidhuber, 1997), GRU(Cho et al., 2014a) and PRU(Long et al., 2018). We note that among these models, except for Vanilla RNN, all other models exploit some “gating mechanism”.

In this paper, we prove that all studied gated RNNs are capable of passing the test at state dimension $1$, whereas Vanilla RNN fails the test at state dimension $1$ but passes it at state dimension $2$. Our theoretical analysis and experimental study reveal that there is in general a conflict between selecting and memorizing features in sequence learning. We show that such a conflict can be resolved by introducing gates in RNNs, which allows the RNN to dynamically switch between selection and memorization. Without using gates, e.g., in Vanilla RNN, such a conflict can only be resolved by increasing the state dimension. Specifically, we show that with adequate state space, Vanilla RNN is capable of splitting feature selection and feature memorization, and assigning the two tasks each to a different state dimension.

To the best of our knowledge, this work is the first to formulate the conflict between feature selection and feature memorization in sequence modelling. It is also the first rigorous analysis of RNN’s capability in resolving this conflict. Although the F1B test has a rather simple structure, the microscopic insights we obtain concerning the behaviour of gated and non-gated RNNs can arguably be extrapolated to more complex settings of sequence learning.

In this paper, in addition to presenting the key results, we also make an effort to give some insights in the problem scope. Due to space limitation, detailed proofs, some further discussions and additional results are presented in Supplementary Material, to which we sincerely invite the reader.

2 Recurrent Neural Networks

A generic recurrent neural network (RNN) is essentially a dynamic system specified via the following two equations.

[TABLE]

where $t$ denotes discrete time, $x_{t}$, $y_{t}$ and $s_{t}$ are respectively the input, output and state variables. Note that here all these variables can be in general vectors.

In machine learning, the use of RNN is primarily for learning temporal features in the input sequence $x_{1},x_{2},\ldots,x_{n}$. The extraction of temporal information is expected to be carried out by the state-update equation, or, (1), where the state $s_{t}$ at time $t$ serves as a complete summary of the “useful” information contained in the past inputs up to time $t$. The network uses (2), or the output equation, to generate output if needed.

In this paper, since we are only concerned with how temporal features are extracted and maintained in the state variable, we largely ignore the exact form of the output equation. That is, we regard each recurrent network as being completely defined by its state-update function $F$ in (1). We use $\Theta$ to denote the parameter of function $F$.

In this setting an RNN model ${\cal F}$ is a family of state-update functions having the same parameterization. We now give a concise description of several RNN models, all of which are studied in this work.

Vanilla RNN, denoted by ${\cal F}_{\rm RNN}$, is among the earliest neural network models. It is conventionally known as “recurrent neural network” or simply “RNN”(Elman, 1990). In the modern literature, it is referred to as Vanilla RNN. Its state-update equation is given by (3).

[TABLE]

LSTM, denoted by ${\cal F}_{\rm LSTM}$, was first presented in (Hochreiter & Schmidhuber, 1997) and (Gers & Schmidhuber, 2000). In this paper, we adopt the formalism of LSTM in (Gers & Schmidhuber, 2000). Specifically, to better control the gradient signal in back propagation, LSTM introduces several “gating” mechanisms to control its state-update equation, via (4) to (9).

[TABLE]

Note that we use $\sigma(\cdot)$ to denote the sigmoid (i.e. logistic) function and $\odot$ to denote element-wise vector product. In the context of neural networks, gating usually refers to using a dynamically computed variable in $(0,1)$ to scale a signal, as in (8) and (9).

In LSTM, the pair $(c_{t},d_{t})$ of variables together serve as the state variable $s_{t}$, if one is to respect the definition of state variable in system theory111In system theory, a state variable $s_{t}$ is a variable (or a set of variable), given which the future behaviour of the system is independent of its past behaviour. . However, in the literature of LSTM, it is customary to consider $c_{t}$ as the state variable, since in the design of LSTM (Hochreiter & Schmidhuber, 1997), $c_{t}$ is meant to serve as a memory, maintaining the extracted feature and carrying it over to the next time instant. We will also take this latter convention in this paper.

GRU, denoted by ${\cal F}_{\rm GRU}$, was presented in (Cho et al., 2014a). It uses a simpler gating structure compared to LSTM. Its state-update equation is given by (10) to (13).

[TABLE]

Empirical results have shown that with this simplified gating structure, GRU can still perform comparatively or even better than LSTM (Chung et al., 2014).

PRU, or Prototypical Recurrent Unit, which we denote by ${\cal F}_{\rm PRU}$, is a recently presented model(Long et al., 2018). The state-update equation of PRU contains only a single gate as is given by (14) to (16).

[TABLE]

It was shown in (Long et al., 2018) that even with this minimum gate structure, PRU still performs very well. With the same total number of parameters, PRU was shown to outperform GRU and LSTM.

In summary, LSTM, GRU, and PRU are all “gated models”. In particular, their state-update equations are all in a “gated combination” form, as in (8), (13), and (16). Vanilla RNN is not gated.

2.1 Related Works

Despite their numerous applications, fundamental understanding of the working of RNN remains fairly limited.

In (Siegelmann & Sontag, 1992), Vanilla RNN is shown to be Turing-complete. In (Bengio et al., 1994; Pascanu et al., 2013), the difficulty of gradient-based training of Vanilla RNN is demonstrated and the gradient vanishing/exploding problem is explained. Significant research effort has been spent on curing this gradient problem, including, e.g., (Arjovsky et al., 2016; Dorobantu et al., 2016; Wisdom et al., 2016). In (Collins et al., 2016), trainablity and information-theoretic capacities of RNNs are evaluated empirically. Recently (Chen et al., 2018) proposes a theory, based on the notion of dynamical isometry and statistical mechanics, to model signal propagation in RNN and to explain the effectiveness of gating.

3 Flagged-1-Bit Test

Definition 1** (Flagged-1-Bit (F1B) Process)**

A Flagged-1-Bit Process $F1B(n)$ of length $n$ is a random sequence $X_{1},X_{2},\ldots,X_{n}$, defined as follows. Each X_{t}:=\left[\begin{array}[]{c}X^{\rm I}_{t}\\ X^{\rm F}_{t}\end{array}\right] is a length-2 vector, where both $X^{\rm I}_{t}$ and $X^{\rm F}_{t}$ take values in $\{\pm 1\}$. The two values $X^{\rm I}_{t}$ and $X^{\rm F}_{t}$ are respectively referred to as an “information bit” and a “flag bit”. To generate the information bits, for each $t=1,2,\ldots,n$, $X_{t}^{\rm I}$ is drawn independently from $\{\pm 1\}$ with equal probabilities. To generate the flag bits, first a random variable $L$ is drawn uniformly at random from the set of integers $\{1,2,\ldots,n\}$, then $X_{L}^{\rm F}$ is set to $1$, and $X_{t}^{F}$ is set to $-1$ for every $t\neq L$.

In this process, we call $X^{\rm I}_{L}$ as the flagged information bit. A sample path of $F1B(n)$ is called a positive sample path if $X^{\rm I}_{L}=+1$, and a negative sample path if $X^{\rm I}_{L}=-1$. Table 1 shows two example sample paths of an $F1B(n)$ process.

Now consider the learning problem with the objective of classifying the sample paths of $F1B(n)$ into the positive and negative classes. We wish to decide whether it is possible for an RNN model, at a given state dimension $K$, to learn a perfect classifier. We hope this exercise gives some insights as to how RNN detects and remembers the desired features.

To formally introduce the problem, first recall the definition of a binary linear classifier, where we will use ${\mathbb{R}}^{K}$ to denote the Euclidean space of dimension $K$ over the field ${\mathbb{R}}$ of real numbers: A binary linear classifier $C$ on ${\mathbb{R}}^{K}$ is a function mapping ${\mathbb{R}}^{K}$ to $\{\pm 1\}$ defined by

[TABLE]

where $\beta\in{\mathbb{R}}^{K}$ and $\gamma\in{\mathbb{R}}$ are parameters. We denote $(\beta,\gamma)$ collectively by $\Phi$.

For an arbitrary RNN with state-update function $F$ (and a fixed parameter setting), suppose that we draw a sample path $X=(X_{1},X_{2},\ldots,X_{n})$ from $F1B(n)$ and feed it to the network $F$. Suppose that $C_{\Phi}$ is a binary linear classifier, parameterized by $\Phi$, on the state space of the network. When $C_{\Phi}$ is applied to the state variable $S_{n}$, its error probability $P_{e}(F,\Phi)$ is $P_{e}(F,\Phi):={\rm Pr}[C_{\Phi}(S_{n})\neq X^{\rm I}_{L}]$, where the probability measure ${\rm Pr}[\cdot]$ is induced by the $F1B(n)$ process through the functions $F$ and $C_{\Phi}$.

Definition 2** (F1B Test)**

Suppose that ${\cal F}$ is an RNN model with state dimension $K$ and parameterized by $\Theta$. The model ${\cal F}$ is said to pass the F1B test if for any integer $n>0$, there exist an initial configuration $s_{0}$ of $S_{0}$, a parameter setting $\Theta^{*}$ of $\Theta$, which defines $F_{\Theta^{*}}\in{\cal F}$, and a setting $\Phi^{*}$ of $\Phi$ such that $P_{e}(F_{\Theta^{*}},\Phi^{*})=0$.

In essence, passing the F1B test means that for any given $n$, it is possible to find a parameter setting (depending on $n$) for the RNN model such that the positive and negative sample paths of the $F1B(n)$ process are perfectly and linearly separable at the final state of the RNN. This paper studies whether each afore-mentioned RNN model is capable of passing the test and at which state dimension.

Although the proposed F1B test may seem a toy problem, it in fact captures fundamental challenges in sequence learning. Specifically, for a model to pass this test, it needs to detect and select the flagged information bit when it enters the system, and load it (in some representation) in its state variable. Additionally, it must maintain this information, or “memorize” it, by preventing it from being over-written or suppressed by the subsequent noise sequence. The test thus challenges the model in both its ability to select features and its ability to memorizing them.

For more discussion on the rationale of the F1B test, the reader is referred to Supplementary Material (Section 1).

4 Theoretical Analysis

Theorem 1

For any of the four models ${\cal F}_{\rm LSTM}$, ${\cal F}_{\rm GRU}$, ${\cal F}_{\rm PRU}$, ${\cal F}_{\rm RNN}$, if it passes the F1B test at state dimension $K$, it also passes the test at state dimension $K+1$.

This result is intuitive, since increasing the state dimension should only increase the modelling power. For each of the four models, the proof of this result relies on constructing a parameter $\Theta^{(K+1)}$ for the model with state dimension $K+1$ from a parameter $\Theta^{(K)}$, where $\Theta^{(K)}$ is a parameter that allows the model to pass the test at dimension $K$. The construction of $\Theta^{(K+1)}$ essentially makes the extra dimension in the model useless (i.e., equal to 0), thereby reducing the model to one with state dimension $K$ and parameter $\Theta^{(K)}$.

Due to this theorem, we only need to determine the smallest state dimension $K$ at which a model passes the test.

4.1 Vanilla RNN

Theorem 2

At state dimension $K=1$, ${\cal F}_{\rm RNN}$ fails the F1B test.

Theorem 3

At state dimension $K=2$, ${\cal F}_{\rm RNN}$ passes the F1B test.

We note that in the proofs of these two theorems, we replace the $\tanh(\cdot)$ activation function in (3) with a piece-wise linear function $g(\cdot)$, defined by

[TABLE]

It is well-known that replacing $\tanh$ with function $g$ only changes the smoothness of the model, without altering its expressivity(Siegelmann & Sontag, 1992). We now give some intuitive explanation as to why these theorems hold.

Intuition of Theorem 2 Consider the following parameter setting of ${\cal F}_{\rm RNN}$ for example: W=\left[\begin{array}[]{cc}W_{1},&W_{2}\end{array}\right],~{}b=0. In this setting, when feeding the $F1B(n)$ process to Vanilla RNN, the state $S_{t}$ evolves according to

[TABLE]

To intuitively analyze what is required for the model to pass the test, we divide our discussion into the following phases.

Noise Suppression ($t<L$):* In this phase, the desired flagged information bit has not arrived and all incoming information is noise. Then the network should suppress its previous state value. This would require a small value of $U$.*

Feature Loading ($t=L$): This is the time when the flagged information bit arrives. The network then needs to pick up the information and load it into its state. At this point, the network demands $W_{1}$ to be reasonably large so that the flagged bit gets amplified sufficiently when it is blended in state $S_{t}$. Only so can the selected feature have sufficient contrast against the background noise in the state.

Feature Memorization ($t>L$):* In this phase, the selected feature already resides in the state. The network must then protect the selected feature against the incoming noise. To achieve this, it desires $W_{1}$ to be small, so that the incoming noise is sufficiently attenuated. At the same time, it desires $U$ to be large, so as to maintain a strong amplitude of the selected feature.*

At this end, we see a conflict in the requirements of $U$ and $W_{1}$. Such a conflict is arguably fundamental since it reflects the incompatibility between feature selection and memorization. Not only arising in the F1B test, such a conflict is expected to exist in much broader context of sequence learning using RNNs.

Intuition of Theorem 3* At state dimension $K=2$, we express $S_{t}$ as $[S_{t}^{1},S_{t}^{2}]^{\rm T}$. To make Vanilla RNN pass the test, the key insight is that the two states $S_{t}^{1}$ and $S_{t}^{2}$ need to assume separate functions, specifically, one responsible for memorizing the feature (“memorization state”) and the other responsible for selecting the feature (“loading state”). We now illustrate a construction of the Vanilla RNN parameters in which $S_{1}^{t}$ is chosen as the memorization state and $S_{2}^{t}$ as the loading state.*

For simplicity, we consider the cases where the flag variable $X_{t}^{\rm F}$ takes values in $\{0,1\}$, instead of in $\{\pm 1\}$. We note that this modification does not change the nature of the problem (see Lemma 2 in Supplementary Materials). We also consider the case where the activation function of state update is the piece-wise linear function $g$.

Now consider the following construction.

[TABLE]

The state-update equation then becomes

[TABLE]

This induces a dependency structure of the state and input variables as shown in Figure 1. For convenience, the pre-activation term in the $S_{t}^{1}$ equation will be denoted by $h(S_{t-1}^{1},S_{t-1}^{2})$. That is,

[TABLE]

We also impose the following conditions on the parameters: $W_{21}\in(0,1)$, $b_{2}<0$, $W_{21}X_{t}^{I}+b_{2}<-1$, $b_{1}\neq 0$, and $b_{1}\pm b_{1}W_{21}\in(-1,1)$.

It is possible to verify that under such a setting, four distinct “working mechanisms” exist. These mechanisms, their respective conditions and effects are shown in Table 2.

Let the state be initialized as $S_{0}^{1}=0$ and $S_{0}^{2}=-1$. The dynamics of Vanilla RNN may then be divided into four phases, each controlled by exactly two mechanisms.

Noise Suppression ($t<L$): In this phase, the “load emptying” and “memorization” mechanisms are invoked, where the former keeps the loading state $S_{t}^{2}$ clean, with value $-1$, and the latter assures that the memorization state $S_{t}^{1}$ keeps its initial value [math].

Feature Loading* ($t=L$): In this phase, “feature loading” is invoked, the feature $X_{L}^{\rm I}$ is then loaded into the loading state $S_{L}^{2}$. The “memorization” mechanism remains in effect, making the memorization state $S_{L}^{1}$ stay at [math].*

Feature Transfer ($t=L+1$): In this phase, “state mixing” is invoked. This makes the memorization state $S_{L+1}^{1}$ switch to a linear mixing of the previous loading and memorization states, causing the feature contained in the previous loading state $S_{L}^{2}$ transferred to the memorization state $S_{L+1}^{1}$. At this time, “load emptying” is again activated, resetting the loading state $S_{L+1}^{2}$ to $-1$.

Feature Memorization* ($t>L+1$): In this phase, “load emptying” remains active, making the loading state $S_{t}^{2}$ stay at $-1$. At the same time, “memorization” is again activated, allowing the memorization state $S_{t}^{1}$ to maintain its previous value, thereby keeping the feature until the end.*

For $\tanh$-activated Vanilla RNN with $K=2$, feature selection and memorization appear to work in a similar manner, in the sense that the two states need to execute different tasks and that similar working mechanisms are involved. However, in that case, the four mechanisms are less sharply defined, and in each phase the state update is dominated, rather than completely controlled, by its two mechanisms.

4.2 Gated RNN Models

Theorem 4

At state dimension $K=1$, ${\cal F}_{\rm LSTM}$, ${\cal F}_{\rm GRU}$ and ${\cal F}_{\rm PRU}$ all pass the F1B test.

The theorem is proved by constructing specific parameters for each of the models and for any given $n$. Under those parameters, it is possible to track the mean $\mu^{+}_{t}$ and variance ${\sigma^{2}_{t}}^{+}$ of state $s_{t}$ for the positive sample paths, and likewise $\mu^{-}_{t}$ and ${\sigma^{2}_{t}}^{-}$ for the negative sample paths. It can then be shown that the chosen parameters will make $\mu^{+}=-\mu^{-}$ and ${\sigma^{2}_{t}}^{+}={\sigma^{2}_{t}}^{-}$, and the ratio $\sqrt{{\sigma^{2}_{n}}^{+}}/\mu^{+}_{n}$ can be made arbitrarily small. Then if one uses the threshold [math] on $S_{n}$ to classify the positive and the negative sample paths, the error probability can be made arbitrarily close to [math] using the Chebyshev Inequality*(Feller, 2008)**. Then via a simple lemma (Lemma 3 in Supplementary Materials), arbitrary small error probability in fact implies zero error probability.*

Using GRU as an example, we now explain the construction of the model parameters and give some insights into how such a construction allows both feature selection and feature memorization.

*In GRU, consider its parameter in the following form: *

[TABLE]

*Let $A:=\sigma(a),B:=\tanh(b)$.

Then the gated combination equation (13) becomes*

[TABLE]

In above, $B$ is always bundled with $X_{t}^{\rm I}$, serving merely as a global constant that scales the inputs and having no impact on the problem nature. We then take $B=1$.

Observe that for both $t=L$ and $t\neq L$, the new state is a convex combination of the old state and the current input, however the weights are swapped between the two cases. This contrasts the case of Vanilla RNN (with $K=1$), in which the same linear combination formula applies to all $t$.

This phenomenon of swapped weights can be precisely attributed to the gating mechanism in GRU, namely, that the gate variable $z_{t}$ in (13) is computed dynamically from the previous state and the current input. To analyze the effect of gating, we discuss the consequence of (19) and (20) next.

Noise Suppression ($t<L$): In this phase, (19) applies and the network must suppress the content of the state, since it contains completely noise. This can be achieved by making $A$ either close to [math] or close to $1$. When $A$ is near [math], it suppresses the noise by directly attenuating the state. When $A$ is near $1$, it suppresses the noise by attenuating the input.

Feature Loading ($t=L$):* At this time, (20) applies. In this scenario, the network must amplify the incoming $X_{L}^{\rm I}$ and at the same time attenuate the old state. Only so will the desired information bit be superimposed on the noisy state with sufficient contrast. It is easy to see that both objectives can be achieved by choosing $A$ close to $1$.*

Feature Memorization ($t>L$): In this phase, (19) applies again. At this time, the state contains the selected feature, and the network must sufficiently amplify the state and suppress the incoming noise. These two objectives can be achieved simultaneously by choosing $A$ close to $1$.

Summarizing the requirements of $A$ in the three phases, we see that when choosing $A$ close to $1$, both feature selection and feature memorization can be achieved. It is in fact precisely due to gating that GRU is able to dynamically control what input to select and how to scale the state.

5 Experiments

5.1 Vanilla RNN: $K=1$

We have performed extensive computer search in the parameter space of ${\cal F}_{\rm RNN}$, and all checked parameter settings fail the F1B test. Specifically, we apply each checked parameter setting to the Vanilla RNN model and feed $10,000$ randomly generated positive sample paths of length $1000$ to the model. This Monte-Carlo simulation then give rise to the final state distribution for the positive sample paths. Similarly, we obtain the final state distribution for the negative sample paths. For each examined parameter, we observe that the two distributions significantly overlap, suggesting a failure of the F1B test.

The results in Figure 2 are obtained by similar Monte-Carlo simulations as above. The figure shows some typical behaviours of Vanilla RNN with state dimension $K=1$. The first row of the figure corresponds to a case where the value of $U$ is relatively small. In this case, in the noise-suppression phase, the model is able to suppress the noise in the state, and we see the state values move towards the centre. This then allows the success in feature loading, where the positive distribution is separated from the negative distribution. However, such a parameter setting makes the network lack memorization capability. In the feature-memorization phase, we see the two distributions quickly overlap, and can not be separated in the end. That is, the memory of the feature is lost. The second row of the figure corresponds to a case where $U$ is relatively large. In this case, the model is unable to compress the state values in the noise-suppression phase. As a consequence, when the feature is loaded into the state, the positive and the negative distributions can not be separated by a linear classifier. That is, feature selection fails. Then in the feature-memorization phase, the large value of $U$ keeps magnifying the state values in order to keep its memory. As noise is continuously blended in, this effort of “memorization” makes the two distributions even more noisy and in the end completely overlap.

5.2 GRU: $K=1$

Figure 3 shows some Monte-Carlo simulation results, obtained similarly as those in Figure 2, that validate Theorem 4. The top row of the figure corresponds to a case where $A$ is chosen not close to 1. In this case, we see that in the noise-suppression phase, the state values move away from the centre, suggesting an increased noise power in the state. This noise is however not too strong, which allows the feature to be loaded in the state reasonably well. This is indicated by the well separated positive and negative distributions in the feature-loading phase. But this value of $A$ does not support feature memorization. After the feature is loaded, the two distributions quickly smear into each other and become completely overlapping in the end. The bottom row of the figure corresponds to a case where $A$ is chosen close to 1 (as suggested by the construction). In this case, the state is well suppressed in the noise-suppression phase, allowing for perfect feature loading. The positive and negative distributions are kept well separated in the feature memorization phrase, allowing for perfect linear classification. Hence GRU passes the test.

Previous explanations on the effectiveness of gating are mostly based on gradient arguments. For example, in (Hochreiter & Schmidhuber, 1997), introducing gates is for “trapping” the gradient signal in back propagation. Recently the effectiveness of gating is also justified using a signal-propagation model based on dynamical isometry and mean field theory  (Chen et al., 2018). This paper demonstrates the power of gating from a different perspective, namely, that regardless of the training algorithm, gating intrinsically allows the network to dynamically adapt to the input and state configuration. This perspective, to the best of our knowledge, is made precise for the first time.

5.3 Vanilla RNN: $K=2$

For various sequence lengths $n$, we train Vanilla RNN with state dimension $K=2$ where the activation function in the state-update equation is $\tanh$ (some results of Vanilla RNN with $K=2$ and the piece-wise linear activation function $g$ are given in Supplementary Materials). During training, the final state $S_{n}$ is sent to a learnable logistic regression classifier. Mini-batched back-propagation is used to train the model. With increasing $n$, the chance of successful training (namely, training loss converging to near zero) decreases significantly, due to the well-known gradient vanishing problem of Vanilla RNN. Figure 4 shows some Monte-Carlo simulation results obtained for a Vanilla RNN parameter setting learned successfully, the shown behaviour is typical in all successfully learned models.

The learned model in Figure 4 is a case where the $S_{t}^{1}$ serves as the memorization state and $S_{t}^{2}$ as the loading state. When $t<L=50$, $S_{t}^{2}$ remains at a low value, providing a clean background for the loading of the upcoming feature. When $t=L$, the feature $X_{L}^{\rm I}$ is loaded into the loading state $S_{L}^{2}$, where the positive and negative sample paths exhibit themselves as two separable distributions. When $t=L+1$, the feature is transferred to the memorization state $S_{L+1}^{1}$, where positive sample paths are separable from the negative ones. Note that at this point, information about the feature is in fact lost in the loading state $S^{2}_{L+1}$ and the two distributions on the loading state are no longer separable. But the feature in the memorization state remains memorized for $t>L$, which allows the eventual classification of the positive and negative paths.

6 Concluding Remarks

We propose to use the “Flagged-1-Bit” (F1B) test to RNN’s behaviour in selecting and memorizing temporal features. This test strips off the influence of any training algorithm and reveals the models’ intrinsic capability. Using this test, we articulate that there is in general a conflict between feature selection and feature memorization. Although the F1B test is a simplified special case, it reveals some insights concerning how RNN deals with this conflict, which might be extrapolated to a broader context of sequence learning.

Specifically with limited state dimension, with or without gate appears to be “the great divide” in the models’ ability and behaviour to resolve such a conflict. Gating allows the network to dynamically adjust its state-update equation, thereby resolving this conflict. Without gates, Vanilla RNN can only exploit the freedom in its state space to accommodate these conflicting objectives. In particular, we point out that Vanilla RNN may resolve this conflict by assigning each state dimension a different function; in the special case of the F1B test and with 2-dimensional state space, one dimension serves to select feature, and the other serves to memorize it. Such an insight is expected to extend to more complex sequence learning problems, although much study is required in those settings. One potential direction is to consider a more general “Flagged-$k$-Bit” test, in which $k$ randomly spread flags specify the locations of $k$ desired information bits.

This research also implies that if not subject to gradient-based training methods, Vanilla RNN, with adequate state dimensions, is not necessarily inferior to gated models. Thus fixing the gradient problem and developing new optimization techniques for Vanilla RNN remain important.

Finally, consider the spectrum of models from Vanilla RNN, to PRU, to GRU, and to LSTM. At one end of the spectrum, Vanilla RNN uses no gate and relies on increasing state dimension to resolve the feature selection-memorization conflict. At the other end, LSTM uses a complicated gate structure to resolve the same conflict. This observation makes one wonder whether a better compromise may exploit both worlds, i.e., using a simpler gate structure and slightly increased state dimensions. Indeed, experimental evidences have shown that with simpler gate structures, GRU and PRU may outperform LSTM(Chung et al., 2014; Long et al., 2018).