Get away with less: Need of source side data curation to build parallel corpus for low resource Machine Translation

This paper introduces LALITA, a framework that curates efficient parallel corpora for low-resource machine translation by selecting complex source sentences based on lexical and linguistic features, thereby significantly improving translation quality while reducing data requirements by more than half.

The Gist

Here is an explanation of the paper "Get away with less: Need of source side data curation to build parallel corpus for low resource Machine Translation" using simple language and creative analogies.

The Big Problem: The "Quantity vs. Quality" Trap

Imagine you are trying to teach a robot how to speak a new language (like Hindi, Odia, or Nepali). Traditionally, the rule has been: "The more books you give the robot, the smarter it gets."

But here's the catch: For many languages, especially those spoken in the "Global South," there aren't enough books (data) available. And if you try to hire humans to translate millions of sentences to create these books, it costs a fortune. It's like trying to build a library for a small village by importing millions of books from abroad—it's too expensive and slow.

Furthermore, the data that is available (scraped from the internet) is often messy. It's like a library filled with books that have torn pages, missing chapters, or are written in a language the robot doesn't understand.

The Solution: Enter LALITA (The "Smart Librarian")

The authors of this paper introduce a new framework called LALITA. Think of LALITA not as a machine that makes more data, but as a super-smart librarian who knows exactly which books to put on the shelf.

Instead of dumping a million random books on the robot's desk, LALITA says: "Wait! We don't need a million simple, boring books. We need a few hundred complex, interesting books. If we give the robot the right kind of books, it will learn faster and better."

How Does LALITA Work? (The "Complexity Score")

LALITA looks at every sentence in the training data and gives it a "Complexity Score."

• Low Score: Simple sentences like "The cat sat on the mat." (Easy to learn, but not very helpful for teaching complex grammar).
• High Score: Complex sentences like "While the minister denied any wrongdoing, the committee, which had been investigating for months, decided to launch a formal inquiry into the matter." (Harder to learn, but teaches the robot how to handle real-world, messy language).

LALITA uses math (specifically something called Principal Component Analysis) to analyze features like:

• How long is the sentence?
• How many verbs are there?
• How many different types of words (nouns, adjectives) are used?
• How are the words connected?

It then groups sentences into four "buckets" (Clusters):

1. Bucket 0: Very simple.
2. Bucket 1: A bit more complex.
3. Bucket 2: Getting interesting.
4. Bucket 3: The "Master Class" sentences (very complex and rich).

The Big Discovery: "Less is More"

The researchers ran a massive experiment. They trained robots using different combinations of these buckets. Here is what they found:

The Old Way: Give the robot a mix of all buckets (mostly simple ones because that's what's usually available).
The LALITA Way: Give the robot mostly Bucket 3 (the complex sentences), even if it means using fewer total sentences.

The Result?

• A robot trained on 800,000 complex sentences performed better than a robot trained on 1.8 million mixed sentences.
• They achieved the same (or better) results with less than half the data.
• This works for low-resource languages (like Hindi) and even high-resource ones (like German).

The "Synthetic" Trick (Filling the Gaps)

What if they wanted 800,000 complex sentences, but they only found 400,000 in the real world?
LALITA doesn't just give up. It uses a trick called Back-Translation.

1. It takes a Hindi sentence.
2. Translates it to English using a robot.
3. Checks if that English sentence is "complex" enough.
4. If it is, it keeps it. If not, it throws it away.

This is like a chef who only uses the freshest, most flavorful ingredients. If they can't find enough fresh tomatoes in the market, they grow their own, but they are picky about which ones they pick.

Why Does This Matter? (The Real-World Impact)

1. Saving Money: If you need half the data to get the same result, you need half the computing power and half the time. This makes building translation tools for poor or rare languages much cheaper.
2. Better Quality: The robots trained on complex sentences don't just translate simple phrases; they understand nuance, sarcasm, and long, winding sentences.
3. Environmental Good: Training huge AI models uses a lot of electricity. By needing less data, we reduce the carbon footprint of AI.

The Analogy: Learning to Play Chess

Imagine you want to teach someone to play Chess.

• The Old Way: You give them 10,000 games where the players just move pawns back and forth randomly. They learn the rules, but they can't play a real game.
• The LALITA Way: You give them 5,000 games of Grandmasters. Every move is strategic, complex, and full of patterns. Even though there are fewer games, the student learns to think like a master much faster.

Summary

This paper proves that quality beats quantity. By using a smart filter (LALITA) to pick out the most linguistically complex and rich sentences, we can build better translation systems with much less data. It's a shift from "collecting everything" to "curating the best."

The takeaway: You don't need a bigger library; you just need a better librarian.

Technical Summary

Here is a detailed technical summary of the paper "Get away with less: Need of source side data curation to build parallel corpus for low resource Machine Translation" by Saumitra Yadav and Manish Shrivastava.

1. Problem Statement

The development of robust Machine Translation (MT) systems traditionally relies on vast quantities of high-quality parallel data. However, for low-resource languages (particularly those from the Global South), acquiring such data through human translation is prohibitively expensive and resource-intensive.

• The Bottleneck: Existing large-scale web-mined corpora (e.g., OSCAR, Samanantar) often contain significant noise, misalignment, and a high prevalence of simple, redundant sentences that do not provide a strong learning signal for Neural Machine Translation (NMT) models.
• The Misconception: The prevailing assumption is that "more data is always better." This paper challenges that notion, arguing that indiscriminate data accumulation is inefficient. Instead, the focus should shift from quantity to quality, specifically by selecting source sentences that offer the highest structural and linguistic complexity to maximize the learning signal per token.

2. Methodology: The LALITA Framework

