Analyzing and Exploiting NARX Recurrent Neural Networks for Long-Term Dependencies
Robert DiPietro Christian Rupprecht Nassir Navab Gregory D. Hager



Three-particle correlations in relativistic heavy ion collisions in a multiphase transport model
    Che Ming Ko
    December 30, 2023
================================================================================================




Recurrent neural networks (RNNs) have achieved state-of-the-art performance on many diverse tasks, from machine translation to surgical activity recognition, yet training RNNs to capture long-term dependencies remains difficult. To date, the vast majority of successful RNN architectures alleviate this problem using nearly-additive connections between states, as introduced by long short-term memory (LSTM). We take an orthogonal approach and introduce MIST RNNs, a NARX RNN architecture that allows direct connections from the very distant past. We show that MIST RNNs 1) exhibit superior vanishing-gradient properties in comparison to LSTM and previously-proposed NARX RNNs; 2) are far more efficient than previously-proposed NARX RNN architectures, requiring even fewer computations than LSTM; and 3) improve performance substantially over LSTM and Clockwork RNNs on tasks requiring very long-term dependencies.




§ INTRODUCTION



Recurrent neural networks <cit.> are a powerful class of neural networks that are naturally suited to modeling sequential data. For example, in recent years alone, RNNs have achieved state-of-the-art performance on tasks as diverse as machine translation <cit.>, speech recognition <cit.>, generative image modeling <cit.>, and surgical activity recognition <cit.>.

These successes, and the vast majority of other RNN successes, rely on a mechanism introduced by long short-term memory <cit.>, which was designed to alleviate the so called vanishing gradient problem <cit.>. The problem is that gradient contributions from events at time t - τ to a loss at time t diminish exponentially fast with τ, thus making it extremely difficult to learn from distant events (see Figures <ref> and <ref>). LSTM alleviates the problem using nearly-additive connections between adjacent states, which help push the base of the exponential decay toward 1. However LSTM in no way solves the problem, and in many cases still fails to learn long-term dependencies (see, e.g., <cit.>).

NARX[The acronym NARX stems from Nonlinear AutoRegressive models with eXogeneous inputs.] RNNs <cit.> offer an orthogonal mechanism for dealing with the vanishing gradient problem, by allowing direct connections, or delays, from the distant past. However NARX RNNs have received much less attention in literature than LSTM, which we believe is for two reasons. First, as previously introduced, NARX RNNs have only a small effect on vanishing gradients, as they reduce the exponent of the decay by only a factor of n_d, the number of delays. Second, as previously introduced, NARX RNNs are extremely inefficient, as both parameter counts and computation counts grow by the same factor n_d.

In this paper, we introduce MIxed hiSTory RNNs (MIST RNNs), a novel NARX RNN architecture which 1) exhibits superior vanishing-gradient properties in comparison to LSTM and previously-proposed NARX RNNs; 2) improves performance substantially over LSTM on tasks requiring very long-term dependencies; and 3) remains efficient in parameters and computation, requiring even fewer than LSTM for a fixed number of hidden units. Importantly, MIST RNNs reduce the decay's exponent by a factor of 2^n_d - 1; see Figure <ref>.





§ BACKGROUND AND RELATED WORK



Recurrent neural networks, as commonly described in literature, take on the general form

    _t = f(_t-1, _t, )

which compute a new state _t in terms of the previous state _t-1, the current input _t, and some parameters  (which are shared over time).

One of the earliest variants, now known to be especially vulnerable to the vanishing gradient problem, is that of simple RNNs <cit.>, described by

    _t = tanh(_h _t-1 + _x _t + )

In this equation and elsewhere in this paper, all weight matrices  and biases  collectively form the parameters  to be learned, and tanh is always written explicitly.

Long short-term memory <cit.>, the most widely-used RNN architecture to date, was specifically introduced to address the vanishing gradient problem. The term LSTM is often overloaded; we refer to the variant with forget gates and without peephole connections, which performs similarly to more complex variants <cit.>:

    _t    = (_fh_t-1 + _fx_t + _f) 
    _t    = (_ih_t-1 + _ix_t + _i) 
    _t    = (_oh_t-1 + _ox_t + _o) 
    _t    = tanh(_ch_t-1 + _cx_t + _c) 
    _t    = _t ⊙_t-1 + _t ⊙_t 
    _t    = _t ⊙tanh(_t)

