Kronecker Recurrent Units
Abstract
Our work addresses two important issues with recurrent neural networks: (1) they are overparametrized, and (2) the recurrent weight matrix is illconditioned. The former increases the sample complexity of learning and the training time. The latter causes the vanishing and exploding gradient problem.
We present a flexible recurrent neural network model called Kronecker Recurrent Units (KRU). KRU achieves parameter efficiency in RNNs through a Kronecker factored recurrent matrix. It overcomes the illconditioning of the recurrent matrix by enforcing soft unitary constraints on the factors. Thanks to the small dimensionality of the factors, maintaining these constraints is computationally efficient.
Our experimental results on seven standard datasets reveal that KRU can reduce the number of parameters by three orders of magnitude in the recurrent weight matrix compared to the existing recurrent models, without trading the statistical performance.
These results in particular show that while there are advantages in having a high dimensional recurrent space, the capacity of the recurrent part of the model can be dramatically reduced.
Kronecker Recurrent Units
Cijo Jose 

Idiap Research Institute EPFL 
cijo.jose@idiap.ch 
Moustapha Cissé 

Facebook AI Research 
moustaphacisse@fb.com 
François Fleuret 

Idiap Research Institute EPFL 
francois.fleuret@idiap.ch 
1 Introduction
Deep neural networks have defined the stateoftheart in a wide range of problems in computer vision, speech analysis, and natural language processing (Krizhevsky et al., 2012; Hinton et al., 2012; Mikolov, 2012). However, these models suffer from two key issues. (1) They are overparametrized; thus it takes a very long time for training and inference. (2) Learning deep models is difficult because of the poor conditioning of the matrices that parametrize the model. These difficulties are especially problematic to recurrent neural networks. Indeed, the number of distinct parameters in RNNs grows as the square of the size of the hidden state conversely to convolutional networks which enjoy weight sharing. Moreover, poor conditioning of the recurrent matrices results in the gradients to explode or vanish exponentially fast along the time horizon. This problem prevents RNN from capturing longterm dependencies (Hochreiter, 1991; Bengio et al., 1994).
There exists an extensive body of literature addressing overparametrization in neural networks. LeCun et al. (1990) first studied the problem and proposed to remove unimportant weights in neural networks by exploiting the second order information. Several techniques which followed include lowrank decomposition (Denil et al., 2013), training a small network on the softtargets predicted by a big pretrained network (Ba & Caruana, 2014), low bit precision training (Courbariaux et al., 2014), hashing (Chen et al., 2015), etc. A notable exception is the deep fried convnets (Yang et al., 2015) which explicitly parametrizes the fully connected layers in a convnet with a computationally cheap and parameterefficient structured linear operator, the Fastfood transform (Le et al., 2013). These techniques are primarily aimed at feedforward fully connected networks and very few studies have focused on the particular case of recurrent networks (Arjovsky et al., 2016).
The problem of vanishing and exploding gradients has also received significant attention. Hochreiter & Schmidhuber (1997) proposed an effective gating mechanism in their seminal work on LSTMs. Later, this technique was adopted by other models such as the Gated Recurrent Units (GRU) (Chung et al., 2015) and the Highway networks (Srivastava et al., 2015) for recurrent and feedforward neural networks respectively. Other popular strategies include gradient clipping (Pascanu et al., 2013), and orthogonal initialization of the recurrent weights (Le et al., 2015). More recently (Arjovsky et al., 2016) proposed to use a unitary recurrent weight matrix. The use of norm preserving unitary maps prevent the gradients from exploding or vanishing, and thus help to capture longterm dependencies. The resulting model called unitary RNN (uRNN) is computationally efficient since it only explores a small subset of general unitary matrices. Unfortunately, since uRNNs can only span a reduced subset of unitary matrices their expressive power is limited (Wisdom et al., 2016). We denote this restricted capacity unitary RNN as RC uRNN. Full capacity unitary RNN (FC uRNN) (Wisdom et al., 2016) proposed to overcome this issue by parametrizing the recurrent matrix with a full dimensional unitary matrix, hence sacrificing computational efficiency. Indeed, FC uRNN requires a computationally expensive projection step which takes time ( being the size of the hidden state) at each step of the stochastic optimization to maintain the unitary constraint on the recurrent matrix. Mhammedi et al. (2016) in their orthogonal RNN (oRNN) avoided the expensive projection step in FC uRNN by parametrizing the orthogonal matrices using Householder reflection vectors, it allows a finegrained control over the number of parameters by choosing the number of Householder reflection vectors. When the number of Householder reflection vector approaches this parametrization spans the full reflection set, which is one of the disconnected subset of the full orthogonal set. Jing et al. (2017) also presented a way of parametrizing unitary matrices which allows finegrained control on the number of parameters. This work called as Efficient Unitary RNN (EURNN), exploits the continuity of unitary set to have a tunable parametrization ranging from a subset to the full unitary set.
Although the idea of parametrizing recurrent weight matrices with strict unitary linear operator is appealing, it suffers from several issues: (1) Strict unitary constraints severely restrict the search space of the model, thus making the learning process unstable. (2) Strict unitary constraints make forgetting irrelevant information difficult. While this may not be an issue for problems with nonvanishing long term influence, it causes failure when dealing with real world problems that have vanishing long term influence. Henaff et al. (2016) have previously pointed out that the good performance of strict unitary models on certain synthetic problems is because it exploits the biases in these datasets which favours a unitary recurrent map and these models may not generalize well to real world datasets. More recently Vorontsov et al. (2017) have also studied this problem of unitary RNNs and the authors found out that relaxing the strict unitary constraint on the recurrent matrix to a soft unitary constraint improved the convergence speed as well as the generalization performance.
Our motivation is to address the problems of existing recurrent networks mentioned above. We present a new model called Kronecker Recurrent Units (KRU). At the heart of KRU is the use of Kronecker factored recurrent matrix which provide an elegant way to adjust the number of parameters to the problem at hand. This factorization allows us to finely modulate the number of parameters required to encode matrices, from when using factors of size , to parameters when using a single factor of the size of the matrix itself. We tackle the vanishing and exploding gradient problem through a soft unitary constraint (Jose & Fleuret, 2016; Henaff et al., 2016; Cisse et al., 2017; Vorontsov et al., 2017). Thanks to the properties of Kronecker matrices (Van Loan, 2000), this constraint can be enforced efficiently. Please note that KRU can readily be plugged into vanilla real space RNN, LSTM and other variants inplace of standard recurrent matrices. However in case of LSTMs we do not need to explicitly enforce the approximate orthogonality constraints as the gating mechanism is designed to prevent vanishing and exploding gradients. Our experimental results on seven standard datasets reveal that KRU and KRU variants of real space RNN and LSTM can reduce the number of parameters drastically (hence the training and inference time) without trading the statistical performance. Our core contribution in this work is a flexible, parameter efficient and expressive recurrent neural network model which is robust to vanishing and exploding gradient problem.
The paper is organized as follows, in section 2 we restate the formalism of RNN and detail the core motivations for KRU. In section 3 we present the Kronecker recurrent units (KRU). We present our experimental findings in section 4 and section 5 concludes our work.
Input, hidden and output dimensions 
or , Input and hidden state at time 
or , or Prediction targets and RNN predictions at time 
Input, recurrent amd output weight matrices 
or or Hidden and output bias 
Pointwise nonlinear activation function and the loss function 
2 Recurrent neural network formalism
Table 1 summarizes some notations that we use in the paper. We consider the field to be complex rather than real numbers. We will motivate the choice of complex numbers later in this section. Consider a standard recurrent neural network (Elman, 1990). Given a sequence of input vectors: , at a time step RNN performs the following:
(1)  
(2) 
where is the predicted value at time step .
2.1 Over parameterization and computational efficiency
The total number of parameters in a RNN is , where is for real and for complex parametrizations. As we can see, the number of parameters grows quadratically with the hidden dimension, i.e., . We show in the experiments that this quadratic growth is an over parametrization for many real world problems. Moreover, it has a direct impact on the computational efficiency of RNNs because the evaluation of takes time and it recursively depends on previous hidden states. However, other components and can usually be computed efficiently by a single matrixmatrix multiplication for each of the components. That is, we can perform and , this is efficient using modern BLAS libraries. So to summarize, if we can control the number of parameters in the recurrent matrix , then we can control the computational efficiency.
2.2 Poor conditioning implies gradients explode or vanish
The vanishing and exploding gradient problem refers to the decay or growth of the partial derivative of the loss with respect to the hidden state i.e. as the number of time steps grows (Arjovsky et al., 2016). By the application of the chain rule, the following can be shown (Arjovsky et al., 2016):
(3) 
From Equation 3, it is clear that if the absolute value of the eigenvalues of deviates from 1 then may explode or vanish exponentially fast with respect to . So a strategy to prevent vanishing and exploding gradient is to control the spectrum of .
2.3 Why complex field?
Although Arjovsky et al. (2016) and Wisdom et al. (2016) use complex valued networks with unitary constraints on the recurrent matrix, the motivations for such models are not clear. We give a simple but compelling reason for complexvalued recurrent networks.
The absolute value of the determinant of a unitary matrix is . Hence in the real space, the set of all unitary (orthogonal) matrices have a determinant of or , i.e., the set of all rotations and reflections respectively. Since the determinant is a continuous function, the unitary set in real space is disconnected. Consequently, with the realvalued networks we cannot span the full unitary set using the standard continuous optimization procedures. On the contrary, the unitary set is connected in the complex space as its determinants are the points on the unit circle and we do not have this issue.
As we mentioned in the introduction (Jing et al., 2017) uses this continuity of unitary space to have a tunable continuous parametrization ranging from subspace to full unitary space. Any continuous parametrization in real space can only span a subset of the full orthogonal set. For example, the Householder parametrization (Mhammedi et al., 2016) suffers from this issue.
3 Kronecker recurrent units (KRU)
We consider parameterizing the recurrent matrix as a Kronecker product of matrices ,
(4) 
Where each and . ’s are called as Kronecker factors.
To illustrate the Kronecker product of matrices, let us consider the simple case when . This implies . And is recursevly defined as follows:
(5)  
(6) 
When the number of parameters is and the time complexity of hidden state computation is . When then and we will recover standard complex valued recurrent neural network. We can span every Kronecker representations in between by choosing the number of factors and the size of each factor. In other words, the number of Kronecker factors and the size of each factor give us finegrained control over the number of parameters and hence over the computational efficiency. This strategy allows us to design models with the appropriate tradeoff between computational budget and statistical performance. All the existing models lack this flexibility.
The idea of using Kronecker factorization for approximating Fisher matrix in the context of natutal gradient methods have recently received much attention. The algorithm was originally presented in Martens & Grosse (2015) and was later extended to convolutional layers (Grosse & Martens, 2016), distributed second order optimization (Ba et al., 2016) and for deep reinforcement learning (Wu et al., 2017). However Kronecker matrices have not been well explored as learnable parameters except (Zhang et al., 2015) used it’s spectral property for fast orthogonal projection and (Zhou et al., 2015) used it as a layer in convolutional neural networks.
3.1 Soft unitary constraint
Poor conditioning results in vanishing or exploding gradients. Unfortunately, the standard solution which consists of optimization on the strict unitary set suffers from the retention of noise over time. Indeed, the small eigenvalues of the recurrent matrix can represent a truly vanishing longterm influence on the particular problem and in that sense, there can be good or bad vanishing gradients. Consequently, enforcing strict unitary constraint (forcing the network to never forget) can be a bad strategy. A simple solution to get the best of both worlds is to enforce unitary constraint approximately by using the following regularization:
(7) 
Please note that these constraints are enforced on each factor of the Kronecker factored recurrent matrix. This procedure is computationally very efficient since the size of each factor is typically small. It suffices to do so because if each of the Kronecker factors are unitary then the full matrix is unitary (Van Loan, 2000) and if each of the factors are approximately unitary then the full matrix is approximately unitary.
This type of regularizer has recently been exploited for realvalued models. (Cisse et al., 2017) showed that enforcing approximate orthogonality constraint on the weight matrices make the network robust to adversarial samples as well as improve the learning speed. In metric learning (Jose & Fleuret, 2016) have shown that it better conditions the projection matrix thereby improving the robustness of stochastic gradient over a wide range of step sizes as well as the generalization performance. Henaff et al. (2016) and Vorontsov et al. (2017) have also used this soft unitary constraints on standard RNN after identifying the problems with the strict unitary RNN models. However the computational complexity of naively applying this soft constraint is . This is prohibitive for RNNs with large hidden state unless one considers a Kronecker factorization.
4 Experiments
Existing deep learning libraries such as Theano (Bergstra et al., 2011), Tensorflow (Abadi et al., 2016) and Pytorch (Paszke et al., 2017) do not support fast primitives for Kronecker products with arbitrary number of factors. So we wrote custom CUDA kernels for Kronecker forward and backward operations. All our models are implemented in C++. We will release our library to reproduce all the results which we report in this paper. We use as activation function for RNN, LSTM and our model KRULSTM. Whereas RC uRNN, FC uRNN and KRU uses complex rectified linear units (Arjovsky et al., 2016).
4.1 Copy memory problem
Copy memory problem (Hochreiter & Schmidhuber, 1997) tests the model’s ability to recall a sequence after a long time gap. In this problem each sequence is of length + 20 and each element in the sequence come from 10 classes . The first 10 elements are sampled uniformly with replacement from . The next elements are filled with , the ‘blank’ class followed by , the ‘delimiter’ and the remaining 10 elements are ‘blank’ category. The goal of the model is to output a sequence of + 10 blank categories followed by the 10 element sequence from the beginning of the input sequence. The expected average cross entropy for a memoryless strategy is .


