L EARNING R ECURRENT B INARY /T ERNARY W EIGHTS
Anonymous authors
Paper under double-blind review
A BSTRACT
Recurrent neural networks (RNNs) have shown excellent performance in processing sequence data.
However, they are both complex and memory intensive due to their recursive nature.
These limitations make RNNs difﬁcult to embed on mobile devices requiring real-time processes with limited hardware resources.
To address the above issues, we introduce a method that can learn binary and ternary weights during the training phase to facilitate hardware implementations of RNNs.
As a result, using this approach replaces all multiply-accumulate operations by simple accumulations, bringing signiﬁcant beneﬁts to custom hardware in terms of silicon area and power consumption.
On the software side, we evaluate the performance (in terms of accuracy) of our method using long short-term memories (LSTMs) and gated recurrent units (GRUs) on various sequential models including sequence classiﬁcation and language modeling.
We demonstrate that our method achieves competitive results on the aforementioned tasks while using binary/ternary weights during the runtime.
On the hardware side, we present custom hardware for accelerating the recurrent computations of LSTMs with binary/ternary weights.
Ultimately, we show that LSTMs with binary/ternary weights can achieve up to 12 × memory saving and 10 × inference speedup compared to the full-precision hardware implementation design.
I NTRODUCTION
Convolutional neural networks (CNNs) have surpassed human-level accuracy in various complex tasks by obtaining a hierarchical representation with increasing levels of abstraction (Bengio (2009);
Lecun et al.
As a result, they have been adopted in many applications for learning hierarchical representation of spatial data.
CNNs are constructed by stacking multiple convolutional layers often followed by fully-connected layers (Lecun et al.
While the vast majority of network parameters (i.e. weights) are usually found in fully-connected layers, the computational complexity of CNNs is dominated by the multiply-accumulate operations required by convolutional layers (Yang et al.
Recurrent neural networks (RNNs), on the other hand, have shown remarkable success in modeling temporal data (Mikolov et al.
; Graves (2013); Cho et al.
(2014a)
; Sutskever et al.
(2014); Vinyals et al.
Similar to CNNs, RNNs are typically over-parameterized since they build on high-dimensional input/output/state vectors and suffer from high computational complexity due to their recursive nature (Xu et al. ; Han et al.
As a result, the aforementioned limitations make the deployment of CNNs and RNNs difﬁcult on mobile devices that require real-time inference processes with limited hardware resources.
Several techniques have been introduced in literature to address the above issues.
In (Sainath et al.
; Jaderberg et al.
(2014); Lebedev et al.
; Tai et al. (2015)), it was shown that the weight matrix can be approximated using a lower rank matrix.
In (Liu et al. (2015); Han et al.
Wen et al.
; Ardakani et al.
, it was shown that a signiﬁcant number of parameters in DNNs are noncontributory and can be pruned without any performance degradation in the ﬁnal accuracy performance.
Finally, quantization approaches were introduced in (Courbariaux et al.
; Lin et al.
(2015); Courbariaux & Bengio (2016); Kim & Smaragdis (2016)
; Hubara et al.
(2016b)
; Rastegari et al.
; Hubara et al.
(2016a)
; Zhou et al.
; Li & Liu (2016);
Zhu et al.
to reduce the required bitwidth of weights/activations.
In this way, power-hungry multiply-accumulate operations are replaced by simple accumulations while also reducing the number of memory accesses to the off-chip memory.
Considering the improvement factor of each of the above approaches in terms of energy and power reductions, quantization has proven to be the most beneﬁcial for hardware implementations.
However, all of the aforementioned quantization approaches focused on optimizing CNNs or fully-connected networks only.
As a result, despite the remarkable success of RNNs in processing sequential data,
RNNs have received the least attention for hardware implementations, when compared to CNNs and fully-connected networks.
In fact, the recursive nature of RNNs makes their quantization difﬁcult.
In (Hou et al.
(2016)), for example, it was shown that the well-known BinaryConnect technique fails to binarize the parameters of RNNs due to the exploding gradient problem (Courbariaux et al. (2015)).
As a result, a binarized RNN was introduced in (Hou et al.
(2016)), with promising results on simple tasks and datasets.
However it does not generalize well on tasks requiring large inputs/outputs (Xu et al.
In (Xu et al.
; Hubara et al.
(2016b))
, multi-bit quantized RNNs were introduced.
These works managed to match their accuracy performance with their full-precision counterparts while using up to 4 bits for data representations.
In this paper, we propose a method that learns recurrent binary and ternary weights in RNNs during the training phase and eliminates the need for full-precision multiplications during the inference time.
In this way, all weights are constrained to { +1 , − 1 } or { +1 , 0 , − 1 } in binary or ternary representations, respectively.
Using the proposed approach, RNNs with binary and ternary weights can achieve the performance accuracy of their full-precision counterparts.
In summary, this paper makes the following contributions:
• We introduce a method for learning recurrent binary and ternary weights during both forward and backward propagation phases, reducing both the computation time and memory footprint required to store the extracted weights during the inference.
• We perform a set of experiments on various sequential tasks, such as sequence classiﬁcation, language modeling, and reading comprehension.
We then demonstrate that our binary/ternary models can achieve near state-of-the-art results with greatly reduced computational complexity.•
We present custom hardware to accelerate the recurrent computations of RNNs with binary or ternary weights.
The proposed dedicated accelerator can save up to 12 × of memory elements/bandwidth and speed up the recurrent computations by up to 10 × when performing the inference computations.
R ELATED W ORK
During the binarization process, each element of the full-precision weight matrix W ∈ R d I × d J with entries w i,j is binarized by w i,j = α
i,j w Bi,j , where α i,j ≥ 0 , i ∈ { 1 , . . .
, d I } , j ∈ { 1 , . . .
, d J } and w Bi,j ∈ {− 1 , +1 } .
In BinaryConnect (Courbariaux et al.
(2015)), the binarized weight element w Bi,j is obtained by the sign function while using a ﬁxed scalling factor α for all the elements: w Bi,j = α × sign( w i,j ) .
In TernaryConnect (Lin et al. (2015)), values hesitating to be either + or -1 are clamped to zero to reduce the accuracy loss of binarization: w i,j = α i,j w Ti,j where w Ti,j ∈ {− 1 , 0 , +1 } .
To further improve the precision accuracy, TernaryConnect stochastically assigns ternary values to the weight elements by performing w i,j = α × Bernoulli ( | w i,j | ) × sign( w i,j ) while using a ﬁxed scaling factor α for each layer.
Ternary weight networks (TWNs) were then proposed to learn the factor α by minimizing the L2 distance between the full-precision and ternary weights for each layer.
Zhou et al.
(2016) introduced DoReFa-Net as a method that can learn different bitwidths for weights, activations and gradients.
Since the quantization functions used in the above works are not differentiable, the derivative of the loss (cid:108) w.r.t the full-precision W is approximated by
[Equation]
where W B and W T denote binarized and ternarized weights, respectively.
Zhu et al.
(2016) introduced the trained ternary quantization (TTQ) method that uses two assymetric scaling parameters ( α 1 for positive values and α 2 for negative values) to ternarize the weights.
In loss- aware binarization (LAB) (Hou et al.
, the loss of binarization was explicitly considered.
More precisely, the loss w.r.t the binarized weights is minimized using the proximal Newton algorithm.
Hou & Kwok (2018) extended LAB to support different bitwidths for the weights.
This method is called loss-aware quantization (LAQ).
Recently, Guo et al.
(2017) introduced a new method that builds the full-precision weight matrix W as k multiple binary weight matrices: w i,j ≈ (cid:80) kz
=1 α ki,j β ki,j where β ki,j ∈ {− 1 , +1 } and α ki,j > 0 .
Xu et al.
(2018) also uses a binary search tree to efﬁciently derive the binary codes β ki,j , improving the prediction accuracy.
While using multiple binary weight matrices reduces the bitwidth by a factor of 32 × compared to its full-precision counterpart, it increases not only the number of parameters but also the number of operations by a factor of k (Xu et al.
Among the aforementioned methods, only works of Xu et al.
and Hou & Kwok (2018) targeted
RNNs to reduce their computational complexity and outperformed all the aforementioned methods in terms of the prediction accuracy.
However, they have shown promising results only on speciﬁc temporal tasks: the former targeted only the character-level language modeling task on small datasets while the latter performs the word-level language modeling task and matches the performance of the full-precision model when using k = 4 .
Therefore, there are no binary models that can match the performance of the full-precision model on the word-level language modeling task.
More generally, there are no binary/ternary models that can perform different temporal tasks while achieving similar prediction accuracy to its full-precision counterpart is missing in literature.
P RELIMINARIES
Despite the remarkable success of RNNs in processing variable-length sequences, they suffer from the exploding gradient problem that occurs when learning long-term dependencies (Bengio et al.
Pascanu et al.
Therefore, various RNN architectures such as Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber (1997)) and Gated Recurrent Unit (GRU) (Cho et al.
(2014b)) were introduced in literature to mitigate the exploding gradient problem.
In this paper, we mainly focus on the LSTM architecture to learn recurrent binary/ternary weights due to their prevalent use in both academia and industry.
The recurrent transition of LSTM is obtained by:
[Equation]
where { W fh , W ih , W oh , W gh } ∈ R d h × d h , { W fx , W ix , W ox , W gx } ∈ R d x × d h and { b f , b i , b o , b g } ∈ R[-
-]
d h denote the recurrent weights and bias.
The parameters h ∈ R d h and c ∈ R
d h are hidden states.
The logistic sigmoid function and Hadamard product are denoted as σ and (cid:12) , respectively.
The updates of the LSTM parameters are regulated through a set of gates: f t , i t , o t and g t .
Eq.
(2) shows that the main computational core of LSTM is dominated by the matrix multiplications.
The recurrent weight matrices W fh , W ih , W oh , W gh , W fx , W ix , W ox and W gx also contain the majority of the model parameters.
As such, we aim to compensate the computational complexity of the LSTM cell and reduce the number of memory accesses to the energy/power-hungry DRAM by binarizing or ternarizing the recurrent weights.  L EARNING R ECURRENT B INARY /T ERNARY W EIGHTS
Hou et al.
(2016) showed that the methods ignoring the loss of the binarization process fail to binarize the weights in LSTMs despite their remarkable performance on CNNs and fully-connected networks. In BinaryConnect as an example, the weights are binarized during the forward computations by thresholding while Eq. (1) is used to estimate the loss w.r.t. the full-precision weights without considering the quantization loss.
When the training is over, both the full-precision and binarized weights can be then used to perform the inference computations of CNNs and fully-connected networks (Lin et al. However, using the aforementioned binarization approach in vanilla LSTMs fails to perform sequential tasks due to the gradient vanishing problem as discussed in (Hou et al. To further explore the cause of this problem, we performed a set of experiments.
We ﬁrst measured the probability density of the gates and hidden states of a binarized LSTM and observed that the binarized LSTM fail to control the ﬂow of information (see Appendix A for more details).
More speciﬁcally, the input gate i and the output gate o tend to let all information through, the gate g tends to block all information, and the forget gate f cannot decide to let which information through.
In the second experiment, we measured the probability density of the input gate i before its non-linear function applied (i.e., i p = W ih h t − 1 + W ix x t + b i ) at different iterations during the training process.
In this experiment, we observed that the binarization process changes the probability density of the gates and hidden states during the training process, resulting in all positive values for i p and values centered around 1 for the input gate i (see Appendix A for more details). To address the above issue, we propose the use of batch normalization in order to learn binarized/ternarized recurrent weights. It is well-known that a network trained using batch normalization is less susceptible to different settings of hyperparameters and changes in the distribution of the inputs to the model (Ioffe & Szegedy (2015)).
The batch normalization transform can be formulated as follows:
[Equation]
) where x and (cid:15) denote the unnormalized vector and a regularization hyperparameter.
The mean and standard deviation of the normalized vector are determined by model parameters φ and γ .
The statistics E ( x ) and V ( x ) also denote the estimations of the mean and variance of the unnormalized vector for the current minibatch, respectively.
Batch normalization is commonly applied to a layer where changing its parameters affects the distributions of the inputs to the next layer.
This occurs frequently in RNN where its input at time t depends on its output at time t − 1 .
Several works have investigated batch normalization in RNNs (Cooijmans et al.
; Laurent et al.
; Amodei et al.
to improve their convergence speed and performance.
The main goal of our method is to represent each element of the full-precision weight W either as w i,j = αw Bi,j or w i,j = αw Ti,j , where α is a ﬁxed scaling factor for all the weights and initialized from Glorot & Bengio (2010).
To this end, we ﬁrst divide each weight by the factor α to normalize the weights.
We then compute the probability of getting binary or ternary values for each element of the full-precision matrix W by
[Equation]
for binarization and
[Equation]
for ternarization, where w Ni,j denotes the normalized weight.
Afterwards, we stochastically sample from the Bernoulli distribution to obtain binarized/ternarized weights as follows
[Equation]
Finally, we batch normalize the vector-matrix multiplications between the input and hidden state vectors with the binarized/ternarized weights [Equation] /Tix , W B/Tox and W B/Tgx .
More precisely, we perform the recurrent computations as
[Equation]
[Equation]
[Table] In fact [Table] batch normalization cancels out the effect of the binarization/ternarization on the distribution of the gates and states during the training process.
Moreover, batch normalization regulates the scale of binarized/ternarized weights using its parameter φ in addition to α .
So far, we have only considered the forward computations.
During the parameter update, we use full-precision weights since the parameter updates are small values.
To update the full-precision weights, we use Eq.
(1) to estimate its gradient since the binarization/ternarization functions are indifferentiable (See Algorithm 1 and its details in Appendix B).
It is worth noting that using batch normalization makes the training process slower due to the additional computations required to perform Eq.
E XPERIMENTAL R ESULTS AND D ISCUSSIONS
In this section, we evaluate the performance of the proposed LSTMs with binary/ternary weights on different temporal tasks to show the generality of our method.
We defer hyperparameters and tasks details for each dataset to Appendix C due to the limited space.
5. C HARACTER -L EVEL L ANGUAGE M ODELING
For the character-level modeling, the goal is to predict the next character and the performance is evaluated on bits per character (BPC) where lower BPC is desirable.
We conduct quantization experiments on Penn Treebank (Marcus et al.
, War & Peace (Karpathy et al.
and
Linux Kernel (Karpathy et al.
corpora.
For Penn Treebank dataset, we use a similar LSTM model conﬁguration and data preparation to Mikolov et al.
For War & Peace and Linux Kernel datasets, we also follow the LSTM model conﬁgurations and settings in (Karpathy et al.
Table 1 summarizes the performance of our binarized/ternarized models compared to state-of-the-art quantization methods reported in literature.
All the models reported in Table 1 use an LSTM layer with 1000, 512 and 512 units on a sequence length of 100 for the experiments on Penn Treebank (Marcus et al.
, War & Peace (Karpathy et al.
and Linux Kernel (Karpathy et al.
(2015)) corpora, respectively.
The experimental results show that our model with binary/ternary weights outperforms all the existing quantized models in terms of prediction accuracy.
Moreover, our ternarized model achieves the same BPC values on War & Peace and Penn Treebank datasets as the full-precision model (i.e., baseline) while requiring 32 × less memory footprint.
It is worth mentioning the accuracy loss of our ternarized model over the full-precision baseline is small.
In order to evaluate the effectiveness of our method on a larger dataset for the character-level language modeling task, we use the Text8 dataset which was derived from Wikipedia.
For this task, we use one
[Table] LSTM layer of size 2000 and train it on sequences of length 180.
We follow the data preparation approach and settings of Mikolov et al.
The test results are reported in Table 2.
While our models use recurrent binary or ternary weights during runtime, they achieve acceptable performance when compared to the full-precision models.
5. W ORD -L EVEL L ANGUAGE M ODELING
Similar to the character-level language modeling, the main goal of word-level modeling is to predict the next word.
However, this task deals with large vocabulary sizes, making the model quantization difﬁcult.
Xu et al.
(2018) introduced a multi-bit quantization method, referred to as alternating method, as a ﬁrst attempt to reduce the complexity of the LSTMs used for this task.
However, the alternating method only managed to almost match its performance with its full-precision counterpart usingbits (i.e., k = 4 ).
However, there is a huge gap in the performance between its quantized model with 2 bits and the full-precision one.
To show the effectiveness of our method over the alternating method, we use a small LSTM of size 300 similar to (Xu et al.
for a fair comparison.
We also examine the prediction accuracy of our method over the medium and large models introduced by Zaremba et al.
(2014): the medium model contains an LSTM layer of size 650 and the large model contains two LSTM layers of size 1500.
We also use the same settings described in (Mikolov et al.
to prepare and train our model.
Table 3 summarizes the performance of our models in terms of perplexity.
The experimental results show that our binarized/ternarized models outperform the alternating method using 2-bit quantization in terms of both perplexity and the memory size [Table]
Moreover, our medium-size model with binary weights also has a substantial improvement over the [Table] [Table] alternating method using 4-bit quantization.
Finally, our models with recurrent binary and ternary weights yield a comparable performance compared to their full-precision counterparts.
5. S EQUENTIAL MNIST
We perform the MNIST classiﬁcation task (Le et al.
by processing each image pixel at each time step.
In this task, we process the pixels in scanline order.
We train our models using an LSTM with 100 nodes, followed by a softmax classiﬁer layer.
Table 4 reports the test performance of our models with recurrent binary/ternary weights.
While our binary model uses a lower bit precision and fewer operations for the recurrent computations compared to the alternating models, its loss of accuracy is small.
On the other hand, our ternary model requires the same memory size and achieves the same accuracy as the alternating method while requiring 2 × fewer operations.
5. Q UESTION A NSWERING
Hermann et al.
(2015) recently introduced a challenging task that involves reading and comprehension of real news articles.
More speciﬁcally, the main goal of this task is to answer questions about the context of the given article.
To this end, they also introduced an architecture, called Attentive
Reader, that exploits an attention mechanism to spot relevant information in the document.
Attentive
Reader uses two bidirectional LSTMs to encode the document and queries.
To show the generality and effectiveness of our quantization method, we train Attentive Reader with our method to learn recurrent binary/ternary weights.
We perform this task on the CNN corpus (Hermann et al.
by replicating Attentive Reader and using the setting described in (Hermann et al.
Tableshows the test accuracy of binarized/ternarized Attentive Reader.
The simulation results show that our Attentive Reader with binary/ternary weights yields similar accuracy rate to its full-precision counterpart while requiring 32 × smaller memory footprint.
5. D ISCUSSIONS
As discussed in Section [Table] the training models ignoring the quantization loss fail to quantize the weights in LSTM while they perform well on CNNs and fully-connected networks.
To address this problem, we proposed the use of batch normalization during the quantization process. To justify
[Table] [Figure] [Figure] the importance of such a decision, we have performed different experiments over a wide range of temporal tasks and compared the accuracy performance of our binarization/ternarization method with binaryconnect as a method that ignores the quantization loss.
The experimental results showed that binaryconnect method fails to learn binary/ternary weights.
On the other hand, our method not only learns recurrent binary/ternary weights but also outperforms all the existing quantization methods in literature.
It is also worth mentioning that the models trained with our method achieve a comparable accuracy performance w.r.t.
their full-precision counterpart
[Figure] Figure 1(a) shows a histogram of the binary/ternary weights of the LSTM layer used for characterlevel language modeling task on the Penn Treebank corpus.
In fact, our model learns to use binary or ternary weights by steering the weights into the deterministic values of -1, 0 or 1.
Despite the
CNNs or fully-connected networks trained with binary/ternary weights that can use either real-valued or binary/ternary weights, the proposed LSTMs trained with binary/ternary can only perform the inference computations with binary/ternary weights.
Moreover, the distribution of the weights is dominated by non-zero values for the model with ternary weights. To show the effect of the probabilistic quantization on the prediction accuracy of temporal tasks, we adopted the ternarized network trained for the character-level language modeling tasks on the Penn
Treebank corpus (see Section 5.1).
We measured the prediction accuracy of this network on the test set over 10000 samples and reported the distribution of the prediction accuracy in Figure 1(b). Figure 1(b) shows that the variance imposed by the stochastic ternarization on the prediction accuracy is very small and can be ignored. It is worth mentioning that we also have observed a similar behavior for other temporal tasks used in this paper.
[Table] Figure 2 illustrates the learning curves and generalization of our method to longer sequences on the validation set of the Penn Treebank corpus.
In fact, the proposed training algorithm also tries to retains the main features of using batch normalization, i.e., fast convergence and good generalization over long sequences.
Figure 2(a) shows that our model converges faster than the full-precision LSTM for the ﬁrst few epochs.
After a certain point, the convergence rate of our method decreases, that prevents the model from early overﬁtting.
Figure 2(b) also shows that our training method generalizes well over longer sequences than those seen during training.
Similar to the full-precision baseline, our binary/ternary models learn to focus only on information relevant to the generation of the next target character. In fact, the prediction accuracy of our models improves as the sequence length increases since longer sequences provides more information from past for generation of the next target character. While we have only applied our binarization/ternarization method on LSTMs, our method can be used to binarize/ternarize other recurrent architectures such as GRUs. To show the versatility of our method, we repeat the character-level language modeling task performed in Section 5.1 using
GRUs on the Penn Treebank, War & Peace and Linux Kernel corpora.
We also adopted the same network conﬁgurations and settings used in Section 5.1 for each of the aforementioned corpora.
Table 6 summarizes the performance of our binarized/ternarized models.
The simulation results show that our method can successfully binarize/ternarize the recurrent weights of GRUs.
As a ﬁnal note, we have investigated the effect of using different batch sizes on the prediction accuracy of our binarized/ternarized models.
To this end, we trained an LSTM of size 1000 over a sequence length of 100 and different batch sizes to perform the character-level language modeling task on the
Penn Treebank corpus.
Batch normalization cannot be used for the batch size of 1 as the output vector will be all zeros.
Moreover, using a small batch size leads to a high variance when estimating the statistics of the unnormalized vector, and consequently a lower prediction accuracy than the baseline model without bath normalization, as shown in Figure 3.
On the other hand, the prediction accuracy of our binarization/ternarization models improves as the batch size increases, while the prediction accuracy of the baseline model decreases.
[Figure]
[Table]
H ARDWARE I MPLEMENTATION
The introduced binarized/ternarized recurrent models can be exploited by various dataﬂows such as DaDianNao (Chen et al. and TPU (Jouppi et al. In order to evaluate the effectiveness of LSTMs with recurrent binary/ternary weights, we build our binary/ternary architecture over DaDianNao as a baseline which has proven to be the most efﬁcient dataﬂow for DNNs with sigmoid/tanh functions.
In fact, DaDianNao achieves a speedup of 656 × and reduces the energy by 184 × over a GPU (Chen et al. Moreover, some hardware techniques can be adopted on top of DaDianNao to further speed up the computations. For instance, Zhang et al. (2016) showed that ineffectual computations of zero-valued weights can be skipped to improve the run-time performance of DaDianNao.
In DaDianNao, a DRAM is used to store all the weights/activations and provide the required memory bandwidth for each multiply-accumulate (MAC) unit.
For evaluation purposes, we consider two different application-speciﬁc integrated circuit (ASIC) architectures implementing Eq.
(2): low-power implementation and high-speed inference engine.
We build these two architectures based on the aforementioned dataﬂow.
For the low-power implementation, we use MAC units.
We also use a 12-bit ﬁxed-point representation for both weights and activations of the full-precision model as a baseline architecture.
As a result, 12-bit multipliers are required to perform the recurrent computations.
Note that using the 12-bit ﬁxed-point representation for weights and activations guarantees no prediction accuracy loss in the full-precision models.
For the LSTMs with recurrent binary/ternary weights, a 12-bit ﬁxed-point representation is only used for activations and multipliers in the MAC units are replaced with low-cost multiplexers.
Similarly, using 12-bit ﬁxed-point representation for activations guarantees no prediction accuracy loss in the introduced binary/ternary models.
We implemented our low-power inference engine for both the full-precision and binary/ternary-precision models in TSMC 65-nm CMOS technology.
The synthesis results excluding the implementation cost of the DRAM are summarized in Table 7.
They show that using recurrent binary/ternary weights results in up to 9 × lower power and 10.6 × lower silicon area compared to the baseline when performing the inference computations at 400 MHz.
For the high-speed design, we consider the same silicon area and power consumption for both the fullprecision and binary/ternary-precision models.
Since the MAC units of the binary/ternary-precision model require less silicon area and power consumption as a result of using multiplexers instead of multipliers, we can instantiate up to 10 × more MAC units, resulting in up to 10 × speedup compared to the full-precision model (see Table 7).
It is also worth noting that the models using recurrent binary/ternary weights also require up to 12 × less memory bandwidth than the full-precision models.
More details on the proposed architecture are provided in Appendix D.
C ONCLUSION
In this paper, we introduced a method that learns recurrent binary/ternary weights and eliminates most of the full-precision multiplications of the recurrent computations during the inference.
We showed that the proposed training method generalizes well over long sequences and across a wide range of temporal tasks such as word/character language modeling and pixel by pixel classiﬁcation tasks.
We also showed that learning recurrent binary/ternary weights brings a major beneﬁt to custom hardware implementations by replacing full-precision multipliers with hardware-friendly multiplexers and reducing the memory bandwidth.
For this purpose, we introduced two ASIC implementations: low-power and high-throughput implementations.
The former architecture can save up to 9 × power consumption and the latter speeds up the recurrent computations by a factor of 10.
A PPENDIX B
Learning recurrent binary/ternary weights are performed in two steps: forward propagation and backward propagation.
Forward Propagation :
A key point to learn recurrent binary/ternary weights is to batch-normalize the result of each vector-matrix multiplication with binary/ternary recurrent weights during the forward propagation.
More precisely, we ﬁrst binarize/ternarize the recurrent weights.
Afterwards, the unit activations are computed while using the recurrent binarized/ternarized weights for each time step and recurrent layer.
The unit activations are then normalized during the forward propagation.
Backward Propagation :
During the backward propagation, the gradient with respects to each parameter of each layer is computed.
Then, the updates for the parameters are obtained using a learning rule.
During the parameter update, we use full-precision weights since the parameter updates are small values.
More speciﬁcally, the recurrent weights are only binarized/ternarized during the forward propagation.
Algorithm 1 summarizes the training method that learns recurrent binary/ternary weights.
It is worth noting that batch normalizing the state unit c can optionally be used to better control over its relative contribution in the model.
B/T() speciﬁes the binarization/ternarization function.
The batch normalization transform is also denoted by BN( · ; φ, γ ).
L and T are also the number of LSTM layers and time steps, respectively
[Figure]
[Equation]
[Figure] [Equation] [Figure]
[Equation]
[Figure]
[Equation]
[Figure] [Figure]
[Equation]
[Figure]
[Equation]
[Figure]
[Equation]
+ BN ( W lox B/T x lt ; φ lox , 0)
+ b lo (cid:17) g lt =
tanh (cid:16) BN
( W lgh B/T h lt − 1 ; φ lgh , 0) + BN ( W lgx B/T x lt ; φ lgx , 0)
+ b lg (cid:17) c lt = f lt (cid:12) c
lt − 1 + i lt (cid:12) g lt h lt =
o lt (cid:12) tanh (cid:0) BN ( c lt ; φ lc , γ lc ) (cid:1) end x l +
=
h l 16 end 17 ˆ y = softmax ( W s h L + b s ) 18 2.
Backward Computations 19 Compute the loss function (cid:108) knowing ˆ y and y {+
+} Obtain the updates ∆ W s and ∆ b s by computing ∂ (cid:108) ∂ W s and ∂ (cid:108) ∂ b s , respectively 21 for l = 1 to L do
Obtain the updates ∆ W lfh , ∆ W lih , ∆ W loh , ∆ W lgh , ∆ W lfx , ∆ W lix , ∆ W lox and ∆ W lgx by computing ∂ (cid:108) ∂ W lfh B/T , ∂ (cid:108) ∂ W lih B/T , ∂ (cid:108) ∂ W loh B/T , ∂ (cid:108) ∂ W lgh B/T , ∂ (cid:108) ∂ W lfx B/T , ∂ (cid:108) ∂ W lix B/T , ∂ (cid:108) ∂ W lox B/T and ∂ (cid:108)
∂ W lgx B/T , respectively Obtain the updates ∆ b lf , ∆ b li , ∆ b lo , ∆ b lg , ∆ h l 0 and ∆ c l 0 by computing ∂ (cid:108) ∂ b lf , ∂ (cid:108) ∂ b li , ∂ (cid:108) ∂ b lo , ∂ (cid:108) ∂
b lg , ∂ (cid:108) ∂
h l 0 and ∂ (cid:108) ∂ c l 0 , respectively ∆ ∆ lfx ∆ lix
∆ lox ∆ φ lgx ∆ φ lc and ∆ γ lc (cid:108)
[Equation] ∂ (cid:108) ∂φ lc and ∂ (cid:108) ∂γ lc , [Figure]
A PPENDIX C C. C HARACTER -L EVEL L ANGUAGE M ODELING
Penn Treebank : Similar to Mikolov et al.
(2012), we split the Penn Treebank corpus into 5017k, 393k and 442k training, validation and test characters, respectively.
For this task, we use an LSTM with 1000 units followed by a softmax classiﬁer.
The cross entropy loss is minimized on minibatches of size 64 while using ADAM learning rule.
We use a learning rate of 0.002.
We also use the training sequence length of size 100.
Figure 6 depicts the probability density of the states/gates of our binarized model trained on the Penn Treebank corpus.
While the probability density of our model is different from its full-precision counterpart (see Figure 4), it shows that the gates can control the ﬂow of information.
Linux Kernel and Leo Tolstoy’s War & Peace : Linux Kernel and Leo Tolstoy’s War and Peace corpora consist of 6,206,996 and 3,258,246 characters and have a vocabulary size of 101 and 87, respectively.
We split these two datasets similar to Karpathy et al. (2015).
We use one LSTM layer of size 512 followed by a softmax classiﬁer layer.
We use an exponentially decaying learning rate initialized with 0.002.
ADAM learning rule is also used as the update rule.
Text8 : This dataset has the vocabulary size of 27 and consists of 100M characters.
Following the data preparation approach of Mikolov et al.
(2012), we split the data into training, validation and test sets as 90M, 5M and 5M characters, respectively.
For this task, we use one LSTM layer of sizeand train it on sequences of length 180 with minibatches of size 128.
The learning rate of 0.001 is used and the update rule is determined by ADAM.
C. W ORD -L EVEL L ANGUAGE M ODELING
Penn Treebank : Similar to Mikolov et al. (2010), we split the Penn Treebank corpus with a 10K size vocabulary, resulting in 929K training, 73K validation, and 82K test tokens.
We start the training with a learning rate of 20.
We then divide it by 4 every time we see an increase in the validation perplexity value.
The model is trained with the word sequence length of 35 and the dropout probability of 0.5,
0.65 and 0.65 for the small, medium and large models, respectively.
Stochastic gradient descent is also used to train our model while the gradient norm is clipped at 0.25.
C. S EQUENTIAL MNIST
MNIST : MNIST dataset contains 60000 gray-scale images (50000 for training and 10000 for testing), falling into 10 classes.
For this task, we process the pixels in scanline order: each image pixel is processed at each time step similar to Le et al.
We train our models using an LSTM withnodes, a softmax classiﬁer layer and ADAM step rule with learning rate of 0.001.
C. Q UESTION A NSWERING
CNN : For this task, we split the data similar to Hermann et al.
We adopt Attentive Reader architecture to perform this task.
We train the model using bidirectional LSTM with unit size of 256.
We also use minibatches of size 128 and ADAM learning rule.
We use an exponentially decaying learning rate initialized with 0.003.
A PPENDIX D
We implemented our binary/ternary architecture in VHDL and synthesized via Cadence Genus
Synthesis Solution using TSMC 65nm GP CMOS technology.
Figure 7 shows the latency of the proposed binary/ternary architecture for each time step and temporal task when performing the vector-matrix multiplications on binary/ternary weights.
The simulation results show that performing the computations on binary and ternary weights can speed up the computations by factors of 10 × and 5 × compared to the full-precision models. [Figure]