Fully Character-Level Neural Machine Translation without Explicit Segmentation

Introduction

Nearly all previous work in machine translation has been at the level of words. Aside from our intuitive understanding of word as a basic unit of meaning [Jackendoff, 1992], one reason behind this is that sequences are significantly longer when represented in characters, compounding the problem of data sparsity and modeling long-range dependencies. This has driven NMT research to be almost exclusively word-level [Bahdanau et al., 2015, Sutskever et al., 2015].

Despite their remarkable success, word-level NMT models suffer from several major weaknesses. For one, they are unable to model rare, out-of-vocabulary words, making them limited in translating languages with rich morphology such as Czech, Finnish and Turkish. If one uses a large vocabulary to combat this [Jean et al., 2015], the complexity of training and decoding grows linearly with respect to the target vocabulary size, leading to a vicious cycle.

To address this, we present a fully character-level NMT model that maps a character sequence in a source language to a character sequence in a target language. We show that our model outperforms a baseline with a subword-level encoder on DE-EN and CS-EN, and achieves a comparable result on FI-EN and RU-EN. A purely character-level NMT model with a basic encoder was proposed as a baseline by ?), but training it was prohibitively slow. We were able to train our model at a reasonable speed by drastically reducing the length of source sentence representation using a stack of convolutional, pooling and highway layers.

One advantage of character-level models is that they are better suited for multilingual translation than their word-level counterparts which require a separate word vocabulary for each language. We verify this by training a single model to translate four languages (German, Czech, Finnish and Russian) to English. Our multilingual character-level model outperforms the subword-level baseline by a considerable margin in all four language pairs, strongly indicating that a character-level model is more flexible in assigning its capacity to different language pairs. Furthermore, we observe that our multilingual character-level translation even exceeds the quality of bilingual translation in three out of four language pairs, both in BLEU score metric and human evaluation. This demonstrates excellent parameter efficiency of character-level translation in a multilingual setting. We also showcase our model’s ability to handle intra-sentence code-switching while performing language identification on the fly.

The contributions of this work are twofold: we empirically show that (1) we can train character-to-character NMT model without any explicit segmentation; and (2) we can share a single character-level encoder across multiple languages to build a multilingual translation system without increasing the model size.

Background: Attentional Neural Machine Translation

Neural machine translation (NMT) is a recently proposed approach to machine translation that builds a single neural network which takes as an input a source sentence $X=(x_{1},\ldots,x_{T_{X}})$ and generates its translation $Y=(y_{1},\ldots,y_{T_{Y}})$, where $x_{t}$ and $y_{t^{\prime}}$ are source and target symbols [Bahdanau et al., 2015, Sutskever et al., 2015, Luong et al., 2015, Cho et al., 2014a]. Attentional NMT models have three components: an encoder, a decoder and an attention mechanism.

Encoder Given a source sentence $X$, the encoder constructs a continuous representation that summarizes its meaning with a recurrent neural network (RNN). A bidirectional RNN is often implemented as proposed in [Bahdanau et al., 2015]. A forward encoder reads the input sentence from left to right: \overrightarrow{\mathbf{h}}_{t}=\overrightarrow{f_{\text{enc}}}\big{(}E_{x}(x_{t}),\overrightarrow{\mathbf{h}}_{t-1}\big{)}. Similarly, a backward encoder reads it from right to left: \overleftarrow{\mathbf{h}}_{t}=\overleftarrow{f_{\text{enc}}}\big{(}E_{x}(x_{t}),\overleftarrow{\mathbf{h}}_{t+1}\big{)}, where $E_{x}$ is the source embedding lookup table, and $\overrightarrow{f_{\text{enc}}}$ and $\overleftarrow{f_{\text{enc}}}$ are recurrent activation functions such as long short-term memory units (LSTMs, [Hochreiter and Schmidhuber, 1997]) or gated recurrent units (GRUs, [Cho et al., 2014b]). The encoder constructs a set of continuous source sentence representations $C$ by concatenating the forward and backward hidden states at each timestep: C=\big{\{}\mathbf{h}_{1},\dots,\mathbf{h}_{T_{X}}\big{\}}, where \mathbf{h}_{t}=\big{[}\overrightarrow{\mathbf{h}}_{t};\overleftarrow{\mathbf{h}}_{t}\big{]}.

