Machine Learning on Sequential Data Using a Recurrent Weighted Average

TL;DR

This paper introduces a novel RNN model called Recurrent Weighted Average (RWA) that incorporates information from all past steps, outperforming standard LSTM models on various sequence tasks.

Contribution

The paper proposes the RWA model, which computes a running average over all past steps, effectively integrating an attention mechanism into RNNs with minimal computational overhead.

Findings

RWA outperforms LSTM on sequence tasks

Effective handling of long-range dependencies

Maintains computational efficiency

Abstract

Recurrent Neural Networks (RNN) are a type of statistical model designed to handle sequential data. The model reads a sequence one symbol at a time. Each symbol is processed based on information collected from the previous symbols. With existing RNN architectures, each symbol is processed using only information from the previous processing step. To overcome this limitation, we propose a new kind of RNN model that computes a recurrent weighted average (RWA) over every past processing step. Because the RWA can be computed as a running average, the computational overhead scales like that of any other RNN architecture. The approach essentially reformulates the attention mechanism into a stand-alone model. The performance of the RWA model is assessed on the variable copy problem, the adding problem, classification of artificial grammar, classification of sequences by length, and classification of the MNIST images (where the pixels are read sequentially one at a time). On almost every task, the RWA model is found to outperform a standard LSTM model.

Equations

$$h_0=f(s_0)$$

$$h_{t}=f\Bigg{(}\frac{\sum\limits_{i=1}^{t}z(x_{i},h_{i-1})\circ e^{a(x_{i},h_{i-1})}}{\sum\limits_{j=1}^{t}e^{a(x_{j},h_{j-1})}}\Bigg{)}$$

$$z(x_i,h_{i-1})=u(x_i)\circ \tanh g(x_i,h_{i-1})$$

$$\begin{array}{rl}& u(x_i)=W_u\cdot x_i+b_u\\ & g(x_i,h_{i-1})=W_g\cdot [x_i,h_{i-1}]+b_g\\ & a(x_i,h_{i-1})=W_a\cdot [x_i,h_{i-1}]\end{array}$$

$$\begin{array}{rl}& n_t=\sum _{i=1}^{t}z(x_i,h_{i-1})\circ e^{a(x_i,h_{i-1})}\\ & d_t=\sum _{j=1}^t{e}^{a(x_j,h_{j-1})}\end{array}$$

$$\begin{array}{rl}& n_t=n_{t-1}+z(x_t,h_{t-1})\circ e^{a(x_t,h_{t-1})}\\ & d_t=d_{t-1}+e^{a(x_t,h_{t-1})}\end{array}$$

$$h_{t}=f\bigg{(}\frac{n_{t}}{d_{t}}\bigg{)}$$

$$\begin{split}&h_{0}=f(s_{0})\ ,\ \ n_{0}=0\ ,\ \ d_{0}=0\\ &u(x_{t})=W_{u}\cdot x_{t}+b_{u}\\ &g(x_{t},h_{t-1})=W_{g}\cdot[x_{t},h_{t-1}]+b_{g}\\ &a(x_{t},h_{t-1})=W_{a}\cdot[x_{t},h_{t-1}]\\ &z(x_{t},h_{t-1})=u(x_{t})\circ\tanh{g(x_{t},h_{t-1})}\\ &n_{t}=n_{t-1}+z(x_{t},h_{t-1})\circ e^{a(x_{t},h_{t-1})}\\ &d_{t}=d_{t-1}+e^{a(x_{t},h_{t-1})}\\ &h_{t}=f\bigg{(}\frac{n_{t}}{d_{t}}\bigg{)}\end{split}$$

$$y_n=\sum _{i=1}^n{r}_i=\sum _{i=1}^{n-1}{r}_i+r_n=y_{n-1}+r_n$$

