IndyLSTMs: Independently Recurrent LSTMs

TL;DR

IndyLSTMs are a new type of recurrent neural network cell with diagonal recurrent weights, leading to smaller, faster models that outperform traditional LSTMs in accuracy and overfitting resistance across multiple handwriting datasets.

Contribution

This paper introduces IndyLSTMs, a novel recurrent cell with diagonal recurrent weights, reducing parameters and FLOPS while improving performance over standard LSTMs.

Findings

IndyLSTMs outperform regular LSTMs in accuracy per parameter.

IndyLSTMs are less prone to overfitting.

Models with IndyLSTMs are smaller and faster.

Abstract

We introduce Independently Recurrent Long Short-term Memory cells: IndyLSTMs. These differ from regular LSTM cells in that the recurrent weights are not modeled as a full matrix, but as a diagonal matrix, i.e.\ the output and state of each LSTM cell depends on the inputs and its own output/state, as opposed to the input and the outputs/states of all the cells in the layer. The number of parameters per IndyLSTM layer, and thus the number of FLOPS per evaluation, is linear in the number of nodes in the layer, as opposed to quadratic for regular LSTM layers, resulting in potentially both smaller and faster models. We evaluate their performance experimentally by training several models on the popular \iamondb and CASIA online handwriting datasets, as well as on several of our in-house datasets. We show that IndyLSTMs, despite their smaller size, consistently outperform regular LSTMs both in terms of accuracy per parameter, and in best accuracy overall. We attribute this improved performance to the IndyLSTMs being less prone to overfitting.

Figures

Tables

Table 1. TABLE I: Character Error Rate (CER) of best models trained using our in-house datasets for the languages in [ 11 ] . The first pair of columns show the CER reported and model architecture used therein. The final two columns contain the CER of the best IndyLSTM model over different depth × \times width combinations corresponding to roughly the same number of parameters as the original LSTM model, and over different dropout rates.

	LSTM in [11]		best IndyLSTM
Language	CER [%]	model	CER [%]	model
en	6.48	5$\times$224 (0.5)	6.25	9$\times$201 (0.3)
de	5.40		4.97
es	4.56		4.69
ar	7.87	5$\times$160 (0.5)	6.7	6$\times$181 (0.3)
ko	6.79	5$\times$160 (0.5)	6.65	9$\times$146 (0.2)
th	1.78	5$\times$128 (0.5)	1.6	5$\times$162 (0.4)
hi	7.42	5$\times$192 (0.5)	7.14	6$\times$218 (0.5)
zh	1.39	4$\times$192 (0.5)	1.27	9$\times$166 (0.3)

Equations

$${\mathbf{h}}_t=\sigma \left(\mathbf{W}{\mathbf{x}}_t+\mathbf{U}{\mathbf{h}}_{t-1}+\mathbf{b}\right)$$

$${\mathbf{h}}_t=\sigma \left(\mathbf{W}{\mathbf{x}}_t+\mathbf{u}\odot {\mathbf{h}}_{t-1}+\mathbf{b}\right)$$

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

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

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

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

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

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

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

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

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

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

Full text

We evaluate their performance experimentally by training several models on the popular IAM-OnDB and CASIA online handwriting datasets, as well as on several of our in-house datasets. We show that IndyLSTMs, despite their smaller size, consistently outperform regular LSTMs both in terms of accuracy per parameter, and in best accuracy overall. We attribute this improved performance to the IndyLSTMs being less prone to overfitting.

I Introduction

In this paper we introduce Independently Recurrent Long-Short-term Memory cells, i.e. IndyLSTMs. IndyLSTMs are a variation on Long Short-term Memory (LSTM) Cell neural networks [1] where individual units within a hidden layer are not interconnected across time-steps – inspired by the IndRNN architecture [2]. We are using IndyLSTMs for the task of Online Handwriting Recognition, where given a user input in the form of an ink, i.e. a sequence of touch points, the task is to output the textual interpretation of this input.