Attention First introduced in [Bahdanau et al., 2015], the attention mechanism lets the decoder attend more to different source symbols for each target symbol. More concretely, it computes the context vector $\mathbf{c}_{t^{\prime}}$ at each decoding time step $t^{\prime}$ as a weighted sum of the source hidden states: $\mathbf{c}_{t^{\prime}}=\sum_{t=1}^{T_{X}}{\alpha_{{t^{\prime}}t}\mathbf{h}_{t}}.$ Similarly to [Chung et al., 2016, Firat et al., 2016a], each attentional weight $\alpha_{{t^{\prime}}t}$ represents how relevant the $t$-th source token $x_{t}$ is to the $t^{\prime}$-th target token $y_{t^{\prime}}$, and is computed as:

where Z={\sum_{k=1}^{T_{X}}{\text{exp}\big{(}\text{score}(E_{y}(y_{t^{\prime}-1}),\mathbf{s}_{t^{\prime}-1},\mathbf{h}_{k})\big{)}}} is the normalization constant. $\text{score}()$ is a feedforward neural network with a single hidden layer that scores how well the source symbol $x_{t}$ and the target symbol $y_{t^{\prime}}$ match. $E_{y}$ is the target embedding lookup table and $\mathbf{s}_{t^{\prime}}$ is the target hidden state at time $t^{\prime}$.

Decoder Given a source context vector $\mathbf{c}_{t^{\prime}}$, the decoder computes its hidden state at time $t^{\prime}$ as: \mathbf{s}_{t^{\prime}}=f_{\text{dec}}\big{(}E_{y}(y_{t^{\prime}-1}),\mathbf{s}_{t^{\prime}-1},\mathbf{c}_{t^{\prime}}\big{)}. Then, a parametric function $\text{out}_{k}()$ returns the conditional probability of the next target symbol being $k$:

where $Z$ is again the normalization constant: Z={\sum_{j}\text{exp}\big{(}\text{out}_{j}(E_{y}(y_{t^{\prime}-1}),\mathbf{s}_{t^{\prime}},\mathbf{c}_{t^{\prime}})\big{)}}.

Training The entire model can be trained end-to-end by minimizing the negative conditional log-likelihood, which is defined as:

where $N$ is the number of sentence pairs, and $X^{(n)}$ and $y_{t}^{(n)}$ are the source sentence and the $t$-th target symbol in the $n$-th pair, respectively.

Fully Character-Level Translation

The benefits of character-level translation over word-level translation are well known. ?) present three main arguments: character level models (1) do not suffer from out-of-vocabulary issues, (2) are able to model different, rare morphological variants of a word, and (3) do not require segmentation. Particularly, text segmentation is highly non-trivial for many languages and problematic even for English as word tokenizers are either manually designed or trained on a corpus using an objective function that is unrelated to the translation task at hand, which makes the overall system sub-optimal.

Here we present two additional arguments for character-level translation. First, a character-level translation system can easily be applied to a multilingual translation setting. Between European languages where the majority of alphabets overlaps, for instance, a character-level model may easily identify morphemes that are shared across different languages. A word-level model, however, will need a separate word vocabulary for each language, allowing no cross-lingual parameter sharing.

Also, by not segmenting source sentences into words, we no longer inject our knowledge of words and word boundaries into the system; instead, we encourage the model to discover an internal structure of a sentence by itself and learn how a sequence of symbols can be mapped to a continuous meaning representation.

2 Related Work

To address these limitations associated with word-level translation, a recent line of research has investigated using sub-word information.

?) replaced the word-lookup table with convolutional and highway layers on top of character embeddings, while still segmenting source sentences into words. Target sentences were also segmented into words, and prediction was made at word-level.

Similarly, ?) employed a bidirectional LSTM to compose character embeddings into word embeddings. At the target side, another LSTM takes the hidden state of the decoder and generates the target word, character by character. While this system is completely open-vocabulary, it also requires offline segmentation. Also, character-to-word and word-to-character LSTMs significantly slow down training.

Most recently, ?) proposed a hybrid scheme that consults character-level information whenever the model encounters an out-of-vocabulary word. As a baseline, they also implemented a purely character-level NMT model with 4 layers of unidirectional LSTMs with 512 cells, with attention over each character. Despite being extremely slow (approximately 3 months to train), the character-level model gave comparable performance to the word-level baseline. This shows the possibility of fully character-level translation.

