Solution_Q1_to_Q4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "69271940",
   "metadata": {},
   "source": [
    "# NLP Assignment PART 1: Text classification for Fake News Detection¶\n",
    "\n",
    "## This assignment has solutions for Questions 1 to 4.\n",
    "\n",
    "This coursework will involve you implementing functions for a text classifier, which you will train to detect fake news in a corpus of approx. 10,000 statements, which will be split into a 80%/20% training/test split.\n",
    "\n",
    "In this template you are given the basis for that implementation, though some of the functions are missing, which you have to fill in.\n",
    "\n",
    "Follow the instructions file NLP_Assignment_1_Instructions.pdf for details of each question - the outline of what needs to be achieved for each question is as below.\n",
    "\n",
    "You must submit all ipython notebooks and extra resources you need to run the code if you've added them in the code submission, and a 2 page report (pdf) in the report submission on QMPlus where you report your methods and findings according to the instructions file for each question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9669213c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: nltk in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (3.7)\n",
      "Requirement already satisfied: regex>=2021.8.3 in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (2022.9.13)\n",
      "Requirement already satisfied: joblib in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (1.2.0)\n",
      "Requirement already satisfied: click in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (8.1.3)\n",
      "Requirement already satisfied: tqdm in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (4.64.1)\n",
      "Requirement already satisfied: colorama in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from click->nltk) (0.4.5)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip available: 22.2.2 -> 22.3.1\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "!pip install nltk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93fe1ec0",
   "metadata": {},
   "source": [
    "### Importing reuired modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7743bd0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv    # csv reader\n",
    "import re\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from sklearn.svm import LinearSVC\n",
    "from nltk.classify import SklearnClassifier\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.metrics import precision_recall_fscore_support # to report on precision and recall\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import precision_recall_fscore_support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "65503883",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(path):\n",
    "    \"\"\"Load data from a tab-separated file and append it to raw_data.\"\"\"\n",
    "    with open(path, encoding='utf-8') as f:\n",
    "        reader = csv.reader(f, delimiter='\\t')\n",
    "        for line in reader:\n",
    "            if line[0] == \"Id\":  # skip header\n",
    "                continue\n",
    "            (label, text) = parse_data_line(line)\n",
    "            raw_data.append((text, label))\n",
    "\n",
    "def split_and_preprocess_data(percentage):\n",
    "    \"\"\"\n",
    "    Split the data between train_data and test_data according to the percentage\n",
    "    and performs the preprocessing.\n",
    "    \"\"\"\n",
    "    num_samples = len(raw_data)\n",
    "    num_training_samples = int((percentage * num_samples))\n",
    "    for (text, label) in raw_data[:num_training_samples]:\n",
    "        train_data.append((to_feature_vector(pre_process(text)),label))\n",
    "    for (text, label) in raw_data[num_training_samples:]:\n",
    "        test_data.append((to_feature_vector(pre_process(text)),label))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf0cc33",
   "metadata": {},
   "source": [
    "# Question 1: Input and Basic preprocessing (10 marks)¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "529e0e9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_label(label):\n",
    "    \"\"\"\n",
    "    Converts the multiple classes into two,\n",
    "    making it a binary distinction between fake news and real.\n",
    "    \"\"\"\n",
    "    #return label\n",
    "    # Converting the multiclass labels to binary label\n",
    "    labels_map = {\n",
    "        'true': 'REAL',\n",
    "        'mostly-true': 'REAL',\n",
    "        'half-true': 'REAL',\n",
    "        'false': 'FAKE',\n",
    "        'barely-true': 'FAKE',\n",
    "        'pants-fire': 'FAKE'\n",
    "    }\n",
    "    return labels_map[label]\n",
    "\n",
    "def parse_data_line(data_line):\n",
    "    \"\"\"\n",
    "    This method get the label and statement columns from the given fake_news.tsv file.\n",
    "    : param data_line: Row data from the given tsv file.\n",
    "    : return: A tuple of label from the data and required columns from the data.\n",
    "    \"\"\"\n",
    "    data_label = convert_label(data_line[1])\n",
    "    statement =  data_line[2]\n",
    "    return (data_label, statement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a62c71b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process(text):\n",
    "    \"\"\"\n",
    "    This method uses a count vectorizer to extract features from the given text. \n",
    "    For that, first, created a count vectorizer which by default does some pre-processing, \n",
    "    tokenizing and convert the words into lower case.\n",
    "    :param text: a string of one statement\n",
    "    : return tokens: list of words after performing data preprocessing and cleanup\n",
    "    \"\"\"\n",
    "    count_vect = CountVectorizer()\n",
    "    count_vect.fit_transform([text])\n",
    "    tokens = count_vect.get_feature_names_out()\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98933b19",
   "metadata": {},
   "source": [
    "# Question 2: Basic Feature Extraction (20 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1943737b",
   "metadata": {},
   "outputs": [],
   "source": [
    "global_feature = [] # A global list of features\n",
    "def to_feature_vector(tokens):\n",
    "    \"\"\"\n",
    "    This method returns a dictionary containing features as keys, and weights as values. \n",
    "    Add every new word in dictionary as a key and assign it value as 1. \n",
    "    If word already exists in dictionary then just increase its weight by 1.\n",
    "    Also, maintains a list (global_feature) to get the all unique words in the given corpus.\n",
    "    : param tokens: List of words\n",
    "    : return feature_vector_dict: a dict = {'word': frequency} for given tokens\n",
    "    \"\"\"\n",
    "    global_featureVector = {}\n",
    "    for w in tokens:\n",
    "        if w not in global_feature:\n",
    "            global_feature.append(w)\n",
    "\n",
    "        if w in global_featureVector:\n",
    "            global_featureVector[w] += 1\n",
    "        else:\n",
    "            global_featureVector[w] = 1\n",
    "    return global_featureVector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2672e265",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TRAINING AND VALIDATING OUR CLASSIFIER\n",
    "\n",
    "def train_classifier(data):\n",
    "    print(\"Training Classifier...\")\n",
    "    pipeline =  Pipeline([('svc', LinearSVC())])\n",
    "    return SklearnClassifier(pipeline).train(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b110d554",
   "metadata": {},
   "source": [
    "# Question 3: Cross-validation (20 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2b91fb29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_validate(dataset, folds):\n",
    "    \"\"\"\n",
    "    This method performs 10 folds cross validation on Train and test dataset\n",
    "    : param dataset: Training Dataset (80% of total dataset)\n",
    "    : param folds: Number of folds, 10\n",
    "    :returns: \n",
    "    cv_results: Average of presicion, recall, fscore, accuracy of each fold\n",
    "    first_fold_actual_label: list of First fold's Actual Label\n",
    "    first_fold_predicted_label: list of First fold's Predicted Label\n",
    "    \"\"\"\n",
    "    fold_size = int(len(dataset)/folds) + 1\n",
    "    results = []\n",
    "\n",
    "    for i in range(0, len(dataset), int(fold_size)):\n",
    "        # trains and tests on the 10 folds of data in the dataset\n",
    "        print(\"Fold start on items %d - %d\" % (i, i+fold_size))\n",
    "        test_data = dataset[i:i+fold_size]\n",
    "        if i == 0:\n",
    "            train_data = dataset[i+fold_size:]\n",
    "        else:\n",
    "            train_data = dataset[:i] + dataset[i+fold_size:]\n",
    "\n",
    "        #Training classifier with train data\n",
    "        classifier = train_classifier(train_data)\n",
    "        actual_label = []\n",
    "        predicted_label = []\n",
    "\n",
    "        #Predicting label for each sample of test data and updating them in list above.\n",
    "        for j in range(0, len(test_data)):\n",
    "            actual_label.append(test_data[j][1])\n",
    "            pred_label = predict_labels(test_data[j][0], classifier)\n",
    "            predicted_label.append(pred_label[0])\n",
    "\n",
    "        # Getting presicion, recall, fscore and accuracy\n",
    "        presicion, recall, fscore, support = precision_recall_fscore_support(actual_label, predicted_label, average='weighted')\n",
    "        accuracy = accuracy_score(actual_label, predicted_label)\n",
    "        results.append([presicion, recall, fscore, accuracy])\n",
    "\n",
    "        # Appening classification report of each fold in Classification_Report_for_Each_Fold_First_Notebook.txt file.\n",
    "        with open(\"Classification_Report_for_Each_Fold_First_Notebook.txt\", \"a+\") as f:\n",
    "            f.write(f\"\\n =============Classification report for {i, i+fold_size} fold=======================\")\n",
    "            f.write(f\"\\n{classification_report(actual_label, predicted_label)}\")\n",
    "            f.write(f\"\\nConfusion matrix: \\n {str(metrics.confusion_matrix(actual_label, predicted_label))}\")\n",
    "\n",
    "        # Getting fist fold's actual and predicted labels\n",
    "        if i == 0:\n",
    "            first_fold_actual_label = actual_label\n",
    "            first_fold_predicted_label = predicted_label\n",
    "\n",
    "    cv_result = [sum(val)/len(results) for val in zip(*results)]\n",
    "    return cv_result, first_fold_actual_label, first_fold_predicted_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e247cc9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PREDICTING LABELS GIVEN A CLASSIFIER\n",
    "\n",
    "def predict_labels(samples, classifier):\n",
    "    \"\"\"Assuming preprocessed samples, return their predicted labels from the classifier model.\"\"\"\n",
    "    return classifier.classify_many(samples)\n",
    "\n",
    "def predict_label_from_raw(sample, classifier):\n",
    "    \"\"\"Assuming raw text, return its predicted label from the classifier model.\"\"\"\n",
    "    return classifier.classify(to_feature_vector(preProcess(reviewSample)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2efe3bf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now 0 rawData, 0 trainData, 0 testData\n",
      "Preparing the dataset...\n",
      "Now 10241 rawData, 0 trainData, 0 testData\n",
      "Preparing training and test data...\n",
      "After split, 10241 rawData, 8192 trainData, 2049 testData\n",
      "Training Samples: \n",
      "8192\n",
      "Features: \n",
      "12193\n"
     ]
    }
   ],
   "source": [
    "# MAIN\n",
    "\n",
    "# loading reviews\n",
    "# initialize global lists that will be appended to by the methods below\n",
    "raw_data = []          # the filtered data from the dataset file\n",
    "train_data = []        # the pre-processed training data as a percentage of the total dataset\n",
    "test_data = []         # the pre-processed test data as a percentage of the total dataset\n",
    "\n",
    "\n",
    "# references to the data files\n",
    "data_file_path = 'fake_news.tsv'\n",
    "\n",
    "# Do the actual stuff (i.e. call the functions we've made)\n",
    "# We parse the dataset and put it in a raw data list\n",
    "print(\"Now %d rawData, %d trainData, %d testData\" % (len(raw_data), len(train_data), len(test_data)),\n",
    "      \"Preparing the dataset...\",sep='\\n')\n",
    "\n",
    "load_data(data_file_path)\n",
    "\n",
    "# We split the raw dataset into a set of training data and a set of test data (80/20)\n",
    "# You do the cross validation on the 80% (training data)\n",
    "# We print the number of training samples and the number of features before the split\n",
    "print(\"Now %d rawData, %d trainData, %d testData\" % (len(raw_data), len(train_data), len(test_data)),\n",
    "      \"Preparing training and test data...\",sep='\\n')\n",
    "\n",
    "split_and_preprocess_data(0.8)\n",
    "\n",
    "\n",
    "\n",
    "# We print the number of training samples and the number of features after the split\n",
    "print(\"After split, %d rawData, %d trainData, %d testData\" % (len(raw_data), len(train_data), len(test_data)),\n",
    "      \"Training Samples: \", len(train_data), \"Features: \", len(global_feature), sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0e88deb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold start on items 0 - 820\n",
      "Training Classifier...\n",
      "Fold start on items 820 - 1640\n",
      "Training Classifier...\n",
      "Fold start on items 1640 - 2460\n",
      "Training Classifier...\n",
      "Fold start on items 2460 - 3280\n",
      "Training Classifier...\n",
      "Fold start on items 3280 - 4100\n",
      "Training Classifier...\n",
      "Fold start on items 4100 - 4920\n",
      "Training Classifier...\n",
      "Fold start on items 4920 - 5740\n",
      "Training Classifier...\n",
      "Fold start on items 5740 - 6560\n",
      "Training Classifier...\n",
      "Fold start on items 6560 - 7380\n",
      "Training Classifier...\n",
      "Fold start on items 7380 - 8200\n",
      "Training Classifier...\n",
      "\n",
      "\n",
      " Average Results of Presicion, Recall, Fscore, Accuracy of all folds: [0.563313403250085, 0.5626558933077016, 0.5626790928460598, 0.5626558933077016]\n"
     ]
    }
   ],
   "source": [
    "cv_results, first_fold_actual_label, first_fold_predicted_label = cross_validate(train_data, 10) # will work and output overall performance of p, r, f-score when cv implemented\n",
    "print(f\"\\n\\n Average Results of Presicion, Recall, Fscore, Accuracy of all folds: {cv_results}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c029323",
   "metadata": {},
   "source": [
    "# Question 4. Error Analysis (10 marks)¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "32ddc7cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "# a function to make the confusion matrix readable and pretty\n",
    "def confusion_matrix_heatmap(y_test, preds, labels):\n",
    "    \"\"\"Function to plot a confusion matrix\"\"\"\n",
    "    # pass labels to the confusion matrix function to ensure right order\n",
    "    cm = metrics.confusion_matrix(y_test, preds, labels=labels)\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(cm)\n",
    "    plt.title('Confusion matrix of the classifier')\n",
    "    fig.colorbar(cax)\n",
    "    ax.set_xticks(np.arange(len(labels)))\n",
    "    ax.set_yticks(np.arange(len(labels)))\n",
    "    ax.set_xticklabels( labels, rotation=45)\n",
    "    ax.set_yticklabels( labels)\n",
    "\n",
    "    for i in range(len(cm)):\n",
    "        for j in range(len(cm)):\n",
    "            text = ax.text(j, i, cm[i, j],\n",
    "                           ha=\"center\", va=\"center\", color=\"w\")\n",
    "\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('True')\n",
    "    \n",
    "    # fix for mpl bug that cuts off top/bottom of seaborn viz:\n",
    "    b, t = plt.ylim() # discover the values for bottom and top\n",
    "    b += 0.5 # Add 0.5 to the bottom\n",
    "    t -= 0.5 # Subtract 0.5 from the top\n",
    "    plt.ylim(b, t) # update the ylim(bottom, top) values\n",
    "    plt.show() # ta-da!\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9fa4dad0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_false_positive_and_false_negative_data(train_data, first_fold_actual_label, first_fold_predicted_label, raw_data):\n",
    "    \"\"\"\n",
    "    This method creates a new file to update all the False Positive and False Negative Data.\n",
    "    For the first fold, all the predicted and actual labels which doesn't match will be written \n",
    "    into this file with the associated statement from raw_data. This file will help in analysing\n",
    "    the actual confusions classifier is making while making the predictions.\n",
    "    \"\"\"\n",
    "    fold_size = int(len(train_data)/10) + 1\n",
    "    for i in range (0, fold_size):\n",
    "        if first_fold_actual_label[i] != first_fold_predicted_label[i]:\n",
    "            with open(\"False_Positives_And_False_Negatives_For_First_Fold.txt\", \"a+\") as f:\n",
    "                f.write(f\"\\n###Incorrect prediction of label for statement:\")\n",
    "                f.write(f\"\\n {str(raw_data[i])}\")\n",
    "                f.write(str(f\"\\n Predicted:{first_fold_predicted_label[i]}\"))                \n",
    "\n",
    "get_false_positive_and_false_negative_data(train_data, first_fold_actual_label, first_fold_predicted_label, raw_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bdadfc5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Final Classification Report for first fold: \n",
      "\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "        FAKE       0.47      0.48      0.48       339\n",
      "        REAL       0.63      0.62      0.62       481\n",
      "\n",
      "    accuracy                           0.56       820\n",
      "   macro avg       0.55      0.55      0.55       820\n",
      "weighted avg       0.56      0.56      0.56       820\n",
      "\n"
     ]
    }
   ],
   "source": [
    "labels = ['FAKE', 'REAL']\n",
    "confusion_matrix_heatmap(first_fold_actual_label, first_fold_predicted_label, labels)\n",
    "\n",
    "report = classification_report(first_fold_actual_label, first_fold_predicted_label)\n",
    "print(f\"\\n Final Classification Report for first fold: \\n\\n {report}\")\n",
    "\n",
    "with open(\"Classification_Report_for_Each_Fold_First_Notebook.txt\", \"a+\") as f:\n",
    "    f.write(f\"\\n ============Classification Report for First Fold==============\\n\")\n",
    "    f.write(f\"\\n\\n{report}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}