Online handwriting recognition is gaining importance for two main reasons: (a) Stylus-based input is gaining importance on tablet devices, e.g. the iPad Pro111https://www.apple.com/ipad-pro/, Microsoft Surface devices222https://www.microsoft.com/en-us/store/b/surface, and Chromebooks with styluses333https://store.google.com/product/google_pixelbook; (b) an increasing number of users world-wide obtaining access to computing devices, many of whom are using scripts that are not as easy to type as English and thus handwriting is a useful means to enter text in their native language and script.

Furthermore, online handwriting recognition systems ideally run on the users’ computing device and thus efficiency in terms of memory consumption and compute power are important features. We show experimentally that the proposed IndyLSTM models are not only smaller and faster but also are able to obtain better recognition results because they are easier to train and less prone to overfitting.

Related work: Long short-term memory (LSTM)-based neural networks have become the de facto standard for sequence modelling because they are easy to train and give good results [3]. Several other recurrent network cells have been proposed [4, 5, 6, 7, 8] and more recently, the idea of an IndRNN [2] has been proposed. The IndRNN cell is based on the standard RNN cell, but removes the connection between different cells in the same layer from one layer to the next. We base this work on the same ideas as the IndRNN work, but apply it to the more commonly used LSTM cell.

II IndyLSTMs

The updates in regular Recurrent Neural Networks (RNN) [9] can be described as:

[TABLE]

where $\mathbf{x}_{t}$ and $\mathbf{h}_{t}$ are vector representing the input and hidden state of the network at time $t$, respectively, $\sigma$ is an activation function, e.g. $\tanh$, and the matrices $\mathbf{W}$ and $\mathbf{U}$, as well as the bias vector $\mathbf{b}$, are parameters of the RNN layer.

Equation 1 can be interpreted as every element of the output/hidden state $\mathbf{h}_{t}$ being a non-linear function of a linear combination of all the inputs $\mathbf{x}_{t}$, plus a linear combination of all the previous outputs/hidden states $\mathbf{h}_{t-1}$.

Similarly, the updates to IndRNNs are described as:

[TABLE]

where $\mathbf{u}\odot\mathbf{h}_{t}$ is the elementwise product of the coefficient vector $\mathbf{u}$ with the previous outputs/hidden states $\mathbf{h}_{t-1}$, which replaces the matrix-vector product $\mathbf{U}\mathbf{h}_{t-1}$ in Equation 1. This is equivalent to requiring the matrix $\mathbf{U}$ to be diagonal.

Equation 2 can be interpreted as every element of the ouput/hidden state $\mathbf{h}_{t}$ being a non-linear function of a linear combination of all the inputs $\mathbf{x}_{t}$, plus the element’s own previous output/hidden state in $\mathbf{h}_{t-1}$. In other words, each output relies only on it’s own previous state, and not on that of the other states in the same layer.

Similarly to the approch in IndRNNs, we start with the updates in a Long-Short Term Memory (LSTM) layer [1]:

[TABLE]

where $\mathbf{c}_{t}$ is the cell state vector, and $\mathbf{f}_{t}$, $\mathbf{i}_{t}$, and $\mathbf{o}_{t}$ are the forget, input, and output activation vectors, respectively, and $\sigma_{[g|c|h]}$ are activation functions. For inputs of length $n$ and $m$ cells, the matrices $\mathbf{W}_{[f|i|o|c]}$ of size $m\times n$, and $\mathbf{U}_{[f|i|o|c]}$ of size $m\times m$, along with the bias vectors $\mathbf{b}_{[f|i|o|c]}$ of length $m$, are the parameters of the LSTM layer. Similarly to the RNN, each element of output/hidden state depends on all the entries of the input vector $\mathbf{x}_{t}$, as well as all the entries of the previous outputs and hidden states in $\mathbf{h}_{t-1}$ and $\mathbf{c}_{t-1}$, respectively.444Note that although the cell states $\mathbf{c}_{t-1}$ are only used element-wise in each update, they are used to compute the outputs $\mathbf{h}_{t-1}$, which are used across the entire layer.

