Initial commit for LSTM with GloVe embeddings

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

GloVe/glove.6B.100d.txt

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

GloVe/glove.6B.300d.txt

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

data_1/Fake.csv

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

data_1/True.csv

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

data_2/WELFake_Dataset.csv

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

data_3/news_articles.csv

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

data_loader.py

@@ -0,0 +1,22 @@
+from torch.utils.data import Dataset, DataLoader
+import torch
+
+
+class NewsDataset(Dataset):
+    def __init__(self, titles, texts, labels=None):
+        self.titles = titles
+        self.texts = texts
+        self.labels = labels
+
+    def __len__(self):
+        return len(self.titles)
+
+    def __getitem__(self, idx):
+        if self.labels is not None:
+            return self.titles[idx], self.texts[idx], self.labels[idx]
+        return self.titles[idx], self.texts[idx]
+
+
+def create_data_loader(titles, texts, labels=None, batch_size=32, shuffle=False, num_workers=6):
+    dataset = NewsDataset(titles, texts, labels)
+    return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True, persistent_workers=True)

inference.py

@@ -0,0 +1,40 @@
+import torch
+import pandas as pd
+from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
+from model import LSTMModel
+
+
+def load_model(model_path, vocab_size):
+    model = LSTMModel(vocab_size)
+    model.load_state_dict(torch.load(model_path))
+    model.eval()
+    return model
+
+
+def predict(model, titles, texts, device):
+    titles, texts = titles.to(device), texts.to(device)
+    model.to(device)
+    with torch.no_grad():
+        outputs = model(titles, texts).squeeze()
+    return outputs
+
+
+def evaluate_model(model, data_loader, device, labels):
+    model.to(device)
+    model.eval()
+    predictions = []
+    labels = torch.tensor(labels).to(device)
+    for titles, texts in data_loader:
+        titles, texts = titles.to(device), texts.to(device)
+        outputs = predict(model, titles, texts, device)
+        predictions.extend(outputs.cpu().numpy())
+
+    labels = labels.cpu().numpy()  # Convert labels to NumPy array for consistency
+    predicted_labels = [1 if p > 0.5 else 0 for p in predictions]
+
+    # Calculate metrics
+    accuracy = accuracy_score(labels, predicted_labels)
+    f1 = f1_score(labels, predicted_labels)
+    auc_roc = roc_auc_score(labels, predictions)
+
+    return accuracy, f1, auc_roc, labels, predicted_labels

inference_analysis.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\kimi\\AppData\\Local\\Temp\\ipykernel_1768\\401420358.py:5: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
+      "  plt.style.use(\"seaborn-whitegrid\")\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "\n",
+    "plt.style.use(\"seaborn-whitegrid\")\n",
+    "\n",
+    "version = 2\n",
+    "\n",
+    "# Read confusion matrix from CSV\n",
+    "cm_df = pd.read_csv(\n",
+    "    f\"./output/version_{version}/confusion_matrix_inference_{version}.csv\"\n",
+    ")\n",
+    "cm = cm_df.values\n",
+    "\n",
+    "# Plotting\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")\n",
+    "plt.title(\"Confusion Matrix (LSTM with GloVe Embeddings, Holdout Set)\")\n",
+    "plt.ylabel(\"True label\")\n",
+    "plt.xlabel(\"Predicted label\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "torch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

inference_main.py