Having a word-level decoder restricts the model to only being able to generate previously seen words. ?) introduced a subword-level NMT model that is capable of open-vocabulary translation using subword-level segmentation based on the byte pair encoding (BPE) algorithm. Starting from a character vocabulary, the algorithm identifies frequent character n-grams in the training data and iteratively adds them to the vocabulary, ultimately giving a subword vocabulary which consists of words, subwords and characters. Once the segmentation rules have been learned, their model performs subword-to-subword translation (bpe2bpe) in the same way as word-to-word translation.

Perhaps the work that is closest to our end goal is [Chung et al., 2016], which used a subword-level encoder from [Sennrich et al., 2015] and a fully character-level decoder (bpe2char). Their results show that character-level decoding performs better than subword-level decoding. Motivated by this work, we aim for fully character-level translation at both sides (char2char).

Outside NMT, our work is based on a few existing approaches that applied convolutional networks to text, most notably in text classification [Zhang et al., 2015, Xiao and Cho, 2016]. Also, we drew inspiration for our multilingual models from previous work that showed the possibility of training a single recurrent model for multiple languages in domains other than translation [Tsvetkov et al., 2016, Gillick et al., 2015].

3 Challenges

Sentences are on average 6 (DE, CS and RU) to 8 (FI) times longer when represented in characters. This poses three major challenges to achieving fully character-level translation.

For the decoder, although the sequence to be generated is much longer, each character-level softmax operation costs considerably less compared to a word- or subword-level softmax. ?) report that character-level decoding is only 14% slower than subword-level decoding.

On the other hand, computational complexity of the attention mechanism grows quadratically with respect to the sentence length, as it needs to attend to every source token for every target token. This makes a naive character-level approach, such as in [Luong and Manning, 2016], computationally prohibitive. Consequently, reducing the length of the source sequence is key to ensuring reasonable speed in both training and decoding.

(2) Mapping character sequence to continuous representation

The arbitrary relationship between the orthography of a word and its meaning is a well-known problem in linguistics [de Saussure, 1916]. Building a character-level encoder is arguably a more difficult problem, as the encoder needs to learn a highly non-linear function from a long sequence of character symbols to a meaning representation.

(3) Long range dependencies in characters

A character-level encoder needs to model dependencies over longer timespans than a word-level encoder does.

Fully Character-Level NMT

We design an encoder that addresses all the challenges discussed above by using convolutional and pooling layers aggressively to both (1) drastically shorten the input sentence and (2) efficiently capture local regularities. Inspired by the character-level language model from [Kim et al., 2015], our encoder first reduces the source sentence length with a series of convolutional, pooling and highway layers. The shorter representation, instead of the full character sequence, is passed through a bidirectional GRU to (3) help it resolve long term dependencies. We illustrate the proposed encoder in Figure 1 and discuss each layer in detail below.

Embedding We map the sequence of source characters $(x_{1},\ldots,x_{T_{x}})$ to a sequence of character embeddings of dimensionality $d_{c}$: $X=(\mathbf{C}(x_{1}),\ldots,\mathbf{C}(x_{T_{x}}))\in\mathbb{R}^{d_{c}\times T_{x}}$ where $T_{x}$ is the number of source characters and $\mathbf{C}$ is the character embedding lookup table: $\mathbf{C}\in\mathbb{R}^{d_{c}\times|\mathbf{C}|}$.

Convolution One-dimensional convolution operation is then used along consecutive character embeddings. Assuming we have a single filter $\mathbf{f}\in\mathbb{R}^{d_{c}\times w}$ of width $w$, we first apply padding to the beginning and the end of $X$, such that the padded sentence $X^{\prime}\in\mathbb{R}^{d_{c}\times(T_{x}+w-1)}$ is $w-1$ symbols longer. We then apply narrow convolution between $X^{\prime}$ and $\mathbf{f}$ such that the $k$-th element of the output $Y_{k}$ is given as:

𝑘𝑤1𝑘𝐟𝑖𝑗Y_{k}=(X^{\prime}*\mathbf{f})_{k}=\sum_{i,j}{(X^{\prime}_{[:,k-w+1:k]}\otimes\mathbf{f})}_{ij}, (3) where $\otimes$ denotes elementwise matrix multiplication and $*$ is the convolution operation. $X^{\prime}_{[:,k-w+1:k]}$ is the sliced subset of $X^{\prime}$ that contains all the rows but only $w$ adjacent columns. The padding scheme employed above, commonly known as half convolution, ensures the length of the output is identical to the input’s: $Y\in\mathbb{R}^{1\times T_{x}}.$

