Multi-Stage Training for Abusive Comment Detection in Indic Languages
This paper proposes a multi-stage training pipeline combining language-based preprocessing and an ensemble of models to detect abusive comments in Indic languages while minimizing false positives to preserve freedom of expression.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine social media as a giant, bustling town square where everyone is shouting their thoughts, sharing news, and chatting. While this is great for connection, sometimes people start throwing rotten tomatoes (abusive comments) at each other. The goal of this paper is to build a smarter security guard for this town square who can spot the rotten tomatoes without accidentally stopping people from just having a loud, but harmless, argument.
Here is how the authors built their security guard, explained in simple terms:
The Problem: A Noisy, Messy Room
The team was given a massive pile of comments (700,000 of them) from an Indian app called "Moj." These comments were in 15+ different Indian languages.
However, the data was a mess, like a room where someone threw everything on the floor:
- Language Confusion: People often typed Hindi words using English letters (like "Hinglish"), or mixed languages together. It was hard for computers to understand the meaning.
- The "Label Noise" Trap: This was the biggest hurdle. The team discovered that the "answer key" (the labels telling them what was abusive) was wrong about 9-10% of the time.
- The Analogy: Imagine a teacher grading a test but accidentally marking a correct answer as "wrong" and a wrong answer as "correct." If the computer tries to learn from this teacher, it gets confused. The authors even did a crazy experiment where they flipped all the labels (told the computer "abusive" means "safe") and the computer actually got a high score, proving the original labels were indeed messed up.
The Solution: A Five-Stage Assembly Line
To fix this, the authors built a multi-stage pipeline, like a factory assembly line that cleans, sorts, and polishes the data before making a final decision.
Stage 1: The Cleanup Crew (Preprocessing)
First, they acted like a janitor. They removed HTML tags (digital trash) and used a tool to "transliterate" the text.
- The Analogy: If someone wrote "Namaste" in English letters, they converted it back to the actual Hindi script. This helped the computer understand the words better, just like reading a book in its original language rather than a bad translation.
Stage 2: The Language Specialists (Model Training)
Instead of using one giant, generic brain to understand all 15 languages, they trained specific "experts" for each language.
- They used advanced AI models (like XLM-R and Muril) that had already read millions of books. They fine-tuned these models to become experts in spotting abuse in specific Indian languages.
Stage 3: The Detective's Notebook (Embeddings & Metadata)
The models didn't just look at the words; they looked at the "vibe" of the comment.
- They turned the text into a mathematical map (called embeddings) that captures the meaning and context.
- They also added "metadata," which is like looking at the comment's popularity. If a comment has thousands of "reports" and zero "likes," it's a strong hint it might be abusive. They combined the text meaning with these social clues.
Stage 4: The "Guess and Check" Loop (Pseudo-Labeling)
Since the original labels were noisy, they tried a clever trick called Pseudo-Labeling.
- The Analogy: Imagine a student who is pretty good at math. The teacher says, "Here are some problems where the answers are missing. You solve them, and then we'll use your answers to teach you even more."
- The computer made its best guesses on the messy data. Then, it used those guesses to re-train itself. It did this over and over, slowly learning to ignore the "bad teacher" (the noisy labels) and trust its own growing intuition.
Stage 5: The Final Committee (Ensemble & Thresholds)
Finally, they didn't rely on just one model. They created a "committee" of different models.
- They took the predictions from their best models and combined them (a weighted ensemble).
- The Secret Sauce: They realized that what counts as "abusive" in Hindi might be different than in Tamil. So, they set different "sensitivity levels" (thresholds) for each language.
- The Analogy: A security guard might be very strict about shouting in a library (Hindi comments) but more relaxed about shouting at a sports stadium (Tamil comments). By tuning the sensitivity for each language, they stopped the system from flagging innocent comments as abusive.
The Result
By cleaning the data, using specific language experts, fixing the "bad teacher" problem with pseudo-labeling, and tuning the sensitivity for each language, they built a system that achieved a score of 0.90000.
The Main Takeaway:
The paper shows that to catch abusive content in diverse languages, you can't just use a "one-size-fits-all" approach. You have to clean the data, fix the mistakes in the training labels, and treat every language with its own specific rules. This ensures the system catches the bad apples without throwing away the good ones, keeping the town square safe but still free for people to speak their minds.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.