main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display, clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import plotly.express as px\n",
    "import plotly.io as pio\n",
    "import seaborn as sns\n",
    "from sklearn import preprocessing, linear_model, metrics, model_selection\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "pio.renderers.default = \"notebook\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Enabling notebook extension jupyter-js-widgets/extension...\n",
      "      - Validating: ok\n",
      "Enabling: voila\n",
      "- Writing config: C:\\Users\\brady\\AppData\\Local\\Programs\\Python\\Python310\\etc\\jupyter\n",
      "    - Validating...\n",
      "      voila 0.4.0 ok\n"
     ]
    }
   ],
   "source": [
    "!jupyter nbextension enable --py widgetsnbextension --sys-prefix\n",
    "!jupyter serverextension enable voila --sys-prefix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"heart.csv\")\n",
    "\n",
    "def prepare_dataset(df):\n",
    "    # Turning all object values to a string\n",
    "    string_cols = df.select_dtypes(include=\"object\").columns\n",
    "    df[string_cols] = df[string_cols].astype(\"string\")\n",
    "\n",
    "    # Converting categorical data into dummy values\n",
    "    df_preped = pd.get_dummies(df, columns=string_cols, drop_first=False)\n",
    "    # Setting the target heart disease column to the end\n",
    "    df_preped.drop(\"HeartDisease\", axis=1, inplace=True)\n",
    "    df_preped = pd.concat([df_preped, df[\"HeartDisease\"]], axis=1)\n",
    "\n",
    "    return df_preped\n",
    "\n",
    "df_preped = prepare_dataset(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_button(description, function, clear_output=True):\n",
    "    layout = widgets.Layout(width=\"auto\", height=\"40px\")\n",
    "    button = widgets.Button(description=description, layout=layout, button_style=\"primary\")\n",
    "    output = widgets.Output()\n",
    "\n",
    "    def on_button_click(b):\n",
    "        with output:\n",
    "            if len(output.outputs) == 0:\n",
    "                button.disabled = True\n",
    "                function()\n",
    "                button.disabled = False\n",
    "            elif clear_output:\n",
    "                output.clear_output()\n",
    "            else:\n",
    "                button.disabled = True\n",
    "                output.clear_output()\n",
    "                function()\n",
    "                button.disabled = False\n",
    "\n",
    "    button.on_click(on_button_click)\n",
    "\n",
    "    display(button)\n",
    "    display(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Heart Disease Prediction Model Based on Logistic Regression\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "## Plot showing how each data point correlates to the existence of heart disease\n",
    "Negative numbers represent a lack of correlation and positive numbers represent the presence of a correlation between the two datapoints"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "485ad566a90c410d845322b0983da66d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Show Correlation Plot', layout=Layout(height='40px', width='auto'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f851efb374424440890d175b6161ff1e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def correlation_plot():\n",
    "    fig = px.imshow(df.corr(), title=\"Correlation Plot of the Heart Disease Prediction\")\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Correlation Plot\", correlation_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Heart disease distribution between male and female"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def heart_disease_distribution_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"HeartDisease\",\n",
    "                       color=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Heart Disease Distribution by Sex\",\n",
    "                       barmode=\"group\")\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Heart Disease Distribution Plot\", heart_disease_distribution_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Ratio of male to female participants in the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def male_female_ratio_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Sex Ratio Data\")\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Male to Female Ratio Plot\", male_female_ratio_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Distribution of chest pain types within the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def chest_pain_types_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"ChestPainType\",\n",
    "                       color=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Chest Pain Type Distribution\")\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Chest Pain Types Plot\", chest_pain_types_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Distribution of max heart rate within the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def max_heart_rate_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"MaxHR\",\n",
    "                       color=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Max Heart Rate Levels Distribution\",)\n",
    "    fig.update_layout(bargap=0.2)\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Max Heart Rate Plot\", max_heart_rate_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Distribution of cholesterol levels within the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def cholesterol_levels_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"Cholesterol\",\n",
    "                       color=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Cholesterol Levels Distribution\",)\n",
    "    fig.update_layout(bargap=0.2)\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Cholesterol Levels Plot\", cholesterol_levels_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Distribution of resting blood pressure levels within the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def resting_blood_pressure_plot():\n",
    "    fig = px.histogram(df,\n",
    "                       x=\"RestingBP\",\n",
    "                       color=\"Sex\",\n",
    "                       hover_data=df.columns,\n",
    "                       title=\"Resting Blood Pressure Levels Distribution\",)\n",
    "    fig.show()\n",
    "\n",
    "create_button(\"Show Resting Blood Pressure Plot\", resting_blood_pressure_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Relationships between every datapoint in the dataset"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def data_relationships_plot():\n",
    "    plt.figure(figsize=(15, 10))\n",
    "    hue = \"HeartDisease\"\n",
    "    g = sns.pairplot(df, hue=hue, palette=\"husl\")\n",
    "    plt.title(\"Looking for Insights in Data\")\n",
    "    plt.legend(title=hue, loc=\"lower right\", handles=g._legend_data.values())\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "create_button(\"Show Data Relationships Plot\", data_relationships_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Frequency polygon histogram describing the distributions for every datapoint"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def data_distribution_plot():\n",
    "    plt.figure(figsize=(15, 10))\n",
    "    for i, col in enumerate(df.columns, 1):\n",
    "        plt.subplot(4, 3, i)\n",
    "        plt.title(f\"Distribution of {col} Data\")\n",
    "        sns.histplot(df[col], kde=True)\n",
    "        plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "create_button(\"Show Data Distribution Plot\", data_distribution_plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "age = 50\n",
    "sex = \"M\"\n",
    "chest_pain_type = \"ATA\"\n",
    "resting_bp = 100\n",
    "cholesterol = 100\n",
    "fasting_bs = 0\n",
    "resting_ecg = \"Normal\"\n",
    "max_hr = 100\n",
    "exercise_angina = \"N\"\n",
    "oldpeak = 0\n",
    "st_slope = \"Flat\"\n",
    "\n",
    "number_of_folds = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "## Here you can input values for each datapoint and recieve a heart disease prediction based on the inputted information"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What sex were you assigned at birth?\")\n",
    "w = widgets.Dropdown(options=[(\"Male\", \"M\"),\n",
    "                                  (\"Female\", \"F\")\n",
    "                                  ])\n",
    "def on_change(change):\n",
    "    global sex\n",
    "    sex = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"How old are you?\")\n",
    "w = widgets.BoundedIntText(\n",
    "    min=0,\n",
    "    max=125,\n",
    "    step=1,\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global age\n",
    "    age = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Which of the following types of chest pain do you have?\")\n",
    "w = widgets.Dropdown(options=[(\"Typical Angina\", \"TA\"),\n",
    "                          (\"Atypical Angina\", \"ATA\"),\n",
    "                          (\"Non-Anginal Pain\", \"NAP\"),\n",
    "                          (\"Asymptomatic\", \"ASY\")\n",
    "                          ])\n",
    "\n",
    "def on_change(change):\n",
    "    global chest_pain_type\n",
    "    chest_pain_type = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What is your resting blood pressure? (mm/Hg)\")\n",
    "w = widgets.BoundedIntText(\n",
    "    min=0,\n",
    "    max=400,\n",
    "    step=1\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global resting_bp\n",
    "    resting_bp = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What are your serum cholesterol levels? (mm/dl)\")\n",
    "w = widgets.BoundedIntText(\n",
    "    min=0,\n",
    "    max=1000,\n",
    "    step=1\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global cholesterol\n",
    "    cholesterol = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Check the box if your fasting blood sugar is greater than 120 mm/dl\")\n",
    "w = widgets.Checkbox()\n",
    "\n",
    "def on_change(change):\n",
    "    global fasting_bs\n",
    "    fasting_bs = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What are your resting electrocardiogram results?\")\n",
    "w = widgets.Dropdown(options=[(\"Normal\", \"Normal\"),\n",
    "                          (\"Having ST-T wave abnormality\", \"ST\"),\n",
    "                          (\"Showing probable or definite left ventricular hypertrophy by Estes' criteria\", \"LVH\")\n",
    "                          ])\n",
    "\n",
    "def on_change(change):\n",
    "    global resting_ecg\n",
    "    resting_ecg = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What is the maximum heart rate you have achieved?\")\n",
    "w = widgets.BoundedIntText(\n",
    "    min=60,\n",
    "    max=202,\n",
    "    step=1\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global max_hr\n",
    "    max_hr = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Check the box if you are diagnosed with exercise-induced angina\")\n",
    "w = widgets.Checkbox()\n",
    "\n",
    "def on_change(change):\n",
    "    global exercise_angina\n",
    "    exercise_angina = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What was your oldpeak measurement during the stress test? This is the measurement of ST segment depression on the electrocardiogram\")\n",
    "w = widgets.BoundedFloatText(\n",
    "    min=-5.0,\n",
    "    max=5.0,\n",
    "    step=0.1\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global oldpeak\n",
    "    oldpeak = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "print(\"During the stress test, what was the slope of the ST segment on the electrocardiogram?\")\n",
    "w = widgets.Dropdown(options=[\"Up\",\n",
    "                          \"Flat\",\n",
    "                          \"Down\"\n",
    "                          ])\n",
    "\n",
    "def on_change(change):\n",
    "    global st_slope\n",
    "    st_slope = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "<br>\n",
    "\n",
    "### Click the button below to see the odds that you have heart disease\n",
    "You will see that all prodvided metrics will change every time you click the button.<br>\n",
    "This is because each time the model is retrained on a different distribution of test and training data each time the button is clicked.<br><br>\n",
    "\n",
    "#### Here you can select the number of folds that the model will run through. The more folds there are the more accurate your prediction will be,\n",
    "#### though the speed that you recieve your prediction may take a hit"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "w = widgets.IntSlider(\n",
    "    value=100,\n",
    "    min=1,\n",
    "    max=1000,\n",
    "    step=1\n",
    ")\n",
    "\n",
    "def on_change(change):\n",
    "    global number_of_folds\n",
    "    number_of_folds = change[\"new\"]\n",
    "\n",
    "w.observe(on_change, names=\"value\")\n",
    "display(w)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def get_user_input():\n",
    "    # Asigning user values to a new dataframe\n",
    "    df_input = pd.DataFrame(columns=df_preped.columns)\n",
    "    df_input[\"Age\"] = [age]\n",
    "\n",
    "    sex_map = {\"M\": (1, 0), \"F\": (0, 1)}\n",
    "    df_input[[\"Sex_M\", \"Sex_F\"]] = sex_map.get(sex, (0, 0))\n",
    "\n",
    "    chest_pain_type_map = {\n",
    "        \"ASY\": (1, 0, 0, 0),\n",
    "        \"ATA\": (0, 1, 0, 0),\n",
    "        \"NAP\": (0, 0, 1, 0),\n",
    "        \"TA\": (0, 0, 0, 1)\n",
    "    }\n",
    "    df_input[\"ChestPainType_ASY\"], df_input[\"ChestPainType_ATA\"], df_input[\"ChestPainType_NAP\"], df_input[\n",
    "        \"ChestPainType_TA\"] = chest_pain_type_map.get(chest_pain_type, (0, 0, 0, 0))\n",
    "\n",
    "    df_input[\"RestingBP\"] = [resting_bp]\n",
    "\n",
    "    df_input[\"Cholesterol\"] = [cholesterol]\n",
    "\n",
    "    df_input[\"FastingBS\"] = [fasting_bs]\n",
    "\n",
    "    resting_ecg_map = {\n",
    "        \"LVH\": (1, 0, 0),\n",
    "        \"Normal\": (0, 1, 0),\n",
    "        \"ST\": (0, 0, 1)\n",
    "    }\n",
    "\n",
    "    df_input[\"RestingECG_LVH\"], df_input[\"RestingECG_Normal\"], df_input[\"RestingECG_ST\"] = resting_ecg_map.get(\n",
    "        resting_ecg, (0, 0, 0))\n",
    "\n",
    "    df_input[\"MaxHR\"] = [max_hr]\n",
    "\n",
    "    exercise_angina_map = {\n",
    "        \"N\": (1, 0),\n",
    "        \"Y\": (0, 1)\n",
    "    }\n",
    "    df_input[\"ExerciseAngina_N\"], df_input[\"ExerciseAngina_Y\"] = exercise_angina_map.get(exercise_angina, (0, 0))\n",
    "\n",
    "    df_input[\"Oldpeak\"] = [oldpeak]\n",
    "\n",
    "    st_slope_map = {\n",
    "        \"Down\": (1, 0, 0),\n",
    "        \"Flat\": (0, 1, 0),\n",
    "        \"Up\": (0, 0, 1)\n",
    "    }\n",
    "    df_input[\"ST_Slope_Down\"], df_input[\"ST_Slope_Flat\"], df_input[\"ST_Slope_Up\"] = st_slope_map.get(st_slope,\n",
    "                                                                                                     (0, 0, 0))\n",
    "    df_input[\"HeartDisease\"] = [-1]  # -1 is just a filler value representing no known diagnosis\n",
    "\n",
    "    return df_input"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Click the button below to see the odds that you have heart disease\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f35563abd213470ab122f39243966b14",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='View Prediction', layout=Layout(height='40px', width='auto'), style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "238783e14c38436fa20e3eb9db5dfb9c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def heart_disease_prediction():\n",
    "    df_input = get_user_input()\n",
    "    accuracy = 0\n",
    "    precision = 0\n",
    "    recall = 0\n",
    "    f1_score = 0\n",
    "    prediction = 0\n",
    "\n",
    "    for i in range(number_of_folds):\n",
    "        # Using min max scaling to normalize training/test data\n",
    "        scaler = preprocessing.MinMaxScaler()\n",
    "        scaler.fit(df_preped)\n",
    "        df_minmax = scaler.transform(df_preped)\n",
    "        df_minmax = pd.DataFrame(df_minmax, columns=df_preped.columns)\n",
    "\n",
    "        # Assigning all dependent and independent test and train datasets\n",
    "        x = df_minmax.iloc[:, :-1]\n",
    "        y = df_minmax.iloc[:, -1]\n",
    "        x_train, x_test, y_train, y_test = model_selection.train_test_split(x, y, test_size=0.3)\n",
    "\n",
    "        # Fitting Logistic Regression Model\n",
    "        logistic_regression_model = linear_model.LogisticRegression(max_iter=1000)\n",
    "        logistic_regression_model.fit(x_train, y_train)\n",
    "        logistic_regression_prediction = logistic_regression_model.predict(x_test)\n",
    "        accuracy += metrics.accuracy_score(y_test, logistic_regression_prediction) * 100\n",
    "        precision += metrics.precision_score(y_test, logistic_regression_prediction) * 100\n",
    "        recall += metrics.recall_score(y_test, logistic_regression_prediction) * 100\n",
    "        f1_score += metrics.f1_score(y_test, logistic_regression_prediction) * 100\n",
    "\n",
    "        # Prepping and applying minmax scaling on user inputted data\n",
    "        df_new = prepare_dataset(df_input)\n",
    "        df_minmax = scaler.transform(df_new)\n",
    "        df_minmax = pd.DataFrame(df_minmax, columns=df_new.columns)\n",
    "\n",
    "        # Making final prediction\n",
    "        prediction += int(logistic_regression_model.predict(df_minmax.drop(columns=[\"HeartDisease\"])))\n",
    "\n",
    "    accuracy = round(accuracy / number_of_folds, 2)\n",
    "    precision = round(precision / number_of_folds, 2)\n",
    "    recall = round(recall / number_of_folds, 2)\n",
    "    f1_score = round(f1_score / number_of_folds, 2)\n",
    "\n",
    "    prediction = round((prediction / number_of_folds) * 100, 2)\n",
    "\n",
    "    if prediction == 1:\n",
    "        prediction_result = \"The model predicts that you have heart disease,\"\n",
    "    else:\n",
    "        prediction_result = \"The model predicts that you do not have heart disease,\"\n",
    "\n",
    "    print(\"The model predicts that you have an \" + str(prediction) + \"% chance to have heart disease with an accuracy of \" + str(accuracy) + \"%, a precision of \" + str(precision) +\n",
    "          \"%, a recall of \" + str(recall) + \"%, and an f1 score of \" + str(f1_score) + \"%\")\n",
    "\n",
    "create_button(\"View Prediction\", heart_disease_prediction, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### How are my results measured?\n",
    "(Note that each result represents the average between all folds ran, thus, fewer fold values will produce less consistent results\n",
    "#### Chance of Heart Disease\n",
    "This number represents the percentage that heart disease might exist based on the user inputted values.\n",
    "#### Accuracy\n",
    "Accuracy measures the percentage of correctly predicted labels among all the labels in the test dataset.\n",
    "#### Precision\n",
    "Precision measures the percentage of correctly predicted positive labels (true positives) among all the predicted positive labels (true positives and false positives)\n",
    "#### Recall\n",
    "Recall measures the percentage of correctly predicted positive labels (true positives) among all the actual positive labels (true positives and false negatives).\n",
    "#### F1 Score\n",
    "F1 score is the harmonic mean of precision and recall. It is a measure of the balance between precision and recall."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "!pip freeze > requirements.txt"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}