Here σ(·) denotes the element-wise sigmoid function and ⊙ denotes element-wise multiplication. _t, _t, and _t are referred as the forget, input, and output gates, which can be interpreted as controlling how much we reset, write to, and read from the memory cell _t. LSTM has better gradient properties than simple RNNs (see Figure <ref>) because of the mechanism in Equation <ref>, which introduces a path between _t-1 and _t which is modulated only by the forget gate. We also remark that gated recurrent units <cit.> alleviate the vanishing gradient problem using this exact same idea.

NARX RNNs <cit.> also address the vanishing gradient problem, but using a mechanism that is orthogonal to (and possibly complementary to) that of LSTM. This is done by allowing delays, or direct connections from the past. NARX RNNs in their general form are described by

    _t = f(_t-1, _t-2, …, _t, _t-1, …, )

but literature typically assumes the specific variant explored in <cit.>,

    _t = tanh( [ ∑_d=1^n_d_d _t-d] + _x _t + )

which we refer to as simple NARX RNNs.

Note that simple NARX RNNs require approximately n_d as much computation and n_d as many parameters as their simple-RNN counterpart (with n_d = 1), which greatly hinders their applicability in practice. To our knowledge, this drawback holds for all NARX RNN variants before MIST RNNs. For example, in <cit.>, higher-order recurrent neural networks (HORNNs) are defined precisely as simple NARX RNNs, and every variant in the paper suffers from this exact same problem. And, in <cit.>, a simple NARX RNN architecture is defined that is limited to having precisely two delays with non-zero weights. This way, at the expense of having fewer, longer paths to the past, parameter and computation counts are only doubled.

The previous work that is most similar to ours is that of Clockwork RNNs <cit.>, which split weights and hidden units into partitions, each with a distinct period. When it's not a partition's time to tick, its hidden units are passed through unchanged, and so Clockwork RNNs in some ways mimic NARX RNNs. However Clockwork RNNs differ in two key ways. First, Clockwork RNNs sever high-frequency-to-low-frequency paths, thus making it difficult to learn long-term behavior that must be detected at high frequency (for example, learning to depend on quick motions from the past for activity recognition). Second, Clockwork RNNs require hidden units to be partitioned a priori, which in practice is difficult to do in any meaningful way. NARX RNNs (and in particular MIST RNNs) suffer from neither of these drawbacks.

Many other approaches have also been proposed to capture long-term dependencies. Notable approaches include maintaining a generative model over inputs and learning to process only unexpected inputs <cit.>, operating explicitly at multiple time scales <cit.>, Hessian-free optimization <cit.>, using associative or explicit memory <cit.>, and initializing or restricting weight matrices to be orthogonal <cit.>.





§ THE VANISHING GRADIENT PROBLEM IN THE CONTEXT OF NARX RNNS



In <cit.>, gradient decompositions and sufficient conditions for vanishing gradients are presented for simple RNNs, which contain one path between times t - τ and t. Here, we use the chain rule for ordered derivatives <cit.> to connect gradient components to paths and edges, which in turn provides a simple extension of the results from <cit.> to general NARX RNNs. We remark that we rely on slightly overloaded notation for clarity, as otherwise notation becomes cumbersome (see <cit.>).

We begin by disambiguating notation, as the symbol  is routinely overloaded in literature. Consider the Jacobian of (, ()) with respect to . We let  denote (), a collection of full derivatives, and we let  denote (, ), a collection of partial derivatives. This lets us write the ordinary chain rule as =  +. Note that this notation is consistent with <cit.>, but is the exact opposite of the convention used in <cit.>.



 §.§ The Chain Rule for Ordered Derivatives


Consider an ordered system of n vectors _1, _2, …, _n, where each is a function of all previous:

    _i ≡_i(_i-1, _i-2, …, _1),    1 ≤ i ≤ n

The chain rule for ordered derivatives expresses the full derivatives _i_j for any j < i in terms of the full derivatives that relate _i to all previous _k:

    _i_j = ∑_i ≥ k > j_i_k_k_j,    j < i




 §.§ Gradient Decomposition for General NARX RNNs


Consider NARX RNNs in their general form (Equation <ref>), which we remark encompasses other RNNs such as LSTM as special cases. Also, for simplicity, consider the situation that is most often encountered in practice, where the loss at time t is defined in terms of the current state _t and its own parameters _l (which are independent of ).

    l_t = f_l(_t, _l)

