VishawjeetJyoti_CSE_NaiveBayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "777cee48",
   "metadata": {},
   "source": [
    "# START"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba5ecbda",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "957a3072",
   "metadata": {},
   "outputs": [],
   "source": [
    "data= pd.read_csv(\"A_Z Handwritten Data.csv\") #Reading the file and making a pandas dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "452e86b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(372450, 785)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape #printing the number of rows and columns in our Dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e26919ef",
   "metadata": {},
   "source": [
    "SPLITTING THE DATA INTO TRAIN AND TEST SET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "48db3ae7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split #importing the train_test_split function to split the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5ae83965",
   "metadata": {},
   "outputs": [],
   "source": [
    "letterVal = data.iloc[:,[0]].copy() #Storing the Data of Letters in letterVal. This is the output which is expected\n",
    "data=data.drop(data.columns[0],axis=1) #Dropping the expected output columns from data. Now data stores the features (Pixels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "030fe4c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(372450, 784)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5caabb20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(372450, 1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letterVal.shape "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ef5ee1",
   "metadata": {},
   "source": [
    "# Training the Model:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a57cf5",
   "metadata": {},
   "source": [
    "# Splitting the data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "92144a87",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, Y_train, Y_test =train_test_split(data,letterVal,test_size=0.1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "de865c2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(335205, 784)\n",
      "(37245, 784)\n",
      "(335205, 1)\n",
      "(37245, 1)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "print(Y_train.shape)\n",
    "print(Y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "94e7e5e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "forPrior = Y_train.copy() #Creating a separate dataframe to work on, so that the original value is not modified in the process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eaed6889",
   "metadata": {},
   "outputs": [],
   "source": [
    "numCount = np.ones(26) #creating an array of size 26, which will store the number of occurrence of each letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dde768a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12562.  7809. 21121.  9091. 10319.  1044.  5231.  6485.  1007.  7596.\n",
      "  5001. 10434. 11067. 17055. 52050. 17412.  5244. 10378. 43664. 20223.\n",
      " 26081.  3772.  9699.  5602.  9773.  5485.]\n"
     ]
    }
   ],
   "source": [
    "n=0\n",
    "while(n<26):\n",
    "    numCount[n]=forPrior.value_counts()[n]\n",
    "    n=n+1\n",
    "print(numCount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "34b5d10e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "335205"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len2=forPrior.shape[0]\n",
    "len2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f25344f",
   "metadata": {},
   "source": [
    "# Finding Prior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c43b4cd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.03747557 0.02329619 0.0630092  0.02712072 0.03078415 0.00311451\n",
      " 0.01560538 0.01934637 0.00300413 0.02266076 0.01491923 0.03112722\n",
      " 0.03301562 0.05087931 0.15527811 0.05194433 0.01564416 0.03096016\n",
      " 0.13026059 0.06033025 0.07780612 0.01125282 0.02893453 0.01671216\n",
      " 0.02915529 0.01636312]\n"
     ]
    }
   ],
   "source": [
    "prior=np.ones(26)\n",
    "n=0\n",
    "while(n<26):\n",
    "    prior[n]=numCount[n]/len2\n",
    "    n=n+1\n",
    "print(prior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9543e7c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = X_train.to_numpy(None,True) #True means that we are making a copy of X_train, so that any updation on arr doesn't change \n",
    "#values in X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ab50c8c",
   "metadata": {},
   "source": [
    "# Scaling down the multinomial into binomial"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a348b25d",
   "metadata": {},
   "source": [
    "The count0 array is of size 26x784, where 26 is the number of rows, each row representing a letter, and 784 columns represents the 784 pixels of an image. This array stores the number of times 0 occurs for a pixel number of a letter.\n",
    "For instance count0[0][0] would store the number of times the 0th pixel of letter A was 0, out of the total number of time letter A occured in the data set :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d3c06ea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "count0=np.zeros([26,784])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "334d804d",
   "metadata": {},
   "source": [
    "Scaling down and Counting the number of zeros: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "332e1dab",
   "metadata": {},
   "outputs": [],
   "source": [
    "rows=len(arr)\n",
    "columns=len(arr[0])\n",
    "r=0\n",
    "while(r<rows):\n",
    "    c=0\n",
    "    while(c<columns):\n",
    "        if(arr[r][c]<128):\n",
    "            arr[r][c]=0\n",
    "        else:\n",
    "            arr[r][c]=1\n",
    "            \n",
    "        if(arr[r][c]==0): \n",
    "            x=Y_train.iloc[r,0] #since this cell is zero, we find which number this row corresponds to\n",
    "            count0[x][c]=count0[x][c]+1 #now X stores the letter for which we found a 0, so we increase the count of the \n",
    "            #corresponding cell in count0 array.\n",
    "        c=c+1\n",
    "    r=r+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cac8eadc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#n=0\n",
    "#while(n<rows):\n",
    "#    c=0\n",
    "#    while(c<columns):\n",
    "        \n",
    "        \n",
    "#        c=c+1\n",
    " #   n=n+1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ef9f060f",
   "metadata": {},
   "outputs": [],
   "source": [
    "count1=np.zeros([26,784]) #like count0, this array will store the number of occurences of 1 for a pixel of a particular image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1ed5763",
   "metadata": {},
   "source": [
    "# Smoothing"
   ]
  },
  {
   "cell_type": "raw",
   "id": "29349ae8",
   "metadata": {},
   "source": [
    "Since there are some images for which some pixels are always 0 or always 1. and hence the count0 and count1 array will contain some cells which is equal to the total number of occurrences of that letter.\n",
    "This may cause divide by 0 error when we try to find the log of the conditional probability of each pixels, as the conditional probability of such a pixel being 1 (or 0) will turn out to be 0. \n",
    "So, to deal with such situations, we deliberately decrease the count of such cells by 1, so that the conditional probability doesn't turn out to be 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "05ed5c0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "c=0\n",
    "r=0\n",
    "flag=0\n",
    "while(r<26):\n",
    "    c=0\n",
    "    while(c<784):\n",
    "        if(count0[r][c]==numCount[r]): #if number of occurences of 0 for a pixel is same as the number of times that letter appeared\n",
    "            count0[r][c]=numCount[r]-1 #we decrease the count by 1\n",
    "        c=c+1\n",
    "    r=r+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6825a836",
   "metadata": {},
   "source": [
    "Finding the number of times 1 appeared for a pixel: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "72fa909f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12561.0\n"
     ]
    }
   ],
   "source": [
    "print(count0[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f320e81a",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0\n",
    "c=0\n",
    "while(n<26):\n",
    "    c=0\n",
    "    while(c<784):\n",
    "        count1[n][c]=numCount[n]-count0[n][c] #subtracting number of times 0 appeared from total number of times the letter appeared\n",
    "        c=c+1\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "729bd30f",
   "metadata": {},
   "source": [
    "# Finding conditional probabilities of a pixel being 1 or 0 given a letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "44fbf6f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(count1[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "69945cdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "conditional0=np.zeros([26,784])  #a 2D array which will store the conditional probability of a cell being 0 given that a letter appeared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "acf32bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n=0\n",
    "while(n<26):\n",
    "    c=0\n",
    "    while(c<784):\n",
    "        conditional0[n][c]=count0[n][c]/numCount[n]\n",
    "        c=c+1\n",
    "    n=n+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "245dfb43",
   "metadata": {},
   "outputs": [],
   "source": [
    "conditional1 = np.zeros([26,784]) #a 2D array which will store the conditional probability of a cell being 1 given that a letter appeared"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "868a6444",
   "metadata": {},
   "source": [
    "Finding the conditional probability of a pixel being 1 given that letter 'n' has occured:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "532cf442",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0\n",
    "while(n<26):\n",
    "    c=0\n",
    "    while(c<784):\n",
    "        conditional1[n][c]=count1[n][c]/numCount[n]\n",
    "        c=c+1\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f8624880",
   "metadata": {},
   "outputs": [],
   "source": [
    "logconditional1=np.log(conditional1) #creating an array from conditional1, storing the log values of corresponding values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d6556128",
   "metadata": {},
   "outputs": [],
   "source": [
    "logprior=np.log(prior) #creating an array from prior, storing the log values of correponding values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e87f4260",
   "metadata": {},
   "outputs": [],
   "source": [
    "logconditional0=np.log(conditional0) #creating an array from conditional, storing the log values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d3edeb2",
   "metadata": {},
   "source": [
    "# Testing our Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4704fd01",
   "metadata": {},
   "source": [
    "NOTE: we don't need to find the total probability because basically (a/b > c/b) is same as (a>b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae69437d",
   "metadata": {},
   "source": [
    "Defining a function for finding the probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d76f2e9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def findprob(a,k): # 'a' is the data point of size 784, containing the features using which we have to find the probability\n",
    "    #of 'a' representing letter 'k'\n",
    "    n=0\n",
    "    x=0\n",
    "    while(n<784):\n",
    "        if(a[n]==0): #if the current feature is 0\n",
    "            x=x+logconditional0[k][n] #since we are multiplying the log values, and in log, log(a*b)=log(a)+log(b)\n",
    "#in the previous line, logconditional contains the conditional probability of a cell being 0\n",
    "        elif(a[n]==1): #if the current feature is 1\n",
    "            x=x+logconditional1[k][n]\n",
    "#in the previous line, logconditonal1 contains the condtionl probability of a cell being 1           \n",
    "        n=n+1\n",
    "    \n",
    "    x=x+logprior[k] #adding the prior probability of k\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9174f44",
   "metadata": {},
   "source": [
    "Defining a function forall() which will take a datapoint and find the probabilities of the data point representing letters A to Z:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "88de55a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def forall(X): #X is the data point (features) of size 784 pixels\n",
    "    prob1=np.zeros(26) #creating an array of size 26, which will store the probabilities of the data point X representing the\n",
    "    #letters A to Z, stored in the corresponding indexes 0 to 25\n",
    "    n=0\n",
    "    while(n<26): \n",
    "        prob1[n]=findprob(X,n) #calling the findprob function and passing the data point and the letter represented by n\n",
    "        n=n+1\n",
    "        \n",
    "    return pd.Series(prob1).idxmax() #will return the index of the maximum value stored in the array prob1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "463f7b98",
   "metadata": {},
   "source": [
    "Creating the copy of the Test Data, so that we don't end up modifying the data of our test data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5b5fefc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "testarr=X_test.to_numpy(None,copy=True) #testarr is a 2-D array of size same as our X_test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "519be39a",
   "metadata": {},
   "source": [
    "Now, before running the algorithm on our testarr, we have to scale down the features into binomial, i.e. 0 for feature being less than 128 and 1 otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "105c1b34",
   "metadata": {},
   "outputs": [],
   "source": [
    "numRow=testarr.shape[0]\n",
    "numCol=testarr.shape[1]\n",
    "n=0\n",
    "c=0\n",
    "while(n<numRow):\n",
    "    c=0\n",
    "    while(c<numCol):\n",
    "        if(testarr[n][c]<128):\n",
    "            testarr[n][c]=0\n",
    "        else:\n",
    "            testarr[n][c]=1\n",
    "        c=c+1\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fabc794f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(37245, 784)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testarr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1508c1f",
   "metadata": {},
   "source": [
    "# Passing the Test data set to our algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b8bab6a",
   "metadata": {},
   "source": [
    "op is an array of same size as the size of test data set, it will store the output values of the corresponding feature of the test data, and later on we will compare the values of op with the Y_test data set, which stores the actual output of the corrensponding features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5f26e601",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n=0\n",
    "Predicted_OP=np.zeros(37245)\n",
    "vec=np.zeros(784) #vec will store the 784 features of the 'n'th data point and we will pass this to our function forall\n",
    "while(n<37245):\n",
    "    vec=testarr[n].copy() #copying the features of our n'th data point in vec\n",
    "    Predicted_OP[n]=forall(vec)\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00fc79d9",
   "metadata": {},
   "source": [
    "# Performance analysis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "75599563",
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix=np.zeros([26,26]) #creating a confusion_matrix\n",
    "count=0\n",
    "n=0\n",
    "while(n<Y_test.shape[0]):\n",
    "    x=int(Y_test.iloc[n,0])\n",
    "    y=int(Predicted_OP[n])\n",
    "    confusion_matrix[x,y]+=1\n",
    "    if(Predicted_OP[n]==Y_test.iloc[n,0]):\n",
    "        count=count+1 #if our predicted output and actual output is same, increase the count value by 1\n",
    "    n=n+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "57643bf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix=confusion_matrix.astype(int) #converting the confusion matrix into values of int, \n",
    "#so that we don't get output in Scientific notations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca3f163f",
   "metadata": {},
   "source": [
    "# Printing the Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9a81d794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 929   21    0    0    3    0   12   60    0    3    8    0   59   44\n",
      "     1   17   20   37    0    0    2    0   15   42   34    0]\n",
      " [  30  610    5   23   20    0    9   13    1   24    1    2    9    9\n",
      "    25   10    5    7   16    0    0    0    2    4   14   20]\n",
      " [   1   28 1601    3   86    6   33    4    0   18   30   97   28   20\n",
      "   131   52   17    6    0   13   32    0   66    0   11    5]\n",
      " [  12   45    4  725    1    0    0    1    0   55    0    9    6    8\n",
      "    93   11   11    0   11    1   20    0   12    0    3   15]\n",
      " [  17   45   38    0  659   10   29    0    3    3   80   60   12   20\n",
      "     5   37    3   51   11   12    4    0    5    2    9    6]\n",
      " [   0    0    0    0    6  102    0    0    0    1    0    0    0    0\n",
      "     0    8    0    0    0    1    0    0    0    0    1    0]\n",
      " [   2   11   10    2   12    0  382    1    0    3    1    5    4    3\n",
      "     7    2   42    3   20    1    9    1    7    0    2    1]\n",
      " [  44   11    0    0    0    0    4  404    0    2    5    0   20  123\n",
      "     0   10    1   12    0    0   20    0   23   21   33    0]\n",
      " [   0    0    0    0    0    0    0    0   95    6    0    0    0    0\n",
      "     0    1    0    0    3    7    0    0    0    1    0    0]\n",
      " [   0   19    2   26    3    1    0    0   67  526    2    2    2    0\n",
      "     1    1    2    1   20  128   38    6   13    1   33    3]\n",
      " [   7    1    4    0    4    0    0   10    0    0  409   22   10   18\n",
      "     1    6    1   44    0    2    0    4    8   33   16    2]\n",
      " [   5    0   30    1    2    0    1    0   36    7   14  827    0    6\n",
      "     1    0    0    1    0    1   43    0   21   23   68   65]\n",
      " [  35    1    0    0    0    0    0   26    0    0    3    0 1107   57\n",
      "     7    1    5    7    0    0   13    0    7    0    0    0]\n",
      " [  50    2    1   21    1    0    1  173    0    3    9    0  106 1251\n",
      "     7   10    4   15    0    0   69   19  182   11   19    1]\n",
      " [  68  145  191  339   14    0   78   13    0   15    0    1   53   86\n",
      "  4541   39   63   27   27    0   46    0    6    4   16    3]\n",
      " [  85    1    0   19    0   75    0    7    1   18    4    1    7   16\n",
      "     4 1408   35   20    0   78    0    0    1    9  140    0]\n",
      " [   5    2    3   14    1    0   35    0    0   10    3    0    3    2\n",
      "    26   15  390   32    5    0   11    0   10    0    1    0]\n",
      " [ 107   18    5    1   29    1    3   10    0    2  130   12   30   49\n",
      "     0   41   31  640    1    1    3    0    5   35   14   20]\n",
      " [  28  279   15   50   64    3  123    2   55  419   26   10    8   21\n",
      "    76    9   33   22 3346   56    8    0   18   34   42    8]\n",
      " [   1    1    1    1    1   65    1    1  225  113   29    0   39    0\n",
      "     0   54    0    2    3 1594    0    0    0    7  127    7]\n",
      " [   6   38    4  100   11    0   12  109    0   25   27   11   38  161\n",
      "    87   15   22   35    1    1 1867   29  285    6   34    3]\n",
      " [   0    0    0    0    0    2    0    4    0    0   13    0    0   23\n",
      "     0    0    1    0    0    0    2  346   18    0    1    0]\n",
      " [   1    0    1    9    1    0    2   29    0    2    8    2   17  105\n",
      "     1    0    0    1    0    0   33   25  843    3    2    0]\n",
      " [  26    2    0    0    0    0    0    4    0    2   37    1    2    1\n",
      "     0    2    0    7    1    6    1   14    0  480   84    0]\n",
      " [   3    6    0    3    0    0    0   30    3   49   25    0    3    0\n",
      "     1   17    0    2    0   39    1   40    3   66  795    0]\n",
      " [   5   27    2    0    4    0    0    0   40   29   22   35    5    8\n",
      "     0    0    2    5    1    7    1    0    8   26    4  360]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd9da21",
   "metadata": {},
   "source": [
    "# Finding the True Positive, True Negative, False Positive and False Negative For each Letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "f808d19b",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0\n",
    "TpTnFpFn=np.zeros([26,4])        \n",
    "while(n<26):\n",
    "    Actual_OP=0\n",
    "    while(Actual_OP<26):\n",
    "        Predicted_Val=0\n",
    "        while(Predicted_Val<26):\n",
    "            if(n==Actual_OP):\n",
    "                if(Actual_OP==Predicted_Val):\n",
    "                    TpTnFpFn[n][0]=confusion_matrix[Actual_OP][Predicted_Val]\n",
    "                else:\n",
    "                    TpTnFpFn[n][3]+=confusion_matrix[Actual_OP][Predicted_Val]\n",
    "            elif(Actual_OP!=n):\n",
    "                if(Predicted_Val==n):\n",
    "                    TpTnFpFn[n][2]+=confusion_matrix[Actual_OP][Predicted_Val]\n",
    "                else:\n",
    "                    TpTnFpFn[n][1]+=confusion_matrix[Actual_OP][Predicted_Val]\n",
    "            Predicted_Val+=1\n",
    "        Actual_OP+=1\n",
    "    n+=1\n",
    "                \n",
    "                \n",
    "                    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8519f3e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "TpTnFpFn=TpTnFpFn.astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77b5bd08",
   "metadata": {},
   "source": [
    "Printing the TP, TN, FP, FN for each letter: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f8845496",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  929 35400   538   378]\n",
      " [  610 35683   703   249]\n",
      " [ 1601 34641   316   687]\n",
      " [  725 35590   612   318]\n",
      " [  659 35861   263   462]\n",
      " [  102 36963   163    17]\n",
      " [  382 36371   343   149]\n",
      " [  404 36015   497   329]\n",
      " [   95 36701   431    18]\n",
      " [  526 35539   809   371]\n",
      " [  409 36166   477   193]\n",
      " [  827 35823   270   325]\n",
      " [ 1107 35515   461   162]\n",
      " [ 1251 34510   780   704]\n",
      " [ 4541 30996   474  1234]\n",
      " [ 1408 34958   358   521]\n",
      " [  390 36379   298   178]\n",
      " [  640 35720   337   548]\n",
      " [ 3346 32370   120  1409]\n",
      " [ 1594 34619   354   678]\n",
      " [ 1867 33962   356  1060]\n",
      " [  346 36697   138    64]\n",
      " [  843 35445   715   242]\n",
      " [  480 36247   328   190]\n",
      " [  795 35451   708   291]\n",
      " [  360 36495   159   231]]\n"
     ]
    }
   ],
   "source": [
    "print(TpTnFpFn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84b43b0d",
   "metadata": {},
   "source": [
    "# Classwise/Letterwise Accuracy, Sensitivity and Precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "8d206463",
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy=np.zeros(26)\n",
    "sensitivity=np.zeros(26)\n",
    "precision=np.zeros(26)\n",
    "n=0\n",
    "while(n<26):\n",
    "    accuracy[n]=(TpTnFpFn[n][0]+TpTnFpFn[n][1])/(TpTnFpFn[n][0]+TpTnFpFn[n][1]+TpTnFpFn[n][2]+TpTnFpFn[n][3])\n",
    "    sensitivity[n]=(TpTnFpFn[n][0])/(TpTnFpFn[n][0]+TpTnFpFn[n][3])\n",
    "    precision[n]=(TpTnFpFn[n][0])/(TpTnFpFn[n][0]+TpTnFpFn[n][2])\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9e411cf6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.97540609 0.97443952 0.97307021 0.97503021 0.9805343  0.99516714\n",
      " 0.98679017 0.97782253 0.98794469 0.9683179  0.98201101 0.9840247\n",
      " 0.98327292 0.96015573 0.9541415  0.97639952 0.98721976 0.97623842\n",
      " 0.95894751 0.97229158 0.96198147 0.99457645 0.97430528 0.98609209\n",
      " 0.97317761 0.9895288 ]\n"
     ]
    }
   ],
   "source": [
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c220a249",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.71078806 0.71012806 0.69973776 0.69511026 0.58786798 0.85714286\n",
      " 0.71939736 0.55115962 0.84070796 0.58639911 0.67940199 0.71788194\n",
      " 0.87234043 0.6398977  0.78632035 0.72991187 0.68661972 0.53872054\n",
      " 0.70368034 0.70158451 0.63785446 0.84390244 0.77695853 0.71641791\n",
      " 0.7320442  0.60913706]\n"
     ]
    }
   ],
   "source": [
    "print(sensitivity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f111ba35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.63326517 0.46458492 0.8351591  0.54225879 0.71475054 0.38490566\n",
      " 0.52689655 0.44839068 0.18060837 0.39400749 0.46162528 0.7538742\n",
      " 0.7059949  0.61595273 0.90548355 0.79728199 0.56686047 0.65506653\n",
      " 0.96537796 0.81827515 0.83985605 0.71487603 0.54107831 0.59405941\n",
      " 0.52894212 0.69364162]\n"
     ]
    }
   ],
   "source": [
    "print(precision)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "fb350ea1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26237\n"
     ]
    }
   ],
   "source": [
    "print(count) #will print the total number of correctly predicted output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "b853f0f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall accuracy of model:  70.44435494697275\n"
     ]
    }
   ],
   "source": [
    "print(\"Overall accuracy of model: \",100*count/Y_test.shape[0]) #will print the percentage of correctly predicted output, i.e. the accuracy of our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82367c66",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}