$$\begin{split}a&{}^{\text{max}}_{0}=-10^{38}\\ a&{}^{\text{max}}_{t}=\text{Max}\big{\{}a^{\text{max}}_{t-1},a(x_{t},h_{t-1})\big{\}}\\ n&{}_{t}=n_{t-1}\circ e^{a^{\text{max}}_{t-1}-a^{\text{max}}_{t}}+z(x_{t},h_{t-1})\circ e^{a(x_{t},h_{t-1})-a^{\text{max}}_{t}}\\ d&{}_{t}=d_{t-1}\circ e^{a^{\text{max}}_{t-1}-a^{\text{max}}_{t}}+e^{a(x_{t},h_{t-1})-a^{\text{max}}_{t}}\end{split}$$

Full text

Source code and experiments at https://github.com/jostmey/rwa

1 Introduction

Types of information as dissimilar as language, music, and genomes can be represented as sequential data. The essential property of sequential data is that the order of the information is important, which is why statistical algorithms designed to handle this kind of data must be able to process each symbol in the order that it appears. Recurrent neural network (RNN) models have been gaining interest as a statistical tool for dealing with the complexities of sequential data. The essential property of a RNN is the use of feedback connections. The sequence is read by the RNN one symbol at a time through the model’s inputs. The RNN starts by reading the first symbol and processing the information it contains. The processed information is then passed through a set of feedback connections. Every subsequent symbol read into the model is processed based on the information conveyed through the feedback connections. Each time another symbol is read, the processed information of that symbol is used to update the information conveyed in the feedback connections. The process continues until every symbol has been read into the model (Fig. 1a). The processed information is passed along each step like in the game telephone (a.k.a. Chinese whispers). With each step, the RNN produces an output that serves as the model’s prediction. The challenge of designing a working RNN is to make sure that processed information does not decay over the many steps. Error correcting information must also be able to backpropagate through the same pathways without degradation (Hochreiter, 1991; Bengio, Simard, and Frasconi, 1994). Hochreiter and Schmidhuber were the first to solve these issues by equipping a RNN with what they called long short-term memory (LSTM) (Hochreiter and Schmidhuber, 1997).

Since the introduction of the LSTM model, several improvements have been proposed. The attention mechanism is perhaps one of the most significant (Bahdanau, Cho, and Bengio, 2014). The attention mechanism is nothing more than a weighted average. At each step, the output from the RNN is weighted by an attention model, creating a weighted output. The weighted outputs are then aggregated together by computing a weighted average (Fig. 1b). The outcome of the weighted average is used as the model’s result. The attention model controls the relative contribution of each output, determining how much of each output is “seen” in the results. The attention mechanism has since been incorporated into several other neural network architectures leading to a variety of new models each specifically designed for a single task (partial reference list: Bahdanau et al. 2014; Vinyals et al. 2015b; Xu et al. 2015; Sønderby et al. 2015; Chan et al. 2015; Vinyals et al. 2015a). Unfortunately, the attention mechanism is not defined in a recurrent manner. The recurrent connections must come from a separate RNN model, restricting where the attention mechanism can be used.

Inspired by the attention mechanism used to modify existing neural network architectures, we propose a new kind of RNN that is created by reformulating the attention mechanism into a stand-alone model. The proposed model includes feedback connections from every past processing step, not just the preceding step (Fig. 1c). The feedback connections from each processing step are weighted by an attention model. The weighted feedback connections are then aggregated together by computing a weighted average. The model is said to use a recurrent weighted average (RWA) because the attention model also uses the feedback connections. At each step, the weighted average can be computed as a running average. By maintaining a running average, the model scales like any other type of RNN.

2 The RWA Model

2.1 Mathematical Description

The proposed model is defined recursively over the length of the sequence. Starting at the first processing step $t=1$ a set of values $h_{0}$, representing the initial state of the model, is required. The distribution of values for $h_{0}$ must be carefully chosen to ensure that the initial state resembles the output from the subsequent processing steps. This is accomplished by defining $h_{0}$ in terms of $s_{0}$, a parameter that must be fitted to the data.

[TABLE]

The parameters $s_{0}$ are passed through the model’s activation function $f$ to mimic the processes that generate the outputs of the later processing steps.

For every processing step that follows, a weighted average computed over every previous step is passed through the activation function $f$ to generate a new output $h_{t}$ for the model. The equation for the model is given below.

[TABLE]