We then re-write Equation 3 as:

[TABLE]

where we replace the matrix-vector products $\mathbf{U}_{[f|i|o|c]}\mathbf{h}_{t-1}$ with the element-wise products $\mathbf{u}_{[f|i|o|c]}\odot\mathbf{h}_{t-1}$, where $\mathbf{u}_{[f|i|o|c]}$ are vectors of length $m$. As with the IndRNNs, each element of output/hidden state depends on all the entries of the input vector $\mathbf{x}_{t}$, as well as only its own previous output and hidden state $\mathbf{h}_{t-1}$ and $\mathbf{c}_{t-1}$, respectively. In other words, each output relies only on it’s own state, and not on that of all the states in the layer. We refer to Equation 4 as Independent Long Short-Term Memory (IndyLSTM) units.555We chose the name IndyLSTM over IndLSTM, and other potentially more precise abbreviations, simply because we were teenagers in the nineties, and Grunge fans to this day, and so to us it sounds cooler.

For an LSTM layer with $n$ inputs and $m$ outputs, the number of parameters is $4mn+4m^{2}+4m=4m(n+m+1)$, which are the sizes of the matrices $\mathbf{W}_{[f|i|o|c]}$ and $\mathbf{U}_{[f|i|o|c]}$, and the bias vectors $\mathbf{b}_{[f|i|o|c]}$, respectively. For an IndyLSTM layer with $n$ inputs and $m$ outputs, the number of parameters is $4mn+4m+4m=4m(n+2)$, which are the size of the matrices $\mathbf{W}_{[f|i|o|c]}$, and the vectors $\mathbf{u}_{[f|i|o|c]}$ and $\mathbf{b}_{[f|i|o|c]}$, respectively. Since the computational cost of evaluating Equations 3 and 4 are linear in the number of parameters, i.e. each parameter corresponds roughly to a single multiply-add operation, the cost of evaluating a single step in an IndyLSTM layer is roughly $n/(n+m)$ times smaller than for regular LSTMs666Our implementation of IndyLSTM is available as tf.contrib.rnn.IndyLSTMCell in TensorFlow 1.10.0 [10]..

In the following sections, we quantify how IndyLSTMs compare to regular LSTMs in terms of model accuracy over size, and by extension speed, and in terms of accuracy overall.

III Experimental setup

We use online handwriting recognition [11] as a model problem to compare IndyLSTMs to regular LSTMs, using publicly available datasets.

The end-to-end model architecture we use is the same as the one described in [11], i.e. one or more layers of bi-directional LSTM/IndyLSTM of the same width, followed by a single softmax layer. We convert the handwriting input, which is a sequence of raw touch points, to a sequence of Bézier curves as described in [11] and use them as inputs to the model, and Connectionist Temporal Classification (CTC) [12] to convert the sequence of softmax outputs to a sequence of characters.

The models are trained with a batch size of 8, on 10 parallel replicas, using the Adam Optimizer [13] with a fixed learning rate of $0.0001$. All weight matrices are initialized using the Glorot uniform initializer [14], all bias vectors were initialized to zero, and the IndyLSTM weights $\mathbf{u}_{[f|i|o|c]}$ were initialized with uniform random values in $[-1,1]$. Random dropout [15] is applied to the outputs of each LSTM/IndyLSTM layer. Training is stopped after 5 M steps without improvement on the validation data.

For each dataset, we train models varying:

• •

The recurrent bi-directional layer type, using either LSTMs or IndyLSTMs,

• •

The number of layers in $\{3,\dots,9\}$,

• •

The width of the layers in $\{32,\dots,256\}$, in increments of $32$,

• •

The dropout rate on the LSTM/IndyLSTM layer outputs during training in $\{0,\dots,0.6\}$ in increments of $0.1$, and up to $0.7$ in cases where the best results were obtained with $0.6$.

and compare them in terms of Character Error Rate (CER) versus model size.

Although some of the models might have benefited from varying a number of other hyper-parameters, we choose the current simple setup for the sake of experimental clarity.

