Deploy Fake News Detector

.gitignore

@@ -0,0 +1,11 @@
+# Python cache
+__pycache__/
+
+# Virtual environment
+.venv/
+venv/
+env/
+ENV/
+
+data/WELFake_Dataset.csv
+models\random_forest_model.pkl

app.py

@@ -0,0 +1,81 @@
+import gradio as gr
+from pipeline.predict import predict_fake_news, load_model_and_predict
+from collections import Counter
+
+# Model label mapping
+model_labels = {
+    0: "BiLSTM Neural Network",
+    1: "Logistic Regression",
+    2: "Naive Bayes",
+    3: "XGBoost",
+    4: "LightGBM",
+    5: "Random Forest"
+}
+
+model_choices = [(name, idx) for idx, name in model_labels.items()]
+
+
+def run_single_model(text, model_index):
+    if model_index == 0:
+        result = predict_fake_news(text)
+    else:
+        result = load_model_and_predict(model_index, [text])[0]
+
+    return f"Model: {model_labels[model_index]}\n" \
+           f"Prediction: {result['verdict']}\n" \
+           f"Confidence: {result['confidence']}"
+
+
+def run_all_models(text=None, file=None):
+    if not text and not file:
+        return "Please enter text or upload a file."
+
+    if not text and file:
+        with open(file.name, 'r', encoding='utf-8') as f:
+            text = f.read()
+
+    results = {}
+    predictions = []
+
+    for idx in range(6):
+        if idx == 0:
+            res = predict_fake_news(text)
+        else:
+            res = load_model_and_predict(idx, [text])[0]
+        results[model_labels[idx]] = res
+        predictions.append(res["label"])
+
+    majority_label = Counter(predictions).most_common(1)[0][0]
+    majority_verdict = "Real News" if majority_label == 1 else "Fake News"
+
+    result_table = "\n".join(
+        f"{model}: {res['verdict']} (Confidence: {res['confidence']})"
+        for model, res in results.items()
+    )
+
+    return f"{result_table}\n\n🗳️ Overall Majority Verdict: **{majority_verdict}**"
+
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("## 📰 Fake News Classifier - Multi-Model Evaluation")
+
+    with gr.Tab("🔍 Single Model Prediction"):
+        with gr.Row():
+            text_input = gr.Textbox(label="Enter News Text", lines=10, placeholder="Paste news text here...")
+            model_dropdown = gr.Dropdown(choices=model_choices, label="Select Model", value=0)
+        single_output = gr.Textbox(label="Prediction", lines=5)
+        predict_btn = gr.Button("Predict")
+        predict_btn.click(fn=run_single_model, inputs=[text_input, model_dropdown], outputs=single_output)
+
+    with gr.Tab("📊 All Models Comparison"):
+        gr.Markdown("Paste news text below **or** upload a `.txt` file")
+        text_input_all = gr.Textbox(label="Paste News Text (optional)", lines=10, placeholder="Paste here...")
+        file_input_all = gr.File(label="Upload .txt File (optional)", file_types=[".txt"])
+        compare_btn = gr.Button("Run All Models")
+        multi_output = gr.Textbox(label="Model-wise Prediction & Majority Verdict", lines=12)
+        compare_btn.click(fn=run_all_models, inputs=[text_input_all, file_input_all], outputs=multi_output)
+
+
+if __name__ == "__main__":
+    demo.launch()

models/bilstm_fake_news_float16.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed26fe011ef944c880d27247ad5524d9b140763ef3b8760616e81dbc35566701
+size 1520076

models/bilstm_fake_news_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4342417a803ac7db8c78280b7c7933d7a5f2f6b2d273e1183113d1b652f6981
+size 9016600

models/bilstm_tokenizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fb9dc8fdf2668f360d586269afad7b7b5e18d1fec0cc1d29fac8127778c819d
+size 16393129

models/lightgbm_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:304d76a4e8c0e173b5151f07a076ad74460e4e1baaef59958c892f0245ce86eb
+size 549988

models/logistic_regression_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abc8cf75db269428c6a4dfaf165c8a20bf14c5c52bb49cc9f2f8e51e2bab09b1
+size 40863

models/naive_bayes_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66363fa9b3617e65ca4657036f2584102e89ee0e59bcd2cfc8e4baf734cddbd5
+size 160791

models/random_forest_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c24d07cf987ee5dc9fd7c05fb6759dd18d4bfd99befca92e404f04578107c8ce
+size 74762217

models/tfidf_vectorizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3da05659b87c351ef2d000811839cd93124c6a7505ea1afd4f92117cc5e9d644
+size 4589922