(This is in not necessary, but we proceed this way to make the connection with RNNs in practice evident. For example, f_l may be a linear transformation with parameters _l followed by squared-error loss.) Then the Jacobian (or transposed gradient) with respect to  can be written as

    l_t = f_l_t_t

because the additional term f_l_l_l is 0. Now, by letting _1 =, _2 = _1, _3 = _2, and so on in Equations <ref> and <ref>, we immediately obtain

    _t = ∑_τ=0^t-1_t_t-τ_t-τ

because all of the partials _t-τ are 0.

Equations <ref> and <ref> extend Equations 3 and 4 of <cit.> to general NARX RNNs, which encompass simple RNNs, LSTM, etc., as special cases. This decomposition breaks _t into its temporal components, making it clear that the spectral norm of _t_t-τ plays a major role in how _t-τ affects the final gradient l_t^T. In particular, if the norm of _t_t-τ is extremely small, then _t-τ has only a negligible effect on the final gradient, which in turn makes it extremely difficult to learn from events that occurred at t - τ.



 §.§ Connecting Gradient Components to Paths and Edges


Equations <ref> and <ref>, along with the chain rule for ordered derivatives, let us connect gradient components to paths and edges, which is useful for a) gaining insights into various architectures and b) solidifying intuitions from backpropagation through time which suggest that short paths between t - τ and t facilitate gradient flow. Here we provide an overview of the main idea; please see the appendix for a full derivation.

By applying the chain rule for ordered derivatives to expand _t_t-τ in Equation <ref>, we obtain a sum over τ terms. However each term involves a partial derivative between _t and a prior hidden state, and thus all of these terms are 0 with the exception of those states that share an edge with _t. Now, for each term, we can repeat this process. This then yields non-zero terms only for hidden states which can be connected to _t through two edges. We can then continue to apply the chain rule for ordered derivatives repeatedly, until only partial derivatives remain.

Upon completion, we have a sum over gradient components, with each component corresponding to exactly one path from t - τ to t and being a product over its path's edges. The spectral norm corresponding to any particular path (t - τ→ t' → t”→⋯→ t) can then bounded as

    ‖_t_t”'^⋯⋯_t'_t-τ‖≤‖_t_t”'^⋯‖⋯‖_t'_t-τ‖≤λ^n_e

where λ is the maximum spectral norm of any factor and n_e is the number of edges on the path. Terms with λ < 1 diminish exponentially fast, and when all λ < 1, shortest paths dominate[We remark that it is also possible for gradient contributions to explode exponentially fast, however this problem can be remedied in practice with gradient clipping. None of the architectures discussed in this work, including LSTM, address the exploding gradient problem.].



§ MIXED HISTORY RECURRENT NEURAL NETWORKS



Viewing gradient components as paths, with each component being a product with one factor per edge along the path, gives us useful insight into various RNN architectures. When relating a loss at time t to events at time t - τ, simple RNNs and LSTM contain shortest paths of length τ, while simple NARX RNNs contain shortest paths of length τ / n_d, where n_d is the number of delays.

One can envision many NARX RNN architectures with non-contiguous delays that reduce these shortest paths further. In this section we introduce one such architecture using base-2 exponential delays. In this case, for all τ≤ 2^n_d - 1, shortest paths exist with only log_2 τ edges; and for τ > 2^n_d - 1, shortest paths exist with only τ / 2^n_d - 1 edges (see Figure <ref>). Finally we must avoid the parameter and computation growth of simple NARX RNNs. We achieve this by sharing weights over delays, instead using an attention-like mechanism <cit.> over delays and a reset mechanism from gated recurrent units <cit.>.

The proposed architecture, which we call mixed history RNNs (MIST RNNs), is described by

    _t    = ( _ah_t-1 + _ax_t + _a ) 
    _t    = ( _rh_t-1 + _rx_t + _r ) 
    _t    = tanh( _h [ _t ⊙∑_i = 0^n_d - 1 a_ti_t - 2^i] + _x _t + )

Here, _t is a learned vector of n_d convex-combination coefficients and _t is a reset gate. At each time step, a convex combination of delayed states is formed according to _t; units of this combination are reset according to _t; and finally the typical linear layer and nonlinearity are applied.



§ EXPERIMENTS