The bulk of our experiments were run on the IAM-OnDB and CASIA datasets described below.

III-A IAM-OnDB

The IAM-OnDB dataset [16] is the most used evaluation dataset for online handwriting recognition. It consists of 298 523 characters in 86 272 word instances from a dictionary of 11 059 words using 79 different characters written by 221 writers. We use the standard IAM-OnDB dataset separation: one training set and a test set containing 5 363 and 3 859 written lines, respectively. The reported CER is the error rate computed over the test set.

III-B CASIA

The ICDAR-2013 Competition for Online Handwriting Chinese Character Recognition [17] introduced a dataset for classifying the most common Chinese characters. Following the experimental setup in [18], the dataset used for training is the CASIA database [19], which contains 2 693 183 samples for training and 224 590 samples for testing, produced by different writers. The number of character classes is 3 755.

Note that although our model is fully capable of recognizing character sequences, the CASIA training and test data consists of only single characters.

III-C In-house data and models

In order to compare our results to those presented in [11], we also train several models using our in-house datasets, which consist of data collected through prompting, commercially available data, artificially inflated data, and labeled/self-labeled anonymized recognition requests (see [20] for a more detailed description).

For each language, we train IndyLSTM models with 3–9 layers each, where the layer widths are chosen such that the resulting number of parameters is at most equal to that of the original LSTM-based models they are compared against. E.g. since the production Latin recognizer in [11] is a 5$\times$224 LSTM-based model with 5 378 088 parameters777This value is slightly larger than the 5 281 061 reported in [11] since we have, since then, slightly increased the size of the recognized Latin alphabet to accommodate new languages., we train IndyLSTM-based models with 3$\times$398, 4$\times$327, 5$\times$284, 6$\times$254, 7$\times$232, 8$\times$215, and 9$\times$201 configurations. As with the other experiments, we vary the dropout rate in the range $\{0,\dots,0.5\}$ in increments of $0.1$.

IV Results and discussion

IV-A IAM-OnDB

Figure 2 shows the results for the best models, in terms of CER over the respective test set, per number of parameters trained on the IAM-OnDB and CASIA datasets. The full set of results can be seen in Appendix A.

On the IAM-OnDB datasets, over all model widths and depths, the IndyLSTMs out-performed the LSTMs with respect to CER vs. number of parameters, as well as in terms of accuracy overall. Additionally, the IndyLSTMs consistently out-perform the LSTMs with respect to CER vs. depth and width, i.e. the 9$\times$160 IndyLSTM model with lowest CER out-performs the 9$\times$160 LSTM model with lowest CER, despite the former having only two thirds as many parameters as the latter.

The best-performing model, with a CER of 4.01%, is the 9$\times$256 IndyLSTM (8.5 M parameters), i.e. the deepest and widest architecture we tested, trained with a dropout rate of 0.6. This beats the previously reported comparable state-of-the-art result in [11] using a 5$\times$64 LSTM and obtaining a CER of 5.9% without the use of language models and other feature functions. The best 5$\times$64 IndyLSTM in this work obtains a CER of 5.15%, thus also beating the previous state-of-the-art.

For comparison, we also evaluated the best-performing IndyLSTM model with the feature functions described in [11], namely

• •

Character Language Model: A 7-gram language model over Unicode codepoints from a large web-mined text corpus using stupid back-off [21] and pruned to 10 million 7-grams.

• •

Word Language Model: We also use a word-based language model trained on a similar corpus [22, 23], using 3-grams pruned to 1.25 million entries.

• •

Character Classes: We add a scoring heuristic which boosts the score of characters from the language’s alphabet, e.g. numbers, upper-case letters, punctuation, etc.

The feature function weights are trained using the Google Vizier service and its default algorithm, specifically batched Gaussian process bandits, and expected improvement as the acquisition function [24]. We run 7 Vizier studies, each performing 500 individual trials, and then pick the configuration that performed best across all trials. The resulting recognizer obtains a CER of 2.91%, which is significantly better than the current state of the art using feature functions of 4.0% in [11].