models/xgboost_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfb29374b9c0ac2d0391041dd0b8a8acf95a2400c7494e6f5d6be08adbf72e0e
+size 353503

pipeline/predict.py

@@ -0,0 +1,131 @@
+import joblib
+import numpy as np
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from pipeline.preprocessing import clean_text  
+import tensorflow as tf
+MAX_LEN = 300
+
+bilstm_model = load_model("models/bilstm_fake_news_model.h5")
+bilstm_tokenizer = joblib.load("models/bilstm_tokenizer.pkl")
+
+#Function Pipeline for using BILSTM Model
+def predict_fake_news(text: str):
+    """
+    Predict using the BiLSTM neural network.
+    Input: Raw text
+    Output: label (0/1), confidence, verdict
+    """
+    cleaned = clean_text(text)
+    sequence = bilstm_tokenizer.texts_to_sequences([cleaned])
+    padded = pad_sequences(sequence, maxlen=MAX_LEN)
+
+    prediction = bilstm_model.predict(padded)[0][0]
+    label = int(prediction >= 0.5)
+    confidence = round(float(prediction), 4)
+
+    return {
+        "label": label,
+        "confidence": confidence,
+        "verdict": "Real News" if label == 1 else "Fake News"
+    }
+
+#Function pipeline for using BILSTM Model
+def load_model_and_predict(model_choice: int, texts: list[str]):
+    """
+    Predict using a saved standard ML model (LogReg, XGB, etc.)
+    
+    Args:
+        model_choice: int from 1 to 5
+            1 - Logistic Regression
+            2 - Naive Bayes
+            3 - XGBoost
+            4 - LightGBM
+            5 - Random Forest
+        texts: list of raw news texts
+
+    Returns:
+        List of prediction dictionaries with label, confidence, and verdict.
+    """
+
+    import joblib
+    import numpy as np
+    from pipeline.preprocessing import clean_text  
+
+    # Mapping
+    model_map = {
+        1: "logistic_regression",
+        2: "naive_bayes",
+        3: "xgboost",
+        4: "lightgbm",
+        5: "random_forest"
+    }
+
+    if model_choice not in model_map:
+        raise ValueError(f"Invalid model_choice {model_choice}. Choose between 1-5.")
+
+    model_name = model_map[model_choice]
+
+    # Load model and vectorizer
+    model = joblib.load(f"models/{model_name}_model.pkl")
+    vectorizer = joblib.load("models/tfidf_vectorizer.pkl")
+
+    # Preprocess and vectorize
+    texts_cleaned = [clean_text(text) for text in texts]
+    X_vec = vectorizer.transform(texts_cleaned)
+
+    # Prediction
+    if hasattr(model, "predict_proba"):
+        probs = model.predict_proba(X_vec)[:, 1]
+    else:
+        decision = model.decision_function(X_vec)
+        probs = 1 / (1 + np.exp(-decision))  # sigmoid
+
+    preds = (probs >= 0.5).astype(int)
+
+    return [
+        {
+            "label": int(p),
+            "confidence": round(float(prob), 4),
+            "verdict": "Real News" if p == 1 else "Fake News"
+        }
+        for p, prob in zip(preds, probs)
+    ]
+
+
+
+
+#For quantized model to reduce inference time
+
+interpreter = tf.lite.Interpreter(model_path="models/bilstm_fake_news_float16.tflite")
+interpreter.allocate_tensors()
+
+# input/output tensor details
+input_details = interpreter.get_input_details()
+output_details = interpreter.get_output_details()
+
+def predict_fake_news_tflite(text: str):
+    """
+    Predict using the float16 quantized BiLSTM TFLite model.
+    Input: Raw text
+    Output: label (0/1), confidence, verdict
+    """
+    # Preprocessing
+    cleaned = clean_text(text)
+    sequence = bilstm_tokenizer.texts_to_sequences([cleaned])
+    padded = pad_sequences(sequence, maxlen=MAX_LEN).astype(np.float32)
+
+    # Set input tensor
+    interpreter.set_tensor(input_details[0]['index'], padded)
+    interpreter.invoke()
+
+    # Get prediction
+    prediction = interpreter.get_tensor(output_details[0]['index'])[0][0]
+    label = int(prediction >= 0.5)
+    confidence = round(float(prediction), 4)
+
+    return {
+        "label": label,
+        "confidence": confidence,
+        "verdict": "Real News" if label == 1 else "Fake News"
+    }

pipeline/preprocessing.py

