Compression of Neural Machine Translation Models via Pruning

Abigail See∗ Minh-Thang Luong∗ Christopher D. ManningComputer Science Department, Stanford University, Stanford, CA 94305

{abisee,lmthang,manning}@stanford.edu

Abstract

Neural Machine Translation (NMT), likemany other deep learning domains, typ-ically suffers from over-parameterization,resulting in large storage sizes. This paperexamines three simple magnitude-basedpruning schemes to compress NMT mod-els, namely class-blind, class-uniform,and class-distribution, which differ interms of how pruning thresholds are com-puted for the different classes of weights inthe NMT architecture. We demonstrate theefficacy of weight pruning as a compres-sion technique for a state-of-the-art NMTsystem. We show that an NMT model withover 200 million parameters can be prunedby 40% with very little performance lossas measured on the WMT’14 English-German translation task. This sheds lighton the distribution of redundancy in theNMT architecture. Our main result is thatwith retraining, we can recover and evensurpass the original performance with an80%-pruned model.

1 Introduction

Neural Machine Translation (NMT) is a simplenew architecture for translating texts from one lan-guage into another (Sutskever et al., 2014; Cho etal., 2014). NMT is a single deep neural networkthat is trained end-to-end, holding several advan-tages such as the ability to capture long-range de-pendencies in sentences, and generalization to un-seen texts. Despite being relatively new, NMT hasalready achieved state-of-the-art translation re-sults for several language pairs including English-French (Luong et al., 2015b), English-German(Jean et al., 2015a; Luong et al., 2015a; Luong and

∗Both authors contributed equally.

student  a  am  I   Je  

Je   suis  

suis   étudiant    

étudiant     _  

_  

source  language  input   target  language  input  

target  language  output  

Figure 1: A simplified diagram of NMT.

Manning, 2015; Sennrich et al., 2016), English-Turkish (Sennrich et al., 2016), and English-Czech(Jean et al., 2015b; Luong and Manning, 2016).Figure 1 gives an example of an NMT system.

While NMT has a significantly smaller memoryfootprint than traditional phrase-based approaches(which need to store gigantic phrase-tables andlanguage models), the model size of NMT is stillprohibitively large for mobile devices. For exam-ple, a recent state-of-the-art NMT system requiresover 200 million parameters, resulting in a stor-age size of hundreds of megabytes (Luong et al.,2015a). Though the trend for bigger and deeperneural networks has brought great progress, it hasalso introduced over-parameterization, resulting inlong running times, overfitting, and the storagesize issue discussed above. A solution to the over-parameterization problem could potentially aid allthree issues, though the first (long running times)is outside the scope of this paper.

Our contribution. In this paper we investi-gate the efficacy of weight pruning for NMT asa means of compression. We show that despite

its simplicity, magnitude-based pruning with re-training is highly effective, and we compare threemagnitude-based pruning schemes — class-blind,class-uniform and class-distribution. Though re-cent work has chosen to use the latter two, wefind the first and simplest scheme — class-blind— the most successful. We are able to prune 40%of the weights of a state-of-the-art NMT systemwith negligible performance loss, and by adding aretraining phase after pruning, we can prune 80%with no performance loss. Our pruning experi-ments also reveal some patterns in the distributionof redundancy in NMT. In particular we find thathigher layers, attention and softmax weights arethe most important, while lower layers and the em-bedding weights hold a lot of redundancy. For theLong Short-Term Memory (LSTM) architecture,we find that at lower layers the parameters for theinput are most crucial, but at higher layers the pa-rameters for the gates also become important.

2 Related Work