Here we compare MIST RNNs to simple RNNs, LSTM, and Clockwork RNNs. We begin with the sequential permuted MNIST task and the copy problem, synthetic tasks that were introduced to explicitly test RNNs for their ability to learn long-term dependencies <cit.>. Next we move on to 3 tasks for which it is plausible that very long-term dependencies play a role: recognizing surgical maneuvers from robot kinematics, recognizing phonemes from speech, and classifying activities from smartphone motion data. We note that for all architectures involved, many variations can be applied (variational dropout, layer normalization, zoneout, etc.). We keep experiments manageable by comparing architectures without such variations.



 §.§ Sequential pMNIST Classification



The sequential MNIST task <cit.> consists of classifying 28x28 MNIST images <cit.> as one of 10 digits, by scanning pixel by pixel – left to right, top to bottom – and emitting a label upon completion. Sequential pMNIST <cit.> is a challenging variant where a random permutation of pixels is chosen and applied to all images before classification. LSTM with 100 hidden units is used as a baseline, with hidden unit counts for other architectures chosen to match the number of parameters. Means and standard deviations are computed using the top 5 randomized trials out of 50 (ranked according to performance on the validation set), with random learning rates and initializations. Additional experimental details can be found in the appendix.

Test error rates are shown in Table <ref>. Here, MIST RNNs outperform simple RNNs, LSTM, and Clockwork RNNs by a large margin. We remark that our LSTM error rates are consistent with best previously-reported values, such as the error rates of 9.8% in <cit.> and 12% in <cit.>, which also use 100 hidden units. One may also wonder if the difference in performance is due to hidden-unit counts. To test this we also increased the LSTM hidden unit count to 139 (to match MIST RNNs), and continued to increase the capacity of each model further. MIST RNNs significantly outperform LSTM in all cases.

We also used this task to visualize gradient magnitudes as a function of τ (the distance from the loss which occurs at time t = 784). Gradient norms for all methods were averaged over a batch of 100 random examples early in training; see Figure <ref>. Here we can see that simple RNNs and LSTM capture essentially no learning signal from steps that are far from the loss. To validate this claim further, we repeated the 512-unit LSTM and MIST RNN experiments, but using only the last 200 permuted pixels (rather than all 784). LSTM performance remains the same (7.4% error, within 1 standard deviation) whereas MIST RNN performance drops by 15 standard deviations (6.0% error).









 §.§ The Copy Problem



The copy problem is a synthetic task that explicitly challenges a network to store and reproduce information from the past. Our setup follows <cit.>, which is in turn based on <cit.>. An input sequence begins with L relevant symbols to be copied, is followed by a delay of D - 1 special blank symbols and 1 special go symbol, and ends with L additional blank symbols. The corresponding target sequence begins with L + D blank symbols and ends with a copy of the relevant symbols from the inputs (in the same order). We run experiments with copy delays of D = 50, 100, 200, and 400. LSTM with 100 hidden units is used as a baseline, with hidden unit counts for other architectures chosen to match the number of parameters. Additional experimental details can be found in the appendix.

Results are shown in Figure <ref>, showing validation curves of the top 5 randomized trials out of 50, with random learning rates and initializations. With a short copy delay of D = 50, we can see that all methods other than Clockwork RNNs can solve the task in a reasonable amount of time. However, as the copy delay D is increased, we can see that simple RNNs and LSTM become unable to learn a solution, whereas MIST RNNs are relatively unaffected. We also note that our LSTM results are consistent with those in <cit.>.

Note that Clockwork RNNs are expected to fail for large delays (for example, the second symbol can only be seen by the highest-frequency partition, so learning to copy this symbol will fail for precisely the same reason that simple RNNs fail). However, here they also fail for short delays, which is surprising because the high-speed partition resembles a simple RNN. We hypothesized that this failure is due to hidden unit counts / parameter counts: here, the high-frequency partition is allocated only 256 / 8 = 32 hidden units. To test this hypothesis, we reran the Clockwork RNN experiments with 1024 hidden units, so that 128 are allocated to the high-frequency partition. Indeed, under this configuration (with 10x as many parameters), Clockwork RNNs do solve the task for a delay of D = 50 and fail to solve the task for all higher delays, thus behaving like simple RNNs.



 §.§ Surgical Maneuver Recognition



Here we consider the task of online surgical maneuver recognition using the MISTIC-SL dataset <cit.>. Maneuvers are fairly long, high-level activities; examples include suture throw and knot tying. The dataset was collected using a da Vinci, and the goal is to map robot kinematics over time (e.g., x, y, z) to gestures over time (which are densely labeled as 1 of 4 maneuvers on a per-frame basis). We follow <cit.>, which achieves state-of-the-art performance on this task, as closely as possible, using the same kinematic inputs, test setup, and hyperparameters; details can be found in the original work or in the appendix. The primary difference is that we replace their LSTM layer with our layers. Results are shown in Table <ref>. Here MIST RNNs match LSTM performance (with half the number of parameters).



 §.§ Phoneme Recognition