@@ -0,0 +1,100 @@
+import torch
+import pandas as pd
+from preprocessing import (
+    preprocess_text,
+    load_tokenizer,
+    prepare_data,
+    load_glove_embeddings,
+)
+from data_loader import create_data_loader
+from inference import load_model, evaluate_model
+from sklearn.metrics import confusion_matrix
+import os
+
+version = 2
+
+
+def run_evaluation(model_path, tokenizer_path, device):
+    cleaned_path = f"./output/version_{version}/cleaned_inference_data_{version}.csv"
+    # Load data
+    if os.path.exists(cleaned_path):
+        df = pd.read_csv(cleaned_path)
+        df.dropna(inplace=True)
+        print("Cleaned data found.")
+    else:
+        print("No cleaned data found. Cleaning data now...")
+
+        df = pd.read_csv("./data_3/news_articles.csv")
+        df.drop(
+            columns=[
+                "author",
+                "published",
+                "site_url",
+                "main_img_url",
+                "type",
+                "text_without_stopwords",
+                "title_without_stopwords",
+                "hasImage",
+            ],
+            inplace=True,
+        )
+        # Map Real to 1 and Fake to 0
+        df["label"] = df["label"].map({"Real": 1, "Fake": 0})
+        df = df[df["label"].isin([1, 0])]
+
+        # Drop rows where the language is not 'english'
+        df = df[df["language"] == "english"]
+        df.drop(columns=["language"], inplace=True)
+
+        # Convert "no title" to empty string
+        df["title"] = df["title"].apply(lambda x: "" if x == "no title" else x)
+
+        df.dropna(inplace=True)
+        df["title"] = df["title"].apply(preprocess_text)
+        df["text"] = df["text"].apply(preprocess_text)
+
+        df.to_csv(cleaned_path, index=False)
+        df.dropna(inplace=True)
+        print("Cleaned data saved.")
+
+    labels = df["label"].values
+
+    # Load tokenizer
+    tokenizer = load_tokenizer(tokenizer_path)
+
+    embedding_matrix = load_glove_embeddings(
+        "./GloVe/glove.6B.300d.txt", tokenizer.word_index, embedding_dim=300
+    )
+
+    model = load_model(model_path, embedding_matrix)
+    model.to(device)
+
+    # Prepare data
+    titles = prepare_data(df["title"], tokenizer)
+    texts = prepare_data(df["text"], tokenizer)
+
+    # Create DataLoader
+    data_loader = create_data_loader(titles, texts, batch_size=32, shuffle=False)
+
+    # Evaluate
+    accuracy, f1, auc_roc, y_true, y_pred = evaluate_model(
+        model, data_loader, device, labels
+    )
+
+    # Generate and save confusion matrix
+    cm = confusion_matrix(y_true, y_pred)
+    cm_df = pd.DataFrame(cm)
+    cm_filename = f"./output/version_{version}/confusion_matrix_inference_{version}.csv"
+    cm_df.to_csv(cm_filename, index=False)
+    print(f"Confusion Matrix saved to {cm_filename}")
+    return accuracy, f1, auc_roc
+
+
+if __name__ == "__main__":
+    model_path = f"./output/version_{version}/best_model_{version}.pth"
+    tokenizer_path = f"./output/version_{version}/tokenizer_{version}.pickle"
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}")
+
+    accuracy, f1, auc_roc = run_evaluation(model_path, tokenizer_path, device)
+    print(f"Accuracy: {accuracy:.4f}, F1 Score: {f1:.4f}, AUC-ROC: {auc_roc:.4f}")

model.py

@@ -0,0 +1,30 @@
+import torch
+import torch.nn as nn
+
+
+class LSTMModel(nn.Module):
+    def __init__(self, embedding_matrix, hidden_size=256, num_layers=2, dropout=0.2):
+        super(LSTMModel, self).__init__()
+        num_embeddings, embedding_dim = embedding_matrix.shape
+        self.embedding = nn.Embedding(num_embeddings, embedding_dim)
+        self.embedding.weight = nn.Parameter(
+            torch.tensor(embedding_matrix, dtype=torch.float32)
+        )
+        self.embedding.weight.requires_grad = False  # Do not train the embedding layer
+
+        self.lstm = nn.LSTM(
+            input_size=embedding_matrix.shape[1],
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout,
+        )
+        self.fc = nn.Linear(hidden_size, 1)
+
+    def forward(self, title, text):
+        title_emb = self.embedding(title)
+        text_emb = self.embedding(text)
+        combined = torch.cat((title_emb, text_emb), dim=1)
+        output, (hidden, _) = self.lstm(combined)
+        out = self.fc(hidden[-1])
+        return torch.sigmoid(out)

output/version_1/best_model_1.pth

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

output/version_1/cleaned_inference_data_1.csv

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

output/version_1/cleaned_news_data_1.csv

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

output/version_1/confusion_matrix_data_1.csv

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

output/version_1/confusion_matrix_inference_1.csv

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

output/version_1/tokenizer_1.pickle

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

output/version_1/training_metrics_1.csv

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

output/version_2/best_model_2.pth

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

output/version_2/cleaned_inference_data_2.csv

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