The weighted average consists of two models: $z$ and $a$. The model $z$ encodes the features $x_{i}$ for each symbol in the sequence. Its recurrence relations, represented by $h_{i-1}$, provide the context necessary to encode the features in a sequence dependent manner. The model $a$ serves as the attention model, determining the relative contribution of $z$ at each processing step. The exponential terms of model $a$ are normalized in the denominator to form a proper weighted average. The recurrent relations in $a$, represented by $h_{i-1}$, are required to compose the weighted average recursively. Because of the recurrent terms in $a$, the model is said to use a RWA.

There are several models worth considering for $z$, but only one is considered here. Because $z$ encodes the features, the output from $z$ should ideally be dominated by the values in $x_{i}$ and not $h_{i-1}$. This can be accomplished by separating the model for $z$ into an unbounded component containing only $x_{i}$ and a bounded component that includes the recurrent terms $h_{i-1}$.

[TABLE]

The model for $u$ contains only $x_{i}$ and encodes the features. With each processing step, information from $u$ can accumulate in the RWA. The model for $g$ contains the recurrent relations and is bounded between $[-1,1]$ by the $\tanh$ function. This model can control the sign of $z$ but cannot cause the absolute magnitude of $z$ to increase. Having a separate model for controlling the sign of $z$ ensures that information encoded by $u$ does not just accumulate but can negate information encoded from previous processing steps. Together the models $u$ and $g$ encode the features in a sequence dependent manner.

The terms $u$, $g$, and $a$ can be modelled as feed-forward linear networks.

[TABLE]

The matrices $W_{u}$, $W_{g}$, and $W_{a}$ represent the weights of the feed-forward networks, and the vectors $b_{u}$ and $b_{g}$ represent the bias terms. The bias term for $a$ would cancel when factored out of the numerator and denominator, which is why the term is omitted.

While running through a sequence, the output $h_{t}$ from each processing step can be passed through a fully connected neural network layer to predict a label. Gradient descent based methods can then be used to fit the model parameters, minimizing the error between the true and predicted label.

2.2 Running Average

The RWA in equation (2) is recalculated from the beginning at each processing step. The first step to reformulate the model as a running average is to separate the RWA in equation (2) as a numerator term $n_{t}$ and denominator term $d_{t}$.

[TABLE]

Because any summation can be rewritten as a recurrence relation, the summations for $n_{t}$ and $d_{t}$ can be defined recurrently (see Appendix A). Let $n_{0}=0$ and $d_{0}=0$.

[TABLE]

By saving the previous state of the numerator $n_{t-1}$ and denominator $d_{t-1}$, the values for $n_{t}$ and $d_{t}$ can be efficiently computed using the work done during the previous processing step. The output $h_{t}$ from equation (2) can now be obtained from the relationship listed below.

[TABLE]

Using this formulation of the model, the RWA can efficiently be computed dynamically.

2.3 Equations for Implementation

The RWA model can be implemented using equations (1) and (3)–(6), which are collected together and written below.

[TABLE]

Starting from the initial conditions, the model is run recursively over an entire sequence. The features for every symbol in the sequence are contained in $x_{t}$, and the parameters $s_{0}$, $W_{u}$, $b_{u}$, $W_{g}$, $b_{g}$, and $W_{a}$ are determined by fitting the model to a set of training data. Because the model is differentiable, the parameters can be fitted using gradient optimization techniques.

In most cases, the numerator and denominator will need to be rescaled to prevent the exponential terms from becoming too large or small. The rescaling equations are provided in Appendix B.

3 Experiments

3.1 Implementations of the Models

A RWA model is implemented in TensorFlow using the equations in (7) (Abadi et al., 2016). The model is trained and tested on five different classification tasks each described separately in the following subsections.