Here we consider the task of online framewise phoneme recognition using the TIMIT corpus <cit.>. Each frame is originally labeled as 1 of 61 phonemes. We follow common practice and collapse these into a smaller set of 39 phonemes <cit.>, and we include glottal stops to yield 40 classes in total. We follow <cit.> for data preprocessing and <cit.> for training, validation, and test splits. LSTM with 100 hidden units is used as a baseline, with hidden unit counts for other architectures chosen to match the number of parameters. Means and standard deviations are computed using the top 5 randomized trials out of 50 (ranked according to performance on the validation set), with random learning rates and initializations. Other experimental details can be found in the appendix. Table <ref> shows that LSTM and MIST RNNs perform nearly identically, which both outperform simple RNNs and Clockwork RNNs.



 §.§ Activity Recognition from Smartphones



Here we consider the task of sequence classification from smartphones using the MobiAct (v2.0) dataset <cit.>. The goal is to classify each sequence as jogging, running, sitting down, etc., using smartphone motion data over time. Approximately 3,200 sequences were collected from 67 different subjects. We use the first 47 subjects for training, the next 10 for validation, and the final 10 for testing. Means and standard deviations are computed using the top 5 randomized trials out of 50 (ranked according to performance on the validation set), with random learning rates and initializations. Other experimental details can be found in the appendix. Results are shown in Table <ref>. Here, MIST RNNs outperform all other methods, including LSTM and LSTM^+, a variant with the same number of hidden units and twice as many parameters.







§ CONCLUSIONS AND FUTURE WORK



In this work we analyzed NARX RNNs and introduced a variant which we call MIST RNNs, which 1) exhibit superior vanishing-gradient properties in comparison to LSTM and previously-proposed NARX RNNs; 2) improve performance substantially over LSTM on tasks requiring very long-term dependencies; and 3) require even fewer parameters and computation than LSTM. One obvious direction for future work is the exploration of other NARX RNN architectures with non-contiguous delays. In addition, many recent techniques that have focused on LSTM are immediately transferable to NARX RNNs, such as variational dropout <cit.>, layer normalization <cit.>, and zoneout <cit.>, and it will be interesting to see if such enhancements can improve MIST RNN performance further.



  §.§.§ Acknowledgments


This work was supported by the Technische Universität München – Institute for Advanced Study, funded by the German Excellence Initiative and the European Union Seventh Framework Programme under grant agreement 291763, and by the National Institutes of Health, grant R01-DE025265.


iclr2018_workshop



§ APPENDIX: GRADIENT COMPONENTS AS PATHS


Here we will apply Equation <ref> repeatedly to associate gradient components with paths connecting t - τ to t, beginning with Equation <ref> and handling simple RNNs and simple NARX RNNs in order. Applying Equation <ref> to expand _t_t-τ, we obtain

    _t_t-τ = ∑_t ≥ t' > t - τ_t_t'_t'_t-τ




  §.§.§ Simple RNNs


For simple RNNs, by examining Equation <ref>, we can immediately see that all partials _t'_t-τ are 0 except for the one satisfying t' = t - τ + 1. This yields

    _t_t-τ = _t_t-τ+1_t-τ+1_t-τ

Now, by applying Equation <ref> again to _t_t-τ+1, and then to _t_t-τ+2, and so on, we trace out a path from t - τ to t, as shown in Figure <ref>, finally resulting the single term

    _t_t-1⋯_t-τ+2_t-τ+1_t - τ + 1_t-τ

which is associated with the only path from t - τ to t, with one factor for each edge that is encountered along the path.



  §.§.§ Simple NARX RNNs and General NARX RNNs