output/version_2/cleaned_news_data_2.csv

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

output/version_2/confusion_matrix_data_2.csv

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

output/version_2/confusion_matrix_inference_2.csv

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

output/version_2/tokenizer_2.pickle

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

output/version_2/training_metrics_2.csv

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

preprocessing.py

@@ -0,0 +1,64 @@
+import re
+import spacy
+from keras.preprocessing.text import Tokenizer
+from keras_preprocessing.sequence import pad_sequences
+import pickle
+import numpy as np
+
+
+# Load spaCy's English model
+nlp = spacy.load("en_core_web_sm")
+
+
+def preprocess_text(text):
+    # Remove patterns like "COUNTRY or STATE NAME (Reuters) -" or just "(Reuters)"
+    text = re.sub(
+        r"(\b[A-Z]{2,}(?:\s[A-Z]{2,})*\s\(Reuters\)\s-|\(Reuters\))", "", text
+    )
+
+    # Remove patterns like "Featured image via author name / image place"
+    text = re.sub(r"Featured image via .+?\.($|\s)", "", text)
+
+    # Process text with spaCy
+    doc = nlp(text)
+
+    lemmatized_text = []
+    for token in doc:
+        # Preserve named entities in their original form
+        if token.ent_type_:
+            lemmatized_text.append(token.text)
+        # Lemmatize other tokens and exclude non-alpha tokens if necessary
+        elif token.is_alpha and not token.is_stop:
+            lemmatized_text.append(token.lemma_.lower())
+
+    return " ".join(lemmatized_text)
+
+
+def load_tokenizer(tokenizer_path):
+    with open(tokenizer_path, "rb") as handle:
+        tokenizer = pickle.load(handle)
+    return tokenizer
+
+
+def prepare_data(texts, tokenizer, max_length=500):
+    sequences = tokenizer.texts_to_sequences(texts)
+    padded = pad_sequences(sequences, maxlen=max_length)
+    return padded
+
+
+def load_glove_embeddings(glove_file, word_index, embedding_dim=100):
+    embeddings_index = {}
+    with open(glove_file, encoding="utf8") as f:
+        for line in f:
+            values = line.split()
+            word = values[0]
+            coefs = np.asarray(values[1:], dtype="float32")
+            embeddings_index[word] = coefs
+
+    embedding_matrix = np.zeros((len(word_index) + 1, embedding_dim))
+    for word, i in word_index.items():
+        embedding_vector = embeddings_index.get(word)
+        if embedding_vector is not None:
+            embedding_matrix[i] = embedding_vector
+
+    return embedding_matrix

train.py

