Fake News Detection

• 

  architecture of my model

• 

  result and metrics

• 

  dashboard banner

Inspiration

Honestly, it started with a WhatsApp message. My family received a viral news clip that turned out to be completely fabricated — and by the time anyone figured that out, it had been forwarded hundreds of times. That moment stuck with me. Misinformation in South Asia is especially tricky because it spreads across multiple languages — Hindi, Urdu, Bengali, English — sometimes all mixed in the same post. Most existing fake news tools only work in English, which leaves a huge chunk of the world's internet users completely unprotected. I wanted to build something that actually works for people like my family, in the languages they actually use.

What it does

FactFinder is a multilingual fake news detector that takes a piece of news text, analyzes it using a deep learning model, and tells you whether it's likely real or fake — along with a confidence score. A few things that make it a bit different: -It works across English, Hindi, Urdu, and Bengali without needing separate models for each. -It factors in the source reputation — where you got the news matters. -It shows you why it made the decision, using explainable AI (LIME highlights the words that pushed the verdict). -There's a Chrome extension so you can check news directly in your browser while scrolling social media. -It also estimates its own uncertainty — so you know when the model is confident vs. when it's unsure.

How we built it

The core model is built in PyTorch on top of XLM-RoBERTa, a multilingual transformer that already understands multiple languages from pre-training. But the key ingredient is something called a Gradient Reversal Layer (GRL). The idea: during training, we add an adversarial branch that tries to detect which language the text is in. The GRL flips the gradients from this branch, which punishes the model for using language-specific patterns. This forces the main classifier to focus purely on the deceptive writing style itself — not the language. We also applied LoRA (Low-Rank Adaptation) to reduce the number of trainable parameters, which made training faster and the final model smaller. The full stack: -Model: PyTorch + HuggingFace Transformers (XLM-RoBERTa + LoRA + GRL) -Backend: FastAPI with persistent caching and fact-check cross-referencing -Frontend: Streamlit dashboard -Explainability: LIME (Local Interpretable Model-agnostic Explanations) -Browser Extension: Manifest V3 Chrome extension -Training: Done on GPU via cloud notebooks

Challenges we ran into

Getting the adversarial training to actually work was harder than expected. Early on, the GRL would destabilize training entirely — the model would just collapse and predict everything as one class. It took a lot of tuning on the alpha (reversal strength) schedule to get it to converge properly. Source bias was another headache. The model was initially memorizing sources rather than learning from the text itself. We added source dropout during training — randomly replacing source IDs with an "unknown" token — to force the model to not rely on it as a shortcut. Multilingual data was also limited. Good labeled fake news datasets in Urdu and Bengali are hard to find, so we had to combine and merge several datasets, which introduced some label noise.

Accomplishments that we're proud of

The model achieves strong separation between real and fake news across languages on a 15,000 sample validation set — the confidence curves are very clean. The lightweight inference mode strips the unused multimodal components, making it fast enough to run on a CPU without a GPU. The Chrome extension actually works end-to-end — you can highlight text on a webpage and get a verdict inline. The LIME explanations are genuinely useful. Seeing which words triggered the "fake" signal is something that even non-technical users find intuitive.

What we learned

Adversarial training is powerful but fragile. Small hyperparameter changes can break convergence entirely. LoRA is genuinely great for fine-tuning large transformers on a budget — I wish I had used it from the start instead of full fine-tuning. Building explainability in from the beginning (not bolting it on at the end) makes the whole system more trustworthy. Caching matters more than you'd think at inference time — a lot of news articles get checked multiple times, and a simple JSON cache cut redundant computation significantly.

What's next for Fake News Detection

More languages: Expanding to Tamil, Marathi, and Punjabi. Image verification: The model architecture already has hooks for vision features (ResNet branch) — the next step is actually training it with multimodal data. Continuous learning: Right now the /report feedback endpoint saves corrections to a file. The next step is building an automated retraining pipeline that fine-tunes the model on user-corrected samples periodically. Better fact-checking: The current fact-check module is basic. Integrating a proper vector search over verified news databases would make the "neural context" feature much more powerful. Mobile: A lightweight API wrapper so the detector can be called from a mobile app.

Built With

• fastapi
• git
• google-collab
• hugging-face-transformers
• javascript
• lime
• numpy
• onnxruntime
• peft(lora)
• pydantic
• python
• pytorch
• resnet-18
• scikit-learn
• streamlit
• uvicorn
• xlm-roberta