Our experimental setup closely follows Wisdom et al. (2016) which in turn follows Arjovsky et al. (2016) but extended to 1000 and 2000. Our model, KRU uses a hidden dimension of 128 with 2x2 Kronecker factors which corresponds to 5K parameters in total. We use a RNN of = 128 ( 19K parameters) , LSTM of = 128 ( 72K parameters), RC uRNN of = 470 ( 21K parameters) , FC uRNN of = 128 ( 37K parameters). All the baseline models are deliberately chosen to have more parameters than KRU. Following Wisdom et al. (2016); Arjovsky et al. (2016), we choose the training and test set size to be 100K and 10K respectively. All the models were trained using RMSprop with a learning rate of , decay of 0.9 and a batch size of 20. For both the settings = 1000 and = 2000, KRU converges to zero average cross entropy faster than FC uRNN. All the other baselines are stuck at the memoryless cross entropy.
The results are shown in figure 1. For this problem we do not learn the recurrent matrix of KRU, We initialize it by random unitary matrix and just learn the input to hidden, hidden to output matrices and the bias. We found out that this strategy already solves the problem faster than all other methods. Our model in this case is similar to a parametrized echo state networks (ESN). ESNs are known to be able to learn longterm dependencies if they are properly initialized (Jaeger, 2001). We argue that this dataset is not an ideal benchmark for evaluating RNNs in capturing long term dependencies. Just a unitary initialization of the recurrent matrix would solve the problem.
4.2 Adding problem
Following Arjovsky et al. (2016) we describe the adding problem (Hochreiter & Schmidhuber, 1997). Each input vector is composed of two sequences of length . The first sequence is sampled from . In the second sequence exactly two of the entries is 1, the ‘marker’ and the remaining is 0. The first 1 is located uniformly at random in the first half of the sequence and the other 1 is located again uniformly at random in the other half of the sequence. The network’s goal is to predict the sum of the numbers from the first sequence corresponding to the marked locations in the second sequence.




