Sequence-to-Sequence Learning as Beam-Search Optimization

Sequence-to-Sequence (seq2seq) modeling has rapidly become an important general-purpose NLP tool that has proven effective for many text-generation and sequence-labeling tasks. Seq2seq builds on deep neural language modeling and inherits its remarkable accuracy in estimating local, next-word distributions. In this work, we introduce a model and beam-search training scheme, based on the work of Daume III and Marcu (2005), that extends seq2seq to learn global sequence scores. This structured approach avoids classical biases associated with local training and unifies the training loss with the test-time usage, while preserving the proven model architecture of seq2seq and its efficient training approach. We show that our system outperforms a highly-optimized attention-based seq2seq system and other baselines on three different sequence to sequence tasks: word ordering, parsing, and machine translation.


Introduction
Sequence-to-Sequence learning with deep neural networks (herein, seq2seq) (Sutskever et al., 2011; has rapidly become a very useful and surprisingly general-purpose tool for natural language processing. In addition to demonstrating impressive results for machine translation (Bahdanau et al., 2015), roughly the same model and training have also proven to be useful for sentence compression (Filippova et al., 2015), parsing , and dialogue systems (Serban et al., 2016), and they additionally underlie other text generation applications, such as image or video captioning (Venugopalan et al., 2015;Xu et al., 2015).
The dominant approach to training a seq2seq system is as a conditional language model, with training maximizing the likelihood of each successive target word conditioned on the input sequence and the gold history of target words. Thus, training uses a strictly word-level loss, usually cross-entropy over the target vocabulary. This approach has proven to be very effective and efficient for training neural language models, and seq2seq models similarly obtain impressive perplexities for word-generation tasks.
Notably, however, seq2seq models are not used as conditional language models at test-time; they must instead generate fully-formed word sequences. In practice, generation is accomplished by searching over output sequences greedily or with beam search. In this context, Ranzato et al. (2016) note that the combination of the training and generation scheme just described leads to at least two major issues: 1. Exposure Bias: the model is never exposed to its own errors during training, and so the inferred histories at test-time do not resemble the gold training histories.
2. Loss-Evaluation Mismatch: training uses a word-level loss, while at test-time we target improving sequence-level evaluation metrics, such as BLEU (Papineni et al., 2002).
We might additionally add the concern of label bias (Lafferty et al., 2001) to the list, since wordprobabilities at each time-step are locally normalized, guaranteeing that successors of incorrect his-tories receive the same mass as do the successors of the true history.
In this work we develop a non-probabilistic variant of the seq2seq model that can assign a score to any possible target sequence, and we propose a training procedure, inspired by the learning as search optimization (LaSO) framework of Daumé III and Marcu (2005), that defines a loss function in terms of errors made during beam search. Furthermore, we provide an efficient algorithm to backpropagate through the beam-search procedure during seq2seq training.
This approach offers a possible solution to each of the three aforementioned issues, while largely maintaining the model architecture and training efficiency of standard seq2seq learning. Moreover, by scoring sequences rather than words, our approach also allows for enforcing hard-constraints on sequence generation at training time. To test out the effectiveness of the proposed approach, we develop a general-purpose seq2seq system with beam search optimization. We run experiments on three very different problems: word ordering, syntactic parsing, and machine translation, and compare to a highlytuned seq2seq system with attention (Luong et al., 2015). The version with beam search optimization shows significant improvements on all three tasks, and particular improvements on tasks that require difficult search.

Related Work
The issues of exposure bias and label bias have received much attention from authors in the structured prediction community, and we briefly review some of this work here. One prominent approach to combating exposure bias is that of SEARN (Daumé III et al., 2009), a meta-training algorithm that learns a search policy in the form of a cost-sensitive classifier trained on examples generated from an interpolation of an oracle policy and the model's current (learned) policy. Thus, SEARN explicitly targets the mismatch between oracular training and non-oracular (often greedy) test-time inference by training on the output of the model's own policy. DAgger (Ross et al., 2011) is a similar approach, which differs in terms of how training examples are generated and aggregated, and there have additionally been impor-tant refinements to this style of training over the past several years (Chang et al., 2015). When it comes to training RNNs, SEARN/DAgger has been applied under the name "scheduled sampling" , which involves training an RNN to generate the t + 1'st token in a target sequence after consuming either the true t'th token, or, with probability that increases throughout training, the predicted t'th token.
Though technically possible, it is uncommon to use beam search when training with SEARN/DAgger. The early-update (Collins and Roark, 2004) and LaSO (Daumé III and Marcu, 2005) training strategies, however, explicitly account for beam search, and describe strategies for updating parameters when the gold structure becomes unreachable during search. Early update and LaSO differ primarily in that the former discards a training example after the first search error, whereas LaSO resumes searching after an error from a state that includes the gold partial structure. In the context of feed-forward neural network training, early update training has been recently explored in a feedforward setting by Zhou et al. (2015) and Andor et al. (2016). Our work differs in that we adopt a LaSO-like paradigm (with some minor modifications), and apply it to the training of seq2seq RNNs (rather than feed-forward networks). We also note that Watanabe and Sumita (2015) apply maximumviolation training (Huang et al., 2012), which is similar to early-update, to a parsing model with recurrent components, and that Yazdani and Henderson (2015) use beam-search in training a discriminative, locally normalized dependency parser with recurrent components.
Recently authors have also proposed alleviating exposure bias using techniques from reinforcement learning. Ranzato et al. (2016) follow this approach to train RNN decoders in a seq2seq model, and they obtain consistent improvements in performance, even over models trained with scheduled sampling. As Daumé III and Marcu (2005) note, LaSO is similar to reinforcement learning, except it does not require "exploration" in the same way. Such exploration may be unnecessary in supervised text-generation, since we typically know the gold partial sequences at each time-step. Shen et al. (2016) use minimum risk training (approximated by sampling) to address the issues of exposure bias and loss-evaluation mismatch for seq2seq MT, and show impressive performance gains.
Whereas exposure bias results from training in a certain way, label bias results from properties of the model itself. In particular, label bias is likely to affect structured models that make sub-structure predictions using locally-normalized scores. Because the neural and non-neural literature on this point has recently been reviewed by Andor et al. (2016), we simply note here that RNN models are typically locally normalized, and we are unaware of any specifically seq2seq work with RNNs that does not use locally-normalized scores. The model we introduce here, however, is not locally normalized, and so should not suffer from label bias. We also note that there are some (non-seq2seq) exceptions to the trend of locally normalized RNNs, such as the work of Sak et al. (2014) and Voigtlaender et al. (2015), who train LSTMs in the context of HMMs for speech recognition using sequence-level objectives; their work does not consider search, however.

Background and Notation
In the simplest seq2seq scenario, we are given a collection of source-target sequence pairs and tasked with learning to generate target sequences from source sequences. For instance, we might view machine translation in this way, where in particular we attempt to generate English sentences from (corresponding) French sentences. Seq2seq models are part of the broader class of "encoder-decoder" models (Cho et al., 2014), which first use an encoding model to transform a source object into an encoded representation x. Many different sequential (and non-sequential) encoders have proven to be effective for different source domains. In this work we are agnostic to the form of the encoding model, and simply assume an abstract source representation x.
Once the input sequence is encoded, seq2seq models generate a target sequence using a decoder. The decoder is tasked with generating a target sequence of words from a target vocabulary V. In particular, words are generated sequentially by conditioning on the input representation x and on the previously generated words or history. We use the notation w 1:T to refer to an arbitrary word sequence of length T , and the notation y 1:T to refer to the gold (i.e., correct) target word sequence for an input x.
Most seq2seq systems utilize a recurrent neural network (RNN) for the decoder model. Formally, a recurrent neural network is a parameterized nonlinear function RNN that recursively maps a sequence of vectors to a sequence of hidden states. Let m 1 , . . . , m T be a sequence of T vectors, and let h 0 be some initial state vector. Applying an RNN to any such sequence yields hidden states h t at each time-step t, as follows: where θ is the set of model parameters, which are shared over time. In this work, the vectors m t will always correspond to the embeddings of a target word sequence w 1:T , and so we will also write h t ← RNN(w t , h t−1 ; θ), with w t standing in for its embedding.
RNN decoders are typically trained to act as conditional language models. That is, one attempts to model the probability of the t'th target word conditioned on x and the target history by stipulating that p(w t |w 1:t−1 , x) = g(w t , h t−1 , x), for some parameterized function g typically computed with an affine layer followed by a softmax. In computing these probabilities, the state h t−1 represents the target history, and h 0 is typically set to be some function of x. The complete model (including encoder) is trained, analogously to a neural language model, to minimize the cross-entropy loss at each time-step while conditioning on the gold history in the training data. That is, the model is trained to minimize − ln T t=1 p(y t |y 1:t−1 , x). Once the decoder is trained, discrete sequence generation can be performed by approximately maximizing the probability of the target sequence under the conditional distribution, y 1:T = argbeam w 1:T T t=1 p(w t |w 1:t−1 , x), where we use the notation argbeam to emphasize that the decoding process requires heuristic search, since the RNN model is non-Markovian. In practice, a simple beam search procedure that explores K prospective histories at each time-step has proven to be an effective decoding approach. However, as noted above, decoding in this manner after conditional languagemodel style training potentially suffers from the is-sues of exposure bias and label bias, which motivates the work of this paper.

Beam Search Optimization
We begin by making one small change to the seq2seq modeling framework. Instead of predicting the probability of the next word, we instead learn to produce (non-probabilistic) scores for ranking sequences. Define the score of a sequence consisting of history w 1:t−1 followed by a single word w t as f (w t , h t−1 , x), where f is a parameterized function examining the current hidden-state of the relevant RNN at time t − 1 as well as the input representation x. In experiments, our f will have an identical form to g but without the final softmax transformation (which transforms unnormalized scores into probabilities), thereby allowing the model to avoid issues associated with the label bias problem.
More importantly, we also modify how this model is trained. Ideally we would train by comparing the gold sequence to the highest-scoring complete sequence. However, because finding the argmax sequence according to this model is intractable, we propose to adopt a LaSO-like (Daumé III and Marcu, 2005) scheme to train, which we will refer to as beam search optimization (BSO). In particular, we define a loss that penalizes the gold sequence falling off the beam during training. 1 The proposed training approach is a simple way to expose the model to incorrect histories and to match the training procedure to test generation. Furthermore we show that it can be implemented efficiently without changing the asymptotic run-time of training, beyond a factor of the beam size K.

Search-Based Loss
We now formalize this notion of a search-based loss for RNN training. Assume we have a set S t of K candidate sequences of length t. We can calculate a score for each sequence in S t using a scoring function f parameterized with an RNN, as above, and we define the sequenceŷ (K) 1:t ∈ S t to be the K'th ranked 1 Using a non-probabilistic model further allows us to incur no loss (and thus require no update to parameters) when the gold sequence is on the beam; this contrasts with models based on a CRF loss, such as those of Andor et al. (2016) and Zhou et al. (2015), though in training those models are simply not updated when the gold sequence remains on the beam. sequence in S t according to f . That is, assuming distinct scores, t−1 is the RNN state corresponding to its t − 1'st step, and where we have omitted the x argument to f for brevity.
We now define a loss function that gives loss each time the score of the gold prefix y 1:t does not exceed that ofŷ (K) 1:t by a margin: Above, the ∆(ŷ (K) 1:t ) term denotes a mistake-specific cost-function, which allows us to scale the loss depending on the severity of erroneously predictinĝ y (K) 1:t ; it is assumed to return 0 when the margin requirement is satisfied, and a positive number otherwise. It is this term that allows us to use sequencerather than word-level costs in training (addressing the 2nd issue in the introduction). For instance, when training a seq2seq model for machine translation, it may be desirable to have ∆(ŷ (K) 1:t ) be inversely related to the partial sentence-level BLEU score ofŷ (K) 1:t with y 1:t ; we experiment along these lines in Section 5.3.
Finally, because we want the full gold sequence to be at the top of the beam at the end of search, when t = T we modify the loss to require the score of y 1:T to exceed the score of the highest ranked incorrect prediction by a margin.
We can optimize the loss L using a two-step process: (1) in a forward pass, we compute candidate sets S t and record margin violations (sequences with non-zero loss); (2) in a backward pass, we backpropagate the errors through the seq2seq RNNs. Unlike standard seq2seq training, the first-step requires running search (in our case beam search) to find margin violations. The second step can be done by adapting back-propagation through time (BPTT). We next discuss the details of this process.

Forward: Find Violations
In order to minimize this loss, we need to specify a procedure for constructing candidate sequencesŷ (k) 1:t at each time step t so that we find margin violations. We follow LaSO (rather than early-update 2 ; see Section 2) and build candidates in a recursive manner. If there was no margin violation at t−1, then S t is constructed using a standard beam search update. If there was a margin violation, S t is constructed as the K best sequences assuming the gold history y 1:t−1 through time-step t−1.
Formally, assume the function succ maps a sequence w 1:t−1 ∈ V t−1 to the set of all valid sequences of length t that can be formed by appending to it a valid word w ∈ V. In the simplest, unconstrained case, we will have succ(w 1:t−1 ) = {w 1:t−1 , w | w ∈ V}.
As an important aside, note that for some problems it may be preferable to define a succ function which imposes hard constraints on successor sequences. For instance, if we would like to use seq2seq models for parsing (by emitting a constituency or dependency structure encoded into a sequence in some way), we will have hard constraints on the sequences the model can output, namely, that they represent valid parses. While hard constraints such as these would be difficult to add to standard seq2seq at training time, in our framework they can naturally be added to the succ function, allowing us to train with hard constraints; we experiment along these lines in Section 5.3, where we refer to a model trained with constrained beam search as ConBSO.
Having defined an appropriate succ function, we specify the candidate set as: t−2 ) + 1, and where topK considers the scores given by f . This search procedure is illustrated in the top portion of Figure 1.
In the forward pass of our training algorithm, shown as the first part of Algorithm 1, we run this version of beam search and collect all sequences and their hidden states that lead to losses.  1:t formed in training with a beam of size K = 3 and with gold sequence y 1:6 = "a red dog runs quickly today". The gold sequence is highlighted in yellow, and the predicted prefixes involved in margin violations (at t = 4 and t = 6) are in gray. Note that time-step T = 6 uses a different loss criterion. Bottom: prefixes that actually participate in the loss, arranged to illustrate the back-propagation process.