We just illustrated how a single convolutional filter of fixed width might be applied to a sentence. In order to extract informative character patterns of different lengths, we employ a set of filters of varying widths. More concretely, we use a filter bank $\mathbf{F}=\{\mathbf{f}_{1},\ldots,\mathbf{f}_{m}\}$ where $\mathbf{f}_{i}=\mathbb{R}^{d_{c}\times i\times n_{i}}$ is a collection of $n_{i}$ filters of width $i$. Our model uses $m=8$, hence extracts character n-grams up to $8$ characters long. Outputs from all the filters are stacked upon each other, giving a single representation $Y\in\mathbb{R}^{N\times T_{x}}$, where the dimensionality of each column is given by the total number of filters $N=\sum_{i=1}^{m}n_{i}$. Finally, rectified linear activation (ReLU) is applied elementwise to this representation.

Max pooling with stride The output from the convolutional layer is first split into segments of width $s$, and max-pooling over time is applied to each segment with no overlap. This procedure selects the most salient features to give a segment embedding. Each segment embedding is a summary of meaningful character n-grams occurring in a particular (overlapping) subsequence in the source sentence. Note that the rightmost segment (above ‘on’) in Figure 1 may capture ‘son’ (the filter in green) although ‘s’ occurs in the previous segment. In other words, our segments are overlapping as opposed to in word- or subword-level models with hard segmentation.

Segments act as our internal linguistic unit from this layer and above: the attention mechanism, for instance, attends to each source segment instead of source character. This shortens the source representation $s$-fold: $Y^{\prime}\in\mathbb{R}^{N\times(T_{x}/s)}.$ Empirically, we found using smaller $s$ leads to better performance at increased training time. We chose $s=5$ in our experiments as it gives a reasonable balance between the two.

Highway network A sequence of segment embeddings from the max pooling layer is fed into a highway network [Srivastava et al., 2015]. Highway networks are shown to significantly improve the quality of a character-level language model when used with convolutional layers [Kim et al., 2015]. A highway network transforms input $\mathbf{x}$ with a gating mechanism that adaptively regulates information flow:

direct-product𝑔ReLUsubscript𝐖1𝑥subscript𝐛1direct-product1𝑔𝐱\mathbf{y}=g\odot\text{ReLU}(\mathbf{W}_{1}x+\mathbf{b}_{1})+(1-g)\odot\mathbf{x}, where $g=\sigma((\mathbf{W}_{2}\mathbf{x}+\mathbf{b}_{2})).$ We apply this to each segment embedding individually.

Recurrent layer Finally, the output from the highway layer is given to a bidirectional GRU from §2, using each segment embedding as input.

Subword-level encoder Unlike a subword-level encoder, our model does not commit to a specific choice of segmentation; it is instead trained to consider every possible character pattern and extract only the most meaningful ones. Therefore, the definition of segmentation in our model is dynamic unlike subword-level encoders. During training, the model finds the most salient character patterns in a sentence via max-pooling, and the character sequences extracted by the model change over the course of training. This is in contrast to how BPE segmentation rules are learned: the segmentation is learned and fixed before training begins.

2 Attention and Decoder

Similarly to the attention model in [Chung et al., 2016, Firat et al., 2016a], a single-layer feedforward network computes the attention score of next target character to be generated with every source segment representation. A standard two-layer character-level decoder then takes the source context vector from the attention mechanism and predicts each target character. This decoder was described as base decoder by ?).

Experiment Settings

We evaluate the proposed character-to-character (char2char) translation model against subword-level baselines (bpe2bpe and bpe2char) on the WMT’15 DE$\rightarrow$EN, CS$\rightarrow$EN, FI$\rightarrow$EN and RU$\rightarrow$EN translation tasks.111http://www.statmt.org/wmt15/translation -task.html We do not consider word-level models, as it has already been shown that subword-level models outperform them by mitigating issues inherent to closed-vocabulary translation [Sennrich et al., 2015, Sennrich et al., 2016]. Indeed, subword-level NMT models have been the de-facto state-of-the-art and are now used in a very large-scale industry NMT system to serve millions of users per day [Wu et al., 2016].