We evaluate four settings as in Arjovsky et al. (2016) with =100, =200, =400, and =750. For all four settings, KRU uses a hidden dimension of 512 with 2x2 Kronecker factors which corresponds to 3K parameters in total. We use a RNN of = 128 ( 17K parameters) , LSTM of = 128 ( 67K parameters), RC uRNN of = 512 ( 7K parameters) , FC uRNN of = 128 ( 33K parameters). The train and test set sizes are chosen to be 100K and 10K respectively. All the models were trained using RMSprop with a learning rate of and a batch size of 20 or 50 with the best results are being reported here.
The results are presented in figure 2. KRU converges faster than all other baselines even though it has much fewer parameters. This shows the effectiveness of soft unitary constraint which controls the flow of gradients through very long time steps and thus deciding what to forget and remember in an adaptive way. LSTM also converges to the solution and this is achieved through its gating mechanism which controls the flow of the gradients and thus the long term influence. However LSTM has 10 times more parameters than KRU. Both RC uRNN and FC uRNN converges for = 100 but as we can observe, the learning is not stable. The reason for this is that RC uRNN and FC uRNN retains noise since they are strict unitary models. Please note that we do not evaluate RC uRNN for = 400 and = 750 because we found out that the learning is unstable for this model and is often diverging.
4.3 Pixel by pixel MNIST
As outlined by Le et al. (2015), we evaluate the Pixel by pixel MNIST task. MNIST digits are shown to the network pixel by pixel and the goal is to predict the class of the digit after seeing all the pixels one by one. We consider two tasks: (1) Pixels are read from left to right from top or bottom and (2) Pixels are randomly permuted before being shown to the network. The sequence length for these tasks is . The size of the MNIST training set is 60K among which we choose 5K as the validation set. The models are trained on the remaining 55K points. The model which gave the best validation accuracy is chosen for test set evaluation. All the models are trained using RMSprop with a learning rate of and a decay of 0.9.