Backward: Merge Sequences
Once we have collected margin violations we can run backpropagation to compute parameter updates. Assume a margin violation occurs at time-step t between the predicted historyŷ (K) 1:t and the gold history y 1:t . As in standard seq2seq training we must back-propagate this error through the gold history; however, unlike seq2seq we also have a gradient for the wrongly predicted history.
Recall that to back-propagate errors through an RNN we run a recursive backward proceduredenoted below by BRNN -at each time-step t, which accumulates the gradients of next-step and future losses with respect to h t . We have: where L t+1 is the loss at step t + 1, deriving, for instance, from the score f (y t+1 , h t ). Running this BRNN procedure from t = T − 1 to t = 0 is known as back-propagation through time (BPTT).
In determining the total computational cost of back-propagation here, first note that in the worst case there is one violation at each time-step, which leads to T independent, incorrect sequences. Since we need to call BRNN O(T ) times for each sequence, a naive strategy of running BPTT for each incorrect sequence would lead to an O(T 2 ) backward pass, rather than the O(T ) time required for the standard seq2seq approach.
Fortunately, our combination of search-strategy and loss make it possible to efficiently share BRNN operations. This shared structure comes naturally from the LaSO update, which resets the beam in a convenient way.
We informally illustrate the process in Figure 1. The top of the diagram shows a possible sequence ofŷ (k) 1:t formed during search with a beam of size 3 for the target sequence y = "a red dog runs quickly today." When the gold sequence falls off the beam at t = 4, search resumes with S 5 = succ(y 1:4 ), and so all subsequent predicted sequences have y 1:4 as a prefix and are thus functions of h 4 . Moreover, because our loss function only involves the scores of the gold prefix and the violating prefix, we end up with the relatively simple computation tree shown at the bottom of Figure 1. It is evident that we can backpropagate in a single pass, accumulating gradients from sequences that diverge from the gold at the time-step that precedes their divergence. The second half of Algorithm 1 shows this explicitly for a single sequence, though it is straightforward to extend the algorithm to operate in batch. 3

