DM_Project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d41f9c69-e1f9-47ed-835e-4ab068ad9a9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import \n",
    "import numpy as np \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt \n",
    "import math\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c73051-72fe-4c77-b3ef-dbc3c0f15f7e",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Naive Bayes Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d0ac5648-2d97-4688-bc81-be7e4c255e57",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def eval_metrics(y_true, y_pred):\n",
    "\n",
    "    confusion_matrix = metrics.confusion_matrix(y_true, y_pred)\n",
    "    cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])\n",
    "    \n",
    "    prec = precision_score(y_true, y_pred, average='binary', pos_label='1')\n",
    "    f1 = f1_score(y_true, y_pred, average='binary', pos_label='1')\n",
    "    acc = accuracy_score(y_true, y_pred)\n",
    "    rec = recall_score(y_true, y_pred, average='binary', pos_label='1')\n",
    "    cm_display.plot()\n",
    "    plt.show()\n",
    "    \n",
    "    return prec, f1, acc, rec\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "587efc9a-c5e6-463f-b2ab-2b10bb8aeb4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "659f8ae6-4373-47a9-a399-ffca8ecf05a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_processing(df):\n",
    "\n",
    "    # Pre-processing\n",
    "    \n",
    "    df = df.drop(['id'], axis=1)\n",
    "    \n",
    "    df = df.dropna()\n",
    "    \n",
    "    #Convert int to categorical types\n",
    "    df['gender'] = df['gender'].astype('object')\n",
    "    df['hypertension'] = df['hypertension'].astype('object')\n",
    "    df['heart_disease'] = df['heart_disease'].astype('object')\n",
    "    df['ever_married'] = df['ever_married'].astype('object')\n",
    "    df['Residence_type'] = df['Residence_type'].astype('object')\n",
    "    df['smoking_status'] = df['smoking_status'].astype('object')\n",
    "    df['work_type'] = df['work_type'].astype('object')\n",
    "    df['stroke'] = df['stroke'].astype('object')\n",
    "\n",
    "    \n",
    "    #convert age to categorical\n",
    "    df['age'] = pd.cut(df.age,bins=[0,2,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85])\n",
    "    df['bmi'] = pd.cut(df.bmi,bins=[10,18.5, 25, 30, 35, 40, 100], labels = ['underweight', 'healthy weight', 'overweight', \n",
    "                                                                              'obesity class 1', 'obesity class 2', 'obesity class 3'])\n",
    "    df['avg_glucose_level'] = pd.cut(df.avg_glucose_level, bins=[50, 80, 115, 150, 180, 215, 250, 280])\n",
    "    \n",
    "    \n",
    "    \n",
    "    df['age'] = df['age'].astype('object')\n",
    "    df['bmi'] = df['bmi'].astype('object')\n",
    "    df['avg_glucose_level'] = df['avg_glucose_level'].astype('object')\n",
    "    \n",
    "    #partioning data into features and target\n",
    "        \n",
    "    df=df.astype(str)\n",
    "    \n",
    "    X = df.drop([df.columns[-1]], axis = 1)\n",
    "    \n",
    "    y = df[df.columns[-1]]\n",
    "    \n",
    "    \n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7a557a0b-1c17-41b6-a79e-061a6e78966e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class  NaiveBayes:\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self.features = list\n",
    "        self.likelihoods = {}\n",
    "        self.class_priors = {}\n",
    "        self.pred_priors = {}\n",
    "\n",
    "        self.X_train = np.array\n",
    "        self.y_train = np.array\n",
    "        self.train_size = int\n",
    "        self.num_feats = int\n",
    "\n",
    "    def fit(self, X, y):\n",
    "\n",
    "        self.features = list(X.columns)\n",
    "        self.X_train = X\n",
    "        self.y_train = y\n",
    "        self.train_size = X.shape[0]\n",
    "        self.num_feats = X.shape[1]\n",
    "\n",
    "        for feature in self.features:\n",
    "            self.likelihoods[feature] = {}\n",
    "            self.pred_priors[feature] = {}\n",
    "\n",
    "            for feat_val in np.unique(self.X_train[feature]):\n",
    "                self.pred_priors[feature].update({feat_val: 0})\n",
    "\n",
    "                for outcome in np.unique(self.y_train):\n",
    "                    # print(type(outcome))\n",
    "                    self.likelihoods[feature].update({feat_val+ '_' + outcome:0})\n",
    "                    self.class_priors.update({outcome: 0})\n",
    "\n",
    "        self._calc_class_prior()\n",
    "        self._calc_likelihoods()\n",
    "        self._calc_predictor_prior()\n",
    "\n",
    "    def _calc_class_prior(self):\n",
    "\n",
    "        for outcome in np.unique(self.y_train):\n",
    "            outcome_count = sum(self.y_train == outcome)\n",
    "            self.class_priors[outcome] = outcome_count / self.train_size\n",
    "\n",
    "    def _calc_likelihoods(self):\n",
    "\n",
    "        for feature in self.features:\n",
    "\n",
    "            for outcome in np.unique(self.y_train):\n",
    "                outcome_count = sum(self.y_train == outcome)\n",
    "                feat_likelihood = self.X_train[feature][self.y_train[self.y_train == outcome].index.values.tolist()].value_counts().to_dict()\n",
    "\n",
    "                for feat_val, count in feat_likelihood.items():\n",
    "                    self.likelihoods[feature][feat_val + '_' + outcome] = count/outcome_count\n",
    "\n",
    "\n",
    "    def _calc_predictor_prior(self):\n",
    "\n",
    "\n",
    "        for feature in self.features:\n",
    "            feat_vals = self.X_train[feature].value_counts().to_dict()\n",
    "\n",
    "            for feat_val, count in feat_vals.items():\n",
    "                self.pred_priors[feature][feat_val] = count/self.train_size\n",
    "\n",
    "    def _calc_predictor_prior_complement(self):\n",
    "\n",
    "\n",
    "            for feature in self.features:\n",
    "                feat_vals = self.X_train[feature].value_counts().to_dict()\n",
    "\n",
    "                for feat_val, count in feat_vals.items():\n",
    "                    self.pred_priors[feature][feat_val] = count/self.train_size\n",
    "                    \n",
    "    def predict(self, X):\n",
    "\n",
    "        \"\"\" Calculates Posterior probability P(c|x) \"\"\"\n",
    "\n",
    "        results = []\n",
    "        X = np.array(X)\n",
    "\n",
    "        for query in X:\n",
    "            probs_outcome = {}\n",
    "            for outcome in np.unique(self.y_train):\n",
    "                prior = self.class_priors[outcome]\n",
    "                likelihood = 1\n",
    "                evidence = 1\n",
    "\n",
    "                for feat, feat_val in zip(self.features, query):\n",
    "                    likelihood *= self.likelihoods[feat][feat_val + '_' + outcome]\n",
    "                    evidence *= self.pred_priors[feat][feat_val]\n",
    "\n",
    "                posterior = (likelihood * prior) / (evidence)\n",
    "\n",
    "                probs_outcome[outcome] = posterior\n",
    "\n",
    "            result = max(probs_outcome, key = lambda x: probs_outcome[x])\n",
    "            results.append(result)\n",
    "\n",
    "        return np.array(results)\n",
    "    \n",
    "    def predict_complement(self, X):\n",
    "\n",
    "        \"\"\" Calculates Posterior probability P(c|x) \"\"\"\n",
    "\n",
    "        results = []\n",
    "        X = np.array(X)\n",
    "\n",
    "        for query in X:\n",
    "            probs_outcome = {}\n",
    "            for outcome in np.unique(self.y_train):\n",
    "                prior = self.class_priors[outcome]\n",
    "                likelihood = 1\n",
    "                evidence = 1\n",
    "\n",
    "                for feat, feat_val in zip(self.features, query):\n",
    "                    likelihood *= self.likelihoods[feat][feat_val + '_' + outcome]\n",
    "                    evidence *= self.pred_priors[feat][feat_val]\n",
    "\n",
    "                posterior = 1 / ((likelihood * prior) / (evidence))\n",
    "\n",
    "                probs_outcome[outcome] = posterior\n",
    "\n",
    "            result = min(probs_outcome, key = lambda x: probs_outcome[x])\n",
    "            results.append(result)\n",
    "\n",
    "        return np.array(results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eec5b210-620b-4cbb-8890-4ad228781911",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Stroke Dataset:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.92544306376044\n",
      "Precision: 0.21033210332103322\n",
      "f-1 score: 0.23749999999999996\n",
      "recall: 0.2727272727272727\n",
      "Query 1:- [['Male' '(65, 70]' '0' '1' 'No' 'Private' 'Urban' '(215, 250]'\n",
      "  'obesity class 2' 'formerly smoked']] ---> ['0']\n",
      "Query 2:- [['Female' '(75, 80]' '1' '1' 'Yes' 'Govt_job' 'Urban' '(180, 215]'\n",
      "  'obesity class 1' 'smokes']] ---> ['1']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Weather Dataset\n",
    "print(\"\\nStroke Dataset:\")\n",
    "\n",
    "df = pd.read_csv(\"healthcare-dataset-stroke-data.csv\")\n",
    "df1 = df\n",
    "\n",
    "#Split fearures and target\n",
    "X,y  = pre_processing(df)\n",
    "\n",
    "nb_clf = NaiveBayes()\n",
    "nb_clf.fit(X, y)\n",
    "\n",
    "#Evaluate the model\n",
    "prec, f1, acc, rec = eval_metrics(y, nb_clf.predict(X))\n",
    "\n",
    "print(\"Accuracy: {}\".format(acc))\n",
    "print(\"Precision: {}\".format(prec))\n",
    "print(\"f-1 score: {}\".format(f1))\n",
    "print(\"recall: {}\".format(rec))\n",
    "\n",
    "#     print(X)\n",
    "#     print(y)\n",
    "\n",
    "#Query 1:\n",
    "query = np.array([['Male','(65, 70]', '0', '1', 'No', 'Private', 'Urban', '(215, 250]', 'obesity class 2', 'formerly smoked']])\n",
    "print(\"Query 1:- {} ---> {}\".format(query, nb_clf.predict(query)))\n",
    "\n",
    "#Query 2:\n",
    "query = np.array([['Female','(75, 80]', '1', '1', 'Yes', 'Govt_job', 'Urban', '(180, 215]', 'obesity class 1', 'smokes']])\n",
    "print(\"Query 2:- {} ---> {}\".format(query, nb_clf.predict(query)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bff1c3eb-c51c-4d73-93ed-0c8347fcd3c8",
   "metadata": {
    "tags": []
   },
   "source": [
    "# GUI for Naive Bayes Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a6270441-dc85-4556-9fb9-8c553567f067",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    " \n",
    "# user defined function\n",
    "def predict_stroke():\n",
    "    try:\n",
    "        \n",
    "        x1 = int(gender.get())\n",
    "        x2 = float(age.get())\n",
    "        x3 = int(hypertension.get())\n",
    "        x4 = int(heart_disease.get())\n",
    "        x5 = int(ever_married.get())\n",
    "        x6 = int(work_type.get())\n",
    "        x7 = int(Residence_type.get())\n",
    "        x8 = float(avg_glucose_level.get())\n",
    "        x9 = float(bmi.get())\n",
    "        x10 = int(smoking_status.get())\n",
    "        \n",
    "        #Convert to strings\n",
    "        \n",
    "        #gender\n",
    "        if x1 == 0:\n",
    "            x1 = \"Male\"\n",
    "        elif x1 == 1:\n",
    "            x1 = \"Female\"\n",
    "        else:\n",
    "            x1 = \"Others\" \n",
    "        \n",
    "        #ever married\n",
    "        if x5 == 0:\n",
    "            x5 = \"No\"\n",
    "        else:\n",
    "            x5 = \"Yes\"\n",
    "        \n",
    "        #work type\n",
    "        if x6 == 0:\n",
    "            x6 = \"Private\"\n",
    "        elif x6 == 1:\n",
    "            x6 = \"Self-employed\"\n",
    "        elif x6 == 2:\n",
    "            x6 = \"Govt_job\"\n",
    "        elif x6 == 3:\n",
    "            x6 = \"Children\"\n",
    "        else:\n",
    "            x6 = \"Never_worked\"\n",
    "        \n",
    "        #residence\n",
    "        if x7 == 0:\n",
    "            x7 = \"Urban\"\n",
    "        else:\n",
    "            x7 = \"Rural\"\n",
    "            \n",
    "        #smoking status\n",
    "        if x10 == 0:\n",
    "            x10 = \"formerly smoked\"\n",
    "        elif x10 == 1:\n",
    "            x10 = \"never smoked\"\n",
    "        elif x10 == 2:\n",
    "            x10 = \"smokes\"\n",
    "        else:\n",
    "            x10 = \"Unknown\"\n",
    "        \n",
    "        #age\n",
    "        df1 = df.dropna()\n",
    "        df1.bmi\n",
    "        \n",
    "        age_interval = pd.cut(df1.age,bins=[0,2,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85])\n",
    "        \n",
    "        age_range = age_interval.unique()\n",
    "        temp_x2 = ''\n",
    "        \n",
    "        for rang in age_range:\n",
    "            if x2 in rang:\n",
    "                temp_x2 = str(rang)\n",
    "        \n",
    "        x2 = temp_x2\n",
    "        \n",
    "        #bmi \n",
    "        bmi_interval = pd.cut(df1.bmi,bins=[10,18.5, 25, 30, 35, 40, 100])\n",
    "        bmi_range = bmi_interval.unique()\n",
    "        bmi_labels = ['obesity class 2', 'obesity class 1', 'healthy weight', 'overweight', 'obesity class 3', 'underweight']\n",
    "\n",
    "        temp_x9 = ''\n",
    "\n",
    "        for i in range(len(bmi_range)):\n",
    "            if x9 in bmi_range[i] :\n",
    "                temp_x9 = bmi_labels[i]\n",
    "\n",
    "        x9 = temp_x9\n",
    "\n",
    "\n",
    "        #avg_glucose\n",
    "        \n",
    "        glucose_interval = pd.cut(df1.avg_glucose_level, bins=[50, 80, 115, 150, 180, 215, 250, 280])\n",
    "        \n",
    "        glucose_range = glucose_interval.unique()\n",
    "        temp_x8 = ''\n",
    "\n",
    "        for rang in glucose_range:\n",
    "            if x8 in rang:\n",
    "                temp_x8 = str(rang)\n",
    "\n",
    "        x8 = temp_x8\n",
    "\n",
    "        \n",
    "        #new_X = np.array([gender.get(), age.get(), hypertension.get(), heart_disease.get(), ever_married.get(), \n",
    "        #                  work_type.get(), Residence_type.get(), avg_glucose_level.get(), bmi.get(), smoking_status.get()])\n",
    "        new_X = np.array([[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]])\n",
    "\n",
    "        new_pred = nb_clf.predict(new_X)\n",
    "        \n",
    "        stroke_class = int(new_pred[0])\n",
    "        \n",
    "        #print(stroke_class)\n",
    "        #print(new_X)\n",
    "        if stroke_class == 1:\n",
    "            result.set(\"The patient IS at risk of having a stroke\")\n",
    "            \n",
    "        elif stroke_class == 0:\n",
    "            result.set(\"The patient is NOT at risk of having a stroke\")\n",
    "\n",
    "    except:\n",
    "        result.set(\"something went wrong\")\n",
    "\n",
    "        \n",
    "# object of tkinter\n",
    "# with background set to light grey\n",
    "master = Tk()\n",
    "master.configure(bg='white')\n",
    "master.title(\"Stroke Predictor Application\")\n",
    " \n",
    "# Variable Classes in tkinter\n",
    "result = StringVar();\n",
    " \n",
    "# App introduction\n",
    "Label(master, text=\"This application allows you to check a patient's risk of stroke based on the following parameters.\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=1, sticky=W)\n",
    "Label(master, text=\"Please enter your information in the following format, and hit the predict button. \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=2, sticky=W)\n",
    "Label(master, text=\"This prediction makes use of Complement Naive Bayes, which got 93% accuracy after evaluating 3 models.\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=3, sticky=W)\n",
    "Label(master, text=\"\" , bg = \"white\", font=10).grid(row=4, sticky=W)\n",
    "Label(master, text=\"Input each one of the patient's information in the boxes below:\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=5, sticky=W)\n",
    "    \n",
    "# Creating label for each information\n",
    "# name using widget Label\n",
    "Label(master, text=\"Enter gender (0: Male, 1: Female, 2: Others): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=6, sticky=W)\n",
    "Label(master, text=\"Enter age (year-old): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=7, sticky=W)\n",
    "Label(master, text=\"Enter hypertension (0: patient has no hypertension, 1: patient has hypertension): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=8, sticky=W)\n",
    "Label(master, text=\"Enter heart_disease (0: patient has no heart disease, 1: patient has heart disease): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=9, sticky=W)\n",
    "Label(master, text=\"Enter ever_married (0: Yes, 1: No): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=10, sticky=W)\n",
    "Label(master, text=\"Enter work_type (0: Private, 1: Self-employed, 2: Govt_jov, 3: Children, 4: Never_worked): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=11, sticky=W)\n",
    "Label(master, text=\"Enter Residence_type (0: Urban, 1: Rural): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=12, sticky=W)\n",
    "Label(master, text=\"Enter average glucose level in blood: \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=13, sticky=W)\n",
    "Label(master, text=\"Enter body mass index, BMI: \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=14, sticky=W)\n",
    "Label(master, text=\"Enter smoking_status (0: formerly smoked, 1: never smoked, 2: smokes, 3: Unknown): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=15, sticky=W)\n",
    "\n",
    "# label for the result\n",
    "Label(master, text=\" \", bg = \"white\", font=(\"Arial\", 12)).grid(row=16, sticky=W)\n",
    "Label(master, text=\"Result :\", bg = \"white\", font=(\"Arial\", 17)).grid(row=17, sticky=W)\n",
    " \n",
    "# Output the result\n",
    "Label(master, text=\"\", textvariable=result ,bg = \"white\", font=(\"Arial\", 17)).grid(row=17,column=1, sticky=W)\n",
    "\n",
    "# store variables\n",
    "gender = Entry(master,width = 30)\n",
    "gender.grid(row=6, column=1)\n",
    "age = Entry(master,width = 30)\n",
    "age.grid(row=7, column=1)\n",
    "hypertension = Entry(master,width = 30)\n",
    "hypertension.grid(row=8, column=1)\n",
    "heart_disease = Entry(master,width = 30)\n",
    "heart_disease.grid(row=9, column=1)\n",
    "ever_married = Entry(master,width = 30)\n",
    "ever_married.grid(row=10, column=1)\n",
    "work_type = Entry(master,width = 30)\n",
    "work_type.grid(row=11, column=1)\n",
    "Residence_type = Entry(master,width = 30)\n",
    "Residence_type.grid(row=12, column=1)\n",
    "avg_glucose_level = Entry(master,width = 30)\n",
    "avg_glucose_level.grid(row=13, column=1)\n",
    "bmi = Entry(master,width = 30)\n",
    "bmi.grid(row=14, column=1)\n",
    "smoking_status = Entry(master,width = 30)\n",
    "smoking_status.grid(row=15, column=1)\n",
    "\n",
    " \n",
    "# creating a button using the widget \n",
    "b = Button(master, text=\"Predict\", command=predict_stroke, bg = \"white\", font=(\"Arial\", 12))\n",
    "b.grid(row=16, column=1,columnspan=1, rowspan=1,padx=5, pady=5,)\n",
    " \n",
    "mainloop()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ef28f9a-0a66-4a32-8af3-8e65b8582a75",
   "metadata": {},
   "source": [
    "# Constructing Decision Tree Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1c097f9a-49d7-4f45-976d-9dfbbdf708e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from collections import Counter\n",
    "\n",
    "# class implementing a tree node.\n",
    "class Node:\n",
    "    # contructor to hold data about the feature, threshold, data going left and right, \n",
    "    # information gain, and the leaf node value.\n",
    "    def __init__(self, feature=None, threshold=None, data_left=None, data_right=None, gain=None, value=None):\n",
    "        self.feature = feature\n",
    "        self.threshold = threshold\n",
    "        self.data_left = data_left\n",
    "        self.data_right = data_right\n",
    "        self.gain = gain\n",
    "        self.value = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "fe2aa21e-f619-4175-bb6e-2ea57f5409d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decision Tree Class which implements a decision tree classifier algorithm.\n",
    "# In this case, it is ID3 algorithm where entropy and information gain is used to split the branches.\n",
    "class DecisionTree:\n",
    "    \n",
    "    # a contructor to hold values for min_samples_split and max_depth of the tree.\n",
    "    def __init__(self, min_samples_split=2, max_depth=5):\n",
    "        self.min_samples_split = min_samples_split  # specify a minimum number of samples required to split a node\n",
    "        self.max_depth = max_depth                  # specifies a maximum depth of a tree\n",
    "        self.root = None\n",
    "        \n",
    "    @staticmethod\n",
    "    \n",
    "    # a function to calculate entropy from a list of integer values\n",
    "    def _entropy(s): # @param s: input vector\n",
    "\n",
    "        # convert to integers to avoid runtime errors\n",
    "        counts = np.bincount(np.array(s, dtype=np.int64))\n",
    "        \n",
    "        # probabilities of each class label\n",
    "        percentages = counts / len(s)\n",
    "\n",
    "        # caclulate entropy\n",
    "        entropy = 0\n",
    "        for pct in percentages:\n",
    "            if pct > 0:\n",
    "                entropy += pct * np.log2(pct)\n",
    "        \n",
    "        # return: float, entropy value\n",
    "        return -entropy   \n",
    "    \n",
    "    # a function to calculate information gain \n",
    "    def _information_gain(self, parent, left_child, right_child):  \n",
    "                               # @param parent: list, the parent node\n",
    "                               # @param left_child: list, left child of a parent\n",
    "                               # @param right_child: list, right child of a parent\n",
    "                                \n",
    "        num_left = len(left_child) / len(parent)\n",
    "        num_right = len(right_child) / len(parent)\n",
    "        \n",
    "        # calculate information gain using entropy of parent and children nodes\n",
    "        # return: float, information gain\n",
    "        return self._entropy(parent) - (num_left * self._entropy(left_child) + num_right * self._entropy(right_child))\n",
    "    \n",
    "    # best-split function to calculate the best splitting parameters for input features X and a target variable y\n",
    "    def _best_split(self, X, y):    # @param X: np.array, features\n",
    "                                    # @param y: np.array or list, target\n",
    "\n",
    "        # initializations\n",
    "        best_split = {}\n",
    "        best_info_gain = -1\n",
    "        n_rows, n_cols = X.shape\n",
    "        \n",
    "        # for every dataset feature\n",
    "        for f_idx in range(n_cols):\n",
    "            X_curr = X[:, f_idx]\n",
    "            # for every unique value of that feature\n",
    "            for threshold in np.unique(X_curr):\n",
    "                # construct a dataset and split it to the left and right parts,\n",
    "                # left part includes records lower or equal to the threshold,\n",
    "                # right part includes records higher than the threshold,\n",
    "                df = np.concatenate((X, y.reshape(1, -1).T), axis=1)\n",
    "                df_left = np.array([row for row in df if row[f_idx] <= threshold])\n",
    "                df_right = np.array([row for row in df if row[f_idx] > threshold])\n",
    "\n",
    "                # do the calculation only if there's data in both subsets\n",
    "                if len(df_left) > 0 and len(df_right) > 0:\n",
    "                    # obtain the value of the target variable for subsets\n",
    "                    y = df[:, -1]\n",
    "                    y_left = df_left[:, -1]\n",
    "                    y_right = df_right[:, -1]\n",
    "\n",
    "                    # caclulate the information gain and save the split parameters -\n",
    "                    # if the current split if better then the previous best\n",
    "                    gain = self._information_gain(y, y_left, y_right)\n",
    "                    if gain > best_info_gain:\n",
    "                        best_split = {    # save the split info.\n",
    "                            'feature_index': f_idx,\n",
    "                            'threshold': threshold,\n",
    "                            'df_left': df_left,\n",
    "                            'df_right': df_right,\n",
    "                            'gain': gain\n",
    "                        }\n",
    "                        best_info_gain = gain\n",
    "        # return: dict, best-split info\n",
    "        return best_split\n",
    "    \n",
    "    # a recursive function to build a decision tree from the input data\n",
    "    def _build(self, X, y, depth=0):\n",
    "            # @param X: np.array, features\n",
    "            # @param y: np.array or list, target\n",
    "            # @param depth: current depth of a tree, used as a stopping criteria\n",
    "\n",
    "        # get dimension of X\n",
    "        n_rows, n_cols = X.shape\n",
    "        \n",
    "        # check to see if a node should be leaf node\n",
    "        if n_rows >= self.min_samples_split and depth <= self.max_depth:\n",
    "            # Get the best split\n",
    "            best = self._best_split(X, y)\n",
    "            # If the split isn't pure\n",
    "            if best['gain'] > 0:\n",
    "                # Build a tree on the left\n",
    "                left = self._build(\n",
    "                    X=best['df_left'][:, :-1], \n",
    "                    y=best['df_left'][:, -1], \n",
    "                    depth=depth + 1\n",
    "                )\n",
    "                right = self._build(\n",
    "                    X=best['df_right'][:, :-1], \n",
    "                    y=best['df_right'][:, -1], \n",
    "                    depth=depth + 1\n",
    "                )\n",
    "                return Node(\n",
    "                    feature=best['feature_index'], \n",
    "                    threshold=best['threshold'], \n",
    "                    data_left=left, \n",
    "                    data_right=right, \n",
    "                    gain=best['gain']\n",
    "                )\n",
    "        # for leaf node - value is the most common target value \n",
    "        # return: Node\n",
    "        return Node(\n",
    "            value=Counter(y).most_common(1)[0][0]\n",
    "        )\n",
    "    \n",
    "    # a function to train a decision tree classifier model\n",
    "    def fit(self, X, y): # @param X: np.array, features\n",
    "                         # @param y: np.array or list, target\n",
    "\n",
    "        # call a recursive function to build the tree\n",
    "        self.root = self._build(X, y)\n",
    "    \n",
    "    # a recursive function to predict a single instance (tree traversal)\n",
    "    def _predict(self, x, tree):  # @param x: single observation\n",
    "                                  # @param tree: built tree\n",
    "\n",
    "        # leaf node\n",
    "        if tree.value != None:\n",
    "            return tree.value\n",
    "        feature_value = x[tree.feature]\n",
    "        \n",
    "        # go to the left\n",
    "        if feature_value <= tree.threshold:\n",
    "            # return: float, predicted class\n",
    "            return self._predict(x=x, tree=tree.data_left)\n",
    "        \n",
    "        # go to the right\n",
    "        if feature_value > tree.threshold:\n",
    "            # return: float, predicted class\n",
    "            return self._predict(x=x, tree=tree.data_right)\n",
    "    # predict-function to classify new instances.    \n",
    "    def predict(self, X):   # @param X: np.array, features\n",
    "\n",
    "        # call the _predict() function for every observation\n",
    "        # return: np.array, predicted classes\n",
    "        return [self._predict(x, self.root) for x in X]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7152c308-cc0f-48f2-a378-4364237b0f23",
   "metadata": {},
   "source": [
    "# Constructing Random Forest Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37481439-531a-4a80-9a1b-8911ea23deb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random Forest Class\n",
    "class RandomForest:\n",
    "    \n",
    "    # constructor that holds values for the number of trees in the forest, \n",
    "    # minimum samples split, and maximum depth\n",
    "    def __init__(self, num_trees=25, min_samples_split=2, max_depth=5):\n",
    "        self.num_trees = num_trees\n",
    "        self.min_samples_split = min_samples_split\n",
    "        self.max_depth = max_depth\n",
    "        # store individually trained decision trees as well\n",
    "        self.decision_trees = []\n",
    "        \n",
    "    @staticmethod\n",
    "    # sample function to perform boostrap sampling for sampling random data in random forest\n",
    "    def _sample(X, y):  # @param X: np.array, features\n",
    "                        # @param y: np.array, target       \n",
    "        # get dimension of X\n",
    "        n_rows, n_cols = X.shape\n",
    "        \n",
    "        # sample with replacement\n",
    "        samples = np.random.choice(a=n_rows, size=n_rows, replace=True)\n",
    "        \n",
    "        # return: tuple (sample of features, sample of target)\n",
    "        return X[samples], y[samples]\n",
    "    \n",
    "    # fit function to train RF classifier\n",
    "    def fit(self, X, y):    # @param X: np.array, features\n",
    "                            # @param y: np.array, target\n",
    "        # start building new trees from a fresh-start\n",
    "        if len(self.decision_trees) > 0:\n",
    "            self.decision_trees = []\n",
    "            \n",
    "        # build each tree of the forest\n",
    "        num_built = 0\n",
    "        while num_built < self.num_trees:\n",
    "            try:\n",
    "                clf = DecisionTree(\n",
    "                    min_samples_split=self.min_samples_split,\n",
    "                    max_depth=self.max_depth\n",
    "                )\n",
    "                # obtain random data sample\n",
    "                _X, _y = self._sample(X, y)\n",
    "                # train the model\n",
    "                clf.fit(_X, _y)\n",
    "                # save the classifier\n",
    "                self.decision_trees.append(clf)\n",
    "                num_built += 1\n",
    "            except Exception as e:\n",
    "                continue\n",
    "    \n",
    "    # a predict function to predict class labels for new data instances\n",
    "    def predict(self, X):  # @param X: np.array, new instances to predict\n",
    "\n",
    "        # make predictions with every tree in the forest\n",
    "        y = []\n",
    "        for tree in self.decision_trees:\n",
    "            y.append(tree.predict(X))\n",
    "        \n",
    "        # reshape to find the most common value\n",
    "        y = np.swapaxes(a=y, axis1=0, axis2=1)\n",
    "        \n",
    "        # majority voting for the final prediction\n",
    "        predictions = []\n",
    "        for preds in y:\n",
    "            counter = Counter(preds)\n",
    "            predictions.append(counter.most_common(1)[0][0])\n",
    "        # return: array of predicted classes\n",
    "        return predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2932cb28-34d4-4f85-ada1-d3eaafc57070",
   "metadata": {},
   "source": [
    "# Stroke Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "afbd39bf-989f-41b0-84e1-86e52de39163",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import stroke data\n",
    "import pandas as pd\n",
    "stroke_df = pd.read_csv('healthcare-dataset-stroke-data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2819090e-14a5-4016-b700-139be87c5a25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>gender</th>\n",
       "      <th>age</th>\n",
       "      <th>hypertension</th>\n",
       "      <th>heart_disease</th>\n",
       "      <th>ever_married</th>\n",
       "      <th>work_type</th>\n",
       "      <th>Residence_type</th>\n",
       "      <th>avg_glucose_level</th>\n",
       "      <th>bmi</th>\n",
       "      <th>smoking_status</th>\n",
       "      <th>stroke</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>9046</td>\n",
       "      <td>Male</td>\n",
       "      <td>67.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>228.69</td>\n",
       "      <td>36.6</td>\n",
       "      <td>formerly smoked</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>51676</td>\n",
       "      <td>Female</td>\n",
       "      <td>61.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Rural</td>\n",
       "      <td>202.21</td>\n",
       "      <td>NaN</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>31112</td>\n",
       "      <td>Male</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Rural</td>\n",
       "      <td>105.92</td>\n",
       "      <td>32.5</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>60182</td>\n",
       "      <td>Female</td>\n",
       "      <td>49.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>171.23</td>\n",
       "      <td>34.4</td>\n",
       "      <td>smokes</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1665</td>\n",
       "      <td>Female</td>\n",
       "      <td>79.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Rural</td>\n",
       "      <td>174.12</td>\n",
       "      <td>24.0</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5105</th>\n",
       "      <td>18234</td>\n",
       "      <td>Female</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>83.75</td>\n",
       "      <td>NaN</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5106</th>\n",
       "      <td>44873</td>\n",
       "      <td>Female</td>\n",
       "      <td>81.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Urban</td>\n",
       "      <td>125.20</td>\n",
       "      <td>40.0</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5107</th>\n",
       "      <td>19723</td>\n",
       "      <td>Female</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Rural</td>\n",
       "      <td>82.99</td>\n",
       "      <td>30.6</td>\n",
       "      <td>never smoked</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5108</th>\n",
       "      <td>37544</td>\n",
       "      <td>Male</td>\n",
       "      <td>51.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Rural</td>\n",
       "      <td>166.29</td>\n",
       "      <td>25.6</td>\n",
       "      <td>formerly smoked</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5109</th>\n",
       "      <td>44679</td>\n",
       "      <td>Female</td>\n",
       "      <td>44.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Govt_job</td>\n",
       "      <td>Urban</td>\n",
       "      <td>85.28</td>\n",
       "      <td>26.2</td>\n",
       "      <td>Unknown</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5110 rows × 12 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         id  gender   age  hypertension  heart_disease ever_married  \\\n",
       "0      9046    Male  67.0             0              1          Yes   \n",
       "1     51676  Female  61.0             0              0          Yes   \n",
       "2     31112    Male  80.0             0              1          Yes   \n",
       "3     60182  Female  49.0             0              0          Yes   \n",
       "4      1665  Female  79.0             1              0          Yes   \n",
       "...     ...     ...   ...           ...            ...          ...   \n",
       "5105  18234  Female  80.0             1              0          Yes   \n",
       "5106  44873  Female  81.0             0              0          Yes   \n",
       "5107  19723  Female  35.0             0              0          Yes   \n",
       "5108  37544    Male  51.0             0              0          Yes   \n",
       "5109  44679  Female  44.0             0              0          Yes   \n",
       "\n",
       "          work_type Residence_type  avg_glucose_level   bmi   smoking_status  \\\n",
       "0           Private          Urban             228.69  36.6  formerly smoked   \n",
       "1     Self-employed          Rural             202.21   NaN     never smoked   \n",
       "2           Private          Rural             105.92  32.5     never smoked   \n",
       "3           Private          Urban             171.23  34.4           smokes   \n",
       "4     Self-employed          Rural             174.12  24.0     never smoked   \n",
       "...             ...            ...                ...   ...              ...   \n",
       "5105        Private          Urban              83.75   NaN     never smoked   \n",
       "5106  Self-employed          Urban             125.20  40.0     never smoked   \n",
       "5107  Self-employed          Rural              82.99  30.6     never smoked   \n",
       "5108        Private          Rural             166.29  25.6  formerly smoked   \n",
       "5109       Govt_job          Urban              85.28  26.2          Unknown   \n",
       "\n",
       "      stroke  \n",
       "0          1  \n",
       "1          1  \n",
       "2          1  \n",
       "3          1  \n",
       "4          1  \n",
       "...      ...  \n",
       "5105       0  \n",
       "5106       0  \n",
       "5107       0  \n",
       "5108       0  \n",
       "5109       0  \n",
       "\n",
       "[5110 rows x 12 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stroke_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b79f2bcc-87cf-40db-8366-2c56e4759ce6",
   "metadata": {},
   "source": [
    "# Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "12d0595b-6cfd-4139-ad1e-b16b5b6fb900",
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove 'id' since it is not a feature and could influence the model\n",
    "del stroke_df[\"id\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a0c29a22-ca07-4eec-aeda-e9a528763df1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "id                     int64\n",
       "gender                object\n",
       "age                  float64\n",
       "hypertension           int64\n",
       "heart_disease          int64\n",
       "ever_married          object\n",
       "work_type             object\n",
       "Residence_type        object\n",
       "avg_glucose_level    float64\n",
       "bmi                  float64\n",
       "smoking_status        object\n",
       "stroke                 int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check data type of each attribute\n",
    "stroke_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "46f6b9fa-e302-4e3b-8379-b5b0bd45e331",
   "metadata": {},
   "outputs": [],
   "source": [
    "# factorize all string (object) type attribute, to have factor attributes for classification\n",
    "stroke_df[\"gender\"] = pd.factorize(stroke_df[\"gender\"])[0]\n",
    "stroke_df[\"ever_married\"] = pd.factorize(stroke_df[\"ever_married\"])[0]\n",
    "stroke_df[\"work_type\"] = pd.factorize(stroke_df[\"work_type\"])[0]\n",
    "stroke_df[\"Residence_type\"] = pd.factorize(stroke_df[\"Residence_type\"])[0]\n",
    "stroke_df[\"smoking_status\"] = pd.factorize(stroke_df[\"smoking_status\"])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "81f85bb7-8ef6-45d6-94aa-3d1e631cf8e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gender                 int64\n",
       "age                  float64\n",
       "hypertension           int64\n",
       "heart_disease          int64\n",
       "ever_married           int64\n",
       "work_type              int64\n",
       "Residence_type         int64\n",
       "avg_glucose_level    float64\n",
       "bmi                  float64\n",
       "smoking_status         int64\n",
       "stroke                 int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check data type of each attribute\n",
    "stroke_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a8cc978f-33f2-4b3f-ab2d-f8492bf955fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gender                 0\n",
       "age                    0\n",
       "hypertension           0\n",
       "heart_disease          0\n",
       "ever_married           0\n",
       "work_type              0\n",
       "Residence_type         0\n",
       "avg_glucose_level      0\n",
       "bmi                  201\n",
       "smoking_status         0\n",
       "stroke                 0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check for missing values\n",
    "stroke_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "8b560c82-3333-4925-b5ff-877a2d7ed00b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# missing values imputation\n",
    "# imputing with MICE\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import IterativeImputer\n",
    "from sklearn import linear_model\n",
    "\n",
    "# Define MICE Imputer and fill missing values\n",
    "mice_imputer = IterativeImputer(estimator=linear_model.BayesianRidge(), n_nearest_features=None, imputation_order='ascending')\n",
    "\n",
    "# impute missing values\n",
    "stroke_df_imputed = pd.DataFrame(mice_imputer.fit_transform(stroke_df), columns=stroke_df.columns)\n",
    "\n",
    "# copy just 'bmi' column back into the original df\n",
    "stroke_df[\"bmi\"] = stroke_df_imputed[\"bmi\"] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "e681275f-fd8d-49fc-9b93-99cbb764e0d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gender               0\n",
       "age                  0\n",
       "hypertension         0\n",
       "heart_disease        0\n",
       "ever_married         0\n",
       "work_type            0\n",
       "Residence_type       0\n",
       "avg_glucose_level    0\n",
       "bmi                  0\n",
       "smoking_status       0\n",
       "stroke               0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# double check for missing values\n",
    "stroke_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "4b26ffa4-5546-408f-ba82-0c3b76254b09",
   "metadata": {},
   "outputs": [],
   "source": [
    "# split data\n",
    "# first, put it in X and y (features and target)\n",
    "X = stroke_df.drop(['stroke'], axis = 1).to_numpy()\n",
    "y = stroke_df['stroke'].to_numpy()\n",
    "\n",
    "# split the dataset into training and testing portions\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.98, random_state=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "342dc404-3239-4eb0-9a71-240955d11966",
   "metadata": {},
   "source": [
    "# Decision Tree ID3 Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "4e3af3cb-cda9-4bca-9774-89e7bf465996",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decision Tree Model\n",
    "DT_model = DecisionTree()\n",
    "\n",
    "DT_model.fit(X_train, y_train)\n",
    "\n",
    "DT_preds = DT_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49dc208c-2549-4484-9a2c-4baf9d02eece",
   "metadata": {
    "tags": []
   },
   "source": [
    "# ID3 Model Evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5b8525cf-0225-4985-88c3-3c1a7d79431f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# confusion matrix\n",
    "confusion_matrix = metrics.confusion_matrix(y_test, DT_preds)\n",
    "cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])\n",
    "cm_display.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "08637a35-95f3-4cb3-b62e-105140d485f2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# accuracy score\n",
    "from sklearn.metrics import accuracy_score\n",
    "DT_acc = accuracy_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "dda51719-7920-4bb7-a02f-325133e0ae92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5491797950834134"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# balanced_accuracy_score\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "balanced_accuracy_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "97c0f62a-a042-49e7-8bd1-a1f7e7e1e128",
   "metadata": {},
   "outputs": [],
   "source": [
    "# precision score\n",
    "from sklearn.metrics import precision_score\n",
    "DT_prec = precision_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "87baa6b2-81cc-488c-b043-14db0c0f8e5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# f-1 score\n",
    "from sklearn.metrics import f1_score\n",
    "DT_f1 = f1_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "0fd683fa-2897-4d68-a72d-34b23d1b2103",
   "metadata": {},
   "outputs": [],
   "source": [
    "# recall score\n",
    "from sklearn.metrics import recall_score\n",
    "DT_rec = recall_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "db19b1dd-36ef-4f6b-946d-fc5f5d9742d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.917610710607621\n",
      "Precision: 0.14163090128755365\n",
      "f-1 score: 0.14163090128755365\n",
      "recall: 0.14163090128755365\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy: {}\".format(DT_acc))\n",
    "print(\"Precision: {}\".format(DT_prec))\n",
    "print(\"f-1 score: {}\".format(DT_f1))\n",
    "print(\"recall: {}\".format(DT_rec))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26b0d5b4-2076-4088-a127-10972a635d30",
   "metadata": {},
   "source": [
    "# Random Forest Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "ec8aa12d-ebbf-469a-8823-ab2561f1c7cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# trains the model with default hyperparameters and makes predictions on the test set\n",
    "RF_model = RandomForest()\n",
    "RF_model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "ee646387-f495-4f68-ace8-c5b50ccc3911",
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict the test data\n",
    "RF_preds = RF_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9700e5b7-40dd-4fa0-9825-9d9236a687de",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Random Forest Model Evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "1cb5cea4-0a84-43cd-a130-0e89e5e997f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# confusion matrix\n",
    "confusion_matrix = metrics.confusion_matrix(y_test, RF_preds)\n",
    "cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])\n",
    "cm_display.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "894ea4f8-90ab-4273-adc0-e4b4089ba221",
   "metadata": {},
   "outputs": [],
   "source": [
    "# accuracy score\n",
    "from sklearn.metrics import accuracy_score\n",
    "RF_acc = accuracy_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "ff7c805f-eba6-437a-afee-8a8b5dcc91ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5626006524342404"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# balanced_accuracy_score\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "balanced_accuracy_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "f85b50a0-4029-459b-b491-e915aa300620",
   "metadata": {},
   "outputs": [],
   "source": [
    "# precision score\n",
    "from sklearn.metrics import precision_score\n",
    "RF_prec = precision_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "5746ec83-c56f-40f1-ae81-46048f489bc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# f-1 score\n",
    "from sklearn.metrics import f1_score\n",
    "RF_f1 = f1_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "c2575973-172f-424e-bf1b-002b615b7bb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# recall score\n",
    "from sklearn.metrics import recall_score\n",
    "RF_rec = recall_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "1240c6a5-9153-47ca-a2a3-9390b7a77e97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9261182108626198\n",
      "Precision: 0.19117647058823528\n",
      "f-1 score: 0.17410714285714285\n",
      "recall: 0.1598360655737705\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy: {}\".format(RF_acc))\n",
    "print(\"Precision: {}\".format(RF_prec))\n",
    "print(\"f-1 score: {}\".format(RF_f1))\n",
    "print(\"recall: {}\".format(RF_rec))"
   ]
  },
  {
   "cell_type": "raw",
   "id": "082e0a3c-9357-4525-82ae-0c52ee8ce27a",
   "metadata": {},
   "source": [
    "Run-Time Recorded for each data size\n",
    "with 1% data for training: 1 sec; acc score = 0.904131251235422\n",
    "with 5% data for training: 17 sec; acc score = 0.9476828012358394\n",
    "with 20%: 230 sec; acc score = 0.9493639921722113\n",
    "with 80%: 4970 sec; acc score = 0.9393346379647749"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1e5219-fa09-4b17-b18e-3a613e1cd556",
   "metadata": {},
   "source": [
    "# GUI For Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "b5e43661-c88c-41dc-90ec-98dacab38843",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import modules\n",
    "from tkinter import *\n",
    " \n",
    "# user defined function\n",
    "def predict_stroke():\n",
    "    try:\n",
    "        \n",
    "        x1 = int(gender.get())\n",
    "        x2 = float(age.get())\n",
    "        x3 = int(hypertension.get())\n",
    "        x4 = int(heart_disease.get())\n",
    "        x5 = int(ever_married.get())\n",
    "        x6 = int(work_type.get())\n",
    "        x7 = int(Residence_type.get())\n",
    "        x8 = float(avg_glucose_level.get())\n",
    "        x9 = float(bmi.get())\n",
    "        x10 = int(smoking_status.get())\n",
    "        \n",
    "        \n",
    "        #new_X = np.array([gender.get(), age.get(), hypertension.get(), heart_disease.get(), ever_married.get(), \n",
    "        #                  work_type.get(), Residence_type.get(), avg_glucose_level.get(), bmi.get(), smoking_status.get()])\n",
    "        new_X = np.array([[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]])\n",
    "\n",
    "        new_pred = RF_model.predict(new_X)\n",
    "        \n",
    "        stroke_class = int(new_pred[0])\n",
    "        \n",
    "        #print(stroke_class)\n",
    "        #print(new_X)\n",
    "        if stroke_class == 1:\n",
    "            result.set(\"The patient IS at risk of having a stroke\")\n",
    "            \n",
    "        elif stroke_class == 0:\n",
    "            result.set(\"The patient is NOT at risk of having a stroke\")\n",
    "\n",
    "    except:\n",
    "        result.set(\"something went wrong\")\n",
    "\n",
    "        \n",
    "# object of tkinter\n",
    "# with background set to light grey\n",
    "master = Tk()\n",
    "master.configure(bg='white')\n",
    "master.title(\"Stroke Predictor Application\")\n",
    " \n",
    "# Variable Classes in tkinter\n",
    "result = StringVar();\n",
    " \n",
    "# App introduction\n",
    "Label(master, text=\"This application allows you to check a patient's risk of stroke based on the following parameters.\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=1, sticky=W)\n",
    "Label(master, text=\"Please enter your information in the following format, and hit the predict button. \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=2, sticky=W)\n",
    "Label(master, text=\"This prediction makes use of Random forest, which got 94.9% accuracy after evaluating 3 models.\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=3, sticky=W)\n",
    "Label(master, text=\"\" , bg = \"white\", font=10).grid(row=4, sticky=W)\n",
    "Label(master, text=\"Input each one of the patient's information in the boxes below:\" , bg = \"white\", font=(\"Arial\", 12)).grid(row=5, sticky=W)\n",
    "    \n",
    "# Creating label for each information\n",
    "# name using widget Label\n",
    "Label(master, text=\"Enter gender (0: Male, 1: Female, 2: Others): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=6, sticky=W)\n",
    "Label(master, text=\"Enter age (year-old): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=7, sticky=W)\n",
    "Label(master, text=\"Enter hypertension (0: patient has no hypertension, 1: patient has hypertension): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=8, sticky=W)\n",
    "Label(master, text=\"Enter heart_disease (0: patient has no heart disease, 1: patient has heart disease): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=9, sticky=W)\n",
    "Label(master, text=\"Enter ever_married (0: Yes, 1: No): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=10, sticky=W)\n",
    "Label(master, text=\"Enter work_type (0: Private, 1: Self-employed, 2: Govt_jov, 3: Children, 4: Never_worked): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=11, sticky=W)\n",
    "Label(master, text=\"Enter Residence_type (0: Urban, 1: Rural): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=12, sticky=W)\n",
    "Label(master, text=\"Enter average glucose level in blood: \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=13, sticky=W)\n",
    "Label(master, text=\"Enter body mass index, BMI: \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=14, sticky=W)\n",
    "Label(master, text=\"Enter smoking_status (0: formerly smoked, 1: never smoked, 2: smokes, 3: Unknown): \" , bg = \"white\", font=(\"Arial\", 12)).grid(row=15, sticky=W)\n",
    "\n",
    "# label for the result\n",
    "Label(master, text=\" \", bg = \"white\", font=(\"Arial\", 12)).grid(row=16, sticky=W)\n",
    "Label(master, text=\"Result :\", bg = \"white\", font=(\"Arial\", 17)).grid(row=17, sticky=W)\n",
    " \n",
    "# Output the result\n",
    "Label(master, text=\"\", textvariable=result ,bg = \"white\", font=(\"Arial\", 17)).grid(row=17,column=1, sticky=W)\n",
    "\n",
    "# store variables\n",
    "gender = Entry(master,width = 30)\n",
    "gender.grid(row=6, column=1)\n",
    "age = Entry(master,width = 30)\n",
    "age.grid(row=7, column=1)\n",
    "hypertension = Entry(master,width = 30)\n",
    "hypertension.grid(row=8, column=1)\n",
    "heart_disease = Entry(master,width = 30)\n",
    "heart_disease.grid(row=9, column=1)\n",
    "ever_married = Entry(master,width = 30)\n",
    "ever_married.grid(row=10, column=1)\n",
    "work_type = Entry(master,width = 30)\n",
    "work_type.grid(row=11, column=1)\n",
    "Residence_type = Entry(master,width = 30)\n",
    "Residence_type.grid(row=12, column=1)\n",
    "avg_glucose_level = Entry(master,width = 30)\n",
    "avg_glucose_level.grid(row=13, column=1)\n",
    "bmi = Entry(master,width = 30)\n",
    "bmi.grid(row=14, column=1)\n",
    "smoking_status = Entry(master,width = 30)\n",
    "smoking_status.grid(row=15, column=1)\n",
    "\n",
    " \n",
    "# creating a button using the widget \n",
    "b = Button(master, text=\"Predict\", command=predict_stroke, bg = \"white\", font=(\"Arial\", 12))\n",
    "b.grid(row=16, column=1,columnspan=1, rowspan=1,padx=5, pady=5,)\n",
    " \n",
    "mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90a126ad-f3a8-43f3-a718-aa8871726274",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}