The same configuration of the RWA model is used on each dataset. The activation function is $f(x)=\tanh⁡{x}$ and the model contains $250$ units. Following general guidelines for initializing the parameters of any neural network, the initial weights in $W_{u}$, $W_{g}$ and $W_{a}$ are drawn at random from the uniform distribution \Big{[}-\sqrt{\frac{3}{(N_{\text{in}}+N_{\text{out}})/2}},\sqrt{\frac{3}{(N_{\text{in}}+N_{\text{out}})/2}}\Big{]} and the bias terms $b_{u}$ and $b_{g}$ are initialized to [math]’s (Glorot and Bengio, 2010). The initial state $s_{0}$ for the RWA model is drawn at random from a normal distribution according to $s_{0}\sim\mathcal{N}(\mu=0,\sigma^{2}=1)$. To avoid not-a-number (NaN) and divide-by-zero errors, the numerator and denominator terms in equations (7) are rescaled using equations (8) in Appendix B, which do not alter the model’s output.

The datasets are also scored on a LSTM model that contains $250$ cells to match the number of units in the RWA model. Following the same guidelines used for the RWA model, the initial values for all the weights are drawn at random from the uniform distribution \Big{[}-\sqrt{\frac{3}{(N_{\text{in}}+N_{\text{out}})/2}},\sqrt{\frac{3}{(N_{\text{in}}+N_{\text{out}})/2}}\Big{]} and the bias terms are initialized to 0’s except for the forget gates (Glorot and Bengio, 2010). The bias terms of the forget gates are initialized to $1$’s, since this has been shown to enhance the performance of LSTM models (Gers, Schmidhuber, and Cummins, 2000; Jozefowicz, Zaremba, and Sutskever, 2015). All initial cell states of the LSTM model are [math].

A fully connected neural network layer transforms the output from the $250$ units into a predicted label. The error between the true label and predicted label is then minimized by fitting the model’s parameters using Adam optimization (Kingma and Ba, 2014). All values for the ADAM optimizer follow published recommended settings. A step size of $0.001$ is used throughout this study, and the other optimizer settings are $\beta_{1}=0.9$, $\beta_{2}=0.999$, and $\epsilon=10^{-8}$. Each parameter update consists of a batch of 100 training examples. Gradient clipping is not used.

