Assignment1_10.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "00bbeb75",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function, division\n",
    "from future.utils import iteritems\n",
    "from builtins import range, input\n",
    "# Note: you may need to update your version of future\n",
    "# sudo pip install -U future\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from datetime import datetime\n",
    "from scipy.stats import norm\n",
    "from scipy.stats import multivariate_normal as mvn\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix as cm\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5812d2f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(path):\n",
    "    df = pd.read_excel(path,header=None)\n",
    "    data = df.values\n",
    "  \n",
    "    X = (data[:,:-1]-data[:,:-1].mean())/data[:,:-1].std()\n",
    "    Y = data[:,-1]\n",
    "    Y = Y-1\n",
    "    #print(X)\n",
    "    #print(Y)\n",
    "    return X,Y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aac18500",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = r\"C:\\Users\\gprak\\Downloads\\BITS Courses\\CS F464 Machine Learning I\\data\\data3.xlsx\"\n",
    "X,Y = get_data(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9365df88",
   "metadata": {},
   "source": [
    "## Holdout CV acc to split size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "22ff7904",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, Y, test_size=0.4, random_state=1234\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "205d34a0",
   "metadata": {},
   "source": [
    "## Applying LR test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2b0b92c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GaussianNB():\n",
    "    def __init__(self):\n",
    "        self.__summary = None\n",
    "        self.__totaal_cnt = None\n",
    "        \n",
    "    def __summarize(self,X,y):\n",
    "        summary = []\n",
    "        for label in sorted(np.unique(y)):\n",
    "            X_label = X[y==label]\n",
    "            means,std,cnt = X_label.mean(axis=0),X_label.std(axis=0)*np.sqrt(len(X_label)/(len(X_label)-1)),len(X_label)\n",
    "            summary.append((means,std,cnt))\n",
    "        return summary\n",
    "    \n",
    "    def fit(self,X,y):\n",
    "        self.__summary = self.__summarize(X,y)\n",
    "        self.__total_cnt = len(y)\n",
    "    \n",
    "    def __calculate_probability(self,x,mean,stdev):\n",
    "        exponent = np.exp(-((x-mean)**2/(2*stdev**2)))\n",
    "        return (1/(np.sqrt(2*np.pi)*stdev))*exponent\n",
    "    \n",
    "    def __predict_row(self,x):\n",
    "        probs = []\n",
    "        for means,stds,cnt in self.__summary:\n",
    "            prob = cnt/self.__total_cnt\n",
    "            for feature_index in range(len(x)):\n",
    "                prob = prob*self.__calculate_probability(x[feature_index],means[feature_index],stds[feature_index])\n",
    "                \n",
    "            probs.append(prob)\n",
    "        return np.array(probs)/sum(probs)\n",
    "    \n",
    "    def predict_proba(self,X):\n",
    "        return np.array([self.__predict_row(x) for x in X])\n",
    "    \n",
    "    def predict(self,X):\n",
    "        return np.argmax(self.predict_proba(X),axis = 1)\n",
    "    \n",
    "    def score(self,X,y):\n",
    "        return (self.predict(X)==y).sum()/len(y)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0de7a919",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = GaussianNB()\n",
    "model.fit(X_train,y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "20bb413c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train accuracy: 1.0\n"
     ]
    }
   ],
   "source": [
    "print(f\"Train accuracy: {model.score(X_train,y_train)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fc427799",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_test_pred = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8a6e3109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 1.0\n"
     ]
    }
   ],
   "source": [
    "print(f\"Test accuracy: {model.score(X_test,y_test)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "375eeda2",
   "metadata": {},
   "source": [
    "## Get all of metrics like Accuracy, Sensitivity and Specificity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "535ebbe7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_metrics(y_true,y_pred):\n",
    "    confusion_matrix = cm(y_true,y_pred)\n",
    "    FP = confusion_matrix.sum(axis=0) - np.diag(confusion_matrix)  \n",
    "    FN = confusion_matrix.sum(axis=1) - np.diag(confusion_matrix)\n",
    "    TP = np.diag(confusion_matrix)\n",
    "    TN = confusion_matrix.sum() - (FP + FN + TP)\n",
    "\n",
    "    # Sensitivity, hit rate, recall, or true positive rate\n",
    "    TPR = TP/(TP+FN)\n",
    "    # Specificity or true negative rate\n",
    "    TNR = TN/(TN+FP) \n",
    "    # Precision or positive predictive value\n",
    "    PPV = TP/(TP+FP)\n",
    "    # Negative predictive value\n",
    "    NPV = TN/(TN+FN)\n",
    "    # Fall out or false positive rate\n",
    "    FPR = FP/(FP+TN)\n",
    "    # False negative rate\n",
    "    FNR = FN/(TP+FN)\n",
    "    # False discovery rate\n",
    "    FDR = FP/(TP+FP)\n",
    "\n",
    "    # Overall accuracy\n",
    "    ACC = (TP+TN)/(TP+FP+FN+TN)\n",
    "    return {\n",
    "        \"ACC\":ACC,\n",
    "        \"TPR\":TPR,\n",
    "        \"TNR\":TNR\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0f7adb3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics = get_metrics(y_test,Y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5180ea18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ACC': array([1., 1.]), 'TPR': array([1., 1.]), 'TNR': array([1., 1.])}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27a48524",
   "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.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}