Model  n  # Parameters  Unpermuted accuracy  Permuted accuracy  

Total  Recurrent  Valid.  Test  Valid.  Test  
LSTM (Arjovsky et al., 2016)  128  68K  65K  98.1  97.8  91.7  91.3 
RC uRNN (Wisdom et al., 2016)  512  16K  3.6K  97.9  97.5  94.2  93.3 
FC uRNN (Wisdom et al., 2016)  512  540K  524K  97.5  96.9  94.7  94.1 
FC uRNN (Wisdom et al., 2016)  116  30K  27K  92.7  92.8  92.2  92.1 
oRNN (Mhammedi et al., 2016)  256  11K  8K  97.0  97.2     
EURNN (Jing et al., 2017)  1024  13K  4K      94.0  93.7 
KRU  512  11K  72  96.6  96.4  94.7  94.5 
The results are summarized in figure 3 and table 2. On the unpermuted task LSTM achieve the state of the art performance even though the convergence speed is slow. Recently a low rank plus diagonal gated recurrent unit (LRD GRU) (Barone, 2016) have shown to achieves 94.7 accuracy on permuted mnist with 41.2K parameters whereas KRU achieves 94.5 with just 12K parameters i.e KRU has 3x parameters less than LRD GRU. Please also note that KRU is a simple model without a gating machanism. KRU can be straightforwardly plugged into LSTM and GRU to exploit the additional benefits of the gating mechanism which we will show in the next experiments with a KRULSTM.
4.4 Character level language modelling on Penn TreeBank (PTB)
We now consider character level language modelling on Penn TreeBank dataset (Marcus et al., 1993). Penn TreeBank is composed of 5017K characters in the training set, 393K characters in the validation set and 442K characters in the test set. The size of the vocabulary was limited to 10K most frequently occurring words and the rest of the words are replaced by a special UNK character (Mikolov, 2012). The total number of unique characters in the dataset is 50, including the special UNK character.
Model  N  # Parameters  Valid. BPC  Test BPC  

