MachineLearning_K_Nearest_Neighbor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Machine Learning - Assignment 2<h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1157,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from collections import defaultdict, Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Loading the Review Training and Test Data set provided</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1158,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k=1\n",
    "\n",
    "#k = int(input(\"Please input value for K: \"))\n",
    "NumTrainClassLabels1 = 0\n",
    "NumTrainClassLabels0 = 0\n",
    "    \n",
    "TrainingWordsSet = []\n",
    "TrainingClassesSet = []\n",
    "\n",
    "with open(\"reviewstrain.txt\") as fHandler:\n",
    "    for line in fHandler:\n",
    "        rowTokens = line.rstrip(\"\\n\\t\").split(\" \")\n",
    "        \n",
    "        TrainingClassesSet.append(rowTokens[0])\n",
    "        \n",
    "        if rowTokens[0] == '1':\n",
    "            NumTrainClassLabels1 += 1\n",
    "        else:\n",
    "            NumTrainClassLabels0 += 1 \n",
    "        \n",
    "        del rowTokens[0]\n",
    "        \n",
    "        TrainingWordsSet.append(list(set(rowTokens)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Calculating the total label count of 0's and 1's from the Training data set</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total training samples labelled as 0 :  689\n",
      "Total training samples labelled as 1 :  811\n"
     ]
    }
   ],
   "source": [
    "#print(TrainingClassesSet[5])\n",
    "#print(TrainingWordsSet[5])\n",
    "\n",
    "print(\"Total training samples labelled as 0 : \", NumTrainClassLabels0)\n",
    "print(\"Total training samples labelled as 1 : \", NumTrainClassLabels1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1160,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "TestWordsSet = []\n",
    "TestClassesSet = []\n",
    "\n",
    "\n",
    "with open(\"reviewstest.txt\") as fHandler:\n",
    "    for line in fHandler:\n",
    "        rowTokens = line.rstrip(\"\\n\\t\").split(\" \")\n",
    "        \n",
    "        TestClassesSet.append(rowTokens[0])\n",
    "        \n",
    "        del rowTokens[0]\n",
    "        \n",
    "        TestWordsSet.append(list(set(rowTokens)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1161,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#print(TestWordsSet[5])\n",
    "#print(TestClassesSet[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Implementation of the distance function provided in the assignment to calculate the distance of a Test data sample from all the samples in the training set </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1162,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#The below function will calculate the distance for the given test data with each of the sample from the training set\n",
    "#This function will calculate and return an dictiornay with the distance as the index and all the classess that are at that\n",
    "#distance as the value of the dictionary\n",
    "\n",
    "def checkForDistance(ExpectedClass, TestData, TrainingClassSet, TrainingDataSet):\n",
    "    distanceCalcList = defaultdict(list)\n",
    "    \n",
    "    index = 0\n",
    "    \n",
    "    for data in TrainingDataSet:\n",
    "        #print (data, TestData)\n",
    "        matchCount=0\n",
    "        \n",
    "        for word in TestData:\n",
    "            if word in data:\n",
    "                matchCount+=1\n",
    "        \n",
    "        #print(matchCount)\n",
    "        \n",
    "        if (matchCount != 0): \n",
    "            distanceCalcList[1/matchCount].append(int(TrainingClassSet[index]))\n",
    "            \n",
    "        index+=1\n",
    "\n",
    "    return distanceCalcList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>Function to be used to performing k-NN search for the entire test data setbased on the value of K passed</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1163,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def performNearestNeighbourSearchForTest(k):\n",
    "    df = pd.DataFrame(columns=['Expected Class', 'Predicted Class'])\n",
    "    correct = 0\n",
    "    error = 0\n",
    "    index1 = 0 #index to be used as reference for Expected class\n",
    "    FP = 0 #False positive \n",
    "    FN = 0 #False Negative \n",
    "    TP = 0 #True positive\n",
    "    TN = 0 #True Negative\n",
    "    \n",
    "    for testSample in TestWordsSet:\n",
    "        ClassLabel = 0 #Label assigned to the current class\n",
    "\n",
    "        #print(testSample)\n",
    "        DistanceCalc = checkForDistance(TestClassesSet[index1], testSample, TrainingClassesSet, TrainingWordsSet)\n",
    "\n",
    "        sortedKeys = sorted(DistanceCalc) \n",
    "\n",
    "        #print(sortedKeys)\n",
    "        #print(DistanceCalc)\n",
    "\n",
    "        #Instead of doing a direct comparision for all the labels here to check the count of the majority label\n",
    "        #we do another mathematical computation to make it more efficient\n",
    "        # i.e. we knew that if there are 4 labels out of which we have to select the majority and the lables are\n",
    "        #  1 1 1 0 , then we know that the label based on this will be 1 and if the labels as 1 0 0 0 then the label\n",
    "        #  based on this will be zero. Thus, what we do is we calculate the sum of all the labels and divide it by the total number\n",
    "        # Labels i.e we add up 1110 which gives us 3 and divide it by the total number of lables i.e 4 \n",
    "        # thus we get the answer as 3/4 i.e 0.75 based on this we have derived the formula to efficiently calculate it\n",
    "        # and determine that if the mean of all the labels is greater than or equal to 0.5 we assign the label zero,\n",
    "        # otherwise we assign them the label zero\n",
    "            \n",
    "        \n",
    "        #Handling in case if k==1\n",
    "        if (k == 1):\n",
    "            #print(DistanceCalc)\n",
    "            if (len(DistanceCalc[sortedKeys[0]])) > 1:\n",
    "                sumVal = sum(DistanceCalc[sortedKeys[0]])\n",
    "                Mean= sumVal/(len(DistanceCalc[sortedKeys[0]]))\n",
    "\n",
    "                if Mean >= 0.5:\n",
    "                    ClassLabel = 1\n",
    "                else:\n",
    "                    ClassLabel = 0\n",
    "            else:\n",
    "                ClassLabel = DistanceCalc[sortedKeys[0]][0]\n",
    "                \n",
    "        else:\n",
    "            \n",
    "            #Handle condition for value of K more than 2\n",
    "            NN = k\n",
    "            TotalNN = 0\n",
    "            sumVal = 0\n",
    "            \n",
    "            for key in sortedKeys:\n",
    "                \n",
    "                if (len(DistanceCalc[key])) > 1:\n",
    "                    sumVal += sum(DistanceCalc[key])\n",
    "                    TotalNN += len(DistanceCalc[key])\n",
    "                else:\n",
    "                    sumVal += DistanceCalc[key][0]\n",
    "                    TotalNN += 1\n",
    "                    \n",
    "                NN = NN-len(DistanceCalc[key])\n",
    "                \n",
    "                if NN <= 0:\n",
    "                    #print(NN)\n",
    "                    break\n",
    "            \n",
    "            Mean = sumVal/TotalNN\n",
    "            \n",
    "            if Mean >= 0.5:\n",
    "                ClassLabel = 1\n",
    "            else:\n",
    "                ClassLabel = 0\n",
    "                \n",
    "            #print(Mean, \" \", sumVal, \" \", TotalNN, \" \", ClassLabel)\n",
    "                    \n",
    "        LabelList = [int(TestClassesSet[index1]), ClassLabel]\n",
    "        \n",
    "        #print(LabelList, index1)\n",
    "        tempVal = int(TestClassesSet[index1])\n",
    "        if (tempVal == ClassLabel):\n",
    "            correct+=1\n",
    "        else:\n",
    "            error+=1\n",
    "        \n",
    "        if (tempVal == 1):\n",
    "            if (ClassLabel == 1):\n",
    "                TP += 1\n",
    "            else:\n",
    "                FN += 1\n",
    "        else:\n",
    "            if (ClassLabel == 0):\n",
    "                TN += 1\n",
    "            else:\n",
    "                FP+=1\n",
    "                \n",
    "        \n",
    "        df.loc[len(df)] = LabelList  \n",
    "        \n",
    "        #print(\"ClassLabel \", ClassLabel, TestClassesSet[index])\n",
    "        \n",
    "        index1 += 1 \n",
    "        #print(\"index 1 \", index1)\n",
    "    \n",
    "    print(correct, \" \", error)\n",
    "    \n",
    "    return df, TP, FN, TN, FP\n",
    "    "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Performing Nearest neighbour search for k=1</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "302   198\n"
     ]
    }
   ],
   "source": [
    "k=1 # set the value for nearest neighbour for k=1\n",
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTest(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True  Positive :  209\n",
      "True  Negative :  93\n",
      "False Negative :  64\n",
      "False Positive :  134\n",
      "True positive rate for k=1 is  0.7655677655677655\n",
      "False positive rate for k=1 is  0.5903083700440529\n",
      "Accuracy for k=1 is  60.4 %\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Expected Class</th>\n",
       "      <th>Predicted Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Expected Class Predicted Class\n",
       "0               1               1\n",
       "1               1               0\n",
       "2               1               1\n",
       "3               0               1\n",
       "4               0               0\n",
       "5               0               0\n",
       "6               1               1\n",
       "7               1               1\n",
       "8               0               0\n",
       "9               1               1\n",
       "10              1               0\n",
       "11              0               1\n",
       "12              1               1\n",
       "13              1               1\n",
       "14              1               1\n",
       "15              1               1\n",
       "16              1               1\n",
       "17              1               1\n",
       "18              0               0\n",
       "19              1               1"
      ]
     },
     "execution_count": 1165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "#Calculate the True Positive rate for k=1\n",
    "print(\"True positive rate for k=1 is \", TP/(TP+FN))\n",
    "\n",
    "#Calculate the False positive rate for k=1\n",
    "print(\"False positive rate for k=1 is \", FP/(FP+TN))\n",
    "\n",
    "#Calculate the accuracy for k=1\n",
    "print(\"Accuracy for k=1 is \", ((TP+TN)/(TP+TN+FP+FN)) * 100, \"%\")\n",
    "\n",
    "df.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Performing Nearest neighbour algorithm for k=5</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "303   197\n",
      "True  Positive :  212\n",
      "True  Negative :  91\n",
      "False Negative :  61\n",
      "False Positive :  136\n",
      "True positive rate for k=5 is  0.7765567765567766\n",
      "False positive rate for k=5 is  0.5991189427312775\n",
      "Accuracy for k=5 is  60.6 %\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Expected Class</th>\n",
       "      <th>Predicted Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Expected Class Predicted Class\n",
       "0               1               1\n",
       "1               1               0\n",
       "2               1               1\n",
       "3               0               1\n",
       "4               0               0\n",
       "5               0               0\n",
       "6               1               1\n",
       "7               1               1\n",
       "8               0               0\n",
       "9               1               1\n",
       "10              1               0\n",
       "11              0               1\n",
       "12              1               1\n",
       "13              1               1\n",
       "14              1               1\n",
       "15              1               1\n",
       "16              1               1\n",
       "17              1               1\n",
       "18              0               0\n",
       "19              1               1"
      ]
     },
     "execution_count": 1166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=5 # set the value for nearest neighbour for k=5\n",
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTest(k)\n",
    "\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "#Calculate the True Positive rate for k=5\n",
    "print(\"True positive rate for k=5 is \", TP/(TP+FN))\n",
    "\n",
    "#Calculate the False positive rate for k=5\n",
    "print(\"False positive rate for k=5 is \", FP/(FP+TN))\n",
    "\n",
    "#Calculate the accuracy for k=5\n",
    "print(\"Accuracy for k=5 is \", ((TP+TN)/(TP+TN+FP+FN)) * 100, \"%\")\n",
    "\n",
    "df.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Perform Zero-R Algorithm analysis for Predictions</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1167,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def performZeroRAlogPredictions(TestClassesSet):\n",
    "    ClassLabel = 0\n",
    "    TP = 0\n",
    "    TN = 0\n",
    "    FP = 0\n",
    "    FN = 0\n",
    "    Correct = 0\n",
    "    Error = 0\n",
    "    \n",
    "    \n",
    "    if NumTrainClassLabels1 >= NumTrainClassLabels0:\n",
    "        ClassLabel = 1\n",
    "    else:\n",
    "        ClassLabel = 0\n",
    "        \n",
    "    print(\"Class Label \", ClassLabel)\n",
    "    \n",
    "    for val in TestClassesSet:\n",
    "        Label = int(val)\n",
    "        \n",
    "        if ClassLabel==Label:\n",
    "            Correct+=1\n",
    "        else:\n",
    "            Error+=1\n",
    "        \n",
    "        if (Label == 1):\n",
    "            if (ClassLabel == 1):\n",
    "                TP += 1\n",
    "            else:\n",
    "                FN += 1\n",
    "        else:\n",
    "            if (ClassLabel == 0):\n",
    "                TN += 1\n",
    "            else:\n",
    "                FP+=1\n",
    "\n",
    "    return Correct,Error,TP,TN,FP,FN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class Label  1\n",
      "Correct predictions : 273\n",
      "Error predictions : 227\n",
      "True  Positive :  273\n",
      "True  Negative :  0\n",
      "False Negative :  0\n",
      "False Positive :  227\n"
     ]
    }
   ],
   "source": [
    "Correct,Error,TP,TN,FP,FN = performZeroRAlogPredictions(TestClassesSet)\n",
    "\n",
    "print(\"Correct predictions :\", Correct)\n",
    "print(\"Error predictions :\", Error)\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Performing Cross-Validation</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1169,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def performNearestNeighbourSearchForTestCV(TrainingData, TrainingClass, TestData, TestClassSet, results):\n",
    "    correct = 0\n",
    "    error = 0\n",
    "    index1 = 0 #index to be used as reference for Expected class\n",
    "    \n",
    "    for testSample in TestData:\n",
    "        ClassLabel = 0 #Label assigned to the current class\n",
    "\n",
    "        DistanceCalc = checkForDistance(TestClassSet[index1], testSample, TrainingClass, TrainingData)\n",
    "\n",
    "        sortedKeys = sorted(DistanceCalc)\n",
    "        \n",
    "        #Handling in case if k==1\n",
    "        for k in results:\n",
    "            #Handle condition for value of K more than 2\n",
    "            NN = k\n",
    "            TotalNN = 0\n",
    "            sumVal = 0\n",
    "\n",
    "            for key in sortedKeys:\n",
    "\n",
    "                if (len(DistanceCalc[key])) > 1:\n",
    "                    sumVal += sum(DistanceCalc[key])\n",
    "                    TotalNN += len(DistanceCalc[key])\n",
    "                else:\n",
    "                    sumVal += DistanceCalc[key][0]\n",
    "                    TotalNN += 1\n",
    "\n",
    "                NN = NN-len(DistanceCalc[key])\n",
    "\n",
    "                if NN <= 0:\n",
    "                    #print(NN)\n",
    "                    break\n",
    "\n",
    "            Mean = sumVal/TotalNN\n",
    "\n",
    "            if Mean >= 0.5:\n",
    "                ClassLabel = 1\n",
    "            else:\n",
    "                ClassLabel = 0\n",
    "                \n",
    "            if (int(TestClassSet[index1]) == ClassLabel):\n",
    "                results[k][\"correct\"]+=1\n",
    "                correct+=1\n",
    "            else:\n",
    "                results[k][\"error\"]+=1\n",
    "                error+=1\n",
    "        \n",
    "        index1 += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1170,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def performTestingForCrossValidation(TrainingData, TrainingClass, TestData, TestClassSet, results):\n",
    "    performNearestNeighbourSearchForTestCV(TrainingData, TrainingClass, TestData, TestClassSet, results)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1171,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Function to peform 5 fold cross validation\n",
    "def performCrossValidationForTraining(TrainingWordsData, TrainingClassesData):\n",
    "    results = {3:{\"correct\" : 0, \"error\" : 0}, 7:{\"correct\" : 0, \"error\" : 0}, 99:{\"correct\" : 0, \"error\" : 0}}\n",
    "    \n",
    "    for indexVal in range(0, 1500, 300):\n",
    "        RangeVal = indexVal + 300\n",
    "        \n",
    "        TempTestSet = TrainingWordsData[indexVal: RangeVal]  \n",
    "        TempTestClassesSet = TrainingClassesData[indexVal : RangeVal]\n",
    "        \n",
    "        TempTrainingSet = list(TrainingWordsData)\n",
    "        TempClassesSet = list(TrainingClassesData)\n",
    "            \n",
    "        del TempTrainingSet[indexVal:RangeVal]\n",
    "        del TempClassesSet[indexVal:RangeVal]\n",
    "    \n",
    "        \n",
    "        performTestingForCrossValidation(TempTrainingSet, TempClassesSet, TempTestSet, TempTestClassesSet, results)\n",
    "    \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results obtained for different values of K after cross-validation {3: {'correct': 991, 'error': 509}, 7: {'correct': 988, 'error': 512}, 99: {'correct': 919, 'error': 581}}\n"
     ]
    }
   ],
   "source": [
    "results = performCrossValidationForTraining(TrainingWordsSet, TrainingClassesSet)\n",
    "\n",
    "print(\"Results obtained for different values of K after cross-validation\", results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for k =3  66.06666666666666 %\n",
      "Accuracy for k =7  65.86666666666666 %\n",
      "Accuracy for k = 99  61.266666666666666 %\n"
     ]
    }
   ],
   "source": [
    "#Calculating the accuracy for different values of  k i.e 3,7,99 using cross validation\n",
    "#Accuracy for K=3\n",
    "print(\"Accuracy for k =3 \", (results[3]['correct']/1500)*100, \"%\")\n",
    "\n",
    "#Accuracy for K=7\n",
    "print(\"Accuracy for k =7 \", (results[7]['correct']/1500)*100, \"%\")\n",
    "\n",
    "#Accuracy for K=99\n",
    "print(\"Accuracy for k = 99 \", (results[99]['correct']/1500)*100, \"%\")\n",
    "\n",
    "#We fetch the value of k for which we have obtainend the maximum accuracy\n",
    "currentMaxVal=0\n",
    "currentValofK=0\n",
    "\n",
    "for k in results:\n",
    "    if results[k][\"correct\"] > currentMaxVal:\n",
    "        currentMaxVal = results[k][\"correct\"]\n",
    "        currentValofK = k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "991 3\n"
     ]
    }
   ],
   "source": [
    "print (currentMaxVal, currentValofK)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "295   205\n",
      "Analysis for the Test data set using the value of K obtained after cross validation of training dataset\n",
      "True  Positive :  212\n",
      "True  Negative :  83\n",
      "False Negative :  61\n",
      "False Positive :  144\n",
      "Accuracy for current value of K with maximum accuracy in cross validation is  59.0 %\n"
     ]
    }
   ],
   "source": [
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTest(currentValofK)\n",
    "print(\"Analysis for the Test data set using the value of K obtained after cross validation of training dataset\")\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "#calculate the accuracy for k=3 for the entire training set\n",
    "print(\"Accuracy for current value of K with maximum accuracy in cross validation is \", ((TP+TN)/500)*100, \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Custom distance function - Using Jaccard Distance function</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1176,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#implementing jaccard\n",
    "#version1\n",
    "def jaccard(TrainDataSet, TestDataSet):\n",
    "    InterSecSet = TrainDataSet.intersection(TestDataSet)\n",
    "    return 1-float(len(InterSecSet)) / (len(TrainDataSet) + len(TestDataSet) - len(InterSecSet))\n",
    "\n",
    "#version2\n",
    "def DistJaccard(TrainDataSet, TestDataSet):\n",
    "    return 1-float(len(TrainDataSet & TestDataSet)) / len(TrainDataSet | TestDataSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Function to calculate distance between any given test data with all the training samples based on the custom distance function to be used </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1177,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def getDistanceUsingCustomDistanceFunction(TestData, TrainingClassSet, TrainingDataSet, distanceFunctionToBeUsed='default'):\n",
    "    distanceCalcList = defaultdict(list)\n",
    "    \n",
    "    index = 0\n",
    "    \n",
    "    for data in TrainingDataSet:\n",
    "        \n",
    "        if (distanceFunctionToBeUsed == 'jaccard'):\n",
    "            distance = DistJaccard(set(data), set(TestData))\n",
    "            distanceCalcList[distance].append(int(TrainingClassSet[index]))\n",
    "        else:\n",
    "            matchCount=0\n",
    "\n",
    "            for word in TestData:\n",
    "                if word in data:\n",
    "                    matchCount+=1\n",
    "\n",
    "            if (matchCount != 0): \n",
    "                distanceCalcList[1/matchCount].append(int(TrainingClassSet[index]))\n",
    "            \n",
    "        index+=1\n",
    "\n",
    "    return distanceCalcList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1178,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def performNearestNeighbourSearchForTestForCustomDistFunc(k, distanceFuncType='default'):\n",
    "    print(\"using function type \", distanceFuncType)\n",
    "    df = pd.DataFrame(columns=['Expected Class', 'Predicted Class'])\n",
    "    correct = 0\n",
    "    error = 0\n",
    "    index1 = 0 #index to be used as reference for Expected class\n",
    "    FP = 0 #False positive \n",
    "    FN = 0 #False Negative \n",
    "    TP = 0 #True positive\n",
    "    TN = 0 #True Negative\n",
    "    \n",
    "    for testSample in TestWordsSet:\n",
    "        ClassLabel = 0 #Label assigned to the current class\n",
    "\n",
    "        DistanceCalc = getDistanceUsingCustomDistanceFunction(testSample, TrainingClassesSet, TrainingWordsSet, distanceFuncType)\n",
    "\n",
    "        sortedKeys = sorted(DistanceCalc) \n",
    "\n",
    "        #Handling in case if k==1\n",
    "        if (k == 1):\n",
    "            if (len(DistanceCalc[sortedKeys[0]])) > 1:\n",
    "                sumVal = sum(DistanceCalc[sortedKeys[0]])\n",
    "                Mean= sumVal/(len(DistanceCalc[sortedKeys[0]]))\n",
    "\n",
    "                if Mean >= 0.5:\n",
    "                    ClassLabel = 1\n",
    "                else:\n",
    "                    ClassLabel = 0\n",
    "            else:\n",
    "                ClassLabel = DistanceCalc[sortedKeys[0]][0]\n",
    "        else:\n",
    "            \n",
    "            #Handle condition for value of K more than 2\n",
    "            NN = k\n",
    "            TotalNN = 0\n",
    "            sumVal = 0\n",
    "            \n",
    "            for key in sortedKeys:\n",
    "                \n",
    "                if (len(DistanceCalc[key])) > 1:\n",
    "                    sumVal += sum(DistanceCalc[key])\n",
    "                    TotalNN += len(DistanceCalc[key])\n",
    "                else:\n",
    "                    sumVal += DistanceCalc[key][0]\n",
    "                    TotalNN += 1\n",
    "                    \n",
    "                NN = NN-len(DistanceCalc[key])\n",
    "                \n",
    "                if NN <= 0:\n",
    "                    #print(NN)\n",
    "                    break\n",
    "            \n",
    "            Mean = sumVal/TotalNN\n",
    "            \n",
    "            if Mean >= 0.5:\n",
    "                ClassLabel = 1\n",
    "            else:\n",
    "                ClassLabel = 0\n",
    "                    \n",
    "        LabelList = [int(TestClassesSet[index1]), ClassLabel]\n",
    "        \n",
    "        tempVal = int(TestClassesSet[index1])\n",
    "        if (tempVal == ClassLabel):\n",
    "            correct+=1\n",
    "        else:\n",
    "            error+=1\n",
    "        \n",
    "        if (tempVal == 1):\n",
    "            if (ClassLabel == 1):\n",
    "                TP += 1\n",
    "            else:\n",
    "                FN += 1\n",
    "        else:\n",
    "            if (ClassLabel == 0):\n",
    "                TN += 1\n",
    "            else:\n",
    "                FP+=1\n",
    "                \n",
    "        \n",
    "        df.loc[len(df)] = LabelList\n",
    "        \n",
    "        index1 += 1 \n",
    "    \n",
    "    print(correct, \" \", error)\n",
    "    \n",
    "    return df, TP, FN, TN, FP\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>Performing K-NN for test set using Custom distance function i.e. Jaccard distance function</h2>\n",
    "\n",
    "<h3> For k=1 </h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using function type  jaccard\n",
      "321   179\n",
      "True  Positive :  206\n",
      "True  Negative :  115\n",
      "False Negative :  67\n",
      "False Positive :  112\n",
      "True positive rate for k=1 is  0.7545787545787546\n",
      "False positive rate for k=1 is  0.4933920704845815\n",
      "Accuracy for k=1 is  64.2 %\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Expected Class</th>\n",
       "      <th>Predicted Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Expected Class Predicted Class\n",
       "0               1               1\n",
       "1               1               0\n",
       "2               1               1\n",
       "3               0               0\n",
       "4               0               0\n",
       "5               0               1\n",
       "6               1               1\n",
       "7               1               0\n",
       "8               0               1\n",
       "9               1               1\n",
       "10              1               1\n",
       "11              0               0\n",
       "12              1               0\n",
       "13              1               1\n",
       "14              1               1\n",
       "15              1               1\n",
       "16              1               1\n",
       "17              1               1\n",
       "18              0               0\n",
       "19              1               1"
      ]
     },
     "execution_count": 1179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=1\n",
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTestForCustomDistFunc(k, 'jaccard')\n",
    "\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "#Calculate the True Positive rate for k=1\n",
    "print(\"True positive rate for k=1 is \", TP/(TP+FN))\n",
    "\n",
    "#Calculate the False positive rate for k=1\n",
    "print(\"False positive rate for k=1 is \", FP/(FP+TN))\n",
    "\n",
    "#Calculate the accuracy for k=1\n",
    "print(\"Accuracy for k=1 is \", ((TP+TN)/(TP+TN+FP+FN)) * 100, \"%\")\n",
    "\n",
    "df.head(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> For k=5 </h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using function type  jaccard\n",
      "334   166\n",
      "True  Positive :  220\n",
      "True  Negative :  114\n",
      "False Negative :  53\n",
      "False Positive :  113\n",
      "True positive rate for k=5 is  0.8058608058608059\n",
      "False positive rate for k=5 is  0.4977973568281938\n",
      "Accuracy for k=5 is  66.8 %\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Expected Class</th>\n",
       "      <th>Predicted Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Expected Class Predicted Class\n",
       "0               1               1\n",
       "1               1               1\n",
       "2               1               1\n",
       "3               0               0\n",
       "4               0               1\n",
       "5               0               1\n",
       "6               1               1\n",
       "7               1               1\n",
       "8               0               1\n",
       "9               1               1\n",
       "10              1               1\n",
       "11              0               0\n",
       "12              1               0\n",
       "13              1               1\n",
       "14              1               1\n",
       "15              1               1\n",
       "16              1               1\n",
       "17              1               1\n",
       "18              0               0\n",
       "19              1               1"
      ]
     },
     "execution_count": 1180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=5\n",
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTestForCustomDistFunc(k, 'jaccard')\n",
    "\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "#Calculate the True Positive rate for k=5\n",
    "print(\"True positive rate for k=5 is \", TP/(TP+FN))\n",
    "\n",
    "#Calculate the False positive rate for k=5\n",
    "print(\"False positive rate for k=5 is \", FP/(FP+TN))\n",
    "\n",
    "#Calculate the accuracy for k=5\n",
    "print(\"Accuracy for k=5 is \", ((TP+TN)/(TP+TN+FP+FN)) * 100, \"%\")\n",
    "\n",
    "df.head(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Using Custom input for selecting any given value of K and selecting the distance function required (i.e Either the default function or using the Custom distance function i.e. Jaccard)</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input value for K: 1\n",
      "Please select Func type (1 -> jaccard, 2 -> default): 2\n",
      "using function type  default\n",
      "302   198\n",
      "True  Positive :  209\n",
      "True  Negative :  93\n",
      "False Negative :  64\n",
      "False Positive :  134\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Expected Class</th>\n",
       "      <th>Predicted Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Expected Class Predicted Class\n",
       "0              1               1\n",
       "1              1               0\n",
       "2              1               1\n",
       "3              0               1\n",
       "4              0               0"
      ]
     },
     "execution_count": 1155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=1\n",
    "funcType=1\n",
    "func='jaccard'\n",
    "\n",
    "k = int(input(\"Please input value for K: \"))\n",
    "funcType = int(input(\"Please select Func type (1 -> jaccard, 2 -> default): \"))\n",
    "\n",
    "if (funcType == 1):\n",
    "    func = 'jaccard'\n",
    "else:\n",
    "    func = 'default'\n",
    "\n",
    "df, TP, FN, TN, FP = performNearestNeighbourSearchForTestForCustomDistFunc(k, func)\n",
    "\n",
    "print(\"True  Positive : \", TP)\n",
    "print(\"True  Negative : \", TN)\n",
    "print(\"False Negative : \", FN)\n",
    "print(\"False Positive : \", FP)\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}