@@ -0,0 +1,50 @@
+import re
+import nltk
+import pandas as pd
+from nltk.tokenize import wordpunct_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+
+nltk.download('stopwords')
+nltk.download('punkt')
+nltk.download('wordnet')
+nltk.download('omw-1.4')
+
+# Initializing stopwords and lemmatizer once
+stop_words = set(stopwords.words('english'))
+lemmatizer = WordNetLemmatizer()
+
+
+def clean_text(text: str) -> str:
+    """
+    Preprocesses input text:
+    - Lowercase conversion
+    - Removing non-alphanumeric characters
+    - Tokenization
+    - Stopword removal
+    - Lemmatization
+
+    Returns a cleaned string.
+    """
+    text = text.lower()
+    text = re.sub(r"[^a-zA-Z0-9\s]", '', text)
+    tokens = wordpunct_tokenize(text)
+    tokens = [t for t in tokens if t not in stop_words]
+    tokens = [lemmatizer.lemmatize(t) for t in tokens]
+    return ' '.join(tokens)
+
+def load_and_preprocess(filepath: str) -> pd.DataFrame:
+    """
+    Loads dataset from a CSV file, merges title + text, applies cleaning,
+    and adds num_words column.
+
+    Returns:
+        Cleaned pandas DataFrame.
+    """
+    df = pd.read_csv(filepath)
+    df.dropna(subset=['text', 'title'], inplace=True)
+    df['text'] = df['title'] + ' ' + df['text']
+    df.drop(columns=['title'], inplace=True)
+    df['clean_text'] = df['text'].apply(clean_text)
+    df['num_words'] = df['clean_text'].apply(lambda x: len(x.split()))
+    return df

pipeline/quantization.py

@@ -0,0 +1,23 @@
+#For reducing the size of model while keeping accuracy same for faster inference
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+
+# Model Loading
+model = load_model("models/bilstm_fake_news_model.h5")
+
+# Conversion with TFLiteConverter
+converter = tf.lite.TFLiteConverter.from_keras_model(model)
+converter.optimizations = [tf.lite.Optimize.DEFAULT]
+converter.target_spec.supported_types = [tf.float16]
+
+converter.target_spec.supported_ops = [
+    tf.lite.OpsSet.TFLITE_BUILTINS,      
+    tf.lite.OpsSet.SELECT_TF_OPS
+]
+converter._experimental_lower_tensor_list_ops = False  
+
+tflite_model = converter.convert()
+
+# Saving
+with open("models/bilstm_fake_news_float16.tflite", "wb") as f:
+    f.write(tflite_model)

pipeline/train_standard_models.py

@@ -0,0 +1,37 @@
+
+import joblib
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.ensemble import RandomForestClassifier
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+
+from pipeline.preprocess import load_and_clean_data
+from pipeline.vectorizer import fit_and_save_vectorizer
+
+def train_and_save_standard_models():
+    df = load_and_clean_data()
+    X_tfidf = fit_and_save_vectorizer(df['clean_text'])  # saves vectorizer
+    y = df['label']
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X_tfidf, y, test_size=0.2, stratify=y, random_state=42
+    )
+
+    models = {
+        "logistic_regression": LogisticRegression(max_iter=200),
+        "naive_bayes": MultinomialNB(),
+        "random_forest": RandomForestClassifier(n_estimators=100, n_jobs=-1),
+        "xgboost": XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
+        "lightgbm": LGBMClassifier()
+    }
+
+    for name, model in models.items():
+        print(f"Training {name}...")
+        model.fit(X_train, y_train)
+        joblib.dump(model, f"models/{name}_model.pkl")
+        print(f"Saved {name} model ✔")
+
+if __name__ == "__main__":
+    train_and_save_standard_models()

pipeline/vectorizer.py

@@ -0,0 +1,16 @@
+
+import joblib
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+VECTORIZER_PATH = "models/tfidf_vectorizer.pkl"
+
+def fit_and_save_vectorizer(texts, max_features=5000):
+    """Fits TF-IDF vectorizer and saves it to disk."""
+    vectorizer = TfidfVectorizer(max_features=max_features)
+    X_tfidf = vectorizer.fit_transform(texts)
+    joblib.dump(vectorizer, VECTORIZER_PATH)
+    return X_tfidf
+
+def load_vectorizer():
+    """Loads the TF-IDF vectorizer from disk."""
+    return joblib.load(VECTORIZER_PATH)

requirements.txt

@@ -0,0 +1,12 @@
+tensorflow
+scikit-learn
+xgboost
+lightgbm
+pandas
+numpy
+matplotlib
+joblib
+nltk
+spacy
+wordcloud
+gradio