On Romanization for Model Transfer Between Scripts in Neural Machine Translation

Transfer learning is a popular strategy to improve the quality of low-resource machine translation. For an optimal transfer of the embedding layer, the child and parent model should share a substantial part of the vocabulary. This is not the case when transferring to languages with a different script. We explore the benefit of romanization in this scenario. Our results show that romanization entails information loss and is thus not always superior to simpler vocabulary transfer methods, but can improve the transfer between related languages with different scripts. We compare two romanization tools and find that they exhibit different degrees of information loss, which affects translation quality. Finally, we extend romanization to the target side, showing that this can be a successful strategy when coupled with a simple deromanization model.


Introduction
Neural Machine Translation (NMT) has opened up new opportunities in transfer learning from highresource to low-resource language pairs (Zoph et al., 2016;Kocmi and Bojar, 2018;Lakew et al., 2018). While transfer learning has shown great promise, the transfer between languages with different scripts brings additional challenges. For a successful transfer of the embedding layer, both the parent and the child model should use the same or a partially overlapping vocabulary (Aji et al., 2020). It is common to merge the two vocabularies by aligning identical subwords and randomly assigning the remaining subwords from the child vocabulary to positions in the parent vocabulary (Lakew et al., 2018(Lakew et al., , 2019Kocmi and Bojar, 2020).
This works well for transfer between languages that use the same script, but if the child language is written in an unseen script, most vocabulary positions are replaced by random subwords. This significantly reduces the transfer from the embedding layer. Gheini and May (2019) argue that romanization can improve transfer to languages with unseen scripts. However, romanization can also introduce information loss that might hurt translation quality. In our work, we study the usefulness of romanization for transfer from many-to-many multilingual MT models to low-resource languages with different scripts. Our contributions are the following: -We show that romanized MT is not generally optimal, but can improve transfer between related languages that use different scripts.
-We study information loss from different romanization tools and its effect on MT quality.
-We demonstrate that romanization on the target side can also be effective when combined with a learned deromanization model.

Related Work
Initial work on transfer learning for NMT has assumed that the child language is known in advance and that the parent and child model can use a shared vocabulary (Nguyen and Chiang, 2017;Kocmi and Bojar, 2018). Lakew et al. (2018) argue that this is not feasible in most real-life scenarios and propose using a dynamic vocabulary. Most studies have since opted to replace unused parts of the parent vocabulary with unseen subwords from the child vocabulary (Lakew et al., 2019;Kocmi and Bojar, 2020); others use various methods to align embedding spaces (Gu et al., 2018;Kim et al., 2019). Recently, Aji et al. (2020) showed that transfer of the embedding layer is only beneficial if there is an overlap between the parent and child vocabulary such that embeddings for identical subwords can be aligned. Such alignments are very rare if the child language uses an unseen script.
Gheini and May (2019) train a universal vocabulary on multiple languages by romanizing languages written in a non-Latin script. Their many-toone parent model can be transferred to new source languages without exchanging the vocabulary. In our work, we extend this idea to many-to-many translation settings using subsequent deromanization of the output. We study the trade-off between a greater vocabulary overlap and information loss as a result of romanization. Based on experiments on a diverse set of low-resource languages, we show that romanization is helpful for model transfer to related languages with different scripts.

Romanization
Romanization describes the process of mapping characters in various scripts to Latin script. This mapping is not always reversible. The goal is to approximate the pronunciation of the text in the original script. However, depending on the romanization tool, more or less information encoded in the original script is lost. We compare two tools for mapping our translation input to Latin script: uroman 1 (Hermjakob et al., 2018) is a tool for universal romanization that can romanize almost all character sets. It is unidirectional; mappings from Latin script back to other scripts are not available. uconv 2 is a command-line tool similar to iconv that can be used for transliteration. It preserves more information from the original script, which is expressed with diacritics. uconv is bi-directional for a limited number of script pairs.
Below is an example of the same Chinese sentence romanized with uroman and uconv: 她到塔皓湖去了 uroman: ta dao ta hao hu qu le uconv: tā dào tǎ hào hú qù le "She went to Lake Tahoe." The two tools exhibit different degrees of information loss. uroman ignores tonal information and consequently collapses the representations of 塔 (Pinyin tǎ; 'tower') and 她 (Pinyin tā; 'she'). Romanization with uconv retains this distinction but it still adds ambiguity and loses the distinction between 她 (Pinyin tā; 'she') and 他 (Pinyin tā; 'he'), among others. While uconv exhibits less information loss, its use of diacritics limits subword sharing between languages. We measure

Deromanization
Romanization is not necessarily reversible with simple rules due to information loss. Therefore, previous work on romanized machine translation has focused on source-side romanization only (Du and Way, 2017;Wang et al., 2018;Aqlan et al., 2019;Briakou and Carpuat, 2019;Gheini and May, 2019). We argue that romanization can also be applied on the target side, followed by an additional deromanization step. This step can be performed by a character-based Transformer (Vaswani et al., 2017) that takes data romanized with uroman or uconv as input and is trained to map it back to the original script. We provide more details on our deromanization systems in Appendix A.2.

Data
We use OPUS-100 (Zhang et al., 2020) 3 , an English-centric dataset that includes parallel data for 100 languages. It provides up to 1 million sentence pairs for every X-EN language pair as well as 2,000 sentence pairs for development and testing each. There is no overlap between any of the data splits across any of the languages, i.e. every English sentence occurs only once.
We pretrain our multilingual models on 5 highresource languages that cover a range of different scripts {AR, DE, FR, RU, ZH} ↔ EN. For our transfer learning experiments, we choose 7 additional languages that are either: (a) Not closely related to any of the pretraining languages and written in an unseen script, e.g. Marathi is not related to any of our pretraining languages and written in Devanagari script.
(b) Closely related to a pretraining language and written in an unseen script, e.g. Yiddish is related to German and written in Hebrew script. (c) Written in Latin script but closely related to a pretraining language in non-Latin script, e.g. Maltese is related to Arabic and written in Latin script.
Our selection of low-resource languages covers a wide range of language families and training data sizes. Table 1 gives an overview of the selected languages.

Model Descriptions
We use nematus 4 (Sennrich et al., 2017) to train our models and SacreBLEU 5 (Post, 2018) to evaluate them. We compute statistical significance with paired bootstrap resampling (Koehn, 2004) using a significance level of 0.05 (sampling 1,000 times with replacement from our 2,000 test sentences). Our subword vocabularies are computed with byte pair encoding (Sennrich et al., 2016) using the Sen-tencePiece implementation (Kudo and Richardson, 2018). We use a character coverage of 0.9995 to ensure the resulting models do not consist of mostly single characters. Bilingual Baselines: We follow the recommended setup for low-resource translation in Sennrich and Zhang (2019) to train our bilingual baselines for the low-resource pairs (original script). For our bilingual low-resource models, we use language-specific vocabularies of size 2,000. Pretrained multilingual models: We pretrain three multilingual standard Transformer Base machine translation models (Vaswani et al., 2017): One keeps the original, non-Latin script for Arabic, Russian and Chinese (orig). The others (uroman and uconv) apply the respective romanization to these parent languages. We follow Johnson et al. (2017) for multilingual training by prepending a target language indicator token to the source input. For our pretrained models, we use a shared vocabulary of size 32,000. An overview of our model hyperparameters is given in Appendix A.1.
Finetuning: We finetune our pretrained models independently for every low-resource language X. For finetuning on a child X↔EN pair, we use the same preprocessing as for the respective parent, i.e. we keep original script, use uroman, or use uconv for romanization. We reuse 250,000 sentence pairs from the original pretraining data and oversample the X↔EN data for a total of around 650,000 parallel sentences for finetuning. This corresponds roughly to a 3:2 ratio which helps to prevent overfitting. We early stop on the respective X↔EN development set. For finetuning, we use a constant learning rate of 0.001. The remaining hyperparameters are identical to pretraining.

Vocabulary Transfer
For our transfer baseline without romanization, we merge our bilingual baseline vocabulary with that of the parent model following previous work (Aji et al., 2020;Kocmi and Bojar, 2020  align subwords that occur in both vocabularies. Next, we assign the remaining subwords from the bilingual baseline vocabulary to random unused positions in the parent vocabulary. With uroman, we can reuse the parent vocabulary as is. uconv, however, may produce unseen diacritics, which can result in a small number of unseen subwords. If that is the case, we perform the same vocabulary replacement for these subwords as for the vocabulary with the original script.

Does Romanization Hurt Translation?
To study the effects of information loss from romanization, we compare the translation quality of our three pretrained multilingual models. To minimize the impact of deromanization, we only discuss X→EN directions for languages with non-Latin scripts. The results are presented in Table 2. Whether romanization hurts the translation quality depends largely on the language pair. For example, for ZH→EN, both romanization tools perform worse than the model trained on original scripts. This is in line with our previous discussion: Even though uconv keeps tonal information, there is still more ambiguity compared to using Chinese characters. The model trained with uconv romanization consistently outperforms uroman. This indicates that it is more important to minimize information loss than to maximize subword sharing.
An additional effect of using romanization, and thus being able to reuse the subword segmentation model during transfer, is that compression rates are worse than for dedicated segmentation models (see Table 3). The resulting longer sequences with potentially suboptimal subword splits may also have a negative influence on translation quality.   Relying on uconv's built-in deromanization is not optimal. First, it does not support mappings back into all scripts. Second, the performance of builtin uconv deromanization varies with the amount of "script code-switching", e.g. due to hyperlinks or email addresses. Character-based Transformers can learn to handle mixed script and outperform uconv's built-in deromanization. Our models can reconstruct the original script much better from uconv data than from uroman. This is not surprising considering that uroman causes more information loss and ambiguity. As a shallow measure of the ambiguity introduced, we can compare the vocabulary size (before subword segmentation): With romanization, the total number of types in our training sets decreases on average by 10% for uconv and by 14% for uroman.
Preliminary experiments with artificial lowresource settings (Appendix B.1) showed that additional training data can improve deromanization but it performs well even with very small amounts of training data (10,000 sentences). This shows that our proposed character-based Transformer models are powerful enough to learn a mapping back to  the original script as much as this is possible, given the increased ambiguity. This finding is supported by concurrent work showing that character-based Transformers are well-suited to a range of string transduction tasks (Wu et al., 2020). Table 5 shows the results from our experiments on transfer learning with romanization. Romanizing non-Latin scripts is not always useful. For lowresource languages that use an unseen script but are not related to any of the pretraining languages (a), the performance degrades for uroman and is not statistically significantly different for uconv. The extremely low BLEU score for EN→AM shows another problem with uroman romanization: uroman ignores the Ethiopic word space character which increases the distance between translation and reference. However, for languages that are related to a pretraining language with a different script (groups (b) and (c)), there is an added benefit of using romanization. The statistically significant improvement of uconv over uroman strengthens our claim that it is important to keep as much information as possible from the original script when mapping to Latin script. Despite potential information loss from romanization and error propagation from deromanization, our results show that romanization has merit when applied to related languages that can profit from a greater vocabulary overlap.

Conclusion
We analyzed the value of romanization for transferring multilingual models to low-resource languages with different scripts. While we cannot recommend avg imp -+ 13.9 + 14.3 + 14.8 Table 5: BLEU scores of the bilingual baselines (no transfer learning) and finetuned models using original scripts (orig), romanized with uroman and uconv. Average improvement over bilingual baseline is shown per group of languages. Best systems (no other being statistically significantly better) marked in bold.
romanization as the default strategy for multilingual models and transfer learning across scripts because of the information loss inherent to it, we find that it benefits transfer between related languages that use different scripts. The uconv romanization tool outperforms uroman because it preserves more information encoded in the original script and consequently causes less information loss. Furthermore, we demonstrated that romanization can also be successful on the target side if followed by an additional, learned deromanization step. We hope that our results provide valuable insights for future work in transfer learning and practical applications for low-resource languages with unseen scripts.

A.1 Multilingual Pretrained Models
We train multilingual Transformer Base machine translation models (Vaswani et al., 2017) with 6 encoder layers, 6 decoder layers, 8 heads, an embedding and hidden state dimension of 512 and a feed-forward network dimension of 2048. We regularize our models with a dropout of 0.1 for the embeddings, the residual connections, in the feedforward sub-layers and for the attention weights. Furthermore, we apply exponential smoothing of 0.0001 and label smoothing of 0.1. We tie both our encoder and decoder input embeddings as well as the decoder input and output embeddings (Press and Wolf, 2017). All of our multilingual machine translation models are trained with a maximum token length of 200 and a vocabulary of size 32,000. For optimization, we use Adam (Kingma and Ba, 2015) with standard hyperparameters and a learning rate of 0.0001. We follow the Transformer learning schedule described in (Vaswani et al., 2017) with a linear warmup over 4,000 steps. Our token batch size is set to 16,348 and we train on 4 NVIDIA Tesla V100 GPUs. All models were trained using the implementation provided in nematus (Sennrich et al., 2017) using early stopping on a development set with patience 5.

A.2 Character-Based Deromanization
We train character-based Transformer Base machine translation models (Vaswani et al., 2017). To achieve character-level deromanization, we do not make any changes to the architecture. We simply change the input format such that every character is separated by spaces. The original space characters are replaced by another character that does not occur in the training data ( ). The following example shows the parallel training data for learned deromanization: uroman source: C H t o t a m d a l s h e ?
uconv source:Č t o t a m d a l 'š e ? target: Ч т о т а м д а л ь ш е ? "What's next?" We use a maximum sequence length of 1,200 since character-level sequences are much longer than subword-level sequences. Our vocabularies are made up of all characters that occur in the respective training data. All other parameters are set as for multilingual pretraining described in Appendix A.1. data size zh uconv Figure 1: chrF scores of deromanization models trained on 1%, 10% and 100% of the total data (corresponding to 10,000, 100,000 and 1,000,000 parallel sentences). Results compare romanization with uroman and uconv for Arabic, Russian and Chinese. Figure 1 shows the influence of the training data size on the chrF score between the deromanized test set and the original script test set. Additional data can improve deromanization models, especially for languages such as Chinese, where a mapping back to the original script is difficult to learn due to the information loss from romanization.
We analyze how deromanization quality affects the BLEU score of deromanized translations. This is shown in Table 6. We find that the deromanization models for uroman are more affected by an extreme low-resource setting. For uconv, deromanization models trained on smaller data sets show less performance loss compared to using full data. It is notable that training uconv deromanization models only on 100,000 sentences has almost no effect on the BLEU score for EN→AR and EN→ZH. For EN→RU, there is a loss of 1.1 BLEU points compared to training on 100% of the data. Looking at the deromanization outputs for EN→RU, we found that deromanization models trained on less data could not handle "script code-uroman 1% 10% 100% en-ar 20.3 21.6 21.7 en-ru 26.5 27.9 28.5 en-zh 38.8 41.6 41.9 uconv 1% 10% 100% en-ar 21.2 21.8 21.7 en-ru 27.9 28.2 29.3 en-zh 40.2 41.8 41.9 Table 6: EN→X BLEU scores of the multilingual pretrained models after deromanization. Deromanization models were trained on 1%, 10% and 100% of the total data (corresponding to 10,000, 100,000 and 1,000,000). Best systems (no other being statistically significantly better) marked in bold.
switching" as well as the models trained on full data.
While these results show that additional training material can improve deromanization, they do not mean that romanization on the target side cannot be used in low-resource machine translation settings. First, our results in Section 6.3 have shown that romanization on the target side can bring improvements even if deromanization models cannot perfectly reconstruct the original script. Second, it will often be possible to find additional monolingual data to improve deromanization models.