IV-B CASIA

Over almost the entire range of model sizes (Figure 2, bottom), the IndyLSTMs outperform the LSTMs in terms of accuracy over number of parameters, as well as in terms of accuracy overall. The 6$\times$256 IndyLSTM model, trained with a dropout rate of $0.4$, obtained the lowest CER of 2.43%. This is 14% better than the best CER of 2.82% obtained by the 5$\times$224 LSTM-based model (6.9 M parameters), trained with a dropout rate of $0.4$.

The best IndyLSTM models still fails to beat the current state of the art CER of 1.95% in [18] obtained with an ensemble model with 20.5M parameters and input sub-sequence sampling. The latter model, however, used several data augmentation techniques for training and inference that were not used in our own experiments.

IV-C In-house data and models

Following the procedure in Section III-C, we train IndyLSTM-based models of different depths and widths for English (en), German (de), Spanish (es), Arabic (ar), Korean (ko), Thai (th), Devanagari (hi), and Chinese (zh). Table I compares the best IndyLSTM models, in terms of CER over our test sets, with the corresponding results in [11], which were all trained with a dropout rate of $0.5$, as well as the best LSTM-based models re-trained varying the dropout rate.

In all cases, the best IndyLSTM models out-perform the original LSTM models, despite having at most as many parameters. The best IndyLSTM models are neither consistently the deepest nor the widest, and the optimal dropout rate varies from model to model.

Figure 3 shows in detail the CER for the English-language (en) LSTM and IndyLSTM models. With the exception of the 3-layer IndyLSTM model, all models perform more or less in the same range of accuracy, and the differences between one model and another are smaller than the differences due to the different dropout rates within the same model.

IV-D Speed

On the IAM-OnDB data, over all model sizes and dropout ratios, the IndyLSTMs required roughly 1.8 more epochs to train than the regular LSTM models of the same depth and width. For the CASIA data set, and our own data sets, the number of training steps was roughly equal over all model sizes and dropout ratios.

In order to verify how the size differences affect the inference speed, we implemented the IndyLSTM layer in TensorFlow [10] analogously to the BasicLSTMLayer therein and ran the models trained over the IAM-OnDB dataset through TensorFlow’s benchmark_model tool. Over all model sizes, the IndyLSTMs were roughly 20% faster than their LSTM counterparts, on average, despite containing roughly 37% fewer parameters, on average. We attribute this difference in performance to overheads within TensorFlow, e.g. the 3$\times$128 LSTM model spends less than 22% of the total time in the MatMul op, which constitutes the bulk of the computation, while the Merge, Const and Select ops make up for 24% of the total time.

V Conclusions

We introduce IndyLSTMs, an independently-recurrent variant of the well-known LSTM recursive neural networks, and compare their accuracy on both academic datasets, and our in-house production datasets.

Our experiments show that, over a wide range of online handwriting recognition tasks, IndyLSTMs outperform the LSTMs in terms of accuracy over number of parameters, as well as in terms of accuracy overall. In many cases, IndyLSTM models outperform LSTM models with the same depth and width, and thus $\sim$50% more parameters.

Furthermore, the IndyLSTM models presented herein establish new state of the art results on the IAM-OnDB dataset, both with and without the use of feature functions. The results are not just restricted academic datasets such as IAM-OnDB and CASIA; on our in-house datasets, the IndyLSTM models consistently out-performed their production LSTM counterparts. Due to their better accuracy, smaller size, and faster execution, IndyLSTMs are interesting models for on-device inference, where resource consumption is often a limiting factor.

We attribute this improved accuracy to IndyLSTMs being less prone to overfitting than regular LSTMs. Figure 4 shows the evolution of the CER computed over the IAM-OnDB test data and the training loss for the 3$\times$96 LSTM model (541 520 parameters), and the 3$\times$96 and 3$\times$128 IndyLSTM models (322 640 and 561 232 parameters, respectively). The 3$\times$128 IndyLSTM was chosen since it has roughly as many parameters as the 3$\times$96 LSTM. All three models were trained with a dropout rate of 0.5, which produced the best result for each architecture. After $\sim$200k steps, the LSTM model’s training loss stops decreasing and starts increasing while the training loss all but vanishes, i.e. the model overfits to the training data. The IndyLSTM models, on the other hand, do not seem to overfit, i.e. the test error decreases monotonically while the training loss levels off after $\sim$1M steps.