@@ -0,0 +1,89 @@
+import torch
+import pandas as pd
+import time
+from torch.nn.utils import clip_grad_norm_
+
+
+def train(model, train_loader, val_loader, criterion, optimizer, epochs, device, version, max_grad_norm=1.0, early_stopping_patience=5, early_stopping_delta=0.001):
+    best_accuracy = 0.0
+    best_model_path = f'./output/version_{version}/best_model_{version}.pth'
+    best_epoch = 0
+    early_stopping_counter = 0
+    total_batches = len(train_loader)
+    metrics = {
+        'epoch': [], 'train_loss': [], 'val_loss': [], 'train_accuracy': [], 'val_accuracy': []
+    }
+
+    for epoch in range(epochs):
+        model.train()
+        total_loss, train_correct, train_total = 0, 0, 0
+        for batch_idx, (titles, texts, labels) in enumerate(train_loader):
+            start_time = time.time()  # Start time for the batch
+
+            titles, texts, labels = titles.to(device), texts.to(
+                device), labels.to(device).float()
+
+            # Forward pass
+            outputs = model(titles, texts).squeeze()
+            loss = criterion(outputs, labels)
+
+            # Backward and optimize
+            optimizer.zero_grad()
+            loss.backward()
+            if max_grad_norm:
+                clip_grad_norm_(model.parameters(), max_norm=max_grad_norm)
+            optimizer.step()
+
+            total_loss += loss.item()
+            train_pred = (outputs > 0.5).float()
+            train_correct += (train_pred == labels).sum().item()
+            train_total += labels.size(0)
+
+            # Calculate and print batch processing time
+            batch_time = time.time() - start_time
+            print(
+                f'Epoch: {epoch+1}, Batch: {batch_idx+1}/{total_batches}, Batch Processing Time: {batch_time:.4f} seconds')
+
+        train_accuracy = 100 * train_correct / train_total
+        metrics['train_loss'].append(total_loss / len(train_loader))
+        metrics['train_accuracy'].append(train_accuracy)
+
+        # Validation
+        model.eval()
+        val_loss, val_correct, val_total = 0, 0, 0
+        with torch.no_grad():
+            for titles, texts, labels in val_loader:
+                titles, texts, labels = titles.to(device), texts.to(
+                    device), labels.to(device).float()
+                outputs = model(titles, texts).squeeze()
+                loss = criterion(outputs, labels)
+                val_loss += loss.item()
+                predicted = (outputs > 0.5).float()
+                val_total += labels.size(0)
+                val_correct += (predicted == labels).sum().item()
+
+        val_accuracy = 100 * val_correct / val_total
+        metrics['val_loss'].append(val_loss / len(val_loader))
+        metrics['val_accuracy'].append(val_accuracy)
+        metrics['epoch'].append(epoch + 1)
+
+        # Early stopping logic
+        if val_accuracy > best_accuracy + early_stopping_delta:
+            best_accuracy = val_accuracy
+            early_stopping_counter = 0
+            best_epoch = epoch + 1
+            torch.save(model.state_dict(), best_model_path)
+        else:
+            early_stopping_counter += 1
+
+        if early_stopping_counter >= early_stopping_patience:
+            print(f"Early stopping triggered at epoch {epoch + 1}")
+            break
+
+        print(
+            f'Epoch [{epoch+1}/{epochs}], Loss: {total_loss/len(train_loader):.4f}, Validation Accuracy: {val_accuracy:.2f}%')
+
+    pd.DataFrame(metrics).to_csv(
+        f'./output/version_{version}/training_metrics_{version}.csv', index=False)
+
+    return model, best_accuracy, best_epoch

train_main.py