We experiment in two different scenarios: 1) a bilingual setting where we train a model on data from a single language pair; and 2) a multilingual setting where the task is many-to-one translation: we train a single model on data from all four language pairs. Hence, our baselines and models are:

bilingual bpe2bpe: from [Firat et al., 2016a].

bilingual bpe2char: from [Chung et al., 2016].

We train all the models ourselves other than (a), for which we report the results from [Firat et al., 2016a]. We detail the configuration of our models in Table 1 and Table 2.

2 Datasets and Preprocessing

We use all available parallel data on the four language pairs from WMT’15: DE-EN, CS-EN, FI-EN and RU-EN.

For the bpe2char baselines, we only use sentence pairs where the source is no longer than 50 subword symbols. For our char2char models, we only use pairs where the source sentence is no longer than 450 characters. For all the language pairs apart from FI-EN, we use newstest-2013 as a development set and newstest-2014 and newstest-2015 as test sets. For FI-EN, we use newsdev-2015 and newstest-2015 as development and test sets respectively. We tokenize222This is unnecessary for char2char models, yet was carried out for comparison. each corpus using the script from Moses.333https://github.com/moses-smt/mosesdecod er

When training bilingual bpe2char models, we extract 20,000 BPE operations from each of the source and target corpus using a script from [Sennrich et al., 2015]. This gives a source BPE vocabulary of size 20k$-$24k for each language.

3 Training Details

Each model is trained using stochastic gradient descent and Adam [Kingma and Ba, 2014] with learning rate $0.0001$ and minibatch size 64. Training continues until the BLEU score on the validation set stops improving. The norm of the gradient is clipped with a threshold of 1 [Pascanu et al., 2013]. All weights are initialized from a uniform distribution $[-0.01,0.01].$

Each model is trained on a single pre-2016 GTX Titan X GPU with 12GB RAM.

4 Decoding Details

As from [Chung et al., 2016], a two-layer unidirectional character-level decoder with 1024 GRU units is used for all our experiments. For decoding, we use beam search with length-normalization to penalize shorter hypotheses. The beam width is 20 for all models.

5 Training Multilingual Models

Task description We train a model on a many-to-one translation task to translate a sentence in any of the four languages (German, Czech, Finnish and Russian) to English. We do not provide a language identifier to the encoder, but merely the sentence itself, encouraging the model to perform language identification on the fly. In addition, by not providing the language identifier, we expect the model to handle intra-sentence code-switching seamlessly.

Model architecture The multilingual char2char model uses slightly more convolutional filters than the bilingual char2char model, namely (200-250-300-300-400-400-400-400). Otherwise, the architecture remains the same as shown in Table 1. By not changing the size of the encoder and the decoder, we fix the capacity of the core translation module, and only allow the multilingual model to detect more character patterns.

Similarly, the multilingual bpe2char model has the same encoder and decoder as the bilingual bpe2char model, but a larger vocabulary. We learn 50,000 multilingual BPE operations on the multilingual corpus, resulting in 54,544 subwords. See Table 2 for the exact configuration of our multilingual models.

Data scheduling For the multilingual models, an appropriate scheduling of data from different languages is crucial to avoid overfitting to one language too soon. Following [Firat et al., 2016a, Firat et al., 2016b], each minibatch is balanced, in that the proportion of each language pair in a single minibatch corresponds to that of the full corpus. With this minibatch scheme, roughly the same number of updates is required to make one full pass over the entire training corpus of each language pair. Minibatches from all language pairs are combined and presented to the model as a single minibatch. See Table 3 for the minibatch size for each language pair.

Treatment of Cyrillic To facilitate cross-lingual parameter sharing, we convert every Cyrillic character in the Russian source corpus to Latin alphabet according to ISO-9. Table 5.5 shows an example of how this conversion may help the multilingual models identify lexemes that are shared across multiple languages.

škola & školy RU школа школы RU (ISO-9) škola školy

Multilingual BPE For the multilingual bpe2char model, multilingual BPE segmentation rules are extracted from a large dataset containing training source corpora of all the language pairs. To ensure the BPE rules are not biased towards one language, larger datasets such as Czech and German corpora are trimmed such that every corpus contains an approximately equal number of characters.

In this section, we first establish our main hypotheses for introducing character-level and multilingual models, and investigate whether our observations support or disagree with our hypotheses. From our empirical results, we want to verify: (1) if fully character-level translation outperforms subword-level translation, (2) in which setting and to what extent is multilingual translation beneficial and (3) if multilingual, character-level translation achieves superior performance to other models. We outline our results with respect to each hypothesis below.

