Just Use XML: Revisiting Joint Translation and Label Projection

This paper introduces LabelPigeon, a novel framework that uses XML tags to jointly perform machine translation and label projection, demonstrating that this approach not only outperforms existing baselines in cross-lingual transfer tasks but also actively improves translation quality across multiple languages.

The Gist

Imagine you have a treasure map written in English, but the "X" marks the spot where a specific treasure (like a person's name or a date) is hidden. You want to give this map to a friend who speaks only German, so they can find the treasure too.

The old way of doing this was a two-step process:

1. Translate the whole map into German.
2. Go back and try to guess where the "X" should be in the German version by matching words one-by-one.

The problem? Sometimes the translation changes the sentence structure so much that the "X" ends up in the wrong place, or the map gets messy and hard to read. Previous researchers tried to fix this by putting brackets around the "X" before translating, but they found that the brackets confused the translator, making the German map sound robotic and unnatural.

Enter "LabelPigeon": The New Way

The authors of this paper say, "Wait a minute! What if we just teach the translator to understand the brackets from the start?"

They created a new method called LabelPigeon. Instead of treating translation and label-mapping as two separate jobs, they combine them into one smooth operation using XML tags (think of these as colorful, invisible sticky notes like <name> or <date>).

Here is how it works, using a few creative analogies:

1. The "Bilingual Chef" Analogy

Imagine a chef who usually cooks English recipes. Previously, if you asked them to cook a German version of a recipe that had specific instructions like "add salt here," they would:

• First, translate the whole recipe to German.
• Then, a sous-chef would try to find where "salt" went in the German text and stick a note there.

Often, the sous-chef would get it wrong because the German sentence structure was different.

LabelPigeon is like hiring a Bilingual Chef who knows exactly what "salt" means in both languages. You hand them the English recipe with the word "salt" wrapped in a special tag: add <salt> here. The chef translates the whole thing while keeping that tag intact, ensuring the German version says füge <salt> hier hinzu. The tag travels perfectly with the word it describes, and the sentence still flows naturally.

2. Why XML Tags are Better than Brackets

The previous method used simple square brackets like [salt]. The authors argue this is like trying to write a letter with sticky notes that just say "NOTE." It's vague.

They used XML tags (like <person> or <year>). This is like using color-coded, labeled folders.

• If you have a nested instruction (a note inside another note), brackets get messy and confusing.
• XML tags are like Russian nesting dolls that fit perfectly together. They can handle complex sentences where one label is inside another without getting lost.

3. The "Training" Secret

The big surprise in this paper is that adding these tags actually makes the translation better, not worse.

Usually, you'd think adding extra symbols (the tags) would distract the AI. But the authors took a massive, high-quality dataset of translated text that already had these tags (from software localization) and fine-tuned their AI model on it.

It's like teaching a student not just to translate words, but to translate structure. The AI learned that "Oh, when I see this tag, I need to keep the meaning of this specific chunk of text intact." This extra training made the AI a better translator overall, even for sentences without tags.

The Results: A Win-Win

The team tested this on over 200 languages and three different types of tasks (finding names, answering questions, and figuring out who "he" or "she" refers to).

• Better Labels: They found the "X" (the labels) much more accurately than before.
• Better Translation: The German (and other language) translations sounded more natural and accurate than the old methods.
• No Extra Cost: Unlike other methods that require running two different programs (one to translate, one to fix the labels), LabelPigeon does it all in one single pass. It's fast and efficient.

The Bottom Line

This paper proves that you don't have to choose between a good translation and accurate data labels. By teaching the AI to wear "glasses" (XML tags) that help it see the structure of the sentence, you get a translation that is both fluent and precise. It's a simple, elegant solution that stops the "two-step dance" and lets the AI do the whole job in one smooth move.

Technical Summary

1. Problem Statement

Cross-lingual transfer for NLP tasks (e.g., Named Entity Recognition, Coreference Resolution) often relies on label projection: translating span-annotated data from a high-resource language (like English) to a low-resource language and mapping the labels to the translated text.

• The Status Quo: Most existing pipelines treat translation and label projection as separate steps. They translate the text first, then use word alignment models or LLMs to project labels onto the translation.
• The Prevailing Assumption: Prior work (specifically Chen et al., 2023) suggested that attempting to perform joint translation and label projection (inserting markers into the source text before translation) inherently degrades translation quality. Consequently, the field shifted toward complex, multi-stage pipelines (e.g., constrained decoding or separate projection steps) to avoid this perceived quality loss.
• The Gap: These multi-stage pipelines introduce significant computational overhead and engineering complexity. The authors challenge the assumption that joint processing necessarily harms translation quality.

2. Methodology: LabelPigeon

The authors propose LabelPigeon, a framework that performs translation and label projection in a single pass using XML tags as markers.

Core Components:

1. Marker Choice (XML vs. Square Brackets):

   • Previous work used square brackets (e.g., [Entity]) as markers. The authors argue this is suboptimal because brackets lack semantic correspondence between source and target, requiring fuzzy string matching to map spans, which fails with nested or overlapping spans.
   • LabelPigeon uses XML tags (e.g., <a>Entity</a>). This provides a direct, structural correspondence between source and target spans, handles nesting gracefully, and allows for semantic information if needed.

2. Data Preparation & Training:

   • Source Data: The authors utilize the Salesforce Localization XML MT dataset (Hashimoto et al., 2019), a high-quality parallel corpus containing naturally occurring XML tags (originally for UI elements).
   • Tag Normalization: To make the data generalizable for arbitrary span labels, they replace specific UI tags with generic, non-descriptive alphabetical tags (e.g., <a>, <b>, <c>) based on appearance order.
   • Filtering: They filter out examples without tags, resulting in ~150k training samples across three high-resource language pairs (English-German, English-Russian, English-Chinese).
   • Base Model: They fine-tune the NLLB-200 3.3B model on this modified dataset.

3. Inference Process:

   • Input: Source text with spans wrapped in XML tags.
   • Process: The model translates the text while preserving the XML structure.
   • Output: Translated text with corresponding XML tags.
   • Extraction: Standard XML parsers extract the translated spans.
   • Efficiency: This requires only a single forward pass, incurring negligible computational overhead compared to multi-stage pipelines.

3. Key Contributions

1. Re-evaluation of Joint Processing: The paper disproves the claim that joint translation and label projection degrades translation quality. Instead, they demonstrate that with appropriate training data and markers, translation quality can actually improve.
2. LabelPigeon Framework: A simple, efficient method using XML tags that handles frequent, nested, and overlapping spans without complex post-processing.
3. Novel Evaluation Scheme: The authors introduce a direct evaluation metric for label projection (Label Match F1) using parallel span-annotated datasets (XQuAD, MLQA), moving away from relying solely on downstream task performance as a proxy.
4. Comprehensive Benchmarking: Extensive evaluation across 203 languages for translation quality and 27 languages for downstream tasks.

4. Experimental Results

A. Direct Label Projection Evaluation (11 Languages)

Using XQuAD and MLQA datasets:

• Label Accuracy: LabelPigeon achieved the highest Label Match F1 scores (79.2% on XQuAD, 79.9% on MLQA), outperforming baselines like Awesome-align (50.6%), Gemma 3 (78.1%), and EasyProject (77.7%).
• Generalization: Despite training on data with a maximum of 6 unique tags per example, LabelPigeon successfully generalized to test sets with up to 24 tags per example.
• Translation Quality: Contrary to prior assumptions, LabelPigeon improved translation quality (measured by COMET scores) over the base NLLB model for the majority of languages.

B. Translation Quality Impact (203 Languages)

Using the FLORES-200 dataset with synthetic markers:

• Single/Simple Markers: LabelPigeon maintained or slightly improved translation quality (BLEU/chrF++) compared to the baseline.
• Complex Markers: While translation quality degraded slightly with highly nested/overlapping markers (as expected), LabelPigeon still significantly outperformed EasyProject.
• Ablation Study: The improvement in translation quality was attributed to the additional fine-tuning on high-quality parallel data, not just the presence of markers. A model fine-tuned on the same data but without markers (NF) performed similarly well, suggesting the data quality drives the gain.

C. Downstream Task Performance (27 Languages)

Evaluated on NER, Coreference Resolution (CR), and Question Answering (QA):

• NER: LabelPigeon showed substantial gains, with an average F1 improvement of +14.2 over EasyProject. Notable gains in low-resource languages: Cebuano (+30.7) and Tagalog (+39.9).
• Coreference Resolution: While CR is a difficult task with low baseline scores, LabelPigeon significantly reduced failure rates. EasyProject failed (F1 < 1.0) in 12/16 languages, whereas LabelPigeon only failed in 2 historical languages.
• QA: LabelPigeon matched or slightly exceeded EasyProject (66.15 vs 66.13 F1).

5. Significance and Conclusion

• Paradigm Shift: The paper challenges the field's abandonment of joint translation/projection. It demonstrates that a straightforward training regimen with high-quality, XML-tagged data is superior to complex, multi-stage pipelines.
• Efficiency: LabelPigeon eliminates the need for word alignment models, constrained decoding, or separate LLM-based projection steps, offering a single-pass, low-overhead solution.
• Scalability: The method is effective across a vast number of languages (203 tested) and handles complex annotation structures (nesting/overlap) that previously caused failures in other methods.
• Practical Impact: The approach provides a simple, effective alternative for extending NLP tasks to low-resource languages without compromising translation fidelity.

In summary, the authors successfully argue that "Just Use XML" is a viable, superior strategy for cross-lingual label transfer, combining high label projection accuracy with improved or maintained translation quality.