Data and Methods
We run experiments on three different tasks, comparing our approach to the seq2seq baseline, and to other relevant baselines.

Model
While the method we describe applies to seq2seq RNNs in general, for all experiments we use the global attention model of Luong et al. (2015) -which consists of an LSTM (Hochreiter and Schmidhuber, 1997) encoder and an LSTM decoder with a global attention model -as both the baseline seq2seq model (i.e., as the model that computes the g in Section 3) and as the model that computes our sequence-scores f (w t , h t−1 , x). As in Luong et al. (2015), we also use "input feeding," which involves feeding the attention distribution from the previous time-step into the decoder at the current step. This model architecture has been found to be highly performant for neural machine translation and other seq2seq tasks. 3 We also note that because we do not update the parameters until after the T 'th search step, our training procedure differs slightly from LaSO (which is online), and in this aspect is essentially equivalent to the "delayed LaSO update" of Björkelund and Kuhn (2014). for t = 1, . . . , T do 6: t−1 ) + 1 then 8:ĥ r:t−1 ←ĥ (K) r:t−1 9:ŷ r+1:t ←ŷ To distinguish the models we refer to our system as BSO (beam search optimization) and to the baseline as seq2seq. When we apply constrained training (as discussed in Section 4.2), we refer to the model as ConBSO. In providing results we also distinguish between the beam size K tr with which the model is trained, and the beam size K te which is used at test-time. In general, if we plan on evaluating with a beam of size K te it makes sense to train with a beam of size K tr = K te + 1, since our objective requires the gold sequence to be scored higher than the last sequence on the beam.