The overfitting hypothesis is also supported by comparing our in-house English-language data results to the IAM-OnDB results. The datasets differ in that the former is more than 10$\times$ larger than the latter.888Although our in-house data supports a larger alphabet (313 symbols, all characters for all Latin script-based languages), the bulk of the data consist of the same 79 symbols used in the IAM-OnDB data. Given the order of magnitude size difference, overfitting should be much less likely to occur with our in-house training datasets than with the IAM-OnDB dataset, and the advantage of using IndyLSTMs over LSTMs should be smaller. This is effectively the case: on the IAM-OnDB data, IndyLSTMs consistently out-perform their LSTM counterparts for the same architecture and models with roughly the same number of parameters differ by 5–20% (see Figure 2), whereas on our in-house data, the 5$\times$224 IndyLSTM model does not out-perform the 5$\times$224 LSTM model (see Figure 3), and the (best) 9$\times$201 IndyLSTM model with the same number of parameters is only 3.5% better than the LSTM model (see Table I).

Unfortunately, at this point we can only speculate as to why the IndyLSTMs are less prone to overfitting than LSTMs, even for models with the same number of parameters.

We hypothesize that it is the difference in model complexity that make the IndyLSTM less likely to overfit than LSTMs. The number of parameters is, in this case, a poor measure for model complexity, since as shown in Figure 4, the 3$\times$128 IndyLSTM has slightly more parameters than the 3$\times$96 LSTM, but does not overfit. We therefore assume that it is the number of connections which make the difference: as pointed out in Section II, the output of every node in an IndyLSTM layer depends only on the input and the node’s previous output and hidden state, whereas the output every node in an LSTM layer depends on the input and the previous output and hidden state of every other node in the layer. These additional connections allow the LSTM layers to much better adapt to the data, which, in the use cases studied herein, only leads to overfitting.

Acknowledgments

The authors would like to thank Victor Carbune, Henry Rowley, and Yasuhisa Fuji for their valuable input on both the methods presented here, as well as on the manuscript itself.

Appendix A Detailed results

Figure 5 shows the CER versus the number of parameters for each model trained on both the IAM-OnDB and CASIA datasets.

Appendix B Optimal dropout rate

Given the large number of experiments run over a wide range of models and dropout rates, we provide some additional data and analysis on the optimal dropout rate. Figures 6 and 7 show the effect of the dropout rate on CER for both the IAM-OnDB and CASIA datasets using both IndyLSTMs and LSTMs, as a function of model width and model depth, respectively.

Figure 6 shows the CER as a function of the dropout rate for both IndyLSTMs and LSTMs trained on both the IAM-OnDB and CASIA datasets, for models with a fixed depth of six layers and varying layer widths. In all four setups, the optimal dropout rate increases with the layer width, e.g. for IndyLSTMs trained on the CASIA data, the optimal dropout rate is zero for the 6$\times$32 models, 0.1 for the 6$\times$64 models, and increases up to 0.4 with increasing layer width. The range in which the optimal dropout rate varies is larger for the IndyLSTM models than for the LSTM models.

Analogously, Figure 7 shows the same results, yet varying the model depth using a fixed width of 160 nodes in each layer. Although there is some indication that deeper models require higher dropout rates, the effect is restricted to 3–5 layers, and less obvious than those varying the width.

Finally, Figure 3, which varies both model width and depth, does not show a large variation in the optimal dropout rate, which varies between $0.2$ and $0.3$.

The results are not sufficiently consistent as to provide concrete guidance on how to select the optimal dropout rate, but the overall impact of the dropout rates do make clear that this is a hyperparameter that deserves some consideration and experimentation.