NewsDataClassification.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/omkarsk98/NewsDataClassification/blob/development/NewsDataClassification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zUJRD-W05nMs"
      },
      "source": [
        "Download the repo for original and raw csv data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "colab_type": "code",
        "id": "OtVE_u-I0m91",
        "outputId": "0e31271b-14a1-49ac-bbe4-5a7cda997a16"
      },
      "outputs": [],
      "source": [
        "# !git clone https://github.com/omkarsk98/NewsDataClassification.git"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "1FmiqMubHZ_a"
      },
      "source": [
        "Go the directory and checkout to the required folder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "colab_type": "code",
        "id": "Y8wVHW5d00z1",
        "outputId": "865c6091-5525-480b-cc73-d454aa9f4402"
      },
      "outputs": [],
      "source": [
        "# %cd NewsDataClassification\n",
        "# !git checkout development"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WZiinfyg54Ta"
      },
      "source": [
        "Download trained model and unzip it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "colab_type": "code",
        "id": "qTChM-bd_umC",
        "outputId": "e41e9621-931c-488d-a0d8-a3b21e7598e3"
      },
      "outputs": [],
      "source": [
        "# !wget -c \"https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz\"\n",
        "# !gunzip GoogleNews-vectors-negative300.bin.gz"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "b5leTMSU5-wT"
      },
      "source": [
        "Download nltk libraries and dependencies"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "colab_type": "code",
        "id": "OJDZ2gA83IWg",
        "outputId": "4be9fea0-5d2b-43f9-8a67-4d2c1839520c"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package punkt to /Users/kullya/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n",
            "[nltk_data] Downloading package stopwords to\n",
            "[nltk_data]     /Users/kullya/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n"
          ]
        }
      ],
      "source": [
        "import nltk\n",
        "nltk.download('punkt')\n",
        "nltk.download('stopwords')\n",
        "from gensim import downloader\n",
        "from keras import layers, models, backend"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Og2mnsbQ6EzL"
      },
      "source": [
        "import all required libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "c8ozUYJ3oXO0"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "# from gensim import models\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "import numpy as np\n",
        "from nltk.tokenize import word_tokenize\n",
        "from nltk.corpus import stopwords\n",
        "from sklearn.metrics import accuracy_score ,confusion_matrix\n",
        "import time\n",
        "from sklearn.manifold import TSNE\n",
        "# from google.colab import files"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 112,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "colab_type": "code",
        "id": "55YAVl-Oua1m",
        "outputId": "be51c26a-45ae-4b29-b741-3566835a27be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dimensions of the model 300\n"
          ]
        }
      ],
      "source": [
        "# Load word2vec model (trained on Google's corpus)\n",
        "model = downloader.load('word2vec-google-news-300')\n",
        "# model = models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin', binary = True) \n",
        "# Check dimension of word vectors\n",
        "print(\"Dimensions of the model\",model.vector_size)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7p8AmIVB6KPk"
      },
      "source": [
        "Read the raw data and set max records to be used"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "colab_type": "code",
        "id": "w70GDVH6tL1r",
        "outputId": "6b392128-1f84-4279-922b-d5d5a50514b8"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/6q/k6zt03hn645cnsdj26f8d44h0000gn/T/ipykernel_23998/3374548816.py:2: DtypeWarning: Columns (11) have mixed types. Specify dtype option on import or set low_memory=False.\n",
            "  main_data = pd.read_csv('News_Final.csv')\n"
          ]
        }
      ],
      "source": [
        "# read csv\n",
        "main_data = pd.read_csv('News_Final.csv')\n",
        "\n",
        "# read titles from it\n",
        "article_titles = main_data['TITLE']\n",
        "labels = main_data[\"CATEGORY\"]\n",
        "\n",
        "# Create a list of strings, one for each title\n",
        "titles_list = [title for title in article_titles]\n",
        "# form a single string fro the list of strings\n",
        "big_title_string = ' '.join(titles_list)\n",
        "\n",
        "# define total records to be considered for analysis\n",
        "total = 50000\n",
        "# 422178 total records as max value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tzMgB8HD6dbT"
      },
      "source": [
        "Tokenise all words and get stop words for english"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "9WqUDhgQJaIQ"
      },
      "outputs": [],
      "source": [
        "# Tokenize the string into words\n",
        "tokens = word_tokenize(big_title_string)\n",
        "\n",
        "# Remove non-alphabetic tokens, such as punctuation\n",
        "words = [word.lower() for word in tokens if word.isalpha()]\n",
        "stop_words = set(stopwords.words('english'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Uo5Yg-u06i7I"
      },
      "source": [
        "Define all the function that can be used for later stage"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "P_h-pzrEzhNS"
      },
      "outputs": [],
      "source": [
        "def document_vector(word2vec_model, doc):\n",
        "    # remove out-of-vocabulary words\n",
        "    doc = [word for word in doc if word in model]\n",
        "    return np.mean(model[doc], axis=0)\n",
        "\n",
        "# Our earlier preprocessing was done when we were dealing only with word vectors\n",
        "# Here, we need each document to remain a document \n",
        "def preprocess(text):\n",
        "    text = text.lower()\n",
        "    doc = word_tokenize(text)\n",
        "    doc = [word for word in doc if word not in stop_words]\n",
        "    doc = [word for word in doc if word.isalpha()] \n",
        "    return doc\n",
        "\n",
        "# Function that will help us drop documents that have no word vectors in word2vec\n",
        "def has_vector_representation(word2vec_model, doc):\n",
        "    \"\"\"check if at least one word of the document is in the\n",
        "    word2vec dictionary\"\"\"\n",
        "    return not all(word not in word2vec_model for word in doc)\n",
        "\n",
        "# Filter out documents\n",
        "def filter_docs(corpus, texts, labels, condition_on_doc):\n",
        "    \"\"\"\n",
        "    Filter corpus and texts given the function condition_on_doc which takes a doc. The document doc is kept if condition_on_doc(doc) is true.\n",
        "    \"\"\"\n",
        "    number_of_docs = len(corpus)\n",
        "    \n",
        "    if texts is not None:\n",
        "        texts = [text for (text, doc) in zip(texts, corpus)\n",
        "                 if condition_on_doc(doc)]\n",
        "    \n",
        "\n",
        "    corpus = [doc for doc in corpus if condition_on_doc(doc)]\n",
        "    \n",
        "    final_labels = []\n",
        "    for i in range(len(corpus)):\n",
        "      if condition_on_doc(corpus[i]):\n",
        "        final_labels.append(labels[i])\n",
        "    \n",
        "    print(\"{} docs removed\".format(number_of_docs - len(corpus)))\n",
        "\n",
        "    return (corpus, texts, final_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zNpB7L-a6njk"
      },
      "source": [
        "Remove stop words, non vocab words, empty docs and prepare vector for each title"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 116,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "colab_type": "code",
        "id": "n-19jVUuzsHe",
        "outputId": "a6a400d5-d505-4432-e6fb-ddef8226fb99"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "240 docs removed\n",
            "1st filter: Length of corpus:422179, Length of titles_list:422179, Length of labels:422179\n",
            "0 docs removed\n",
            "2nd filter: Length of corpus:422179, Length of titles_list:422179, Length of labels:422179\n"
          ]
        }
      ],
      "source": [
        "# # Preprocess the corpus to get list of documents with stop words removed and containing only the words that are present in the vocab\n",
        "corpus = [preprocess(title) for title in titles_list]\n",
        "# # still contains all the documents, nothing is filtered\n",
        "\n",
        "# # Remove docs that don't include any words in W2V's vocab\n",
        "corpus, titles_list, labels = filter_docs(corpus, titles_list, labels, lambda doc: has_vector_representation(model, doc))\n",
        "print(\"1st filter: Length of corpus:\"+str(len(corpus))+\", Length of titles_list:\"+ str(len(titles_list))+\", Length of labels:\"+str(len(labels)))\n",
        "\n",
        "# # Filter out any empty docs\n",
        "corpus, titles_list, labels = filter_docs(corpus, titles_list, labels, lambda doc: (len(doc) != 0))\n",
        "print(\"2nd filter: Length of corpus:\"+str(len(corpus))+\", Length of titles_list:\"+ str(len(titles_list))+\", Length of labels:\"+str(len(labels)))\n",
        "\n",
        "x = []\n",
        "for doc in corpus: # append the vector for each document\n",
        "    x.append(document_vector(model, doc))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "C8Tp1BD1ibrf"
      },
      "source": [
        "# **After removing stop words and empty docs** <br>\n",
        "\n",
        "---\n",
        "241 docs removed <br>\n",
        "1st filter: Length of corpus:422178, Length of titles_list:422178, Length of labels:422178 <br>\n",
        "0 docs removed <br>\n",
        "2nd filter: Length of corpus:422178, Length of titles_list:422178, Length of labels:422178 <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "Md8PjWZJVqrO",
        "outputId": "d5c397e3-f1b7-4d97-e033-c9e2dbdd5014"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((422179, 300), (422179, 1))"
            ]
          },
          "execution_count": 117,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "vectorsForEachDocument = np.array(x) # list to array\n",
        "labels = np.array(labels)\n",
        "labels = labels.reshape(labels.shape[0],1)\n",
        "vectorsForEachDocument.shape, labels.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "v-pmoZA-of0k"
      },
      "source": [
        "# **Vectors for each title** \n",
        "\n",
        "---\n",
        "A list of vectors of 300 dimensions each for all the titles and labels contain the respective labels<br>\n",
        "Shape of these vectors is (422178, 300) <br>\n",
        "Shape pf it respective labels (422178, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dToFAFzWpPi5"
      },
      "source": [
        "# **Filter improper labels**\n",
        "\n",
        "---\n",
        "Filter out the data that has improper labels. Labels should only be of the following types. <br>\n",
        "1. b: business\n",
        "2. t: technology\n",
        "3. e: entertainment\n",
        "4. m: health"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "T28DgqDk4M93",
        "outputId": "972c37c4-d04a-4841-ed92-9f5459f1ee74"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((50000, 300), (50000, 1))"
            ]
          },
          "execution_count": 118,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# filter out data that has improper labels\n",
        "possibleLabels = [\"b\",\"t\",\"e\",\"m\"]\n",
        "finalLabels = []\n",
        "features = []\n",
        "for i in range(len(labels)):\n",
        "  if labels[i] in possibleLabels:\n",
        "    finalLabels.append(labels[i])\n",
        "    features.append(vectorsForEachDocument[i])\n",
        "  if(len(finalLabels)==total):\n",
        "    break\n",
        "\n",
        "\n",
        "features = np.array(features)\n",
        "labels = np.array(finalLabels)\n",
        "labels = labels.reshape(labels.shape[0],1)\n",
        "features.shape, labels.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "dT1O6Fg30g9j"
      },
      "source": [
        "# **Create a dataframe to shuffle it**\n",
        "\n",
        "---\n",
        "Create dataframe to shuffle it and split it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "lc40d1IU7txC",
        "outputId": "f5daf732-bf50-4792-f1b8-5e064473faeb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((50000, 300), (50000, 1))"
            ]
          },
          "execution_count": 119,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "finalData = pd.DataFrame.from_records(features)\n",
        "finalData.columns = range(1,301)\n",
        "finalData[\"labels\"] = labels\n",
        "# finalData.to_csv('FinalData.csv')\n",
        "data = finalData.sample(frac=1) #shuffles the data\n",
        "labels = data[\"labels\"]\n",
        "labels = np.array(labels) \n",
        "labels = labels.reshape(labels.shape[0],1)\n",
        "del data[\"labels\"]\n",
        "features = np.array(data)\n",
        "features.shape, labels.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "17fLx5KcBoI8"
      },
      "source": [
        "# Split the data\n",
        "---\n",
        "**Train Data**: Use 80% of the data for training purpose. <br>\n",
        "**Test Data**: Use 20% of the data for testing purpose. <br>\n",
        "**Features**: Use 300 dimensional vectors as features. It can be found in `vectorsForEachDocument`.<br>\n",
        "**Labels**: Use the categories as labels. I can be found in `labels`.<br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "colab_type": "code",
        "id": "YvfSgoRmBdIp",
        "outputId": "db7c66c8-0335-42d8-b9af-1ce5d83c8fe9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((40000, 300), (40000, 1), (10000, 300), (10000, 1))"
            ]
          },
          "execution_count": 120,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "train = int((80/100)*len(features))\n",
        "trainFeatures, testFeatures = features[:train], features[train:]\n",
        "trainLabels, testLabels = labels[:train], labels[train:]\n",
        "trainFeatures.shape, trainLabels.shape, testFeatures.shape, testLabels.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KPMISgZnDsB6"
      },
      "source": [
        "**Shapes of the data** <br>\n",
        "trainFeatures: (160000,300) <br>\n",
        "trainLabels: (160000,1) <br>\n",
        "testFeatures: (40000,300) <br>\n",
        "testLabels: (40000,1) <br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "a60mKGCXHvx8"
      },
      "source": [
        "# **Train the logistic regression model** <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        },
        "colab_type": "code",
        "id": "87M4P4AJHccd",
        "outputId": "d871e48c-e2fb-44d5-b551-01576e3e4f9a"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/kullya/miniforge3/lib/python3.8/site-packages/sklearn/utils/validation.py:1111: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
            "  y = column_or_1d(y, warn=True)\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "85.44%\n",
            "Time taken: 5.9677 seconds\n"
          ]
        }
      ],
      "source": [
        "tic = time.time()\n",
        "logistic_Regression = LogisticRegression(multi_class=\"auto\", solver=\"lbfgs\", max_iter=1000)\n",
        "logistic_Regression.fit(trainFeatures,trainLabels)\n",
        "Y_predict = logistic_Regression.predict(testFeatures)\n",
        "print(str((accuracy_score(testLabels,Y_predict)*100))+\"%\")\n",
        "toc = time.time()\n",
        "print(\"Time taken: \"+str(round(toc - tic, 4))+\" seconds\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "8dB0ddhLqZux"
      },
      "source": [
        "# **Outcomes of the training** <br>\n",
        "\n",
        "---\n",
        "|Train |Test |Dimensions |Accuracy |Time(sec) | Comments |\n",
        "|---|---|---|---|---|---|\n",
        "|40000|10000|300|86|12|Data randomly shuffled|\n",
        "|80000|20000|300|78|53||\n",
        "|40000|10000|300|74|12||\n",
        "|80000|20000|300|78|53||\n",
        "|24000|6000|300|73|11||\n",
        "|160000|40000|300|72|53||\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "H3nInS38OoiW"
      },
      "source": [
        "**Precision and recall**\n",
        "\n",
        "---\n",
        "Calculating precision and recall using sklearn.metrics.precision_recall_fscore_support.<br>\n",
        "Precision is the fraction of relevant instances among the retrieved instances, while recall is the fraction of the total amount of relevant instances that were actually retrieved.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "colab_type": "code",
        "id": "jTPnPUaX4kM7",
        "outputId": "e00b0191-d5bc-4370-f8e4-3c00b6a30fb0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "For labels in sequence as ['b', 't', 'e', 'm']\n",
            "precision: [0.82423652 0.82466997 0.89775706 0.86948357]\n",
            "recall: [0.85478437 0.79514718 0.91617122 0.80242634]\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import precision_recall_fscore_support as score\n",
        "precision, recall, fscore, support = score(testLabels, Y_predict, labels=possibleLabels)\n",
        "print(\"For labels in sequence as\", possibleLabels)\n",
        "print('precision: {}'.format(precision))\n",
        "print('recall: {}'.format(recall))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "HOcBD_hrQF5M"
      },
      "source": [
        "**Result of precision and recall**\n",
        "\n",
        "---\n",
        "\n",
        "For labels in sequence as ['b', 't', 'e', 'm'] <br>\n",
        "precision: [82.94729775 83.25883787 89.44781729 87.46594005] <br>\n",
        "recall: [84.79752917 80.92417062 91.4843288  82.16723549] <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "colab_type": "code",
        "id": "dnWCGgFwVwsS",
        "outputId": "fef146ec-34e4-4630-8939-c0b846b031d9"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn import metrics\n",
        "from sklearn.multiclass import OneVsRestClassifier\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "from sklearn.preprocessing import label_binarize\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "testLabelsBinary = label_binarize(testLabels, classes=possibleLabels)\n",
        "trainLabelsBinary = label_binarize(trainLabels, classes=possibleLabels)\n",
        "\n",
        "# classifier\n",
        "clf = OneVsRestClassifier(LogisticRegression(solver='sag'), n_jobs=1)\n",
        "y_score = clf.fit(trainFeatures, trainLabelsBinary).decision_function(testFeatures)\n",
        "\n",
        "fpr = dict()\n",
        "tpr = dict()\n",
        "roc_auc = dict()\n",
        "\n",
        "for i in range(4):\n",
        "    fpr[i], tpr[i], _ = roc_curve(testLabelsBinary[:, i], y_score[:, i])\n",
        "    roc_auc[i] = auc(fpr[i], tpr[i])\n",
        "\n",
        "for i in range(4):\n",
        "    plt.figure()\n",
        "    plt.plot(fpr[i], tpr[i], label='ROC curve (area = %0.2f)' % roc_auc[i])\n",
        "    plt.plot([0, 1], [0, 1], 'k--')\n",
        "    plt.xlim([0.0, 1.0])\n",
        "    plt.ylim([0.0, 1.05])\n",
        "    plt.xlabel('False Positive Rate')\n",
        "    plt.ylabel('True Positive Rate')\n",
        "    title = 'ROC for '+possibleLabels[i]\n",
        "    plt.title(title)\n",
        "    plt.legend(loc=\"lower right\")\n",
        "    plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Neural Network\n",
        "---\n",
        "One hot encode labels"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 124,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "trainLabels: (40000,)\n",
            "testLabels: (10000,)\n"
          ]
        }
      ],
      "source": [
        "trainLabelsTags = {\"b\":0, \"t\":1, \"e\":2, \"m\":3}\n",
        "trainLabels = np.reshape(trainLabels, trainLabels.shape[0])\n",
        "testLabels = np.reshape(testLabels, testLabels.shape[0])\n",
        "print(\"trainLabels:\", trainLabels.shape)\n",
        "print(\"testLabels:\", testLabels.shape)\n",
        "trainLabels = np.array([trainLabelsTags[tag[0]] for tag in trainLabels])\n",
        "testLabels = np.array([trainLabelsTags[tag] for tag in testLabels])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 125,
      "metadata": {},
      "outputs": [],
      "source": [
        "# trainLabels\n",
        "# testLabels"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 126,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "trainLabels.size: 160000 (40000, 4)\n",
            "trainLabelsEncoded: [[1. 0. 0. 0.]\n",
            " [1. 0. 0. 0.]\n",
            " [0. 1. 0. 0.]\n",
            " ...\n",
            " [0. 1. 0. 0.]\n",
            " [0. 0. 1. 0.]\n",
            " [1. 0. 0. 0.]]\n",
            "testLabelsEncoded: [[0. 0. 0. 1.]\n",
            " [0. 0. 1. 0.]\n",
            " [0. 0. 1. 0.]\n",
            " ...\n",
            " [0. 0. 0. 1.]\n",
            " [0. 1. 0. 0.]\n",
            " [0. 1. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "trainLabelsEncoded = np.zeros((len(trainLabels), 4))\n",
        "print(\"trainLabels.size:\", trainLabelsEncoded.size, trainLabelsEncoded.shape)\n",
        "trainLabelsEncoded[np.arange(trainLabelsEncoded.shape[0]), trainLabels] = 1\n",
        "\n",
        "testLabelsEncoded = np.zeros((len(testLabels), 4))\n",
        "testLabelsEncoded[np.arange(testLabelsEncoded.shape[0]), testLabels] = 1\n",
        "\n",
        "print(\"trainLabelsEncoded:\", trainLabelsEncoded)\n",
        "print(\"testLabelsEncoded:\", testLabelsEncoded)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_10\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_30 (Dense)            (None, 100)               30100     \n",
            "                                                                 \n",
            " dense_31 (Dense)            (None, 50)                5050      \n",
            "                                                                 \n",
            " dense_32 (Dense)            (None, 4)                 204       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 35,354\n",
            "Trainable params: 35,354\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Epoch 1/10\n",
            "  6/625 [..............................] - ETA: 7s - loss: 1.3498 - accuracy: 0.3151  "
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2022-10-16 18:22:44.464873: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "625/625 [==============================] - 6s 9ms/step - loss: 0.5012 - accuracy: 0.8271\n",
            "Epoch 2/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.3599 - accuracy: 0.8789\n",
            "Epoch 3/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.3050 - accuracy: 0.8983\n",
            "Epoch 4/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2615 - accuracy: 0.9136\n",
            "Epoch 5/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2285 - accuracy: 0.9243\n",
            "Epoch 6/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2024 - accuracy: 0.9322\n",
            "Epoch 7/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.1794 - accuracy: 0.9397\n",
            "Epoch 8/10\n",
            "625/625 [==============================] - 6s 10ms/step - loss: 0.1593 - accuracy: 0.9468\n",
            "Epoch 9/10\n",
            "625/625 [==============================] - 6s 10ms/step - loss: 0.1431 - accuracy: 0.9519\n",
            "Epoch 10/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.1278 - accuracy: 0.9562\n",
            " 15/313 [>.............................] - ETA: 2s - loss: 0.2986 - accuracy: 0.9083"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2022-10-16 18:23:43.644112: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 3s 8ms/step - loss: 0.3103 - accuracy: 0.9094\n",
            "Accuracy: 90.94%\n"
          ]
        }
      ],
      "source": [
        "avgFNN = models.Sequential()\n",
        "avgFNN.add(layers.Input(shape = 300))\n",
        "avgFNN.add(layers.Dense(100, activation = \"relu\"))\n",
        "avgFNN.add(layers.Dense(50, activation = \"relu\"))\n",
        "avgFNN.add(layers.Dense(4, activation = \"softmax\"))\n",
        "\n",
        "avgFNN.summary()\n",
        "avgFNN.compile(optimizer = \"adam\", metrics = [\"accuracy\"], loss = \"categorical_crossentropy\")\n",
        "\n",
        "avgFNN.fit(trainFeatures, trainLabelsEncoded, batch_size = 64, epochs = 10)\n",
        "# print(\"++++++++++++++++++++++++++++++++++++++\\nDone training!!!!!!!!!!!!!!!!!!\\n++++++++++++++++++++++++++++++++++++++\")\n",
        "predictedLabels = avgFNN.evaluate(testFeatures, testLabelsEncoded)\n",
        "print(\"Accuracy: \"+str(round(predictedLabels[1], 4) * 100)+\"%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# **Outcomes of the training on Neural Network** <br>\n",
        "\n",
        "---\n",
        "|Train |Test |Dimensions |Accuracy |Time(sec) | Comments |\n",
        "|---|---|---|---|---|---|\n",
        "|40000|10000|300|90.9|73||\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 128,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2022-10-16 18:23:46.866204: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "625/625 [==============================] - 10s 16ms/step - loss: 0.5376 - accuracy: 0.8101\n",
            "Epoch 2/10\n",
            "625/625 [==============================] - 10s 16ms/step - loss: 0.3982 - accuracy: 0.8602\n",
            "Epoch 3/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.3686 - accuracy: 0.8747\n",
            "Epoch 4/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.3446 - accuracy: 0.8828\n",
            "Epoch 5/10\n",
            "625/625 [==============================] - 11s 17ms/step - loss: 0.3234 - accuracy: 0.8917\n",
            "Epoch 6/10\n",
            "625/625 [==============================] - 10s 15ms/step - loss: 0.3079 - accuracy: 0.8967\n",
            "Epoch 7/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.2931 - accuracy: 0.9034\n",
            "Epoch 8/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.2796 - accuracy: 0.9077\n",
            "Epoch 9/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.2684 - accuracy: 0.9107\n",
            "Epoch 10/10\n",
            "625/625 [==============================] - 9s 15ms/step - loss: 0.2577 - accuracy: 0.9151\n",
            "  6/313 [..............................] - ETA: 3s - loss: 0.3030 - accuracy: 0.8854  "
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2022-10-16 18:25:23.424538: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "313/313 [==============================] - 4s 11ms/step - loss: 0.3451 - accuracy: 0.8856\n",
            "Accuracy: 88.56%\n"
          ]
        }
      ],
      "source": [
        "rnnTrainFeatures = np.reshape(trainFeatures, (trainFeatures.shape[0], 1, trainFeatures.shape[1]))\n",
        "rnnTestFeatures = np.reshape(testFeatures, (testFeatures.shape[0], 1, testFeatures.shape[1]))\n",
        "\n",
        "network = models.Sequential()\n",
        "network.add(layers.SimpleRNN(20,  input_shape=(None,rnnTrainFeatures.shape[2]),activation='relu'))\n",
        "network.add(layers.Dense(100, activation = \"relu\"))\n",
        "network.add(layers.Dense(50, activation = \"relu\"))\n",
        "network.add(layers.Dense(4, activation = \"softmax\"))\n",
        "\n",
        "# network.summary()\n",
        "network.compile(optimizer = \"adam\", metrics = [\"accuracy\"], loss = \"categorical_crossentropy\")\n",
        "\n",
        "network.fit(rnnTrainFeatures, trainLabelsEncoded, epochs = 10, batch_size = 64)\n",
        "predictedLabels = network.evaluate(rnnTestFeatures, testLabelsEncoded)\n",
        "print(\"Accuracy: \"+str(round(predictedLabels[1], 4) * 100)+\"%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# **Outcomes of the training on Recurrent Neural Network** <br>\n",
        "\n",
        "---\n",
        "|Train |Test |Dimensions |Accuracy |Time(sec) | Comments |\n",
        "|---|---|---|---|---|---|\n",
        "|40000|10000|300|88.63|96||\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "include_colab_link": true,
      "machine_shape": "hm",
      "name": "NewsDataClassification.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8.8 ('base')",
      "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.8.8"
    },
    "vscode": {
      "interpreter": {
        "hash": "6d213053b985c30c7a49e6049c0b9d16202465318109f223c8499d47c078f76c"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}