Total  Recurrent  
RNN  300  120K  90K  1.65  1.60 
LSTM  150  127K  90K  1.63  1.59 
oRNN (Mhammedi et al., 2016)  512  183K  130K  1.73  1.68 
KRU  411  120K  38K  1.65  1.60 
RNN  600  420K  360K  1.56  1.51 
LSTM  300  435K  360K  1.50  1.45 
KRU  993  418K  220K  1.53  1.48 
KRULSTM  500  377K  250K  1.53  1.47 
All our models were trained for 50 epochs with a batch size of 50 and using ADAM (Kingma & Ba, 2014). We use a learning rate of which was found through crossvalidation with default beta parameters (Kingma & Ba, 2014). If we do not see an improvement in the validation bits per character (BPC) after each epoch then the learning rate is decreased by 0.30. Backpropagation through time (BPTT) is unrolled for 30 time frames on this task.
We did two sets of experiments to have fair evaluation with the models whose results were available for a particular parameter setting (Mhammedi et al., 2016) and also to see how the performance evolves as the number of parameters are increased. We present our results in table 3. We observe that the strict orthogonal model, oRNN fails to generalize as well as other models even with a high capacity recurrent matrix. KRU and KRULSTM performs very close to RNN and LSTM with fewer parameters in the recurrent matrix. Please recall that the computational bottleneck in RNN is the computation of hidden states 2.1 and thus having fewer parameters in the recurrent matrix can significantly reduce the training and inference time.
Recently HyperNetworks (Ha et al., 2016) have shown to achieve the state of the art performance of 1.265 and 1.219 BPC on the PTB test set with 4.91 and 14.41 million parameters respectively. This is respectively 13 and 38 times more parameters than the KRULSTM model which achieves 1.47 test BPC. Also Recurrent Highway Networks (RHN) (Zilly et al., 2016) proved to be a promising model for learning very deep recurrent neural networks. Running experiments, and in particular exploring metaparameters with models of that size, requires unfortunately computational means beyond what was at our disposal for this work. However, there is no reason that the consistent behavior and improvement observed on the other reference baselines would not generalize to that type of largescale models.
4.5 Polyphonic music modeling
We exactly follow the experimental framework of Chung et al. (2014) for Polyphonic music modeling (BoulangerLewandowski et al., 2012) on two datasets: JSB Chorales and Pianomidi. Similar to (Chung et al., 2014) our main objective here is to have a fair evaluation of different recurrent neural networks. We took the baseline RNN and LSTM models of (Chung et al., 2014) whose model sizes were choosen to be small enough to avoid overfitting. We choose the model size of KRU and KRULSTM in such way that it has fewer parameters compared to the baselines. As we can see in the table 4 both our models (KRU and KRULSTM) overfit less and generalizes better.
Model  n  # Parameters  JSB Chorales  Pianomidi  