(1) Character- vs. subword-level In a bilingual setting, the char2char model outperforms both subword-level baselines on DE-EN (Table 5 (a-c)) and CS-EN (Table 5 (f-h)). On the other two language pairs, it exceeds the bpe2bpe model and achieves similar performance with the bpe2char baseline (Table 5 (k-m) and (p-r)). We conclude that the proposed character-level model is comparable to or better than both subword-level baselines.

Meanwhile, in a multilingual setting, the character-level encoder significantly surpasses the subword-level encoder consistently in all the language pairs (Table 5 (d-e), (i-j), (n-o) and (s-t)). From this, we conclude that translating at the level of characters allows the model to discover shared constructs between languages more effectively. This also demonstrates that the character-level model is more flexible in assigning model capacity to different language pairs.

(2) Multilingual vs. bilingual At the level of characters, we note that multilingual translation is indeed strongly beneficial. On the test sets, the multilingual character-level model outperforms the single-pair character-level model by 2.64 BLEU in FI-EN (Table 5 (m, o)) and 0.78 BLEU in CS-EN (Table 5 (h, j)), while achieving comparable results on DE-EN and RU-EN.

At the level of subwords, on the other hand, we do not observe the same degree of performance benefit from multilingual translation. Also, the multilingual bpe2char model requires much more updates to reach the performance of the bilingual bpe2char model (see Figure 2). This suggests that learning useful subword segmentation across languages is difficult.

(3) Multilingual char2char vs. others The multilingual char2char model is the best performer in CS-EN, FI-EN and RU-EN (Table 5 (j, o, t)), and is the runner-up in DE-EN (Table 5 (e)). The fact that the multilingual char2char model outperforms the single-pair models goes to show the parameter efficiency of character-level translation: instead of training $N$ separate models for $N$ language pairs, it is possible to get better performance with a single multilingual character-level model.

2 Human Evaluation

It is well known that automatic evaluation metrics such as BLEU encourage reference-like translations and do not fully capture true translation quality [Callison-Burch, 2009, Graham et al., 2015]. Therefore, we also carry out a recently proposed evaluation from [Graham et al., 2016] where we have human assessors rate both (1) adequacy and (2) fluency of each system translation on a scale from 0 to 100 via Amazon Mechanical Turk. Adequacy is the degree to which assessors agree that the system translation expresses the meaning of the reference translation. Fluency is evaluated using system translation alone without any reference translation.

Approximately 1k turkers assessed a single test set (3k sentences in newstest-2014) for each system and language pair. Each turker conducted a minimum of 100 assessments for quality control, and the set of scores generated by each turker was standardized to remove any bias in the individual’s scoring strategy.

We consider three models (bilingual bpe2char, bilingual char2char and multilingual char2char) for the human evaluation. We leave out the multilingual bpe2char model to minimize the number of similar systems to improve the interpretability of the evaluation overall.

For DE-EN, we observe that the multilingual char2char and bilingual char2char models are tied with respect to both adequacy and fluency (Table 6 (b-c)). For CS-EN, the multilingual char2char and bilingual bpe2char models ared tied for adequacy. However, the multilingual char2char model yields significantly better fluency (Table 6 (d, f)). For FI-EN and RU-EN, the multilingual char2char model is tied with the bilingual char2char model with respect to adequacy, but significantly outperforms all other models in fluency (Table 6 (g-i, j-l)).

Overall, the improvement in translation quality yielded by the multilingual character-level model mainly comes from fluency. We conjecture that because the English decoder of the multilingual model is tuned on all the training sentence pairs, it becomes a better language model than a bilingual model’s decoder. We leave it for future work to confirm if this is indeed the case.

Qualitative Analysis

In Table 7, we demonstrate our character-level model’s robustness in four translation scenarios that conventional NMT systems are known to suffer in. We also showcase our model’s ability to seamlessly handle intra-sentence code-switching, or mixed utterances from two or more languages. We compare sample translations from the character-level model with those from the subword-level model, which already sidesteps some of the issues associated with word-level translation.

With real-world text containing typos and spelling mistakes, the quality of word-based translation would severely drop, as every non-canonical form of a word cannot be represented. On the other hand, a character-level model has a much better chance recovering the original word or sentence. Indeed, our char2char model is robust against a few spelling mistakes (Table 7 (a)).

