Final_V1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f05780ae-e326-4ac7-89ca-75aac39af7f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "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": "code",
   "execution_count": 2,
   "id": "c8898749-10ce-4fcf-af7e-b5fa3a4d1a57",
   "metadata": {},
   "outputs": [],
   "source": [
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "eeb818b9-b149-43d7-94a8-bf25dd02fd7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eb5648a0-f683-4d65-b6b8-673029220403",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_processing(df):\n",
    "\n",
    "    \"\"\" Pre-processing \"\"\"\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",
    "    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": "markdown",
   "id": "7d822b0d-b6e3-419b-a258-18d24494b27f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Constructing Naive Bayes Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b79b4610-799f-4b86-828a-7b03f5846424",
   "metadata": {},
   "outputs": [],
   "source": [
    "class  NaiveBayes:\n",
    "\n",
    "    \"\"\"\n",
    "        Bayes Theorem:\n",
    "                                        Likelihood * Class prior probability\n",
    "                Posterior Probability = -------------------------------------\n",
    "                                            Predictor prior probability\n",
    "\n",
    "                                         P(x|c) * p(c)\n",
    "                               P(c|x) = ------------------ \n",
    "                                              P(x)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        \"\"\"\n",
    "            Attributes:\n",
    "                likelihoods: Likelihood of each feature per class\n",
    "                class_priors: Prior probabilities of classes \n",
    "                pred_priors: Prior probabilities of features \n",
    "                features: All features of dataset\n",
    "\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",
    "        \"\"\" P(c) - Prior Class Probability \"\"\"\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",
    "        \"\"\" P(x|c) - Likelihood \"\"\"\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",
    "        \"\"\" P(x) - Evidence \"\"\"\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",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bcb0aa43-26cd-4a32-9e0f-a01d7c14947c",
   "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": [
    "#Weather Dataset\n",
    "print(\"\\nStroke Dataset:\")\n",
    "\n",
    "df = pd.read_csv(\"healthcare-dataset-stroke-data.csv\")\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)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d992a2b8-89d0-49c4-bbaf-b30ced5bc5bb",
   "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>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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Male</td>\n",
       "      <td>(65, 70]</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>(215, 250]</td>\n",
       "      <td>obesity class 2</td>\n",
       "      <td>formerly smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Male</td>\n",
       "      <td>(75, 80]</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Rural</td>\n",
       "      <td>(80, 115]</td>\n",
       "      <td>obesity class 1</td>\n",
       "      <td>never smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Female</td>\n",
       "      <td>(45, 50]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>(150, 180]</td>\n",
       "      <td>obesity class 1</td>\n",
       "      <td>smokes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Female</td>\n",
       "      <td>(75, 80]</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Rural</td>\n",
       "      <td>(150, 180]</td>\n",
       "      <td>healthy weight</td>\n",
       "      <td>never smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Male</td>\n",
       "      <td>(80, 85]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Urban</td>\n",
       "      <td>(180, 215]</td>\n",
       "      <td>overweight</td>\n",
       "      <td>formerly smoked</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",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5104</th>\n",
       "      <td>Female</td>\n",
       "      <td>(10, 15]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>No</td>\n",
       "      <td>children</td>\n",
       "      <td>Rural</td>\n",
       "      <td>(80, 115]</td>\n",
       "      <td>healthy weight</td>\n",
       "      <td>Unknown</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5106</th>\n",
       "      <td>Female</td>\n",
       "      <td>(80, 85]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Urban</td>\n",
       "      <td>(115, 150]</td>\n",
       "      <td>obesity class 2</td>\n",
       "      <td>never smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5107</th>\n",
       "      <td>Female</td>\n",
       "      <td>(30, 35]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Self-employed</td>\n",
       "      <td>Rural</td>\n",
       "      <td>(80, 115]</td>\n",
       "      <td>obesity class 1</td>\n",
       "      <td>never smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5108</th>\n",
       "      <td>Male</td>\n",
       "      <td>(50, 55]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Private</td>\n",
       "      <td>Rural</td>\n",
       "      <td>(150, 180]</td>\n",
       "      <td>overweight</td>\n",
       "      <td>formerly smoked</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5109</th>\n",
       "      <td>Female</td>\n",
       "      <td>(40, 45]</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Yes</td>\n",
       "      <td>Govt_job</td>\n",
       "      <td>Urban</td>\n",
       "      <td>(80, 115]</td>\n",
       "      <td>overweight</td>\n",
       "      <td>Unknown</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4909 rows × 10 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      gender       age hypertension heart_disease ever_married      work_type  \\\n",
       "0       Male  (65, 70]            0             1          Yes        Private   \n",
       "2       Male  (75, 80]            0             1          Yes        Private   \n",
       "3     Female  (45, 50]            0             0          Yes        Private   \n",
       "4     Female  (75, 80]            1             0          Yes  Self-employed   \n",
       "5       Male  (80, 85]            0             0          Yes        Private   \n",
       "...      ...       ...          ...           ...          ...            ...   \n",
       "5104  Female  (10, 15]            0             0           No       children   \n",
       "5106  Female  (80, 85]            0             0          Yes  Self-employed   \n",
       "5107  Female  (30, 35]            0             0          Yes  Self-employed   \n",
       "5108    Male  (50, 55]            0             0          Yes        Private   \n",
       "5109  Female  (40, 45]            0             0          Yes       Govt_job   \n",
       "\n",
       "     Residence_type avg_glucose_level              bmi   smoking_status  \n",
       "0             Urban        (215, 250]  obesity class 2  formerly smoked  \n",
       "2             Rural         (80, 115]  obesity class 1     never smoked  \n",
       "3             Urban        (150, 180]  obesity class 1           smokes  \n",
       "4             Rural        (150, 180]   healthy weight     never smoked  \n",
       "5             Urban        (180, 215]       overweight  formerly smoked  \n",
       "...             ...               ...              ...              ...  \n",
       "5104          Rural         (80, 115]   healthy weight          Unknown  \n",
       "5106          Urban        (115, 150]  obesity class 2     never smoked  \n",
       "5107          Rural         (80, 115]  obesity class 1     never smoked  \n",
       "5108          Rural        (150, 180]       overweight  formerly smoked  \n",
       "5109          Urban         (80, 115]       overweight          Unknown  \n",
       "\n",
       "[4909 rows x 10 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74b967b0-8ba2-4594-9e36-2f6939991df8",
   "metadata": {},
   "source": [
    "# GUI for Bayes Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0f64c468-1a76-4692-9db5-5c74b5ed3059",
   "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 = 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 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": "7eb31c9d-eb89-477d-b211-c7d738bbb2ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "107edb81-7a57-4482-bb2f-9ced8ea98245",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cc52fa80-63bd-435e-a533-069b2a7805f9",
   "metadata": {},
   "source": [
    "# Constructing Decision Tree Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eafa8964-f7a0-40a0-9a75-c70888e0cda7",
   "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": 12,
   "id": "ce0e9311-f1f3-413d-95dd-1da040f5b08b",
   "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": "b1e9c67c-db11-4aae-bac9-64753edd1eab",
   "metadata": {},
   "source": [
    "# Constructing Random Forest Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fe4c7368-8f7a-4a9a-8df6-7d33f5453eac",
   "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": "9d3953cd-40de-4476-968b-0188dc240fb3",
   "metadata": {},
   "source": [
    "# Stroke Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6ec1f7a2-6781-4810-861b-5598fe263422",
   "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": 15,
   "id": "5890dff0-c978-4d68-a26d-e038186f115b",
   "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": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stroke_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08869ecb-3819-4416-a506-03cfaa5f8602",
   "metadata": {},
   "source": [
    "# Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "91c40282-6463-4fa4-80a2-52c063331e19",
   "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": 17,
   "id": "6d30f381-0fd7-489d-b6b4-2305fab776fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "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": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check data type of each attribute\n",
    "stroke_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d596b34d-7aeb-4482-b659-90f974975282",
   "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": 19,
   "id": "35def7d5-4366-4180-a44c-2de651378355",
   "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": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check data type of each attribute\n",
    "stroke_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5e1964ee-a0b8-4b85-8865-f5a8ff8284cf",
   "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": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check for missing values\n",
    "stroke_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2ae70583-af30-4e4b-b076-0a6fbc9af23d",
   "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": 22,
   "id": "d441d4e2-d108-4227-ac45-a93f69dfdfb5",
   "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": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# double check for missing values\n",
    "stroke_df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "65448979-33a3-41a7-8d5a-40644ff8a7c6",
   "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": "ef8da45f-bdc4-4dab-bece-178db4c04e47",
   "metadata": {},
   "source": [
    "# Decision Tree ID3 Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0634c53d-5431-4632-af95-46b76b38d9ba",
   "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": "96f26d8d-84a3-4eac-8db3-26292c71812f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# ID3 Model Evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2bf2112b-8ead-408a-bbf8-701894770b92",
   "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": 25,
   "id": "18771447-ebc6-4f0a-b195-26e28044a2dc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8925718849840255"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# accuracy score\n",
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "11d73a0b-fa84-430e-be87-a9bb11c8dcd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5760760347414351"
      ]
     },
     "execution_count": 26,
     "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": 27,
   "id": "446b8736-ec8a-4fe2-90a2-40c1262129a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.13613861386138615"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# precision score\n",
    "from sklearn.metrics import precision_score\n",
    "precision_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "49f62750-443a-48ca-8673-f91c90c5f09c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1697530864197531"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# f-1 score\n",
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3b660488-6f6e-4a8e-99a8-b2b4c588532d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.22540983606557377"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recall score\n",
    "from sklearn.metrics import recall_score\n",
    "recall_score(y_test, DT_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc731f0f-70f5-4b47-94b0-af073ec72ba4",
   "metadata": {},
   "source": [
    "# Random Forest Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "44b7bcc2-d608-406b-85d4-068f0b74b604",
   "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": 33,
   "id": "c9f242f0-0736-45ef-94a4-f055ece733f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict the test data\n",
    "RF_preds = RF_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8cbe0fe-fc1c-4e97-9bab-4c410d16440c",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Random Forest Model Evaluation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "20f63ee7-c44d-4687-a9ec-7925372e009d",
   "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": 35,
   "id": "baaf0894-241e-48d3-8824-471d28d031c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9273162939297125"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# accuracy score\n",
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "fd997067-d3e7-45fe-a127-0614f0963ab9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5651746018637046"
      ]
     },
     "execution_count": 36,
     "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": 37,
   "id": "bbe881e9-7e7e-4e22-8901-0015424e332d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# precision score\n",
    "from sklearn.metrics import precision_score\n",
    "precision_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "aeadb0f8-a1a8-4b3a-a3d6-2b42dd310347",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.18018018018018017"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# f-1 score\n",
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8708a55d-5408-4544-8e0f-1dc7abcc8e1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16393442622950818"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recall score\n",
    "from sklearn.metrics import recall_score\n",
    "recall_score(y_test, RF_preds)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "294d51fc-ec8e-4a49-b5a4-fc463780f126",
   "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": "e090d434-fa79-4bc5-8c78-435ed4550649",
   "metadata": {},
   "source": [
    "# GUI For Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "40b5750b-6cf2-40ce-97c8-b4dbdff676e2",
   "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": "3d8d861a-ac95-4f04-a8f7-f9050f6d561d",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}