Total  Recurrent  Train  Test  Train  Test  
RNN (Chung et al., 2014)  100  20K  10K  8.82  9.10  5.64  9.03 
LSTM (Chung et al., 2014)  36  20K  5.1K  8.15  8.67  6.49  9.03 
KRU  100  10K  58  7.90  8.59  7.57  8.28 
KRULSTM  45  19K  176  7.47  8.54  7.55  8.18 
4.6 Framewise phoneme classification on TIMIT
Framewise phoneme classification (Graves & Schmidhuber, 2005) is the problem of classifying the phoneme corresponding to a sound frame. We evaluate the models for this task on the real world TIMIT dataset (Garofolo et al., 1993). TIMIT contains a training set of 3696 utterances among which we use 184 as the validation set. The test set is composed of 1344 utterances. We extract 12 MelFrequency Cepstrum Coefficients (MFCC) (Mermelstein, 1976) from 26 filter banks and also the log energy per frame. We also concatenate the first derivative, resulting in a feature descriptor of dimension 26 per frame. The frame size is chosen to be 10ms and the window size is 25ms.
The number of time steps to which backpropagation through time (BPTT) is unrolled corresponds to the length of each sequence. Since each sequence is of different length this implies that for each sample BPTT steps are different. All the models are trained for 20 epochs with a batch size of 1 using ADAM with default beta parameters (Kingma & Ba, 2014). The learning rate was crossvalidated for each of the models from and the best results are reported here. The best learning rate for all the models was found out to be for all the models. Again if we do not observe a decrease in the validation error after each epoch, we decrease the learning rate by a factor of which is again crossvalidated. Figure 4 summarizes our results.
5 Conclusion
We have presented a new recurrent neural network model based on its core a Kronecker factored recurrent matrix. Our reason for using a Kronecker factored recurrent matrix stems from it’s elegant algebraic and spectral properties. Kronecker matrices are neither lowrank nor blockdiagonal but it is multiscale like the FFT matrix. Kronecker factorization provides a fine control over the model capacity and it’s algebraic properties enable us to design fast matrix multiplication algorithms. It’s spectral properties allow us to efficiently enforce constraints like positive semidefinitivity, unitarity and stochasticity. As we have shown, we used the spectral properties to efficiently enforce a soft unitary constraint.
Experimental results show that our approach outperform classical methods which uses parameters in the recurrent matrix. Maybe as important, these experiments show that both on toy problems (§ 4.1 and 4.2), and on real ones (§ 4.3, 4.4, , and § 4.6), while existing methods require tens of thousands of parameters in the recurrent matrix, competitive or better than stateoftheart performance can be achieved with far less parameters in the recurrent weight matrix. These surprising results provide a new and counterintuitive perspective on desirable memorycapable architectures: the state should remain of high dimension to allow the use of highcapacity networks to encode the input into the internal state, and to extract the predicted value, but the recurrent dynamic itself can, and should, be implemented with a lowcapacity model.
From a practical standpoint, the core idea in our method is applicable not only to vanilla recurrent neural networks and LSTMS as we showed, but also to a variety of machine learning models such as feedforward networks (Zhou et al., 2015), random projections and boosting weak learners. Our future work encompasses exploring other machine learning models and on dynamically increasing the capacity of the models on the fly during training to have a perfect balance between computational efficiency and sample complexity.
References
 Abadi et al. (2016) Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Largescale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
 Arjovsky et al. (2016) Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In International Conference on Machine Learning, pp. 1120–1128, 2016.
 Ba & Caruana (2014) Jimmy Ba and Rich Caruana. Do deep nets really need to be deep? In Advances in neural information processing systems, pp. 2654–2662, 2014.
 Ba et al. (2016) Jimmy Ba, Roger Grosse, and James Martens. Distributed secondorder optimization using kroneckerfactored approximations. 2016.
 Barone (2016) Antonio Valerio Miceli Barone. Lowrank passthrough neural networks. arXiv preprint arXiv:1603.03116, 2016.
 Bengio et al. (1994) Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning longterm dependencies with gradient descent is difficult. IEEE transactions on neural networks, 5(2):157–166, 1994.
 Bergstra et al. (2011) James Bergstra, Olivier Breuleux, Pascal Lamblin, Razvan Pascanu, Olivier Delalleau, Guillaume Desjardins, Ian Goodfellow, Arnaud Bergeron, Yoshua Bengio, and Pack Kaelbling. Theano: Deep learning on gpus with python. 2011.
 BoulangerLewandowski et al. (2012) Nicolas BoulangerLewandowski, Yoshua Bengio, and Pascal Vincent. Modeling temporal dependencies in highdimensional sequences: Application to polyphonic music generation and transcription. arXiv preprint arXiv:1206.6392, 2012.
 Chen et al. (2015) Wenlin Chen, James Wilson, Stephen Tyree, Kilian Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In International Conference on Machine Learning, pp. 2285–2294, 2015.
 Chung et al. (2014) Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
 Chung et al. (2015) Junyoung Chung, Caglar Gülçehre, Kyunghyun Cho, and Yoshua Bengio. Gated feedback recurrent neural networks. In ICML, pp. 2067–2075, 2015.
 Cisse et al. (2017) Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. arXiv preprint arXiv:1704.08847, 2017.
 Courbariaux et al. (2014) Matthieu Courbariaux, JeanPierre David, and Yoshua Bengio. Low precision storage for deep learning. Arxiv: 1412.7024, 2014.
 Denil et al. (2013) Misha Denil, Babak Shakibi, Laurent Dinh, Nando de Freitas, et al. Predicting parameters in deep learning. In Advances in Neural Information Processing Systems, pp. 2148–2156, 2013.
 Elman (1990) Jeffrey L Elman. Finding structure in time. Cognitive science, 14(2):179–211, 1990.
 Garofolo et al. (1993) John S Garofolo, Lori F Lamel, William M Fisher, Jonathon G Fiscus, and David S Pallett. Darpa timit acousticphonetic continous speech corpus cdrom. nist speech disc 11.1. NASA STI/Recon technical report n, 93, 1993.
 Graves & Schmidhuber (2005) Alex Graves and Jürgen Schmidhuber. Framewise phoneme classification with bidirectional lstm and other neural network architectures. Neural Networks, 18(5):602–610, 2005.
 Grosse & Martens (2016) Roger Grosse and James Martens. A kroneckerfactored approximate fisher matrix for convolution layers. In International Conference on Machine Learning, pp. 573–582, 2016.
 Ha et al. (2016) David Ha, Andrew Dai, and Quoc Le. Hypernetworks. 2016.
 Henaff et al. (2016) Mikael Henaff, Arthur Szlam, and Yann LeCun. Orthogonal RNNs and longmemory tasks. arXiv preprint arXiv:1602.06662, 2016.
 Hinton et al. (2012) Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdelrahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
 Hochreiter (1991) Sepp Hochreiter. Untersuchungen zu dynamischen neuronalen Netzen. PhD thesis, diploma thesis, institut für informatik, lehrstuhl prof. brauer, technische universität münchen, 1991.
 Hochreiter & Schmidhuber (1997) Sepp Hochreiter and Jürgen Schmidhuber. Long shortterm memory. Neural computation, 9(8):1735–1780, 1997.
 Jaeger (2001) Herbert Jaeger. The âecho stateâ approach to analysing and training recurrent neural networkswith an erratum note. Bonn, Germany: German National Research Center for Information Technology GMD Technical Report, 148(34):13, 2001.
 Jing et al. (2017) Li Jing, Yichen Shen, Tena Dubcek, John Peurifoy, Scott Skirlo, Yann LeCun, Max Tegmark, and Marin Soljačić. Tunable efficient unitary neural networks (EUNN) and their application to RNNs. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 1733–1741, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr.press/v70/jing17a.html.
 Jose & Fleuret (2016) Cijo Jose and François Fleuret. Scalable metric learning via weighted approximate rank component analysis. In European Conference on Computer Vision, pp. 875–890. Springer, 2016.
 Kingma & Ba (2014) Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
 Krizhevsky et al. (2012) Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
 Le et al. (2013) Quoc Le, Tamás Sarlós, and Alex Smola. Fastfoodapproximating kernel expansions in loglinear time. In Proceedings of the international conference on machine learning, 2013.
 Le et al. (2015) Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015.
 LeCun et al. (1990) Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.
 Marcus et al. (1993) Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993.
 Martens & Grosse (2015) James Martens and Roger Grosse. Optimizing neural networks with kroneckerfactored approximate curvature. In International Conference on Machine Learning, pp. 2408–2417, 2015.
 Mermelstein (1976) Paul Mermelstein. Distance measures for speech recognition, psychological and instrumental. Pattern recognition and artificial intelligence, 116:374–388, 1976.
 Mhammedi et al. (2016) Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal parametrisation of recurrent neural networks using householder reflections. arXiv preprint arXiv:1612.00188, 2016.
 Mikolov (2012) Tomáš Mikolov. Statistical Language Models Based on Neural Networks. PhD thesis, Ph. D. thesis, Brno University of Technology, 2012.
 Pascanu et al. (2013) Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. ICML (3), 28:1310–1318, 2013.
 Paszke et al. (2017) Adam Paszke, Sam Gross, and Soumith Chintala. Pytorch, 2017.
 Srivastava et al. (2015) Rupesh Kumar Srivastava, Klaus Greff, and Jürgen Schmidhuber. Highway networks. arXiv preprint arXiv:1505.00387, 2015.
 Van Loan (2000) Charles F Van Loan. The ubiquitous kronecker product. Journal of computational and applied mathematics, 123(1):85–100, 2000.
 Vorontsov et al. (2017) Eugene Vorontsov, Chiheb Trabelsi, Samuel Kadoury, and Chris Pal. On orthogonality and learning recurrent networks with long term dependencies. arXiv preprint arXiv:1702.00071, 2017.
 Wisdom et al. (2016) Scott Wisdom, Thomas Powers, John Hershey, Jonathan Le Roux, and Les Atlas. Fullcapacity unitary recurrent neural networks. In Advances In Neural Information Processing Systems, pp. 4880–4888, 2016.
 Wu et al. (2017) Yuhuai Wu, Elman Mansimov, Shun Liao, Roger Grosse, and Jimmy Ba. Scalable trustregion method for deep reinforcement learning using kroneckerfactored approximation. arXiv preprint arXiv:1708.05144, 2017.
 Yang et al. (2015) Zichao Yang, Marcin Moczulski, Misha Denil, Nando de Freitas, Alex Smola, Le Song, and Ziyu Wang. Deep fried convnets. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1476–1483, 2015.
 Zhang et al. (2015) Xu Zhang, Felix X Yu, Ruiqi Guo, Sanjiv Kumar, Shengjin Wang, and ShiFu Chang. Fast orthogonal projection based on kronecker product. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2929–2937, 2015.
 Zhou et al. (2015) Shuchang Zhou, JiaNan Wu, Yuxin Wu, and Xinyu Zhou. Exploiting local structures with the kronecker layer in convolutional networks. arXiv preprint arXiv:1512.09194, 2015.
 Zilly et al. (2016) Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutník, and Jürgen Schmidhuber. Recurrent highway networks. arXiv preprint arXiv:1607.03474, 2016.