Given a long, rare word such as “Siebentausendzweihundertvierundfünfzig” (seven thousand two hundred fifty four) in Table 7 (b), the subword-level model segments “Siebentausend” as (Sieb, ent, aus, end), which results in an inaccurate translation. The character-level model performs better on these long, concatenative words with ambiguous segmentation.

Also, we expect a character-level model to handle novel and unseen morphological inflections well. We observe that this is indeed the case, as our char2char model correctly understands “gesperrt”, a past participle form of “sperren” (to block) (Table 7 (c)).

Nonce words are terms coined for a single use. They are not actual words but are constructed in a way that humans can intuitively guess what they mean, such as workoliday and friyay. We construct a few DE-EN sentence pairs that contain German nonce words (one example shown in Table 7 (d)), and observe that the character-level model can indeed detect salient character patterns and arrive at a correct translation.

Finally, we evaluate our multilingual models’ capacity to perform intra-sentence code-switching, by giving them as input mixed sentences from multiple languages. The newstest-2013 development datasets for DE-EN, CS-EN and FI-EN contain intersecting examples with the same English sentences. We compile a list of these sentences in DE/CS/FI and their translation in EN, and choose a few samples uniformly at random from the English side. Words or clauses from different languages are manually intermixed to create multilingual sentences.

We discover that when given sentences with high degree of language intermixing, as in Table 7 (e), the multilingual bpe2char model fails to seamlessly handle alternation of languages. Overall, however, both multilingual models generate reasonable translations. This is possible because we did not provide a language identifier when training our multilingual models; as a result, they learned to understand a multilingual sentence and translate it into a coherent English sentence. We show supplementary sample translations in each scenario on a webpage.444https://sites.google.com/site/dl4mtc2c

Training and decoding speed On a single Titan X GPU, we observe that our char2char models are approximately 35% slower to train than our bpe2char baselines when the same batch size was used. Our bilingual character-level models can be trained in roughly two weeks.

We further note that the bilingual bpe2char model can translate 3,000 sentences in 66.63 minutes while the bilingual char2char model requires 71.71 minutes (online, not in batch). See Table 8 for the exact details.

Further observations We also note that the multilingual models are less prone to overfitting than the bilingual models. This is particularly visible for low-resource language pairs such as FI-EN. Figure 2 shows the evolution of the FI-EN validation BLEU scores where the bilingual models overfit rapidly but the multilingual models seem to regularize learning by training simultaneously on other language pairs.

Conclusion

We propose a fully character-level NMT model that accepts a sequence of characters in the source language and outputs a sequence of characters in the target language. What is remarkable about this model is the absence of explicitly hard-coded knowledge of words and their boundaries, and that the model learns these concepts from a translation task alone.

Our empirical results show that the fully character-level model performs as well as, or better than, subword-level translation models. The performance gain is distinctly pronounced in the multilingual many-to-one translation task, where results show that character-level model can assign model capacities to different languages more efficiently than the subword-level models. We observe a particularly large improvement in FI-EN translation when the model is trained to translate multiple languages, indicating positive cross-lingual transfer to a low-resource language pair.

We discover two main benefits of the multilingual character-level model: (1) it is much more parameter efficient than the bilingual models and (2) it can naturally handle intra-sentence code-switching as a result of the many-to-one translation task. Ultimately, we present a case for fully character-level translation: that translation at the level of character is strongly beneficial and should be encouraged more.

The repository https://github.com/nyu-dl /dl4mt-c2c contains the source code and pre-trained models for reproducing the experimental results.

In the next stage of this research, we will investigate extending our multilingual many-to-one translation models to perform many-to-many translation, which will allow the decoder, similarly with the encoder, to learn from multiple target languages. Furthermore, a more thorough investigation into model architectures and hyperparameters is needed.

Acknowledgements

KC thanks the support by eBay, Facebook, Google (Google Faculty Award 2016) and NVidia (NVIDIA AI Lab 2016-2019). This work was partly supported by Samsung Advanced Institute of Technology (Deep Learning). JL was supported by Qualcomm Innovation Fellowship, and thanks David Yenicelik and Kevin Wallimann for their contribution in designing the qualitative analysis. The authors would like to thank Prof. Zheng Zhang (NYU Shanghai) for fruitful discussion and comments, as well as Yvette Graham for her help with the human evaluation.

References