Methodology
Here we detail additional techniques we found necessary to ensure the model learned effectively. First, we found that the model failed to learn when trained from a random initialization. 4 We therefore found it necessary to pre-train the model using a standard, word-level cross-entropy loss as described in Sec-tion 3. The necessity of pre-training in this instance is consistent with the findings of other authors who train non-local neural models (Kingsbury, 2009;Sak et al., 2014;Andor et al., 2016;Ranzato et al., 2016). 5 Similarly, it is clear that the smaller the beam used in training is, the less room the model has to make erroneous predictions without running afoul of the margin loss. Accordingly, we also found it useful to use a "curriculum beam" strategy in training, whereby the size of the beam is increased gradually during training. In particular, given a desired training beam size K tr , we began training with a beam of size 2, and increased it by 1 every 2 epochs until reaching K tr .
Finally, it has been established that dropout (Srivastava et al., 2014) regularization improves the performance of LSTMs (Pham et al., 2014;Zaremba et al., 2014), and in our experiments we run beam search under dropout. 6 For all experiments, we trained both seq2seq and BSO models with mini-batch Adagrad (Duchi et al., 2011) (using batches of size 64), and we renormalized all gradients so they did not exceed 5 before updating parameters. We did not extensively tune learning-rates, but we found initial rates of 0.02 for the encoder and decoder LSTMs, and a rate of 0.1 or 0.2 for the final linear layer (i.e., the layer tasked with making word-predictions at each timestep) to work well across all the tasks we considered. Code implementing the experiments described below can be found at https://github.com/ harvardnlp/BSO. 7