Pruning the parameters from a neural network,referred to as weight pruning or network prun-ing, is a well-established idea though it can beimplemented in many ways. Among the mostpopular are the Optimal Brain Damage (OBD)(Le Cun et al., 1989) and Optimal Brain Sur-geon (OBS) (Hassibi and Stork, 1993) techniques,which involve computing the Hessian matrix ofthe loss function with respect to the parameters,in order to assess the saliency of each parame-ter. Parameters with low saliency are then prunedfrom the network and the remaining sparse net-work is retrained. Both OBD and OBS wereshown to perform better than the so-called ‘naivemagnitude-based approach’, which prunes param-eters according to their magnitude (deleting pa-rameters close to zero). However, the high com-putational complexity of OBD and OBS compareunfavorably to the computational simplicity of themagnitude-based approach, especially for largenetworks (Augasta and Kathirvalavakumar, 2013).

In recent years, the deep learning renaissancehas prompted a re-investigation of network prun-ing for modern models and tasks. Magnitude-based pruning with iterative retraining has yieldedstrong results for Convolutional Neural Networks(CNN) performing visual tasks. Collins and Kohli(2014) prune 75% of AlexNet parameters withsmall accuracy loss on the ImageNet task, while

Han et al. (2015b) prune 89% of AlexNet parame-ters with no accuracy loss on the ImageNet task.

Other approaches focus on pruning neuronsrather than parameters, via sparsity-inducing regu-larizers (Murray and Chiang, 2015) or ‘wiring to-gether’ pairs of neurons with similar input weights(Srinivas and Babu, 2015). These approachesare much more constrained than weight-pruningschemes; they necessitate finding entire zero rowsof weight matrices, or near-identical pairs of rows,in order to prune a single neuron. By contrastweight-pruning approaches allow weights to bepruned freely and independently of each other.The neuron-pruning approach of Srinivas andBabu (2015) was shown to perform poorly (it suf-fered performance loss after removing only 35%of AlexNet parameters) compared to the weight-pruning approach of Han et al. (2015b). ThoughMurray and Chiang (2015) demonstrates neuron-pruning for language modeling as part of a (non-neural) Machine Translation pipeline, their ap-proach is more geared towards architecture selec-tion than compression.

There are many other compression techniquesfor neural networks, including approaches basedon on low-rank approximations for weight matri-ces (Jaderberg et al., 2014; Denton et al., 2014),or weight sharing via hash functions (Chen et al.,2015). Several methods involve reducing the pre-cision of the weights or activations (Courbariauxet al., 2015), sometimes in conjunction with spe-cialized hardware (Gupta et al., 2015), or even us-ing binary weights (Lin et al., 2016). The ‘knowl-edge distillation’ technique of Hinton et al. (2015)involves training a small ‘student’ network on thesoft outputs of a large ‘teacher’ network. Someapproaches use a sophisticated pipeline of severaltechniques to achieve impressive feats of compres-sion (Han et al., 2015a; Iandola et al., 2016).

Most of the above work has focused on com-pressing CNNs for vision tasks. We extend themagnitude-based pruning approach of Han et al.(2015b) to recurrent neural networks (RNN), inparticular LSTM architectures for NMT, and toour knowledge we are the first to do so. Therehas been some recent work on compression forRNNs (Lu et al., 2016; Prabhavalkar et al., 2016),but it focuses on other, non-pruning compressiontechniques. Nonetheless, our general observationson the distribution of redundancy in a LSTM, de-tailed in Section 4.5, are corroborated by Lu et al.

studentaamI Je

Je suis

suis étudiant

étudiant _

one-hot vectors length V

word embeddings length n

hidden layer 1 length n

hidden layer 2
length n

scores length V

one-hot vectors
length V

_

source language input target language input

initial (zero) states

target language output

softmax weights size: V × n

Key to weight classes

attention hidden layer length n

context vector (one for each target word)

length n

target 
layer 2

weights size: 4n x 2n

source embedding weights

size: n x V

attention weights

size: n x 2n

target 
layer 1

weights size: 4n x 2n

source
layer 2

weights size: 4n x 2n

source
layer 1


weights size: 4n x 2n

target embedding weights

size: n x V