The authors propose LALITA (Lexical And Linguistically Informed Text Analysis), a framework designed to curate parallel corpora by selecting source sentences based on their intrinsic linguistic complexity.

A. Data Preprocessing

• Dataset: The primary experiments utilize the Samanantar English-Hindi bi-text.
• Filtering: A rigorous cleaning process removes noise, including:
  • Sentences with >35% Roman script in Hindi.
  • Sentence pairs with length ratios >4 (indicating misalignment).
  • Ambiguous pairs where one source maps to multiple targets.
• Result: A clean "Filtered English-Hindi Parallel Sentences" (FPS) dataset of ~1.85 million pairs.

B. Feature Engineering

To quantify sentence complexity, the authors extract a multi-dimensional feature vector for each English source sentence using the Trankit NLP toolkit. Features include:

• Statistical: Perplexity (via Neural and 5-gram language models).
• Lexical: Sentence length (token count).
• Linguistic:
  • Named Entity counts (Location, Person, Org, Misc).
  • Part-of-Speech (POS) tag counts (17 tags).
  • Dependency Relation counts (68 relations, e.g., acl, advcl, conj).
  • Universal Morphological Features (156 features, e.g., tense, animacy, voice).

C. Deriving the LALITA Score

• Dimensionality Reduction: The high-dimensional, sparse feature vectors are processed using Principal Component Analysis (PCA).
• The Metric: The first principal component (PCA1) is identified as the LALITA Score.
  • Interpretation: A higher LALITA score correlates directly with structural complexity (e.g., longer sentences, more verbs, complex dependency trees like clausal modifiers).
  • Validation: PCA1 shows a strong positive correlation with the number of verbs and sentence length, confirming it as a reliable proxy for complexity.

D. Data Curation Strategy

• Clustering: Sentences are clustered into four groups (Cluster 0 to Cluster 3) based on their LALITA scores using the Fisher-Jenks algorithm.
  • Cluster 0: Simplest sentences.
  • Cluster 3: Most structurally complex sentences.
• Selection: Experiments involve training MT models on various configurations (e.g., 100% Cluster 3, or mixed ratios like 60% Cluster 3 + 20% Cluster 2, etc.) to determine the optimal complexity profile.
• Data Augmentation: When specific clusters lack sufficient data (e.g., needing 640k sentences from Cluster 3 but only having 400k), the deficit is filled using synthetic data generated via back-translation. Crucially, synthetic data is also filtered and clustered by LALITA score to ensure the augmented data matches the target complexity profile.

3. Key Contributions

1. LALITA Score: A novel, quantifiable metric for sentence structural complexity derived from a comprehensive set of linguistic and lexical features.
2. Strategic Data Curation: A pipeline that proves training on structurally complex sentences yields superior MT performance compared to training on random or simple sentences.
3. Efficiency in Low-Resource Settings: Demonstrates that high-quality translation can be achieved with significantly less data (reductions of 44% to 86% in dataset size) by focusing on complexity.
4. Universal Applicability: The framework is validated across multiple language pairs (English-Hindi, Odia, Nepali, Norwegian Nynorsk) and even high-resource pairs (English-German), proving its transferability.

4. Key Results

The experiments were conducted on the FLORES test set using CHRF++ as the evaluation metric.

• English-Hindi (Low Resource):

  • A system trained on 800K sentences consisting entirely of Cluster 3 (most complex) achieved performance comparable to a system trained on the full 1.8 million sentence dataset.
  • Data Reduction: Achieved comparable results with 44% less data (800K vs 1.8M) and 64% fewer total tokens.
  • Performance Gain: The curated system outperformed the random sampling baseline by 2.21 CHRF++ points.

• Other Low-Resource Languages:

  • English-Odia: Reduced data requirement to 14% of the original size while improving performance.
  • English-Nepali: Reduced data by 50%.
  • English-Norwegian Nynorsk: Reduced data to 64% of the original.

• High-Resource Scenario (English-German):

  • Using a 20 million sentence dataset, a curated system using only 8 million sentences (100% Cluster 3 + synthetic augmentation) outperformed the system trained on the full 20 million sentences.
  • Gain: +4.32 CHRF++ points over the full dataset baseline, with a 60% reduction in data volume.

• Ablation Studies:

  • Selecting based on single features (e.g., just sentence length or just verb count) was less effective than the holistic LALITA score.
  • Models trained on simple sentences (Cluster 0) failed to generalize to complex test inputs, often producing nonsensical or grammatically flawed translations.

5. Significance and Impact

• Cost Efficiency: By reducing the data requirements by more than half, LALITA significantly lowers the computational costs (GPU hours) and financial costs associated with training MT models.
• Environmental Impact: Smaller datasets and faster training times reduce the carbon footprint of developing large-scale AI models.
• Democratization: This approach makes it feasible for communities with limited resources to build effective translation systems without needing massive, expensive human-translated corpora.
• Paradigm Shift: The paper advocates for a shift from "data accumulation" to "data curation," emphasizing that the structural richness of training data is a more critical factor for NMT performance than sheer volume.

6. Limitations and Future Work

• Dependency on Parsers: The method requires robust NLP parsers for the source language, posing a "cold start" problem for languages with no existing linguistic tools.
• Sentence-Level Focus: The current framework operates at the sentence level and does not capture discourse-level features (cohesion, coherence).
• Future Directions: The authors propose integrating sentence embeddings, applying LALITA to Large Language Model (LLM) pretraining, and exploring curriculum learning (training from simple to complex sentences).

In conclusion, LALITA provides a scientifically grounded, linguistically informed method to "get away with less" data, proving that quality and complexity are the keys to efficient and effective Machine Translation.