@@ -0,0 +1,189 @@
+import torch
+import torch.nn as nn
+import pandas as pd
+from model import LSTMModel
+from preprocessing import preprocess_text, load_glove_embeddings
+from data_loader import create_data_loader
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import f1_score, roc_auc_score
+from keras.preprocessing.text import Tokenizer
+from keras_preprocessing.sequence import pad_sequences
+import pickle
+import train as tr
+from torch.utils.data import Dataset, DataLoader
+from data_loader import NewsDataset
+import os
+
+version = 2
+
+if __name__ == "__main__":
+    data_path = "./data_2/WELFake_Dataset.csv"
+    cleaned_path = f"./output/version_{version}/cleaned_news_data_{version}.csv"
+    # Load data
+    if os.path.exists(cleaned_path):
+        df = pd.read_csv(cleaned_path)
+        df.dropna(inplace=True)
+        print("Cleaned data found.")
+    else:
+        print("No cleaned data found. Cleaning data now...")
+        df = pd.read_csv(data_path)
+
+        # Drop index
+        df.drop(df.columns[0], axis=1, inplace=True)
+        df.dropna(inplace=True)
+
+        # Swapping labels around since it originally is the opposite
+        df["label"] = df["label"].map({0: 1, 1: 0})
+
+        df["title"] = df["title"].apply(preprocess_text)
+        df["text"] = df["text"].apply(preprocess_text)
+
+        # Create the directory if it does not exist
+        os.makedirs(os.path.dirname(cleaned_path), exist_ok=True)
+        df.to_csv(cleaned_path, index=False)
+        print("Cleaned data saved.")
+
+    # Splitting the data
+    train_val, test = train_test_split(df, test_size=0.2, random_state=42)
+    train, val = train_test_split(
+        train_val, test_size=0.25, random_state=42
+    )  # 0.25 * 0.8 = 0.2
+
+    # Initialize the tokenizer
+    tokenizer = Tokenizer()
+
+    # Fit the tokenizer on the training data
+    tokenizer.fit_on_texts(train["title"] + train["text"])
+
+    with open(f"./output/version_{version}/tokenizer_{version}.pickle", "wb") as handle:
+        pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    # Tokenize the data
+    X_train_title = tokenizer.texts_to_sequences(train["title"])
+    X_train_text = tokenizer.texts_to_sequences(train["text"])
+    X_val_title = tokenizer.texts_to_sequences(val["title"])
+    X_val_text = tokenizer.texts_to_sequences(val["text"])
+    X_test_title = tokenizer.texts_to_sequences(test["title"])
+    X_test_text = tokenizer.texts_to_sequences(test["text"])
+
+    # GloVe embeddings
+    embedding_matrix = load_glove_embeddings(
+        "./GloVe/glove.6B.300d.txt", tokenizer.word_index, embedding_dim=300
+    )
+
+    # Padding sequences
+    max_length = 500
+    X_train_title = pad_sequences(X_train_title, maxlen=max_length)
+    X_train_text = pad_sequences(X_train_text, maxlen=max_length)
+    X_val_title = pad_sequences(X_val_title, maxlen=max_length)
+    X_val_text = pad_sequences(X_val_text, maxlen=max_length)
+    X_test_title = pad_sequences(X_test_title, maxlen=max_length)
+    X_test_text = pad_sequences(X_test_text, maxlen=max_length)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}")
+
+    model = LSTMModel(embedding_matrix).to(device)
+
+    # Convert data to PyTorch tensors
+    train_data = NewsDataset(
+        torch.tensor(X_train_title),
+        torch.tensor(X_train_text),
+        torch.tensor(train["label"].values),
+    )
+    val_data = NewsDataset(
+        torch.tensor(X_val_title),
+        torch.tensor(X_val_text),
+        torch.tensor(val["label"].values),
+    )
+    test_data = NewsDataset(
+        torch.tensor(X_test_title),
+        torch.tensor(X_test_text),
+        torch.tensor(test["label"].values),
+    )
+
+    train_loader = DataLoader(
+        train_data,
+        batch_size=32,
+        shuffle=True,
+        num_workers=6,
+        pin_memory=True,
+        persistent_workers=True,
+    )
+    val_loader = DataLoader(
+        val_data,
+        batch_size=32,
+        shuffle=False,
+        num_workers=6,
+        pin_memory=True,
+        persistent_workers=True,
+    )
+    test_loader = DataLoader(
+        test_data,
+        batch_size=32,
+        shuffle=False,
+        num_workers=6,
+        pin_memory=True,
+        persistent_workers=True,
+    )
+
+    criterion = nn.BCELoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+    trained_model, best_accuracy, best_epoch = tr.train(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        criterion=criterion,
+        optimizer=optimizer,
+        version=version,
+        epochs=10,
+        device=device,
+        max_grad_norm=1.0,
+        early_stopping_patience=3,
+        early_stopping_delta=0.01,
+    )
+
+    print(f"Best model was saved at epoch: {best_epoch}")
+
+    # Load the best model before testing
+    best_model_path = f"./output/version_{version}/best_model_{version}.pth"
+    model.load_state_dict(torch.load(best_model_path, map_location=device))
+
+    # Testing
+    model.eval()
+    true_labels = []
+    predicted_labels = []
+    predicted_probs = []
+
+    with torch.no_grad():
+        correct = 0
+        total = 0
+        for titles, texts, labels in test_loader:
+            titles, texts, labels = (
+                titles.to(device),
+                texts.to(device),
+                labels.to(device).float(),
+            )
+            outputs = model(titles, texts).squeeze()
+
+            predicted = (outputs > 0.5).float()
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+            true_labels.extend(labels.cpu().numpy())
+            predicted_labels.extend(predicted.cpu().numpy())
+            predicted_probs.extend(outputs.cpu().numpy())
+
+    test_accuracy = 100 * correct / total
+    f1 = f1_score(true_labels, predicted_labels)
+    auc_roc = roc_auc_score(true_labels, predicted_probs)
+
+    print(
+        f"Test Accuracy: {test_accuracy:.2f}%, F1 Score: {f1:.4f}, AUC-ROC: {auc_roc:.4f}"
+    )
+
+    # Create DataFrame and Save to CSV
+    confusion_data = pd.DataFrame({"True": true_labels, "Predicted": predicted_labels})
+    confusion_data.to_csv(
+        f"./output/version_{version}/confusion_matrix_data_{version}.csv", index=False
+    )