Figure 2: NMT architecture. This example has two layers, but our system has four. The different weightclasses are indicated by arrows of different color (the black arrows in the top right represent simplychoosing the highest-scoring word, and thus require no parameters). Best viewed in color.

(2016).

3 Our Approach

We first give a brief overview of Neural Ma-chine Translation before describing the model ar-chitecture of interest, the deep multi-layer recur-rent model with LSTM. We then explain the dif-ferent types of NMT weights together with our ap-proaches to pruning and retraining.

3.1 Neural Machine TranslationNeural machine translation aims to directly modelthe conditional probability p(y|x) of translating asource sentence, x1, . . . , xn, to a target sentence,y1, . . . , ym. It accomplishes this goal through anencoder-decoder framework (Kalchbrenner andBlunsom, 2013; Sutskever et al., 2014; Cho et al.,2014). The encoder computes a representation sfor each source sentence. Based on that sourcerepresentation, the decoder generates a transla-tion, one target word at a time, and hence, decom-poses the log conditional probability as:

log p(y|x) =∑m

t=1log p (yt|y

The source input sentence and target input sen-tence, represented as a sequence of one-hot vec-tors, are transformed into a sequence of word em-beddings by the embedding weights. These em-bedding weights, which are learned during train-ing, are different for the source words and the tar-get words. The word embeddings and all hiddenlayers are vectors of length n (a chosen hyperpa-rameter).

The word embeddings are then fed as input intothe main network, which consists of two multi-layer RNNs ‘stuck together’ — an encoder for thesource language and a decoder for the target lan-guage, each with their own weights. The feed-forward (vertical) weights connect the hidden unitfrom the layer below to the upper RNN block, andthe recurrent (horizontal) weights connect the hid-den unit from the previous time-step RNN block tothe current time-step RNN block.

The hidden state at the top layer of the decoderis fed through an attention layer, which guides thetranslation by ‘paying attention’ to relevant partsof the source sentence; for more information seeBahdanau et al. (2015) or Section 3 of Luong etal. (2015a). Finally, for each target word, the toplayer hidden unit is transformed by the softmaxweights into a score vector of length V . The tar-get word with the highest score is selected as theoutput translation.

Weight Subgroups in LSTM – For the afore-mentioned RNN block, we choose to use LSTM asthe hidden unit type. To facilitate our later discus-sion on the different subgroups of weights withinLSTM, we first review the details of LSTM as for-mulated by Zaremba et al. (2014) as follows:

ifo

ĥ

=

sigmsigmsigmtanh

T4n,2n(hl−1thlt−1)

(2)

clt = f ◦ clt−1 + i ◦ ĥ (3)hlt = o ◦ tanh(clt) (4)

Here, each LSTM block at time t and layer l com-putes as output a pair of hidden and memory vec-tors (hlt, c

lt) given the previous pair (h

lt−1, c

lt−1)

and an input vector hl−1t (either from the LSTMblock below or the embedding weights if l = 1).All of these vectors have length n.

The core of a LSTM block is the weight matrixT4n,2n of size 4n×2n. This matrix can be decom-posed into 8 subgroups that are responsible for the

interactions between {input gate i, forget gate f ,output gate o, input signal ĥ} × {feed-forward in-put hl−1t , recurrent input h

lt−1}.

3.3 Pruning Schemes

We follow the general magnitude-based approachof Han et al. (2015b), which consists of pruningweights with smallest absolute value. However,we question the authors’ pruning scheme with re-spect to the different weight classes, and exper-iment with three pruning schemes. Suppose wewish to prune x% of the total parameters in themodel. How do we distribute the pruning over thedifferent weight classes (illustrated in Figure 2) ofour model? We propose to examine three differentpruning schemes:

1. Class-blind: Take all parameters, sort themby magnitude and prune the x% with smallestmagnitude, regardless of weight class. (Sosome classes are pruned proportionally morethan others).

2. Class-uniform: Within each class, sort theweights by magnitude and prune the x% withsmallest magnitude. (So all classes have ex-actly x% of their parameters pruned).

3. Class-distribution: For each class c, weightswith magnitude less than λσc are pruned.Here, σc is the standard deviation of that classand λ is a universal parameter chosen suchthat in total, x% of all parameters are pruned.This is used by Han et al. (2015b).

All these schemes have their seeming advantages.Class-blind pruning is the simplest and adheres tothe principle that pruning weights (or equivalently,setting them to zero) is least damaging when thoseweights are small, regardless of their locations inthe architecture. Class-uniform pruning and class-distribution pruning both seek to prune proportion-ally within each weight class, either absolutely,or relative to the standard deviation of that class.We find that class-blind pruning outperforms bothother schemes (see Section 4.1).

3.4 Retraining

In order to prune NMT models aggressively with-out performance loss, we retrain our pruned net-works. That is, we continue to train the remainingweights, but maintain the sparse structure intro-duced by pruning. In our implementation, pruned

0 10 20 30 40 50 60 70 80 900

10

20

percentage pruned

BL

EU

scor

e

class-blindclass-uniformclass-distribution

Figure 3: Effects of different pruning schemes.

weights are represented by zeros in the weight ma-trices, and we use binary ‘mask’ matrices, whichrepresent the sparse structure of a network, to ig-nore updates to weights at pruned locations. Thisimplementation has the advantage of simplicityas it requires minimal changes to the trainingand deployment code, but we note that a morecomplex implementation utilizing sparse matricesand sparse matrix multiplication could potentiallyyield speed improvements. However, such an im-plementation is beyond the scope of this paper.

4 Experiments

We evaluate the effectiveness of our pruningapproaches on a state-of-the-art NMT model.1

Specifically, an attention-based English-GermanNMT system from Luong et al. (2015a) is consid-ered. Training data was obtained from WMT’14consisting of 4.5M sentence pairs (116M Englishwords, 110M German words). For more detailson training hyperparameters, we refer readers toSection 4.1 of Luong et al. (2015a). All modelsare tested on newstest2014 (2737 sentences). Themodel achieves a perplexity of 6.1 and a BLEUscore of 20.5 (after unknown word replacement).2

When retraining pruned NMT systems, we usethe following settings: (a) we start with a smallerlearning rate of 0.5 (the original model uses alearning rate of 1.0), (b) we train for fewer epochs,4 instead of 12, using plain SGD, (c) a simplelearning rate schedule is employed; after 2 epochs,we begin to halve the learning rate every half anepoch, and (d) all other hyperparameters are the

1We thank the authors of Luong et al. (2015a) for provid-ing their trained models and assistance in using the codebaseat https://github.com/lmthang/nmt.matlab.

2The performance of this model is reported under rowglobal (dot) in Table 4 of Luong et al. (2015a).

same, such as mini-batch size 128, maximum gra-dient norm 5, and dropout with probability 0.2.

4.1 Comparing pruning schemesDespite its simplicity, we observe in Figure 3that class-blind pruning outperforms both otherschemes in terms of translation quality at all prun-ing percentages. In order to understand this result,for each of the three pruning schemes, we prunedeach class separately and recorded the effect onperformance (as measured by perplexity). Figure4 shows that with class-uniform pruning, the over-all performance loss is caused disproportionatelyby a few classes: target layer 4, attention and soft-max weights. Looking at Figure 5, we see thatthe most damaging classes to prune also tend to bethose with weights of greater magnitude — theseclasses have much larger weights than others at thesame percentile, so pruning them under the class-uniform pruning scheme is more damaging. Thesituation is similar for class-distribution pruning.

By contrast, Figure 4 shows that under class-blind pruning, the damage caused by pruning soft-max, attention and target layer 4 weights is greatlydecreased, and the contribution of each class to-wards the performance loss is overall more uni-form. In fact, the distribution begins to reflectthe number of parameters in each class — for ex-ample, the source and target embedding classeshave larger contributions because they have moreweights. We use only class-blind pruning for therest of the experiments.

Figure 4 also reveals some interesting informa-tion about the distribution of redundancy in NMTarchitectures — namely it seems that higher lay-ers are more important than lower layers, and thatattention and softmax weights are crucial. We willexplore the distribution of redundancy further inSection 4.5.

4.2 Pruning and retrainingPruning has an immediate negative impact on per-formance (as measured by BLEU) that is exponen-tial in pruning percentage; this is demonstrated bythe blue line in Figure 6. However we find that upto about 40% pruning, performance is mostly un-affected, indicating a large amount of redundancyand over-parameterization in NMT.

We now consider the effect of retraining prunedmodels. The orange line in Figure 6 shows that af-ter retraining the pruned models, baseline perfor-mance (20.48 BLEU) is both recovered and im-

sourc

e lay

er1

sourc

e lay

er2

sourc

e lay

er3

sourc

e lay

er4

targe

t laye

r 1

targe

t laye

r 2

targe

t laye

r 3

targe

t laye

r 4

atten

tion

softm

ax

sourc

e emb

eddin

g

targe

t emb

eddin

g

0

5

10

15pe

rple

xity

chan

geclass-blindclass-uniformclass-distribution

Figure 4: ‘Breakdown’ of performance loss (i.e., perplexity increase) by weight class, when pruning90% of weights using each of the three pruning schemes. Each of the first eight classes have 8 millionweights, attention has 2 million, and the last three have 50 million weights each.

0 0.1 0.2 0.3 0.4 0.5

100

101

magnitude of largest deleted weight

perp

lexi

tych

ange

Figure 5: Magnitude of largest deleted weightvs. perplexity change, for the 12 different weightclasses when pruning 90% of parameters by class-uniform pruning.

proved upon, up to 80% pruning (20.91 BLEU),with only a small performance loss at 90% pruning(20.13 BLEU). This may seem surprising, as wemight not expect a sparse model to significantlyout-perform a model with five times as many pa-rameters. There are several possible explanations,two of which are given below.

Firstly, we found that the less-pruned modelsperform better on the training set than the vali-dation set, whereas the more-pruned models havecloser performance on the two sets. This indicatesthat pruning has a regularizing effect on the re-training phase, though clearly more is not alwaysbetter, as the 50% pruned and retrained model hasbetter validation set performance than the 90%

0 10 20 30 40 50 60 70 80 900

10

20

percentage pruned

BL

EU

scor

e

prunedpruned and retrainedsparse from the beginning

Figure 6: Performance of pruned models (a) afterpruning, (b) after pruning and retraining, and (c)when trained with sparsity structure from the out-set (see Section 4.3).

pruned and retrained model. Nonetheless, this reg-ularization effect may explain why the pruned andretrained models outperform the baseline.

Alternatively, pruning may serve as a means toescape a local optimum. Figure 7 shows the lossfunction over time during the training, pruning andretraining process. During the original trainingprocess, the loss curve flattens out and seems toconverge (note that we use early stopping to ob-tain our baseline model, so the original model wastrained for longer than shown in Figure 7). Prun-ing causes an immediate increase in the loss func-tion, but enables further gradient descent, allowingthe retraining process to find a new, better localoptimum. It seems that the disruption caused by

0 1 2 3 4 5

·105

2

4

6

8

training iterations

loss

Figure 7: The validation set loss during training,pruning and retraining. The vertical dotted linemarks the point when 80% of the parameters arepruned. The horizontal dotted line marks the bestperformance of the unpruned baseline.

pruning is beneficial in the long-run.

4.3 Starting with sparse models

The favorable performance of the pruned and re-trained models raises the question: can we geta shortcut to this performance by starting withsparse models? That is, rather than train, prune,and retrain, what if we simply prune then train?To test this, we took the sparsity structure of our50%–90% pruned models, and trained completelynew models with the same sparsity structure. Thepurple line in Figure 6 shows that the ‘sparse fromthe beginning’ models do not perform as well asthe pruned and retrained models, but they do comeclose to the baseline performance. This shows thatwhile the sparsity structure alone contains usefulinformation about redundancy and can thereforeproduce a competitive compressed model, it is im-portant to interleave pruning with training.

Though our method involves just one pruningstage, other pruning methods interleave pruningwith training more closely by including severaliterations (Collins and Kohli, 2014; Han et al.,2015b). We expect that implementing this forNMT would likely result in further compressionand performance improvements.

4.4 Storage size

The original unpruned model (a MATLAB file)has size 782MB. The 80% pruned and retrainedmodel is 272MB, which is a 65.2% reduction. Inthis work we focus on compression in terms ofnumber of parameters rather than storage size, be-

cause it is invariant across implementations.

4.5 Distribution of redundancy in NMT

We visualize in Figure 8 the redundancy struc-tore of our NMT baseline model. Black pix-els represent weights near to zero (those that canbe pruned); white pixels represent larger ones.First we consider the embedding weight matrices,whose columns correspond to words in the vocab-ulary. Unsurprisingly, in Figure 8, we see thatthe parameters corresponding to the less commonwords are more dispensable. In fact, at the 80%pruning rate, for 100 uncommon source wordsand 1194 uncommon target words, we delete allparameters corresponding to that word. This isnot quite the same as removing the word fromthe vocabulary — true out-of-vocabulary wordsare mapped to the embedding for the ‘unknownword’ symbol, whereas these ‘pruned-out’ wordsare mapped to a zero embedding. However in theoriginal unpruned model these uncommon wordsalready had near-zero embeddings, indicating thatthe model was unable to learn sufficiently distinc-tive representations.

Returning to Figure 8, now look at the eightweight matrices for the source and target connec-tions at each of the four layers. Each matrix corre-sponds to the 4n × 2n matrix T4n,2n in Equation(2). In all eight matrices, we observe — as doesLu et al. (2016) — that the weights connecting tothe input ĥ are most crucial, followed by the in-put gate i, then the output gate o, then the forgetgate f . This is particularly true of the lower lay-ers, which focus primarily on the input ĥ. How-ever for higher layers, especially on the target side,weights connecting to the gates are as important asthose connecting to the input ĥ. The gates repre-sent the LSTM’s ability to add to, delete from orretrieve information from the memory cell. Figure8 therefore shows that these sophisticated memorycell abilities are most important at the end of theNMT pipeline (the top layer of the decoder). Thisis reasonable, as we expect higher-level features tobe learned later in a deep learning pipeline.

We also observe that for lower layers, the feed-forward input is much more important than the re-current input, whereas for higher layers the recur-rent input becomes more important. This makessense: lower layers concentrate on the low-levelinformation from the current word embedding (thefeed-forward input), whereas higher layers make

target embedding weights

source embedding weights

least common wordmost common word

source layer 1 weights

recurrentfeed-forward

input gate

forget gate

output gate

input

source layer 2 weights source layer 3 weights source layer 4 weights

target layer 1 weights target layer 2 weights target layer 3 weights target layer 4 weights

Figure 8: Graphical representation of the location of small weights in various parts of the model. Blackpixels represent weights with absolute size in the bottom 80%; white pixels represent those with absolutesize in the top 20%. Equivalently, these pictures illustrate which parameters remain after pruning 80%using our class-blind pruning scheme.

use of the higher-level representation of the sen-tence so far (the recurrent input).

Lastly, on close inspection, we notice severalwhite diagonals emerging within some subsquaresof the matrices in Figure 8, indicating that evenwithout initializing the weights to identity ma-trices (as is sometimes done (Le et al., 2015)),an identity-like weight matrix is learned. Athigher pruning percentages, these diagonals be-come more pronounced.

5 Generalizability of our results

To test the generalizability of our results, wealso test our pruning approach on a smaller, non-state-of-the-art NMT model trained on the WIT3Vietnamese-English dataset (Cettolo et al., 2012),which consists of 133,000 sentence pairs. Thismodel is effectively a scaled-down version of thestate-of-the-art model in Luong et al. (2015a), withfewer layers, smaller vocabulary size, smaller hid-den layer size, no attention mechanism, and about11% as many parameters in total. It achieves aBLEU score of 9.61 on the validation set.

Although this model and its training set are ona different scale to our main model, and the lan-guage pair is different, we found very similar re-sults. For this model, it is possible to prune 60% ofparameters with no immediate performance loss,and with retraining it is possible to prune 90%, andregain original performance. Our main observa-tions from Sections 4.1 to 4.5 are also replicated;in particular, class-blind pruning is most success-ful, ‘sparse from the beginning’ models are lesssuccessful than pruned and retrained models, andwe observe the same patterns as seen in Figure 8.

6 Future Work

As noted in Section 4.3, including several itera-tions of pruning and retraining would likely im-prove the compression and performance of ourpruning method. If possible it would be highlyvaluable to exploit the sparsity of the pruned mod-els to speed up training and runtime, perhapsthrough sparse matrix representations and mul-tiplications (see Section 3.4). Though we havefound magnitude-based pruning to perform verywell, it would be instructive to revisit the orig-inal claim that other pruning methods (for ex-ample Optimal Brain Damage and Optimal BrainSurgery) are more principled, and perform a com-parative study.

7 Conclusion

We have shown that weight pruning with retrain-ing is a highly effective method of compressionand regularization on a state-of-the-art NMT sys-tem, compressing the model to 20% of its size withno loss of performance. Though we are the first toapply compression techniques to NMT, we obtaina similar degree of compression to other currentwork on compressing state-of-the-art deep neuralnetworks, with an approach that is simpler thanmost. We have found that the absolute size of pa-rameters is of primary importance when choosingwhich to prune, leading to an approach that is ex-tremely simple to implement, and can be appliedto any neural network. Lastly, we have gainedinsight into the distribution of redundancy in theNMT architecture.

8 Acknowledgment

This work was partially supported by NSF AwardIIS-1514268 and partially supported by a giftfrom Bloomberg L.P. We gratefully acknowledgethe support of the Defense Advanced ResearchProjects Agency (DARPA) Communicating withComputers (CwC) program under ARO primecontract no. W911NF-15-1-0462. Lastly, we ac-knowledge NVIDIA Corporation for the donationof Tesla K40 GPUs.

ReferencesM. Gethsiyal Augasta and Thangairulappan Kathir-

valavakumar. 2013. Pruning algorithms of neuralnetworks - a comparative study. Central EuropeanJournal of Computer Science, 3(3):105–115.

Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Ben-gio. 2015. Neural machine translation by jointlylearning to align and translate. In ICLR.

Mauro Cettolo, Christian Girardi, and Marcello Fed-erico. 2012. Wit3: Web inventory of transcribedand translated talks. In EAMT.

Wenlin Chen, James T Wilson, Stephen Tyree, Kilian QWeinberger, and Yixin Chen. 2015. Compressingneural networks with the hashing trick. In ICML.

Kyunghyun Cho, Bart van Merrienboer, Caglar Gul-cehre, Fethi Bougares, Holger Schwenk, and YoshuaBengio. 2014. Learning phrase representationsusing RNN encoder-decoder for statistical machinetranslation. In EMNLP.

Maxwell D. Collins and Pushmeet Kohli. 2014. Mem-ory bounded deep convolutional networks. arXivpreprint arXiv:1412.1442.

Matthieu Courbariaux, Yoshua Bengio, and Jean-PierreDavid. 2015. Training deep neural networks withlow precision multiplications. In ICLR workshop.

Emily L. Denton, Wojciech Zaremba, Joan Bruna,Yann LeCun, and Rob Fergus. 2014. Exploiting lin-ear structure within convolutional networks for effi-cient evaluation. In NIPS.

Suyog Gupta, Ankur Agrawal, Kailash Gopalakrish-nan, and Pritish Narayanan. 2015. Deep learningwith limited numerical precision. In ICML.

Song Han, Huizi Mao, and William J Dally. 2015a.Deep compression: Compressing deep neural net-works with pruning, trained quantization and huff-man coding. In ICLR.

Song Han, Jeff Pool, John Tran, and William Dally.2015b. Learning both weights and connections forefficient neural network. In NIPS.

Babak Hassibi and David G. Stork. 1993. Second or-der derivatives for network pruning: Optimal brainsurgeon. Morgan Kaufmann.

Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. 2015.Distilling the knowledge in a neural network. InNIPS Deep Learning Workshop.

Sepp Hochreiter and Jürgen Schmidhuber. 1997.Long short-term memory. Neural computation,9(8):1735–1780.

Forrest N. Iandola, Matthew W. Moskewicz, KhalidAshraf, Song Han, William J. Dally, and KurtKeutzer. 2016. Squeezenet: Alexnet-level accuracywith 50x fewer parameters and< 0.5MB model size.arXiv preprint arXiv:1602.07360.

Max Jaderberg, Andrea Vedaldi, and Andrew Zisser-man. 2014. Speeding up convolutional neural net-works with low rank expansions. In NIPS.

Sébastien Jean, Kyunghyun Cho, Roland Memisevic,and Yoshua Bengio. 2015a. On using very largetarget vocabulary for neural machine translation. InACL.

Sébastien Jean, Orhan Firat, Kyunghyun Cho, RolandMemisevic, and Yoshua Bengio. 2015b. Montrealneural machine translation systems for WMT’15. InWMT.

Nal Kalchbrenner and Phil Blunsom. 2013. Recurrentcontinuous translation models. In EMNLP.

Quoc V. Le, Navdeep Jaitly, and Geoffrey E. Hin-ton. 2015. A simple way to initialize recurrentnetworks of rectified linear units. arXiv preprintarXiv:1504.00941.

Yann Le Cun, John S. Denker, and Sara A. Solla. 1989.Optimal brain damage. In NIPS.

Zhouhan Lin, Matthieu Courbariaux, Roland Memise-vic, and Yoshua Bengio. 2016. Neural networkswith few multiplications. In ICLR.

Zhiyun Lu, Vikas Sindhwani, and Tara N. Sainath.2016. Learning compact recurrent neural networks.In ICASSP.

Minh-Thang Luong and Christopher D. Manning.2015. Stanford neural machine translation systemsfor spoken language domain. In IWSLT.

Minh-Thang Luong and Christopher D. Manning.2016. Achieving open vocabulary neural machinetranslation with hybrid word-character models. InACL.

Minh-Thang Luong, Hieu Pham, and Christopher D.Manning. 2015a. Effective approaches to attention-based neural machine translation. In EMNLP.

Minh-Thang Luong, Ilya Sutskever, Quoc V. Le, OriolVinyals, and Wojciech Zaremba. 2015b. Address-ing the rare word problem in neural machine trans-lation. In ACL.

Kenton Murray and David Chiang. 2015. Auto-sizingneural networks: With applications to n-gram lan-guage models. In EMNLP.

Rohit Prabhavalkar, Ouais Alsharif, Antoine Bruguier,and Ian McGraw. 2016. On the compressionof recurrent neural networks with an applicationto LVCSR acoustic modeling for embedded speechrecognition. In ICASSP.

Rico Sennrich, Barry Haddow, and Alexandra Birch.2016. Improving neural machine translation modelswith monolingual data. In ACL.

Suraj Srinivas and R. Venkatesh Babu. 2015. Data-free parameter pruning for deep neural networks. InBMVC.

Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. 2014.Sequence to sequence learning with neural net-works. In NIPS.

Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals.2014. Recurrent neural network regularization.arXiv preprint arXiv:1409.2329.