Q1_Text classification_gui-Input.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "from nltk.corpus import stopwords\n",
    "import string\n",
    "import math\n",
    "import numpy as np\n",
    "from nltk.tokenize import RegexpTokenizer\n",
    "from matplotlib import pyplot as plt\n",
    "from scipy.spatial import distance\n",
    "from nltk.stem import PorterStemmer\n",
    "import tkinter as tk\n",
    "import random\n",
    "\n",
    "porter_stemmer=PorterStemmer()\n",
    "stop_words = set(stopwords.words('english'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## function to get files from directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getdatafromfile():\n",
    "    classes=['athletics','cricket','football','rugby','tennis']\n",
    "    list=[glob.glob('bbcsport/{}/*'.format(classes[i])) for i in range(len(classes))]\n",
    "    return list,classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KNN Classification Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TextClassificationKNN:\n",
    "    def __init__(self,list,classes):\n",
    "        self.list=list\n",
    "        self.classes=classes\n",
    "        self.totalfiles=[len(i) for i in list]\n",
    "        print(\"Total files in each class: \",self.totalfiles)\n",
    "        \n",
    "        \n",
    "    def preprocessData(self):\n",
    "\n",
    "        self.alldocDict={}\n",
    "        for mainClass in range(len(self.list)): \n",
    "            for subFiles in range(len(self.list[mainClass])):\n",
    "                f=open(self.list[mainClass][subFiles],'r')\n",
    "                tokenizer = RegexpTokenizer(r'\\w+')\n",
    "                # convert to lower case\n",
    "                fullfile = tokenizer.tokenize(f.read().lower())\n",
    "                # stem document\n",
    "                stemmedDocs=[porter_stemmer.stem(word) for word in fullfile]\n",
    "                #trimming the file name and removing redundant '.txt'\n",
    "                p=os.path.basename(self.list[mainClass][subFiles])\n",
    "                p=p.split('.')[0]\n",
    "                # remove all tokens that are not alphabetic and stop words\n",
    "                tokens_without_sw = [word for word in stemmedDocs if word not in stop_words and word.isalpha()]\n",
    "                self.alldocDict[mainClass,int(p)]=tokens_without_sw\n",
    "\n",
    "        return self.alldocDict\n",
    "    \n",
    "    \n",
    "    def SplitTrainTestDocs(self,testRatio):      \n",
    "        \n",
    "        self.train_count=[len(i)-(int(len(i)*(testRatio))) for i in self.list]        \n",
    "        self.Train_documents=[]\n",
    "        self.Test_documents=[]\n",
    "        self.Train_set=[]        \n",
    "        Train_Init=[]\n",
    "        for classId in range(len(self.classes)):\n",
    "            Train_Init.append(random.sample(range(1, self.totalfiles[classId]), self.train_count[classId]))\n",
    "\n",
    "        for classId in range(len(self.classes)):\n",
    "            for i in Train_Init[classId]:\n",
    "                self.Train_documents.append((classId,i))\n",
    "                self.Train_set.append(self.alldocDict[(classId,i)])\n",
    "\n",
    "        for class_id in self.alldocDict.keys():\n",
    "            if(class_id not in self.Train_documents):\n",
    "                self.Test_documents.append(class_id)\n",
    "\n",
    "        print(\"Number of test documents: \",len(self.Test_documents))\n",
    "        print(\"Number of train documents: \",len(self.Train_documents))\n",
    "        \n",
    "        # index of words in training set(train_set has all the words that are in training set)\n",
    "        self.word_index={}\n",
    "        for doc in range(len(self.Train_set)):\n",
    "            for word in self.Train_set[doc]:\n",
    "                if word not in self.word_index:\n",
    "                    self.word_index[word]={}\n",
    "                    \n",
    "        print(len(self.word_index))\n",
    "\n",
    "        return self.Train_documents, self.Test_documents, self.word_index\n",
    "    \n",
    "    \n",
    "    def tfidfCalculation(self,term_index):\n",
    "        \n",
    "        f = open(\"TFIDFdict_allDocs.txt\",\"w\")\n",
    "        idf={}\n",
    "        for word in term_index.keys():\n",
    "            df=0\n",
    "            for doc in self.alldocDict.keys():\n",
    "                if word in self.alldocDict[doc]:\n",
    "                    df+=1\n",
    "            idf[word]=math.log(len(self.Train_documents)/(df))\n",
    "\n",
    "        for word in term_index.keys():\n",
    "            for doc in self.alldocDict.keys():      \n",
    "                if word in self.alldocDict[doc]:\n",
    "        #             print('word found in ',doc)   \n",
    "                    term_index[word][doc]=((self.alldocDict[doc].count(word))*idf[word])  #calculate tfidf\n",
    "                else:\n",
    "                    term_index[word][doc]=0\n",
    "        f.write(str(term_index))\n",
    "        f.close()\n",
    "        \n",
    "        return term_index\n",
    "    \n",
    "    def formVectors(self,tfidf_dict):\n",
    "\n",
    "        #form train and test vectors\n",
    "        self.trainDoc_vect={}\n",
    "        self.testDoc_vect={}\n",
    "\n",
    "        f1 = open(\"TrainDocs_vector.txt\",\"w\")\n",
    "        f2 = open(\"TestDocs_allDocs.txt\",\"w\")\n",
    "\n",
    "        for docid in self.Train_documents:\n",
    "            self.trainDoc_vect[docid]=[]\n",
    "            for word in tfidf_dict.keys():\n",
    "                self.trainDoc_vect[docid].append(tfidf_dict[word][docid])\n",
    "\n",
    "        for docid in self.Test_documents:\n",
    "            self.testDoc_vect[docid]=[]\n",
    "            for word in tfidf_dict.keys():\n",
    "                self.testDoc_vect[docid].append(tfidf_dict[word][docid])\n",
    "\n",
    "        f1.write(str(self.trainDoc_vect))\n",
    "        f1.close()\n",
    "        f2.write(str(self.testDoc_vect))\n",
    "        f2.close()\n",
    "\n",
    "        return self.trainDoc_vect, self.testDoc_vect\n",
    "    \n",
    "    \n",
    "    def calculateSimilarityAndKNN(self):\n",
    "        self.testsimilarity={}\n",
    "        for testid in self.testDoc_vect:\n",
    "            self.testsimilarity[testid]={}\n",
    "            for trainid in self.trainDoc_vect:\n",
    "                self.testsimilarity[testid][trainid]=(distance.cosine(self.testDoc_vect[testid], self.trainDoc_vect[trainid]))\n",
    "        self.correct=0\n",
    "        self.no=0\n",
    "        self.y=[]\n",
    "        self.yp=[]\n",
    "        for i in self.testsimilarity:\n",
    "            n1,n2,n3=sorted(self.testsimilarity[i], key=self.testsimilarity[i].get)[0:3]\n",
    "            newList=[n1[0],n2[0],n3[0]]\n",
    "            frequentNN=max(set(newList), key = newList.count)\n",
    "            \n",
    "            self.y.append(i[0])\n",
    "            self.yp.append(frequentNN)\n",
    "        \n",
    "            if(i[0]==frequentNN):\n",
    "                self.correct+=1\n",
    "            else:\n",
    "                self.no+=1\n",
    "                \n",
    "    def visualize(self):\n",
    "        plt.plot(range(len(self.y)), self.y, label='Actual Label')\n",
    "        plt.plot(range(len(self.y)), self.yp, label='Predicted Label')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "        plt.savefig('ClassificationResultComparison.png')\n",
    "    \n",
    "    \n",
    "    def getAccuracy(self):\n",
    "        return (self.correct/(self.no+self.correct))*100\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get data from files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "list,classes=getdatafromfile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize class and split data into train and test, in ratio taken through gui, after preprocessing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3\n",
      "Total files in each class:  [101, 124, 265, 147, 100]\n",
      "Number of test documents:  220\n",
      "Number of train documents:  517\n",
      "8014\n"
     ]
    }
   ],
   "source": [
    "# gui for taking train and test ratio input\n",
    "\n",
    "tr=0\n",
    "def get_tr():\n",
    "    root=tk.Tk()\n",
    "    root.geometry(\"400x180\")\n",
    "    root.title('TrainTestRatio')\n",
    "    def clicked():\n",
    "        myLabel2 = tk.Label(root, text=\"The Test ratio is   \"+e.get())\n",
    "        global tr\n",
    "        tr=float(e.get())\n",
    "        trn=str(1-tr)\n",
    "        myLabel2.grid()\n",
    "        myLabel3 = tk.Label(root, text=\"The Train ratio is  \"+trn).grid()\n",
    "        myLabel4 = tk.Label(root, text=\"Please wait!\").grid()\n",
    "        root.after(1000, lambda: root.destroy()) # Destroy the widget after 3 seconds\n",
    "              \n",
    "    tk.Label(root, text=\"Enter The Test Ratio : \",fg=\"white\", bg=\"powder blue\", font=(\"Roboto\",12), relief=\"groove\").grid(row=0,padx=5)\n",
    "\n",
    "    e = tk.Entry(root, font=(\"Ubuntu\",11))\n",
    "    e.grid(row=0,column=1,padx=5)\n",
    "    e.insert(0,'0.3')\n",
    "    \n",
    "    tk.Label(root, text=\"Enter The Train Ratio : \",fg=\"white\", bg=\"powder blue\", font=(\"Roboto\",12), relief=\"groove\").grid(row=1,padx=5,pady=5)\n",
    "\n",
    "    e1 = tk.Entry(root, font=(\"Ubuntu\",11))\n",
    "    e1.grid(row=1,column=1,padx=5,pady=5)\n",
    "    e1.insert(0,'0.7')\n",
    "    \n",
    "    myBtn=tk.Button(root, text=\"Save and submit\", command=clicked)\n",
    "    myBtn.grid(row=2,column=1,pady=5)\n",
    "\n",
    "    tk.mainloop()\n",
    "\n",
    "\n",
    "get_tr() #getting the test ratio\n",
    "print(tr)\n",
    "clf=TextClassificationKNN(list,classes)\n",
    "alldocDict=clf.preprocessData()\n",
    "Train_documents, Test_documents, word_index=clf.SplitTrainTestDocs(tr)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## form document vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidf_dict=clf.tfidfCalculation(word_index)\n",
    "trainVector,testVector=clf.formVectors(tfidf_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## calculate similarity and find K-Nearest Neighbour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf.calculateSimilarityAndKNN()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## get accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99.0909090909091\n"
     ]
    }
   ],
   "source": [
    "#due to random sampling, accuracy will vary between 96-99%\n",
    "\n",
    "print(clf.getAccuracy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf.visualize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}