Appendices
A Analysis of vanishing and exploding gradients in RNN
Given a sequence of input vectors: , let us consider the operation at the hidden layer of a recurrent neural network:
(8)  
(9) 
By the chain rule,
(10)  
(11) 
where is the nonlinear activation function and is the Jacobian matrix of the nonlinear activation function.
(12)  
(13)  
(14) 
From equation 14 it is clear the norm of the gradient is exponentially dependent upon two factors along the time horizon:

The norm of the Jacobian matrix of the nonlinear activation function .

The norm of the hidden to hidden weight matrix .
These two factors are causing the vanishing and exploding gradient problem.
Since the gradient of the standard nonlinear activation functions such as tanh and ReLU are bounded between [0, 1], does not contribute to the exploding gradient problem but it can still cause vanishing gradient problem.
B Long shortterm memory (LSTM) (Hochreiter & Schmidhuber, 1997)
LSTM networks presented an elegant solution to the vanishing and exploding gradients through the introduction of gating mechanism. Apart from the standard hidden state in RNN, LSTM introduced one more state called cell state . LSTM has three different gates whose functionality is described as follows:

Forget gate ():Decides what information to keep and erase from the previous cell state.

Input gate (): Decides what new information should be added to the cell state.

Output gate ():Decides which information from the cell state is going to the output.
In addition to the gates, LSTM prepares candidates for the information from the input gate that might get added to the cell state through the action of input gate. Let’s denote the parameters describing the function that prepares this candidate information as .
Given a sequence of input vectors: , at a time step LSTM performs the following:
(15)  
(16)  
(17)  
(18)  
(19)  
(20) 
where and are the pointwise sigmoid and tanh functions. indicates elementwise multiplication. The first three are gating operations and the 4th one prepares the candidate information. The 5th operation updates the cellstate and finally in the 6th operation the output gate decided what to go into the current hidden state.
C Unitary evolution RNN (Arjovsky et al., 2016)
Unitary evolution RNN (uRNN) proposed to solve the vanishing and exploding gradients through a unitary recurrent matrix, which is for the form:
(21) 
Where:

