Fake News Detection Using Machine Learning: Project & Approach

Here is the pitch most fake news detection tutorials make: train a model, hit 95 percent accuracy, declare victory, and move on. Here is what actually happens when you present that project to an examiner or an interviewer: one question about why your model works, and the whole thing falls apart. Not because the code is wrong, but because the story around it is incomplete.

This guide builds the full pipeline the way it should be built. You will get the easy 95 percent with thirty lines of code using TF-IDF and Logistic Regression. Then you will learn exactly why that number flatters you, what it actually measures, and how to present it honestly. That is the difference between a project that gets a passing grade and one that gets you a job offer.

Fake news detection using machine learning is a text classification problem at its core. You take article text, extract features from it, and train a classifier to label it as real or fake. The techniques are the same ones used in sentiment analysis, spam filtering, and topic categorization. If you can build this, you can build any of those.

The Problem and the Approach (What ML Can and Can't Do Here)

Let us be clear about what we are building and what we are not. A machine learning model for fake news detection learns patterns in text that correlate with the labels in your training data. It learns that certain topics, writing styles, source patterns, and linguistic cues appear more often in articles labeled "fake" versus "real." It does not learn truth. It does not learn facts. It learns statistical correlations.

That distinction matters enormously for two reasons.
First, it tells you what the model is actually good at: flagging articles that share characteristics with previously seen fake news. An article with sensationalist language, unnamed sources, and a topic distribution matching known misinformation sources will get flagged. That is useful.

Second, it tells you where the model breaks: when fake news changes its style or covers new topics. A model trained on 2016 election misinformation will struggle with 2024 health misinformation because the vocabulary, topics, and writing patterns shifted. This is called temporal drift, and it is the reason no production fact-checking system relies solely on ML classification.

The approach we will follow is the standard NLP text classification pipeline, which you can explore in depth in the guide on text classification using scikit-learn:

• Clean and preprocess the text
• Convert text to numerical features (vectorization)
• Train baseline models
• Evaluate honestly
• Upgrade to deep learning if the baseline justifies it
• Deploy as a usable tool

Steps 1–3: Preprocess and Vectorize (TF-IDF)

Transform Your Career

Choose from our industry-leading programs designed for career success

NSDC Certified

Modern Software and AI Engineering Program

Master full-stack development with AI integration

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

Modern Data Science and ML with specialisation in AI

Advanced data science techniques with AI specialization

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

Advanced AIML with Specialisation in Agentic AI

Deep dive into AIML with focus on Agentic systems

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

DevOps, Cloud & AI Platform Engineering

Build and manage AI-powered cloud infrastructure

12 MonthsDuration

AI-LedCurriculum

Career SupportSupport

+1000 more

Go to Program

NSDC Certified

AI Engineering Advanced Certification by IIT-Roorkee

Premier AI engineering certification from IIT-Roorkee

3 MonthsDuration

AI-LedCurriculum

Career SupportSupport

Go to Program

Step 1: Text Cleaning

Raw news articles contain noise that does not help classification. Here is the standard preprocessing pipeline:

Important note for BERT: If you plan to upgrade to BERT later, use lighter preprocessing. BERT's tokenizer handles casing and punctuation, and heavy lemmatization can actually hurt its performance. Keep a raw and a cleaned version of your text column.

Step 2: Train-Test Split (Done Right)

This is where most tutorials introduce a bug. A random train-test split can leak information if the same news source appears in both sets. The model learns source-specific patterns rather than general fake-news indicators.
from sklearn.model_selection import train_test_split

For a more robust split, group by source if your dataset includes source information, and ensure no source appears in both train and test. This is the split an examiner will respect.

Step 3: TF-IDF Vectorization

TF-IDF (Term Frequency-Inverse Document Frequency) converts text into numerical features by scoring each word based on how often it appears in a document relative to how often it appears across all documents. Words that are common across all articles get low scores. Words that are distinctive get high scores.

from sklearn.feature_extraction.text import TfidfVectorizer

The ngram_range=(1, 2) captures phrases like "breaking news" and "sources say" which are more informative than individual words. The max_df=0.7 drops words that appear in more than 70 percent of documents (usually stopwords that slipped through).

Step 4: Baseline Models (Logistic Regression, Naive Bayes, PassiveAggressive)

This is the thirty-line win. Three classical models, all fast to train, all interpretable, and all strong baselines for text classification.

Logistic Regression

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

Typical result on ISOT: 93–95 percent accuracy. Logistic Regression is your best baseline because it is fast, interpretable (you can inspect the coefficients to see which TF-IDF features matter most), and hard to beat by a wide margin on clean text data.

Multinomial Naive Bayes

from sklearn.naive_bayes import MultinomialNB

Naive Bayes is the classic text classification algorithm. It assumes feature independence (the "naive" part) which is wrong for language but works surprisingly well in practice. The full Naive Bayes guide explains the math behind this. Expect 89–92 percent on ISOT, slightly below Logistic Regression.

PassiveAggressiveClassifier

from sklearn.linear_model import PassiveAggressiveClassifier

The PassiveAggressiveClassifier is designed for online learning and large text streams. It often matches or slightly exceeds Logistic Regression on fake news datasets, hitting 94–96 percent. It is less commonly used in tutorials, which makes it a good differentiator in your project.

Build classifier fundamentals in a structured way: Scaler's free Supervised Learning course walks through these models with hands-on exercises and mentor support.

Step 5: Evaluate Honestly

This is the section most tutorials skip, and it is the section that determines whether your project impresses or merely passes.

Hiring Partners:

GoogleAmazonMicrosoftFlipkartAdobe1200+ more

The Metrics That Matter

from sklearn.metrics import confusion_matrix, classification_report
import matplotlib.pyplot as plt
import seaborn as sns

For fake news detection, precision and recall tell a more complete story than accuracy alone. The question you need to answer is: which error is worse?

• False positive (flagging real news as fake): Dangerous for press freedom, creates distrust in legitimate journalism
• False negative (letting fake news pass): Allows misinformation to spread unchecked

In most real-world deployments, false positives are considered worse because the cost of suppressing legitimate speech is higher than the cost of missing one piece of misinformation. This means you want high precision even at the cost of some recall. A model with 95 percent accuracy but 80 percent precision on the fake class is worse than a model with 92 percent accuracy and 95 percent precision.

For a deeper dive into choosing the right metrics, the evaluation metrics guide covers precision-recall tradeoffs across different problem types.

Why the 95 Percent Flatters You

Now the honesty part. Your Logistic Regression model hits 94 percent accuracy on the ISOT dataset. Impressive? Maybe. Here is why you should be skeptical.

Topic bias. The ISOT dataset contains a high concentration of political articles. Your model may have learned that articles about certain political figures or events are labeled "fake" and articles about others are labeled "real." Test this: filter your test set to only non-political articles. Watch the accuracy drop.

Source leakage. If the same news website appears in both your training and test sets, your model is partly memorizing source-level patterns (formatting, headline style, typical vocabulary) rather than learning generalizable fake-news indicators. A source-aware split (described in Step 2) usually drops accuracy by 5–10 percentage points.

Temporal drift. Train on articles from 2016–2018 and test on articles from 2023. The model's performance collapses because misinformation changes its style, topics, and distribution channels over time. Your model learned a snapshot, not a durable pattern.

Cross-dataset testing. The credibility move: train on ISOT, test on the Kaggle Fake News dataset. If your model still performs well, you have learned something generalizable. If it drops to 65–70 percent, you have learned dataset-specific patterns. Report both numbers.

Viva question: "Your model has 94 percent accuracy. What would happen if I tested it on news articles published after your training data?" The answer is about temporal drift, topic shift, and why production misinformation detection requires continuous retraining.

Upgrades: LSTM and BERT (With Real Deltas)

Once your baseline is solid and honestly evaluated, deep learning upgrades make sense. The key is to report what actually improves and what does not.

LSTM (Long Short-Term Memory)

An LSTM captures word order and sequential dependencies that TF-IDF ignores. The phrase "not true" and "true" have the same TF-IDF features (mostly) but opposite meanings. An LSTM handles this.

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout

Typical result: 94–96 percent on ISOT. The gain over Logistic Regression is often 1–2 percentage points, not the leap many tutorials claim. The LSTM's real advantage is interpretability of sequential patterns, not raw accuracy on these datasets.

For understanding how word representations feed into LSTMs, the word embeddings guide covers Word2Vec, GloVe, and learned embeddings.

BERT Fine-Tuning

BERT (Bidirectional Encoder Representations from Transformers) is the current state-of-the-art approach. It uses attention mechanisms to understand context bidirectionally, meaning "bank" in "river bank" versus "bank account" gets different representations.

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Tokenize in batches
train_encodings = tokenizer(
list(X_train[:5000]), truncation=True, padding=True, max_length=256
)
test_encodings = tokenizer(
list(X_test[:1000]), truncation=True, padding=True, max_length=256
)

model = BertForSequenceClassification.from_pretrained(
'bert-base-uncased', num_labels=2
)

BERT models are available through Hugging Face and can be fine-tuned in Google Colab with a free GPU. Use distilbert-base-uncased if memory is tight.

Typical result: 97–99 percent on ISOT and Kaggle datasets. BERT genuinely outperforms classical models on these benchmarks. But remember: the same topic bias and source leakage issues apply. BERT learns the same dataset shortcuts, just more effectively.

The cross-dataset column is the one that matters. Every model drops significantly when tested outside its training distribution. BERT drops less, but it still drops.

Viva question: "BERT gives 98 percent accuracy. Why not just use that?" The answer covers computational cost, interpretability tradeoffs, and the fact that the 2–3 percent gain over Logistic Regression may not justify a model that is 1000x more expensive to run and impossible to explain.

Deploy It: Flask Interface

A model in a notebook is a homework assignment. A model behind a web interface is a project. Here is a minimal Flask app that takes article text and returns a prediction.

from flask import Flask, request, render_template

The index.html template is a simple form with a textarea for pasting article text. The result.html template shows the prediction and confidence score. Deploy to Heroku or Render for a public URL you can include in your portfolio.

This deployment is also a natural extension point. Add a confidence threshold (flag low-confidence predictions for human review), add batch processing for multiple articles, or integrate with a news API for real-time screening.

Viva and Interview Defense

If you are presenting this as a final-year project, these are the questions examiners ask and the answers that demonstrate real understanding.

"Why did you choose TF-IDF over word embeddings for the baseline?" TF-IDF is simpler, faster, interpretable, and performs within a few percentage points of deep learning on standard fake news datasets. It establishes a strong baseline that justifies the added complexity of LSTM or BERT.

"What are the limitations of your model?" The model learns dataset-specific patterns including topic bias and source-level features rather than generalizable truth indicators. It will degrade on new topics, new sources, and over time as misinformation evolves. Production deployment requires continuous retraining and human-in-the-loop verification.

"How would you improve this for a real deployment?" Cross-dataset training for generalization, source-aware data splitting to prevent leakage, a confidence threshold that routes uncertain predictions to human reviewers, and a retraining pipeline triggered by performance monitoring on fresh data.

"Is fake news detection an ethical problem?" Yes. Any automated classifier can be weaponized to suppress legitimate speech, and the definition of "fake" is itself politically contested. A responsible system flags content for human review rather than making final suppression decisions, and its training data and error rates must be transparent.

Where to Go Next

This project shares its core pipeline with other NLP classification tasks. Once you have this working, you can adapt it for:

• Sentiment analysis — same pipeline, different labels and datasets. The sentiment analysis guide covers the domain-specific differences.
• Fraud detection in text — detecting fraudulent reviews, phishing emails, or scam messages uses identical techniques. The fraud detection tutorial covers the class-imbalance challenges that make fraud detection distinct.
• Production NLP systems — if the deployment step interested you, explore MLOps practices for monitoring model drift in production text classifiers.

From class projects to production NLP: Scaler's AI and ML Program takes you beyond textbook implementations with mentor-led guidance on building ML systems that work in real-world conditions.