Solution_Q5_and_Q6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NLP Assignment 1 (40% of grade): Text classification for Fake News Detection\n",
    "\n",
    "# This assignment has Final Model with solutions for Questions 5 and 6.¶\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,
   "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: joblib in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (1.2.0)\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: tqdm in c:\\users\\pranj\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from nltk) (4.64.1)\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: 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",
   "metadata": {},
   "source": [
    "### Importing required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\pranj\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\pranj\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import csv    # csv reader\n",
    "import numpy as np\n",
    "import re\n",
    "import nltk\n",
    "nltk.download('stopwords')\n",
    "nltk.download('punkt')\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 nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.stem import SnowballStemmer\n",
    "from sklearn.linear_model import PassiveAggressiveClassifier\n",
    "from nltk.util import ngrams\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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",
    "    \"\"\"Split the data between train_data and test_data according to the percentage\n",
    "    and performs the preprocessing.\"\"\"\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",
   "metadata": {},
   "source": [
    "# Question 1: Input and Basic preprocessing (10 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_label(label):\n",
    "    \"\"\"Converts the multiple classes into two,\n",
    "    making it a binary distinction between fake news and real.\"\"\"\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 required columns from the given fake_news.tsv file.\n",
    "    : param dataline: 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",
    "    \n",
    "    # We are getting the only those rows where, Party Affiliation(data_column[7]) is not None and Last columns(data_column[13]) is not empty.\n",
    "    # The columns which were added with the statement are: Statement, Subject, Speaker, Resource and party affiliation.\n",
    "    # Earlier these columns were not consider but they hold valuable information, so they have added as a part of corpus.\n",
    "    \n",
    "    if data_line[7] != None and data_line[13] != None: \n",
    "        statement = data_line[2] + data_line[3] + data_line[4] + data_line[13] + data_line[7]\n",
    "    return (data_label, statement)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process(text):\n",
    "    \"\"\"\n",
    "    This methods uses different techniques to preprocess and clean data. \n",
    "    The method's which are commented are tried to verify accuracy using different techniques.\n",
    "    For the final model, we have used a regex to clean the data and we have used Bigram method to get the features.\n",
    "    :param text: a string of one statement\n",
    "    :Return: A list of tokens\n",
    "    \"\"\"\n",
    "    ## Below methods were used while performing multiple techniques in order to achieve good model.\n",
    "#     tokens = count_vectorizing(text)\n",
    "#     tokens = using_tfid(text)\n",
    "#     tokens = normalizing_lamatizing(text)\n",
    "\n",
    "    ## Regex and Bigram are used for the final model.\n",
    "    tokens = using_regex(text)\n",
    "    tokens = add_ngrams(tokens, 2)\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def using_regex(text):\n",
    "    \"\"\"\n",
    "    This method uses a Regex to separates punctuation at beginning and ends of strings. \n",
    "    After that, text is converted to list of words with each word converted to lower case.\n",
    "    :param text: a string of one statement\n",
    "    : return: tokens: list of words in text\n",
    "    \"\"\"\n",
    "    text = re.sub(r\"(\\w)([.,;:!?'\\\"”\\)])\", r\"\\1 \\2\", text) # separates punctuation at ends of strings\n",
    "    text = re.sub(r\"([.,;:!?'\\\"“\\(\\)])(\\w)\", r\"\\1 \\2\", text) # separates punctuation at beginning of strings\n",
    "    tokens = text.split()\n",
    "    tokens = [word.lower() for word in tokens]\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_vectorizing(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": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "def using_tfid(text):\n",
    "    \"\"\"\n",
    "    This method uses a tf-idf vectorizer to extract features from the given text. \n",
    "    The tf-idf vectorizer consider overall text of weight of words. This method also uses stop words with tfid, \n",
    "    to remove them if exists.\n",
    "    :param text: a string of one statement\n",
    "    : Return tokens: list of words after performing data preprocessing and cleanup\n",
    "    \"\"\"\n",
    "    tfid_vect = TfidfVectorizer(stop_words='english')\n",
    "    X = tfid_vect.fit_transform([text])\n",
    "    tokens = tfid_vect.get_feature_names_out()\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_ngrams(tokens, n):\n",
    "    \"\"\"\n",
    "    This method can convert tokens to given add ngrams.\n",
    "    : param tokens: Input list of words/tokens\n",
    "    : param n: number of ngram need to use.\n",
    "    : return: return a list of tokens based on ngram size.\n",
    "    \"\"\"\n",
    "    return list(ngrams(tokens, n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizing_lamatizing(tokens):\n",
    "    \"\"\"\n",
    "    This method performs multiple data cleaning steps, such as removing stopwords, \n",
    "    removing punctuation, and performs stemming(Stemming means reducing inflection in words to their root forms).\n",
    "    : return: a list of tokens after cleaning.\n",
    "    \"\"\"\n",
    "    # removing stopwords\n",
    "    tokens_without_sw = [w for w in tokens if not w.lower() in stopwords.words('english')]\n",
    "    tokes_without_pucn = [w.lower() for w in tokens_without_sw if w.isalpha()]\n",
    "    sb = SnowballStemmer('english')\n",
    "    tokens_after_stem = [sb.stem(w) for w in tokes_without_pucn]\n",
    "    return tokens_after_stem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2: Basic Feature Extraction (20 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "global_feature = [] # A global list of features\n",
    "\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 = {'words': frequency} for given tokens\n",
    "    \"\"\"\n",
    "    feature_vector_dict = {}\n",
    "    for word in tokens:\n",
    "      if word not in global_feature:\n",
    "        global_feature.append(word)\n",
    "\n",
    "      if word in feature_vector_dict:\n",
    "        feature_vector_dict[word] += 1\n",
    "      else:\n",
    "          feature_vector_dict[word] = 1\n",
    "\n",
    "    return feature_vector_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3: Cross-validation (20 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_validate(dataset, folds):\n",
    "    \"\"\"\n",
    "    This method performs 10 folds cross validation on Training dataset by diving the \n",
    "    training dataset into 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 Actual Label\n",
    "    first_fold_predicted_label: list of First fold 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\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 ClassificatioReportforEachFold file.\n",
    "        with open(\"Classification_Report_for_Each_Fold_Final_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\"\\n Confusion 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": 14,
   "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": 15,
   "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",
      "113857\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",
    "# 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",
    "# 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": 16,
   "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: [0.596747412244935, 0.5993704193199567, 0.5967956503093932, 0.5993704193199567]\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\\nAverage Results of presicion, recall, fscore, accuracy: {cv_results}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Error Analysis (10 marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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.55      0.50      0.52       339\n",
      "        REAL       0.67      0.72      0.69       481\n",
      "\n",
      "    accuracy                           0.63       820\n",
      "   macro avg       0.61      0.61      0.61       820\n",
      "weighted avg       0.62      0.63      0.62       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\"\\nFinal Classification Report for first fold: \\n\\n {report}\")\n",
    "\n",
    "with open(\"Classification_Report_for_Each_Fold_Final_notebook.txt\", \"a+\") as f:\n",
    "    f.write(f\"\\n ============Classification Report for First Fold==============\\n\")\n",
    "    f.write(f\"\\n\\n{report}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Questions 5 (20%) and 6 (20%) (recommend starting a new notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "({('the', 'bush'): 1, ('bush', 'tax'): 1, ('tax', 'cuts'): 1, ('cuts', 'helped'): 1, ('helped', 'to'): 1, ('to', 'create'): 1, ('create', 'a'): 1, ('a', 'substantial'): 1, ('substantial', 'part'): 1, ('part', 'of'): 1, ('of', 'the'): 1, ('the', 'deficit'): 1, ('deficit', '.'): 1, ('.', 'bush-administration'): 1, ('bush-administration', ','): 1, (',', 'deficit'): 1, ('deficit', ','): 1, (',', 'taxesdennis-kucinicha'): 1, ('taxesdennis-kucinicha', 'radio'): 1, ('radio', 'interviewdemocrat'): 1}, 'REAL')\n",
      "Training Classifier...\n"
     ]
    },
    {
     "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": [
      "Done training!\n",
      "Precision: 0.586422\n",
      "Recall: 0.590044\n",
      "F Score:0.586059\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "        FAKE       0.55      0.48      0.51       926\n",
      "        REAL       0.61      0.68      0.65      1123\n",
      "\n",
      "    accuracy                           0.59      2049\n",
      "   macro avg       0.58      0.58      0.58      2049\n",
      "weighted avg       0.59      0.59      0.59      2049\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Finally, check the accuracy of your classifier by training on all the traning data\n",
    "# and testing on the test set\n",
    "# Will only work once all functions are complete\n",
    "functions_complete = True  # set to True once you're happy with your methods for cross val\n",
    "if functions_complete:\n",
    "    print(test_data[0])   # have a look at the first test data instance\n",
    "    classifier = train_classifier(train_data)  # train the classifier\n",
    "    test_true = [t[1] for t in test_data]   # get the ground-truth labels from the data\n",
    "    test_pred = predict_labels([x[0] for x in test_data], classifier)  # classify the test data to get predicted labels\n",
    "    final_scores = precision_recall_fscore_support(test_true, test_pred, average='weighted')# evaluate\n",
    "    report = classification_report(test_true, test_pred) # Getting classification report \n",
    "    labels = ['FAKE', 'REAL']\n",
    "    confusion_matrix_heatmap(test_true, test_pred, labels)\n",
    "    print(\"Done training!\")\n",
    "    print(\"Precision: %f\\nRecall: %f\\nF Score:%f\" % final_scores[:3])\n",
    "    print(f\"Classification report: \\n\\n{report}\")\n"
   ]
  }
 ],
 "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": 2
}