: Diagonal matrices whose diagonal entries are of the from , implies each matrix have parameters, .

and : Fast Fourier operator and inverse fast Fourier operator respectively.

: Householder reflections. , where .
The total number of parameters for this uRNN operator is and the matrix vector can be done time. It is parameter efficient and fast but not flexible and suffers from the retention of noise and difficulty in optimization due its unitarity.
D Full capacity unitary RNN (Wisdom et al., 2016)
Full capacity unitary RNN (FC uRNN) does optimization on the full unitary set instead on a subset like uRNN. That is FC uRNN’s recurrent matrix . There are several challenges in optimization over unitary manifold especially when combined with stochastic gradient method. The primary challenge being the optimization cost is per step.
E Orthogonal RNN (Mhammedi et al., 2016)
Orthogonal RNN (oRNN) parametrizes the recurrent matrices using Householder reflections.
(22) 
where
(23) 
and
(24) 
where . The number of parameters in this parameterization is . When and , it spans the rotation subset and when , it spans the full reflection subset.
F Properties of Kronecker matrix (Van Loan, 2000)
Consider a matrix factorized as a Kronecker product of matrices ,
(25) 
Where each respectively and . ’s are called as Kronecker factors.
If the factors ’s are then is
Theorem 1.
If , is unitary then is also unitary.
Proof.
(26)  
(27)  
(28) 
∎
G Product between a dense matrix and a Kronecker matrix
For simplicity here we use real number notations. Consider a dense matrix and a Kronecker factored matrix . That is , where each respectively and and . Let us illustrate the matrix product resulting in a matrix .
(29) 
The computational complexity first expanding the Kronecker factored matrix and then computing the matrix product is . This can be reduced by exploiting the recursive definition of Kronecker matrices. For examples when and , the matrix product can be computed in time instead of .
The matrix product in 29 can be recursively defined as
(30) 
Please note that the binary operator is not the standard matrix multiplication operator but instead it denotes a strided matrix multiplication. The stride is computed according to the algebra of Kronecker matrices. Let us define recursively:
(31)  
(32) 
We use the above notation for in the algorithm. That is the algorithm illustrated here will cache all the intermediate outputs () instead of just . These intermediate outputs are then later to compute the gradients during the backpropagation. This cache will save some computation during the backpropagation. If the model is just being used for inference then the algorithm can the organized in such a way thatwe do not need to cache the intermediate outputs and thus save memory.
Algorithm for computing the product between a dense matrix and a Kronecker factored matrix34 is given below 1. All the matrices are assumed to be stored in row major order. For simplicity the algorithm is illustrated in a serial fashion. Please note the lines 4 to 15 except lines 911 can be trivially parallelized as it writes to independent memory locations. The GPU implementation exploits this fact.
H Gradient computation in a kronecker layer
Following the notations from the above section G, here we illustrate the algorithm for computing the gradients in a Kronecker layer. To be clear and concrete the Kronecker layer does the following computation in the forward pass 32.
(34) 
That is, the Kronecker layer is parametrized by a Kronecker factored matrix stored as it factors and it takes an input and produces output using the algorithm 1.
The following algorithm 2 computes the Gradient of the Kronecker factors: and the Jacobian of the input matrix given the Jacobain of the output matrix: .