Tasks and Results
Our experiments are primarily intended to evaluate the effectiveness of beam search optimization over standard seq2seq training. As such, we run experiments with the same model across three very dif-5 Andor et al. (2016) found, however, that pre-training only increased convergence-speed, but was not necessary for obtaining good results. 6 However, it is important to ensure that the same mask applied at each time-step of the forward search is also applied at the corresponding step of the backward pass. We accomplish this by pre-computing masks for each time-step, and sharing them between the partial sequence LSTMs. 7 Our code is based on Yoon Kim's seq2seq code, https: //github.com/harvardnlp/seq2seq-attn. ferent problems: word ordering, dependency parsing, and machine translation. While we do not include all the features and extensions necessary to reach state-of-the-art performance, even the baseline seq2seq model is generally quite performant.
Word Ordering The task of correctly ordering the words in a shuffled sentence has recently gained some attention as a way to test the (syntactic) capabilities of text-generation systems (Zhang and Clark, 2011;Zhang and Clark, 2015;Liu et al., 2015;Schmaltz et al., 2016). We cast this task as seq2seq problem by viewing a shuffled sentence as a source sentence, and the correctly ordered sentence as the target. While word ordering is a somewhat synthetic task, it has two interesting properties for our purposes. First, it is a task which plausibly requires search (due to the exponentially many possible orderings), and, second, there is a clear hard constraint on output sequences, namely, that they be a permutation of the source sequence. For both the baseline and BSO models we enforce this constraint at testtime. However, we also experiment with constraining the BSO model during training, as described in Section 4.2, by defining the succ function to only allow successor sequences containing un-used words in the source sentence.
For experiments, we use the same PTB dataset (with the standard training, development, and test splits) and evaluation procedure as in Zhang and Clark (2015) and later work, with performance reported in terms of BLEU score with the correctly ordered sentences. For all word-ordering experiments we use 2-layer encoder and decoder LSTMs, each with 256 hidden units, and dropout with a rate of 0.2 between LSTM layers. We use simple 0/1 costs in defining the ∆ function.
We show our test-set results in Table 1. We see that on this task there is a large improvement at each beam size from switching to BSO, and a further improvement from using the constrained model.
Inspired by a similar analysis in Daumé III and Marcu (2005), we further examine the relationship between K tr and K te when training with ConBSO in Table 2. We see that larger K tr hurt greedy inference, but that results continue to improve, at least initially, when using a K te that is (somewhat) bigger than K tr − 1.  Dependency Parsing We next apply our model to dependency parsing, which also has hard constraints and plausibly benefits from search. We treat dependency parsing with arc-standard transitions as a seq2seq task by attempting to map from a source sentence to a target sequence of source sentence words interleaved with the arc-standard, reduce-actions in its parse. For example, we attempt to map the source sentence  and dropout with a rate of 0.3 between LSTM layers. We replace singleton words in the training set with an UNK token, normalize digits to a single symbol, and initialize word embeddings for both source and target words from the publicly available word2vec (Mikolov et al., 2013) embeddings. We use simple 0/1 costs in defining the ∆ function.
As in the word-ordering case, we also experiment with modifying the succ function in order to train under hard constraints, namely, that the emitted target sequence be a valid parse. In particular, we constrain the output at each time-step to obey the stack constraint, and we ensure words in the source are emitted in order.
We show results on the test-set in Table 3. BSO and ConBSO both show significant improvements over seq2seq, with ConBSO improving most on UAS, and BSO improving most on LAS. We achieve a reasonable final score of 91.57 UAS, which lags behind the state-of-the-art, but is promising for a general-purpose, word-only model.