Next we consider simple NARX RNNs, again by expanding Equation <ref>. From Equation <ref>, we can see that up to n_d partials are now nonzero, and that any particular partial _t'_t-τ is nonzero if and only if t' > t - τ and t' and t - τ share an edge. Collecting these t' as the set V_t - τ = {t': t' > t - τ (t-τ, t') ∈ E}, we can write

    _t_t-τ = ∑_t' ∈ V_t - τ_t_t'_t'_t-τ

We can then apply this exact same process to each _t_t'; by defining V_t' = {t”: t” > t'  (t', t”) ∈ E} for all t', we can write

    _t_t-τ = ∑_t' ∈ V_t - τ∑_t”∈ V_t'_t_t”_t”_t'_t'_t-τ

By continuing this process until only partials remain, we obtain a summation over all possible paths from t - τ to t. Each term in the sum is a product over factors, one per edge:

    _t_t”'^⋯⋯_t”_t'_t'_t-τ


The analysis is nearly identical for general NARX RNNs, with the only difference being the specific sets of edges that are considered.



§ APPENDIX: EXPERIMENTAL DETAILS




 §.§ General Experimental Setup



Everything in this section holds for all experiments except surgical maneuver recognition, as in that case we mimicked <cit.> as closely as possible, as described above.

All weight matrices are initialized using a normal distribution with a mean of 0 and a standard deviation of 1 / √(n_h), where n_h is the number of hidden units. All initial hidden states (for t < 1) are initialized to 0. For optimization, gradients are computed using full backpropagation through time, and we use stochastic gradient descent with a momentum of 0.9, with gradient clipping as described by <cit.> at 1, and with a minibatch size of 100. Biases are generally initialized to 0, but we follow best practice for LSTM by initializing the forget-gate bias to 1 <cit.>. For Clockwork RNNs, 8 exponential periods are used, as in the original paper. For MIST RNNs, 8 delays are used. We avoid manual learning-rate tuning in its entirety. Instead we run 50 trials for each experimental configuration. In each trial, the learning rate is drawn uniformly at random in log space between 10^-4 and 10^1, and initial weight matrices are also redrawn at random. We report results over the top 10% of trials according to validation-set error. (An alternative option is to report results over all trials. However, because the majority of trials yields bad performance for all methods, this simply blurs comparisons. See for example Figure 3 of <cit.>, which compares these two options.)



 §.§ Sequential pMNIST Classification


Data preprocessing is kept minimal, with each input image individually shifted and scaled to have mean 0 and variance 1. We split the official training set into two parts, the first 58,000 used for training and the last 2,000 used for validation. Our test set is the same as the official test set, consisting of 10,000 images. Training is carried out by minimizing cross-entropy loss.



 §.§ Copy Problem: Experimental Details


In our experiments, the L relevant symbols are drawn at random (with replacement) from the set {0, 1, …, 9}; D is always a multiple of 10; and L is chosen to be D / 10. This way the simplest baseline of always predicting the blank symbol yields a constant error rate for all experiments. No input preprocessing of any kind is performed. In each case, we generate 100,000 examples for training and 1,000 examples for validation. Training is carried out by minimizing cross-entropy loss.



 §.§ Surgical Activity Recognition: Experimental Details


We use the same experimental setup as <cit.>, which currently holds state-of-the-art performance on these tasks. For kinematic inputs we use positions, velocities, and gripper angles for both hands. We also use their leave-one-user-out teset setup, with 8 users in the case of JIGSAWS and 15 users in the case of MISTIC-SL. Finally we use the same hyperparameters: 1 hidden layer of 1024 units; dropout with p = 0.5; 80 epochs of training with a learning rate of 1.0 for the first 40 epochs and having the learning rate every 5 epochs for the rest of training. As mentioned in the main paper, the primary difference is that we replaced their LSTM layer with our simple RNN, LSTM, or MIST RNN layer. Training is carried out by minimizing cross-entropy loss.



 §.§ Phoneme Recognition: Experimental Details


We follow <cit.> and extract 12 mel frequency cepstral coefficients plus energy every 10ms using 25ms Hamming windows and a pre-emphasis coefficient of 0.97. However we do not use derivatives, resulting in 13 inputs per frame. Each input sequence is individually shifted and scaled to have mean 0 and variance 1 over each dimension. We form our splits according to <cit.>, resulting in 3696 sequences for training, 400 sequences for validation, and 192 sequences for testing. Training is carried out by minimizing cross-entropy loss. Means and standard deviations are computed using the top 5 randomized trials out of 50 (ranked according to performance on the validation set).



 §.§ Activity Recognition from Smartphones


In <cit.>, emphasis was placed on hand-crafted features, and each subject was included during both training and testing (with no official test set defined). We instead operate on the raw sequence data, with no preprocessing other than sequence-wise centering and scaling of inputs, and we define train, val, test splits so that subjects are disjoint among the three groups.