Each model is immediately scored on the test set and no negative results are omitted111The RWA model was initially implemented incorrectly. The mistake was discovered by Alex Nichol. After correcting the mistake, the old results were discarded and the RWA model was run again on each classification task.. No hyperparameter search is done and no regularization is tried. At every $100$ steps of training, a batch of $100$ test samples are scored by each model to generate values that are plotted in the figures for each of the tasks described below. The code and results for each experiment may be found online (see: https://github.com/jostmey/rwa).

3.2 Classifying Artificial Grammar

It is important that a model designed to process sequential data exhibit a sensitivity to the order of the symbols. For this reason, the RWA model is tasked with proofreading the syntax of sentences generated by an artificial grammatical system. Whenever the sentences are valid with respect to the artificial grammar, the model must return a value of 1, and whenever a typo exists the model must return a value of 0. This type of task is considered especially easy for standard RNN models, and is included here to show that the RWA model also performs well at this task (Hochreiter and Schmidhuber, 1997).

The artificial grammar generator is shown in Figure 2a. The process starts with the arrow labeled B, which is always the first letter in the sentence. Whenever a node is encountered, the next arrow is chosen at random. Every time an arrow is used the associated letter is added to the sentence. The process continues until the last arrow E is used. All valid sentences end with this letter. Invalid sentences are constructed by randomly inserting a typo along the sequence. A typo is created by an invalid jump between unconnected arrows. No more than one typo is inserted per sentence. Typos are inserted into approximately half the sentences. Each RNN model must perform with greater than $50$% accuracy to demonstrate it has learned the task.

A training set of $100,000$ samples are used to fit the model, and a test set of $10,000$ samples are used to evaluate model performance. The RWA model does remarkably well, achieving $100$% accuracy in $600$ training steps. The LSTM model also learns to identify valid sentences, but requires $1000$ training steps to achieve the same performance level (Fig 2b). This task demonstrates that the RWA model can classify patterns based on the order of information.

3.3 Classifying by Sequence Length

Classifying sequences by length requires that RNN models track the number of symbols contained in each sequence. For this task, the length of each sequence is randomly drawn from a uniform distribution over every possible length [math] to $T$, where $T$ is the maximum possible length of the sequence. Each step in the sequence is populated with a random number drawn from a unit normal distribution (i.e. $\mu=0$ and $\sigma^{2}=1$). Sequences greater than length $T/2$ are labeled with $1$ while shorter sequences are labeled with [math]. The goal is to predict these labels, which indicates if a RNN model has the capacity to classify sequences by length. Because approximately half the sequences will have a length above $T/2$, each RNN model must perform with greater than $50$% accuracy to demonstrate it has learned the task.

For this task, $T=1,000$ (The task was found to be too easy for both models for $T=100$). A training set of $100,000$ samples are used to fit the model, and a test set of $10,000$ samples are used to evaluate model performance. The RWA model does remarkably well, learning to correctly classify sequences by their length in fewer than 100 training steps. The LSTM model also learns to correctly classify sequences by their length, but requires over 2,000 training steps to achieve the same level of performance (Fig. 3).

3.4 Variable Copy Problem

The variable copy problem, proposed by Henaff et al. (2016), requires that a RNN memorize a random sequence of symbols and recall it only when prompted. The input sequence starts with the recall sequence. The recall sequence for the RNN to memorize consists of $S$ many symbols drawn at random from $\{a_{i}\}_{i=1}^{K}$. After that, the input sequence contains a stretch of $T$ blank spaces, denoted by the symbol $a_{K+1}$. Somewhere along this stretch of blank spaces, one of the symbols is replaced by a delimiter $a_{K+2}$. The delimiter indicates when the recall sequence should be repeated back. The input sequence is then padded with an additional stretch of $S$ blank spaces, providing sufficient time for the model to repeat the recall sequence. The goal is to train the model so that its output is always blank except for the spaces immediately following the delimiter, in which case the output must match the recall sequence.

An example of the task is shown in Figure 4a. The recall pattern drawn at random from symbols A through H is DEAEEBHGBH. Blank spaces represented by *** fill the rest of the sequence. One blank space is chosen at random and replaced by X, which denotes the delimiter. After X appears the model must repeat the recall pattern in the output. The naïve strategy is to always guess that the output is *** because this is the most common symbol. Each RNN must perform better than the naïve strategy to demonstrate that it has learned the task. Using this naïve strategy, the expected cross-entropy error between the true output and predicted output is $\frac{S\cdot\ln{k}}{2\cdot S+T}$, represented by the dashed line in Figures 4b, c. This is the baseline to beat.

For this challenge, $K=8$, $S=10$, and models are trained and evaluated on two separate cases where $T=100$ and $T=1,000$. For both $T=100$ and $T=1,000$, the training set contains $100,000$ examples and the test set contains $10,000$ examples. For the case of $T=100$, the RWA requires roughly $1,000$ training steps to beat the baseline score, whereas the LSTM model requires over $10,000$ training steps to achieve the same level of performance. The RWA model scales well to $T=1,000$, requiring only $3,000$ training steps to beat the baseline score. The LSTM model is only barely able to beat the baseline error after $50,000$ training steps (Fig. 4c). The RWA model appears to scale much better as the sequence length increases.

3.5 Adding Problem

The adding problem, first proposed by Hochreiter and Schmidhuber (1997), tests the ability of a RNN model to form long-range connections across a sequence. The task requires that the model learn to add two numbers randomly spaced apart on a sequence. The input sequence consists of two values at each step. The first value serves as an indicator marking the value to add while the second value is the actual number to be added and is drawn at random from a uniform distribution over $[0,1]$. Whenever the indicator has a value of $1$, the randomly drawn number must be added to the sum, and whenever the indicator has a value of [math], the randomly drawn number must be ignored. Only two steps in the entire sequence will have an indicator of $1$, leaving the indicator [math] everywhere else.

An example of the adding problem is shown in Figure 5a. The top row contains the indicator values and the bottom row contains randomly drawn numbers. The two numbers that have an indicator of 1 must be added together. The numbers in this example are $0.5$ and $0.8$, making the target output $1.3$. Because the two numbers being added together are uniformly sampled over $[0,1]$, the naïve strategy is to always guess that the target output is $1$. Each RNN must perform better than the naïve strategy to demonstrate that it has learned the task. Using this naïve strategy, the expected mean square error (MSE) between the true answer and the prediction is approximately $0.167$, represented by the dashed line in Figures 5b,c. This is the baseline to beat.

The adding problem is repeated twice, first with sequences of length $100$ and again with sequences of length $1,000$. In both cases, a training set of $100,000$ samples are used to fit the model, and a test set of $10,000$ samples are used to evaluate the model’s performance. When the sequences are of length $100$, the RWA model requires fewer than $1,000$ training steps to beat the baseline score while the LSTM model requires around $3,000$ steps (Fig. 5b). When the sequences are of length $1,000$, the RWA model requires approximately $1,000$ training steps to beat the baseline score, while the LSTM model requires over $15,000$ training steps on the same task (Fig. 5c). The RWA model appears to scale much better as the sequence length increases.

3.6 Classifying MNIST Images (Pixel by Pixel)

The MNIST dataset contains $28\times 28$ pixel images of handwritten digits 0 through 9. The goal is to predict the digit represented in the image (LeCun, Bottou, Bengio, and Haffner, 1998). Using the same setup suggested by Le, Jaitly, and Hinton (2015), the images are arranged into a sequence of pixels. The length of each sequence is $28\times 28=784$ pixels. Each RNN model reads the sequence one pixel at a time and must predict the digit being represented in the image from this sequence.

Examples of MNIST digits with the correct label are shown in Figure 6a. The pixels at the top and bottom of each image are empty. When the images are arranged into a sequence of pixels, all the important pixels will be in the middle of the sequence. To utilize these pixels, each RNN model will need to form long-range dependencies that reach the middle of each sequence. The model will have formed the necessary long-range dependencies when it outperforms a naïve strategy of randomly guessing each digit. A naïve strategy will achieve an expected accuracy of $10$%, represented by the dashed line in Figures 6b. This is the baseline to beat.

For this challenge, the standard training set of $60,000$ images is used to fit the model, and the standard test set of $10,000$ images is used to evaluate the model’s performance on unseen data. The RWA model fits the dataset in under $20,000$ steps, considerably faster than the LSTM model (Fig. 6b). After a quarter million training steps, the RWA model achieves an accuracy of $98.1$% with an error of $0.175$ bits, while LSTM model achieves an accuracy of $99.0$% with an error of $0.077$ bits. In this example, the LSTM model generalizes better to the unseen data.

A separate and more challenging task is to randomly permute the pixels, leaving the pixels out of order, as described in Le et al. (2015). The same permutation mapping must be used on each image to keep the data consistent between images. As before, a naïve strategy of randomly guessing the answer will achieve an expected accuracy of $10$%, represented by the dashed line in Figures 6c. This is the baseline to beat.

The classification task is repeated with the pixels randomly permuted. This time the LSTM model fit the dataset faster than the RWA model (Fig. 6c). After a quarter million training steps, the RWA model achieves an accuracy of $93.5$% with an error of $0.561$ bits, while LSTM model achieves an accuracy of $93.6$% with an error of $0.577$ bits. Neither model generalizes noticeably better to the unseen data.

4 Discussion

The RWA model reformulates the attention mechanism into a stand-alone model that can be optimized using gradient descent based methods. Given that the attention mechanism has been shown to work well on a wide range of problems, the robust performance of the RWA model on the five classification tasks in this study is not surprising (Bahdanau, Cho, and Bengio, 2014; Vinyals, Toshev, Bengio, and Erhan, 2015b; Xu, Ba, Kiros, Cho, Courville, Salakhutdinov, Zemel, and Bengio, 2015; Sønderby, Sønderby, Nielsen, and Winther, 2015; Chan, Jaitly, Le, and Vinyals, 2015; Vinyals, Kaiser, Koo, Petrov, Sutskever, and Hinton, 2015a). Moreover, the RWA model did not require a hyperparameter search to tailor the model to each task. The same configuration successfully generalized to unseen data on every task. Clearly, the RWA model can form long-range dependencies across the sequences in each task and does not suffer from the vanishing or exploding gradient problem that affects other RNN models (Hochreiter, 1991; Bengio, Simard, and Frasconi, 1994).

The RWA model requires less clock time and fewer parameters than a LSTM model with the same number of units. On almost every task, the RWA model beat the baseline score using fewer training steps. The number of training steps could be further reduced using a larger step size for the parameter updates. It is unclear how large the step size can become before the convergence of the RWA model becomes unstable (a larger step size may or may not require gradient clipping, which was not used in this study). The RWA model also uses over $25$% fewer parameters per unit than a LSTM model. Depending on the computer hardware, the RWA model can either run faster or contain more units than a LSTM model on the same computer.

Unlike previous implementations of the attention mechanism that read an entire sequence before generating a result, the RWA model computes an output in real time with each new input. With this flexibility, the RWA model can be deployed anywhere existing RNN models can be used. Several architectures are worth exploring. Bidirectional RWA models for interpreting genomic data could be created to simultaneously account for information that is both upstream and downstream in a sequence. Multi-layered versions could also be created to handle XOR classification problems at each processing step. In addition, RWA models could be used to autoencode sequences or to learn mappings from a fixed set of features to a sequence of labels. The RWA model offers a compelling framework for performing machine learning on sequential data.

5 Conclusion

The RWA model opens exciting new areas for research. Because the RWA model can form direct pathways to any past processing step, it can detect patterns in a sequence that other models would miss. This could lead to dramatically different outcomes when applied to complex tasks like natural language processing, automated music composition, and the classification of genomic sequences. Given how easily the model can be inserted into existing RNN architectures, it is worth trying the RWA model on these tasks. The RWA model has the potential to solve problems that have been deemed too difficult until now.

Acknowledgments

Special thanks are owed to Elizabeth Harris for proofreading and editing the manuscript. She brought an element of clarity to the manuscript that it would otherwise lack. Alex Nichol also needs to be recognized. Alex identified a flaw in equations (8), which are used to compute a numerically stable update of the numerator and denominator terms. Without Alex’s careful examination of the manuscript, all the results for the RWA model would be incorrect. The department of Clinical Sciences at the University of Texas Southwestern Medical Center also needs to be acknowledged. Ongoing research projects at the medical center highlighted the need to find better ways to process genomic data and provided the inspiration behind the development of the RWA model.

This work was supported by a training grant from the Cancer Prevention and Research Institute of Texas (RP160157) and an R01 from the National Institute of Allergy and Infectious Diseases (R01AI097403).

Appendix A.

Any summation of the form $y_{n}=\sum\limits_{i=1}^{n}r_{i}$ can be written as a recurrent relation. Let the initial values be $y_{0}=0$.

[TABLE]

The summation is now defined recursively.

Appendix B.

The exponential terms in equations (7) are prone to underflow and overflow. The underflow condition can cause all the terms in the denominator to become zero, leading to a divide-by-zero error. The overflow condition leads to not-a-number (NaN) errors. To avoid both kinds of errors, the numerator and denominator can be multiplied by an exponential scaling factor. Because the numerator and denominator are scaled by the same factor, the quotient remains unchanged and the output of the model is identical. The idea is similar to how a softmax function must sometimes be rescaled to avoid the same errors.

The exponential scaling factor is determined by the largest value in $a$ among every processing step. Let $a^{\text{max}}_{t}$ represent the largest observed value. The initial value for $a^{\text{max}}_{0}$ needs to be less than any value that will be observed, which can be accomplished by using an extremely large negative number.

[TABLE]

The first equation sets the initial value for the exponential scaling factor to one of the largest numbers that can be represented using single-precision floating-point numbers. Starting with this value avoids the underflow condition. The second equation saves the largest value observed in $a$. The final two equations compute an updated numerator and denominator. The equations scale the numerator and denominator accounting for the exponential scaling factor used during previous processing steps. The results from equations (8) can replace the results for $n_{t}$ and $d_{t}$ in equations (7) without affecting the model’s output h_{t}=f\big{(}\frac{n_{t}}{d_{t}}\big{)}.