Adaptive policies are better than fixed policies for simultaneous translation, since they can flexibly balance the tradeoff between translation quality and latency based on the current context information. But previous methods on obtaining adaptive policies either rely on complicated training process, or underper-form simple fixed policies. We design an algorithm to achieve adaptive policies via a simple heuristic composition of a set of fixed policies. Experiments on Chinese  English and German  English show that our adaptive policies can outperform fixed ones by up to 4 BLEU points for the same latency, and more surprisingly, it even surpasses the BLEU score of full-sentence translation in the greedy mode (and very close to beam mode), but with much lower latency. Simultaneous translation (ST) aims to provide good translation quality while keeping the latency of translation process as low as possible. This is very important for the scenarios that require simultaneity, such as international summits and negotiations. For this, human interpreters usually start translation before the source sentence ends. However, this makes the translation process much more challenging than the full-sentence translation, because to balance the translation quality and latency, interpreters need to make decisions on when to continue translation and when to stop temporarily to wait for more source side information, which are diffi-cult, especially for syntactically divergent language pairs, such as German and English. The above decisions can be considered as two actions: READ (wait for a new source word) and WRITE (emit a translated target word) (Gu et al., 2017). Then we only need to decide which action to choose at each step, and the solution can be represented by a policy . Earlier works (Yarmohammadi t  (cid:1372) he y  x  (cid:1310)(cid:6556) probably b (cid:1255) not y  ngg  i (cid:2859)(cid:6598) should du (cid:2642) for c  (cid:3980) this fz (cid:6702)(cid:6705) be responsible He probably should not be responsible for this T a r g e t Source H e s h o u l d b e r e s po n s i b l e f o r t h i s R R R R R R wait-3 wait-2 wait-1 R p r ob a b l y n o t Figure 1: An adaptive policy (in bold arrows) composed of three waitk policies ( k = 1 , 2 , 3 ). et al., 2013; Bangalore et al., 2012; Fugen et al., 2007; Sridhar et al., 2013; Jaitly et al., 2016) study policies as a part of speech-to-speech ST system, where the policies usually try to separate the source sentence into several chunks that can be translated safely. Recent works focus on obtaining policies for text-to-text ST, which can be generally divided into two categories: fixed and adaptive. Fixed policies (Ma et al., 2019; Dalvi et al., 2018) usually follow some simple rules to choose actions. For example, the waitk policy by Ma et al. (2019) first chooses k READ actions, and then chooses WRITE and READ alternatively. This kind of policies do not utilize the context information and can be either too aggressive or too conservative in different cases. By contrast, adaptive policies try to make decisions on the fly using the currently available information. It is obvious that this kind of policies is more desirable for ST than the fixed ones, and different methods are explored to achieve an adaptive policy. The majority of such methods (Grissom II et al., 2014; Cho and Esipova, 2016; Gu et al., 2017; Alinejad et al., 2018; Zheng et al., 2019a) are based on full-sentence translation models, which may be simple to use but cannot outperform fixed policies applied with genuinely simultaneous models trained for ST (Ma et al., 2019). Other methods (Arivazhagan et al., 2019; Zheng et al., 2019b) try to learn a policy together with the underlying translation model, but they rely on complicated and time-consuming training process. In this paper, we propose to achieve an adaptive policy via a much simpler heuristic composition of a set of waitk policies (e.g., k = 1  10 ). See Fig. 1 for an example. To further improve the translation quality of our method, we apply ensemble of models trained with different waitk policies. Our experiments on Chinese  English and German  English translation show that our method can achieve up to 4 BLEU points improvement over the waitk method for same latency. More interestingly, compared with full-sentence translation, our method achieves higher BLEU scores than greedy search but with much lower latency, and is close to the results from beam search. Full-sentence translation. Neural machine translation (NMT) model usually consists of two components: an encoder, which encodes the source sentence x = ( x 1 , . . . , x m ) into a sequence of hidden states, and a decoder, which sequentially predicts target tokens conditioned on those hidden states and previous predictions. The probability of the predicted target sequence y = ( y 1 , . . . , y n ) will be p ( y | x ) = (cid:81) | y | t =1 p ( y t | x , y <t ) where y <t = ( y 1 , . . . , y t  1 ) denotes the target sequence predicted before step t . Simultaneous translation. Ma et al. (2019) propose a prefix-to-prefix framework to train models to make predictions conditioned on partial source sentences. In this way, the probability of predicted sequence y becomes p g ( y | x ) = (cid:81) | y | t =1 p ( y t | x  g ( t ) , y <t ) where g ( t ) is a monotonic non-decreasing function of t , denoting the number of processed source tokens when predicting y t . This function g ( t ) can be used to represent a policy for ST. Ma et al. (2019) introduce a kind of fixed policies, called waitk policy, that can be defined by the following g k ( t ) = min {| x | , t + k  1 } . Intuitively, this policy first waits k source tokens and then outputs predicted tokens concurrently with the rest of source sentence. Assume we have a set of waitk policies and the corresponding models M k ( k = k min . . . k max ). We can obtain an adaptive policy, whose lag at each step is between k min and k max , meaning that at each step, the target sequence falls behind the source sequence at most k max tokens and at least k min tokens. At each step, there is a waitk policy synchronizing the adaptive policy, meaning that they have the same lag at that step. Specifically, at any step t , if the lag of the adaptive policy is k (cid:48) , then we apply the NMT model with the waitk (cid:48) policy and force it to predict existing target tokens until step t , when the model will make a new prediction as the output of step t . However, the above method only shows how to simulate the adaptive policy to make a prediction at one step if we would like to write at that step, but it does not tell us at which steps we should write. We utilize the model confidence to make such a decision. Specifically, we set a probability threshold  k for each waitk policy. At each step, if the NMT model follows a waitk (cid:48) policy, and predicts the most likely token with probability higher than the threshold  k (cid:48) , then we consider the model is confi-dent on this prediction, and choose WRITE action; otherwise, we choose READ action. Figure 2 gives an example for this process. We define the process of applying a waitk model M k with a waitk policy on a given sequence pair ( x , y ) by the following y top , p top  P k ( M k , x , y ) which forces model M k to predict y , and returns the top token y top at the final step with the corresponding probability p top . The process of reading and returning a new source token is denoted by READ () , and expression x  x represents to append an element x to the end of sequence x . We denote by <s> and </s> the start symbol and end symbol of a sequence. Then Algorithm 1 gives the pseudocode of the above method. Using the corresponding model M k with each wait-k policies may not give us the best performance. If we have a set of models trained independently with different waitk policies, then we can apply ensemble of those models (Dietterich, 2000; Hansen and Salamon, 1990) to improve the translation quality, which is also used to improve the translation quality of full-sentence translation (Stahlberg and Byrne, 2017). However, there may be two issues to apply ensemble of all models: (1) the runtime for each prediction could be longer, resulting in higher latency; and (2) the translation accuracy may be worse, for the best model for one policy may give bad performance when doing inference with another policy. To avoid these, we propose to apply ensemble of the top-3 models for each policy. That is, we first generate distribution with the top-3 models independently with the same policy, and then take the arithmetic average of the three distributions as the final token distribution at that step. Datasets and models. We conduct experiments on Chinese  English (ZH  EN) and German  English (DE  EN) translation. For ZH  EN, we use NIST corpus (2M sentence pairs) as training set, NIST 2006 as dev set, and NIST 2008 as test set. For DE  EN, we use WMT15 parallel corpus for training, newstest-2013 for validation and newstest-2015 for testing. All datasets are tokenized and segmented into sub-word units with byte-pair encoding (Sennrich et al., 2016). We take Transformer-base (Vaswani et al., 2017) as our model architecture, and follow Ma et al. (2019) to train our model with waitk policies for integer 1  k  10 . In the following experiments, we only use catchup (Ma et al., 2019) for DE  EN translation, where we read one additional source token after every 6 predictions. We use BLEU (Pa-pineni et al., 2002) as the translation quality metric, and Average Lagging (AL) (Ma et al., 2019) as the latency metric, which measures the lag behind source in terms of the number of source tokens. Performance with different policies. We first evaluate the performance of each model with different policies, which helps us to choose models for different policies. Specifically, we apply each model with ten different waitk policies on dev set to compare the performance. Fig. 3 shows the results of five models. We find the best model for one policy may not be the one trained with that policy. For example, on ZH  EN translation, the best model for wait-1 policy is the one trained with wait-3 policy. Further, there is no one model could achieve the best performance for all policies. Comparing different methods. We compare our method with others from literature: waitk method (Ma et al., 2019) (train and test models with the same waitk policy), test-time wait-k method (Ma et al., 2019) (apply full-sentence model with waitk policies), wait-if-diff (Cho and Esipova, 2016) (start with s 0 source tokens, choose to read only if top token at t -th step diffs from that at ( t   ) -th step), and wait-if-worse (Cho and Es-ipova, 2016) (start with s 0 source tokens, choose to read only if the top probability at t -th step is smaller than that at ( t   ) -th step). For wait-if-diff we set 4 6 8 10 12 27 29 31 33 35 37 39 41 43 45 4 r e f BLEUZH EN 33 AL wait-1 model wait-3 model wait-5 model wait-7 model wait-9 model 4 6 8 10 12 16 18 20 22 24 26 28 30 1 r e f BLEUDE EN 30 AL wait-1 model wait-3 model wait-5 model wait-7 model wait-9 model Figure 3: Performance of models with different policies on dev set. s 0  { 4 , 6 } and   { 2 , 4 } ; and for wait-if-worse we set s 0  { 1 , 2 , 4 , 6 } and   { 1 , 2 } . For our method, we test three different cases: (1) single , where for each policy we apply the corresponding model that trained with the same policy; (2) ensemble top-3 , where for each policy we apply the ensemble of 3 models that achieve the highest BLEU scores with that policy on dev set; (3) ensemble all , where we apply the ensemble of all 10 models for each policy. For thresholds, we first choose  1 and  10 , and the other thresholds are computed in the following way:  i =  1  d  ( i  1) for integer 1  i  10 and d = (  1   10 ) / 9 . We test with  1  { 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 } ,  10 = 0 and  1 = 1 ,  10  { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 } , totally 18 different settings in our experiments. The reason behind these settings is that we assume our adaptive policy cannot be either too aggressive or too conservative (as mentioned at the beginning of Section 3). The policy is the most aggressive for k = 1 , so we set  1 as the largest; while for k = 10 the policy is the most conservative, so we set  10 the smallest. The comparison is provided in Fig. 4 (the corresponding numeric scores are provided in Appendix A). Compared with waitk method, our single method achieves improvement of up to 2 BLEU point, and our ensemble top-3 achieves improvement up to 4 BLEU points. Compared with full-sentence translation, our ensemble top-3 surprisingly outperforms greedy search with much lower latency (AL < 9), and achieves BLEU scores close to that from beam search (see Table 2). We also give one ZH  EN translation example from dev set in Table 1 to compare different methods, showing that our method achieves an adaptive policy with low latency and good translation quality. Efficiency. To evaluate the efficiency, we present in Table 3 the averaged time needed to predict one token for different methods. These methods are tested on one GeForce GTX TITAN-X GPU for ZH  EN test set. We can see that our ensemble top-3 method needs about 0.2 seconds to make a prediction on average. However, if the source sentence is revealed in the same speed as general pinyin womenxi`ang sh`ouh`aizhe de jiashu biaosh` zu` chengzh` de tongqng he ai d`ao input                      .  gloss we to victim 's family express most sincere 's sympathy and condolence ensemble top-3  1 =1 , 10 =0 (AL=7)  we expressour most sincere sympathyand condolences to the families of the victims .  ensemble top-3  1 =0 . speech, which is about 0.6 seconds per token in Chinese (Zheng et al., 2019c), then our method is still faster than that (which means that it could be used for real-time). Further, we believe the efficiency of our method could be improved with other techniques, such as parallelizing the running of three models in the ensemble, making it less an issue. We have designed a simple heuristic algorithm to obtain an adaptive policy based on a set of waitk policies, and applied ensemble in our method to improve the translation quality while maintaining low latency. Experiments show that our method not only outperforms the original waitk method with relatively large gap, but also surpasses greedy full-sentence translation with much lower latency. We thank the anonymous reviewers for helpful suggestions.
abstain abstain result result abstain abstain abstain abstain abstain method other abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain result result result abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain method abstain method abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain other other abstain result abstain abstain abstain abstain abstain result result result abstain abstain abstain result result abstain result result result other