Translation
We finally evaluate our model on a small machine translation dataset, which allows us to experiment with a cost function that is not 0/1, and to consider other baselines that attempt to mitigate exposure bias in the seq2seq setting. We use the dataset from the work of Ranzato et al. (2016), which uses data from the German-to-English portion of the IWSLT 2014 machine translation evaluation campaign (Cettolo et al., 2014). The data comes from translated TED talks, and the dataset contains roughly 153K training sentences, 7K development sentences, and 7K test sentences. We use the same preprocessing and dataset splits as Ranzato et  XENT is similar to our seq2seq model but with a convolutional encoder and simpler attention. DAD trains seq2seq with scheduled sampling . BSO, SB-∆ experiments above have K tr = 6.
al. (2016), and like them we also use a single-layer LSTM decoder with 256 units. We also use dropout with a rate of 0.2 between each LSTM layer. We emphasize, however, that while our decoder LSTM is of the same size as that of Ranzato et al. (2016), our results are not directly comparable, because we use an LSTM encoder (rather than a convolutional encoder as they do), a slightly different attention mechanism, and input feeding (Luong et al., 2015).
For our main MT results, we set ∆(ŷ (k) 1:t ) to 1 − SB(ŷ (K) r+1:t , y r+1:t ), where r is the last margin violation and SB denotes smoothed, sentence-level BLEU (Chen and Cherry, 2014). This setting of ∆ should act to penalize erroneous predictions with a relatively low sentence-level BLEU score more than those with a relatively high sentence-level BLEU score. In Table 4 we show our final results and those from Ranzato et al. (2016). 8 While we start with an improved baseline, we see similarly large increases in accuracy as those obtained by DAD and MIXER, in particular when K te > 1.
We further investigate the utility of these sequence-level costs in Table 5, which compares using sentence-level BLEU costs in defining ∆ with using 0/1 costs. We see that the more sophisticated sequence-level costs have a moderate effect on BLEU score. 8 Some results from personal communication.    Timing Given Algorithm 1, we would expect training time to increase linearly with the size of the beam. On the above MT task, our highly tuned seq2seq baseline processes an average of 13,038 tokens/second (including both source and target tokens) on a GTX 970 GPU. For beams of size K tr = 2, 3, 4, 5, and 6, our implementation processes on average 1,985, 1,768, 1,709, 1,521, and 1,458 tokens/second, respectively. Thus, we appear to pay an initial constant factor of ≈ 3.3 due to the more complicated forward and backward passes, and then training scales with the size of the beam. Because we batch beam predictions on a GPU, however, we find that in practice training time scales sub-linearly with the beam-size.

Conclusion
We have introduced a variant of seq2seq and an associated beam search training scheme, which addresses exposure bias as well as label bias, and moreover allows for both training with sequencelevel cost functions as well as with hard constraints. Future work will examine scaling this approach to much larger datasets.