Project- Text Classification-Copy1(better version- kind of intermediate).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Project-Text Classification</h1>\n",
    "<ul>\n",
    "    <li>\n",
    "        This ipynb file may need 20 to 30 minutes(tested on an Intel Core i3 processor using just one out of its 4 cores for this program) to finish running. So u may like to run it first and then start reading it to save your time. The reason why it will take so long to finish running is that it has lot of computation to do to create a 2D matrix suitable for text classification and a lot of features to iterate through.\n",
    "    </li>\n",
    "    <li>It will take 15 to 25 minutes for a function named \"data_modifier\" and rest 5 to 7 minutes for the Naive Bayes algorithm written from scratch.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Importing Important Libraries</h3>\n",
    "<ul>\n",
    "    <li>I have imported the stopwords from nltk and copied more of them from internet</li>\n",
    "    <li>Instead of split() function, I am using the tokenizer which makes the job much easier.</li>\n",
    "    <li>Instead of manually downloading the data from the internet, I have downloaded it using sklearn.datasets.fetch_20newsgroups</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_20newsgroups\n",
    "import string\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "from sklearn.naive_bayes import MultinomialNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'filenames', 'target_names', 'target', 'DESCR'])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newsgroups=fetch_20newsgroups() \n",
    "#instead of the link, I have fetched the data through sklearn itself just to reduce the amount of unnecessary work.\n",
    "stops=set(stopwords.words('english'))\n",
    "#these are the stopwords which we don't want to include in out vocabulary.\n",
    "punctuations=list(string.punctuation)\n",
    "#punctuation marks also should be removed from our vocabulary.\n",
    "stops.update(punctuations)\n",
    "#i have created a set of stop words and updated it with all the punctuation marks\n",
    "newsgroups.keys()\n",
    "#now we have all the unnecessary words and punctuation marks in our set \"stops\"\n",
    "#lets check what keys do we have in our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "737"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#later on while debugging the code i realised that there are more stop words still residing there in these documents apart from\n",
    "#those i have already included.\n",
    "# so i copied more stop words from the internet and imported them using numpy.loadtxt() and updated my set of stop words.\n",
    "more_stops=np.loadtxt(\"datasets/stops.txt\", dtype=str, delimiter=\" \")\n",
    "stops.update(more_stops)\n",
    "len(stops)\n",
    "#now we have these many stop words..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11314"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(newsgroups.data)\n",
    "#We have these many documents.(this is one of the reasons our algorithm is taking so much of time.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_documents=newsgroups.data\n",
    "#all_documents contains all the \"X\" data in un-tokenized form.\n",
    "all_categories=newsgroups.target\n",
    "#all_cateories contain all the \"Y\" data.\n",
    "all_documents_modified=[word_tokenize(doc) for doc in all_documents]\n",
    "#i have modified the all_documents to a form in which we have list of list of words(tokenized data for each document)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "#splitting these documents in train and test data.\n",
    "x_train, x_test, y_train, y_test=train_test_split(all_documents_modified, all_categories, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_words=[]\n",
    "#this variable is going to contain all the words from all our tokenized documents.\n",
    "for doc in x_train:\n",
    "    for word in doc:\n",
    "        if (word.lower() not in stops) and len(word)!=1 and len(word)!=2 and word[0]!=\"'\" and word!=\"n't\" and word[0]!=\".\":\n",
    "            #I dont't want to include words with length 1 and 2 in my vocabulary because these words are pretty much useless.\n",
    "            # and they might either be the stops which are not there in \"stops\" variable or some punctuation marks which are\n",
    "            # not there in \"punctuations\" variable. apart from the words of length 1 and 2 i have also removed some words\n",
    "            # separately because these words are most probably present in all the documents so they are not helping us much in\n",
    "            # classification.\n",
    "            all_words.append(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1175697"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(all_words)\n",
    "#lets check out the length of our vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This function accepts a list and returns a dictionary in which keys are the perticular words in the list and values are\n",
    "# the frequency of that element in that list.\n",
    "def freq_dict(all_words):\n",
    "    dic=dict()\n",
    "    #it iterates through all the elements in the list and increases the frequency by one if it encounters the same element again.\n",
    "    for word in all_words:\n",
    "        if word in dic.keys():\n",
    "            dic[word]+=1\n",
    "        else:\n",
    "            dic[word]=1\n",
    "    return dic\n",
    "\n",
    "dic=freq_dict(all_words)\n",
    "#Now in the \"dic\" variable we have the frequencies of all the elements of the list \"all words\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "#I have imported numpy because my plan is to get the elements in dic.keys() and dic.values() to two separate variables\n",
    "# namely \"freq\" and \"words\". and then i will arrange them in a decreasing fashion of frequency.\n",
    "freq=np.array([i for i in dic.values()])\n",
    "words=np.array([i for i in dic.keys()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "words=words[np.argsort(freq)][::-1]\n",
    "freq=np.sort(freq)[::-1]\n",
    "#now i have sorted both the arrays and first arranged them in ascending order using np.sort() and np.argsort() and then i have\n",
    "# reversed the so obtained array to get a descending ordered array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Frequency Distribution of words</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#This cell draws a frequency distribution graph for us to from where we can carefully observe the frequency trend of out list.\n",
    "import matplotlib.pyplot as plt\n",
    "#following are the limits for our graph.\n",
    "lower_limit=0    #default\n",
    "upper_limit=3000    #default\n",
    "difference_between_each_xtick=50  #default value. change these values to observe the graph in more depth\n",
    "#adjusting size of the graph for more clearity.\n",
    "plt.figure(figsize=(20, 7))\n",
    "#plotting\n",
    "plt.plot(np.arange(len(freq))[lower_limit:upper_limit], freq[lower_limit:upper_limit])\n",
    "#labelling\n",
    "plt.xlabel('Words(\"nth word\")--->')\n",
    "plt.ylabel(\"Frequency--->\")\n",
    "#adjusting the xticks\n",
    "plt.xticks(np.arange(lower_limit, upper_limit, 50), rotation=45)\n",
    "plt.grid()\n",
    "plt.show()\n",
    "#observe the following graph by changing the values of lower_limit, upper_limit and difference_between_each_xtick."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1354, 46)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features=words[20:4000]\n",
    "#features variable contains all the top words which are most frequently used in all our documents. \n",
    "freq[20], freq[3999]\n",
    "# since there are 11314 documents I don't want the very high frequency words to get into my final features list as\n",
    "# they may be present in all the documents which will not help me much for classiication.\n",
    "# so i have choosen the words having frequency freq[20] to freq[2999]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function is the backbone of our Text Classification.\n",
    "# It takes the patameters x_train or x_test and the list of all features and converts it into a TEXT-CLASSIFICATION-FRIENDLY structure.\n",
    "# By text-classification-friendly, I mean it converts the data into a 2-D array which contains the frequency of that feature\n",
    "# in that perticular document. where rows are the documents and columns are the features.\n",
    "def data_modifier(x_data, features):\n",
    "    modified_data=np.zeros((len(x_data), len(features)))\n",
    "    #modified_data currently have a ZEROS numpy array whose shape is (len(x_data), len(features))\n",
    "    for i in range(len(x_data)):\n",
    "        #looping over each and every row in the x_data\n",
    "        current_doc=x_data[i]\n",
    "        #current_doc contains the current document on which we are iterating.(As the name suggests obviously)\n",
    "        for word in current_doc:\n",
    "            #looping over each word in the current document\n",
    "            if word in features:\n",
    "                #whenever I am finding a perticular word in the features list...\n",
    "                for j in range(len(features)):\n",
    "                    #I am increasing the value of modified[i][j] to the number of times that word is present in the features list.\n",
    "                    if features[j]==word:\n",
    "                        modified_data[i][j]+=1\n",
    "    #finally I have returned the modified array.\n",
    "    return modified_data \n",
    "#this function takes some time to process because i have considered nearly 3000 features and apart from that we have so many\n",
    "#documents which contains so many words. so the algorithm has to go through each word in features list for each word in a perticular\n",
    "#document. and this needs to be done because I think there is probably no other way to create such a modified array from x_data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train_modified = data_modifier(x_train, features)\n",
    "#training and testing data has to be modified saparately because we cant use the testing data for training purpose\n",
    "#as both the Training and testing data must be having their own separate vocabularies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test_modified= data_modifier(x_test, features)\n",
    "#modified testing data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Trying out the inbuilt Multinomial Naive Bayes classifier</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8214916931778014"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#first trying out the inbuilt Multinomial naive bayes classifier.\n",
    "clf=MultinomialNB()\n",
    "clf.fit(x_train_modified, y_train)\n",
    "clf.score(x_test_modified, y_test)\n",
    "#it seems like a descent score to me beacause we haven't used real text classification algorithms like NLP and all."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Writing our own Naive Bayes Classifier</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fit function takes the training data and gives you a dictionary whose keys are the different classes available to classify.\n",
    "# and for each key, value is another dictionary, whose keys are all the features available to us and value corresponding\n",
    "# to each key is sum of all the row of training data corresponding to the current class.(the original key or (say) primary key)\n",
    "def fit(x_train, y_train):\n",
    "    count=dict()\n",
    "    for i in range(20):\n",
    "        needed_docs=x_train[y_train==i]\n",
    "        #these are all the documents we need to work upon corresponding to the class i.\n",
    "        count[i]=dict()\n",
    "        #count is a dictionary whose each key is yet another dictionary.\n",
    "        count[i]['total']=0\n",
    "        #it will maintain the total number of words in class i.\n",
    "        for j in range(len(features)):\n",
    "            count[i][features[j]]=needed_docs[:, j].sum()\n",
    "            #it gives me-\"how many times jth feature is coming corresponding to class i\"\n",
    "            count[i]['total']+=count[i][features[j]]\n",
    "            #this additional key named \"total\" stores the sum of all the values of ith key which signifies the total number of\n",
    "            # words in class i.\n",
    "    #returning the dictionary at last.\n",
    "    return count\n",
    "\n",
    "#this \"probability\" function is another backbone of our naive bayes classifier.But before this function please ckeck out \n",
    "#predict function given below.\n",
    "#This \"Predict\" function takes takes the dictionary, which was originally returned by fit function, the current data point and the current class as its params.\n",
    "def probability(dictionary, x, current_class):\n",
    "    probas_for_each_word=[]\n",
    "    #my plan, here, is to store all the probabilities for each word in features which is available in the current document\n",
    "    # and then return the logarithmic sum of all these probabilities for that perticular document.\n",
    "    for i in range(len(x)):\n",
    "        #iterating through each feature.\n",
    "        if x[i]!=0:\n",
    "            #I am skipping those features whose value corresponding to the current document is 0, that is, they are not present\n",
    "            # in the that document.\n",
    "            numerator=dictionary[current_class][features[i]]\n",
    "            #it denotes that how many times that ith feature is occuring in \"current_class\"\n",
    "            #this is the numerator of our NON LOGARITHMIC PROBABILITY\n",
    "            denominator=dictionary[current_class]['total']\n",
    "            #it denotes that what is the total number of words in the current class.\n",
    "            #this is the denominator of our NON LOGARITHMIC PROBABILITY\n",
    "            proba=np.log((numerator+1)/(denominator+len(x)))\n",
    "            #i have created a variable \"proba\" which stores the logarithmic probability which also includes the laplace crrection.\n",
    "            #here \"1\" with the numerator and len(x) with denominator denotes the laplace correction.\n",
    "            probas_for_each_word.append(proba)\n",
    "            #finally i appended \"proba\" to the probas_for_each_word array.\n",
    "    #returning the logarithmic sum of all the probabilities. (which can be treated as multiplication of all the probabilities,\n",
    "    #but multiplying the probabilities simply won't be a good practice as it may nullify the extreamily small probabilities)\n",
    "    return sum(probas_for_each_word)\n",
    "\n",
    "#The predict_single function takes a perticular data point \"x\" from \"predict\" function and a dictionary which was obtained\n",
    "#originally from fit function. Before going through this function, you may like to check out the \"predict\" function.\n",
    "def predict_single(dic, x):\n",
    "    classes = dictionary.keys()\n",
    "    #this variable \"classes\" maintains all the possible different classes available to us.\n",
    "    best_p = -1000\n",
    "    best_class = -1\n",
    "    #initiated best_p and best_class variables with negative values because we want to consider maximum valued probabilities at\n",
    "    #the end. In the first run itself they will be replaced by positive values. \"best_p\" variable denotes the best probability\n",
    "    #uptill now. and as the name suggests, best_class denotes the best possible class uptill now.\n",
    "    first_run = True\n",
    "    #this boolean variable is taken keeping initial negative values in mind\n",
    "    for current_class in classes:\n",
    "        #iterating through each and every class in all possible classes.\n",
    "        p_current_class = probability(dic, x, current_class)\n",
    "        #p_current_class denotes the probability of current class.\n",
    "        if (first_run or p_current_class > best_p):\n",
    "            #if the probability of current class is better than the best probability then i will update the best probability and\n",
    "            # best_class to probability of current class and the current class respectively.\n",
    "            best_p = p_current_class\n",
    "            best_class = current_class\n",
    "            #updated\n",
    "        first_run = False\n",
    "    #returning the best predicted class for the current data point\n",
    "    return best_class\n",
    "\n",
    "#The predict function takes testing data and a dictionary as its input, where the dictionary is the one returned from fit function.\n",
    "def predict(x_test, dic):\n",
    "    y_pred=[]\n",
    "    #y_pred maintains all the predicted classes for provided testing data(In modified format---> see the \"data_modifier\" function).\n",
    "    for doc in x_test:\n",
    "        #iterating each document in testing data.\n",
    "        y_pred.append(predict_single(dic, doc))\n",
    "        #for each testing data point, we will append the value of predicted class to y_pred. and we will get that value from\n",
    "        #predict_single function\n",
    "    #returning the predicted data finally\n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionary=fit(x_train_modified, y_train)\n",
    "#calling the fit function for the modified data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_predicted=predict(x_test_modified, dictionary)\n",
    "#storing the predicted values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90    0    0    0    0    0    0    0    0    0    0    0    0    1    0    10    1    0    1    11    \n",
      "0    118    4    11    7    6    1    1    0    0    0    1    0    2    0    0    0    0    0    1    \n",
      "0    10    107    11    1    8    0    1    1    0    0    0    0    0    0    0    0    0    0    0    \n",
      "0    9    4    119    10    1    4    1    0    0    0    0    2    0    0    1    1    0    0    0    \n",
      "1    5    0    11    113    0    5    2    0    0    0    0    0    1    0    0    0    0    0    0    \n",
      "0    22    5    3    2    116    0    1    1    1    0    0    1    0    0    0    0    0    1    0    \n",
      "0    6    1    7    2    0    108    8    2    3    0    0    4    1    0    2    0    2    1    0    \n",
      "0    2    0    3    0    0    6    113    8    0    0    0    3    1    1    0    0    0    0    0    \n",
      "0    0    1    0    0    0    5    9    111    1    0    0    1    0    0    0    3    0    0    0    \n",
      "0    1    0    1    0    0    0    0    0    129    1    0    0    0    0    1    0    0    0    2    \n",
      "0    0    0    0    1    0    2    2    1    6    121    0    0    0    0    0    1    0    0    2    \n",
      "0    1    0    0    0    0    0    0    0    0    0    141    0    0    1    0    2    0    0    0    \n",
      "0    10    1    18    10    2    4    5    1    2    0    2    99    1    0    0    0    0    1    1    \n",
      "0    5    0    1    0    0    1    2    1    1    0    0    2    135    1    0    1    0    0    1    \n",
      "0    7    0    3    1    0    2    0    1    1    0    1    0    1    131    1    1    0    5    0    \n",
      "0    2    0    0    0    0    1    0    0    0    0    0    0    1    0    145    1    1    2    6    \n",
      "1    1    0    1    0    0    0    1    0    1    0    3    0    0    0    0    127    1    2    2    \n",
      "1    6    0    2    0    0    3    0    0    0    0    0    0    0    0    1    1    127    8    0    \n",
      "1    1    0    0    0    0    1    1    0    3    1    4    0    0    0    1    10    3    107    5    \n",
      "9    1    0    0    0    0    0    0    0    0    0    0    0    0    2    13    7    3    2    64    \n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "#printing the confusion matrix for our own naive bayes classifier.\n",
    "#here i am manually printing the confusion matrix for a more clear view.\n",
    "for i in confusion_matrix(y_true=y_test, y_pred=y_predicted):\n",
    "    for j in i:\n",
    "        print(j, end=\"    \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.87      0.79      0.83       114\n",
      "           1       0.57      0.78      0.66       152\n",
      "           2       0.87      0.77      0.82       139\n",
      "           3       0.62      0.78      0.69       152\n",
      "           4       0.77      0.82      0.79       138\n",
      "           5       0.87      0.76      0.81       153\n",
      "           6       0.76      0.73      0.74       147\n",
      "           7       0.77      0.82      0.80       137\n",
      "           8       0.87      0.85      0.86       131\n",
      "           9       0.87      0.96      0.91       135\n",
      "          10       0.98      0.89      0.93       136\n",
      "          11       0.93      0.97      0.95       145\n",
      "          12       0.88      0.63      0.74       157\n",
      "          13       0.94      0.89      0.92       151\n",
      "          14       0.96      0.85      0.90       155\n",
      "          15       0.83      0.91      0.87       159\n",
      "          16       0.81      0.91      0.86       140\n",
      "          17       0.93      0.85      0.89       149\n",
      "          18       0.82      0.78      0.80       138\n",
      "          19       0.67      0.63      0.65       101\n",
      "\n",
      "   micro avg       0.82      0.82      0.82      2829\n",
      "   macro avg       0.83      0.82      0.82      2829\n",
      "weighted avg       0.83      0.82      0.82      2829\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "#printing the classification report for our own naive bayes classifier.\n",
    "print(classification_report(y_true=y_test, y_pred=y_predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Observations</h1>\n",
    "<p><b>\n",
    "It seems like recall of some of the classes is excellent while for some other is moderate this is most probably because of selection of features. More accurately we select features, more will be the f1-score, precision and recall values. although from the confusion matrix we can determine that our algorithm is not that bad. Infact it seems to be working very precisely for some classes. And an accuracy of nearly 81% is not that bad. The accuracy is coming out to be equal to the one we got from the inbuilt multinomial naive bayes algorithm. And a better accuracy could be obtained by working on the selection of features.😁\n",
    "</b></p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}