2nd_workbook_stroke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bcb50f0d",
   "metadata": {},
   "source": [
    "# workbook stroke 2nd itteration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe92c44",
   "metadata": {},
   "source": [
    "# Goals\n",
    "* Discover the drivers that increase the risk factor of stroke\n",
    "* Use drivers to develop a machine learning model to predict weather or not a patient has had a stroke.\n",
    "* Use findings to see what preventitave measures if any can be taken to decrease the risk of stroke"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a6c7c2",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "284617e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import scipy.stats as stats\n",
    "\n",
    "\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b4faa9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decision Tree and Model Evaluation Imports\n",
    "from sklearn.tree import DecisionTreeClassifier, plot_tree, export_text\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88c8a038",
   "metadata": {},
   "source": [
    "# Acquire\n",
    "* Data acquired from kaggle on 12-13-2022\n",
    "    https://www.kaggle.com/datasets/fedesoriano/stroke-prediction-dataset?select=healthcare-dataset-stroke-data.csv\n",
    "* Data contains 5110 rows and 12 columns\n",
    "* Each row represents a patient and information about the patient\n",
    "* Each column representa a features related to the patient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad3e0375",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stroke_data():\n",
    "    '''get_stroke_data takes retrives stroke data from csv file saved locally\n",
    "    input:\n",
    "        none\n",
    "    output:\n",
    "        df - data frame\n",
    "    '''\n",
    "    df = pd.read_csv('healthcare-dataset-stroke-data.csv')\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0abbfba",
   "metadata": {},
   "outputs": [],
   "source": [
    "df= get_stroke_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41b20b3e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dcd8e38f",
   "metadata": {},
   "source": [
    "# Prepare\n",
    "prepare actions:\n",
    "  * removed columns with unnecessary information\n",
    "  * renamed columns and values\n",
    "  * 211 null values where found and will be imputed after split\n",
    "  * Outliers have not been removed\n",
    "  * Encoded categorical variables\n",
    "  * Split data into train, validate and test:\n",
    "        -(Approximately: train 56%, validate 24%, test 20%)\n",
    "\n",
    "  * impute 211 null values under BMI column with median due to the right skewness of feature \n",
    "  \n",
    "  * Continuous variables will be scaled before modeling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "497f3a5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dummy(df, columns):\n",
    "    '''\n",
    "    dummy_var takes in data frame and column list and creates dummy variables for columns\n",
    "    appends dummy to main data frame\n",
    "    \n",
    "    returns data frame\n",
    "    '''\n",
    "    # create dummies\n",
    "    dummy_df = pd.get_dummies(df[\n",
    "                                    columns], dummy_na=False)\n",
    "    \n",
    "    # Concatenate dummy_df to original data frame\n",
    "    df = pd.concat([df, dummy_df], axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4634b7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rename_columns_and_values(df):\n",
    "    ''' \n",
    "    rename_columns_and_values renames columns and values \n",
    "    returns dataframe\n",
    "    input:\n",
    "        df - dataframe\n",
    "    output:\n",
    "        df- dataframe\n",
    "    '''\n",
    "    # rename column to lowercase \n",
    "    df.rename(columns = {'Residence_type':'residence_type'}, inplace=True)\n",
    "    \n",
    "    # renames values of smoking status \n",
    "    df.smoking_status.replace({'never smoked': 'never_smoked', 'Unknown':'unknown',\n",
    "                               'formerly smoked':'formely_smoked'},inplace=True)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b8a561b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_prep(df):\n",
    "    '''\n",
    "    data_prep takes in a dataframe and prepares for exploration: renames columms, drops unuseful columns\n",
    "    input:\n",
    "        df = data frame\n",
    "    output:\n",
    "        df = data frame\n",
    "    '''\n",
    "    # use rename_columns_and_values functin to rename columns\n",
    "    df = rename_columns_and_values(df)\n",
    "    \n",
    "\n",
    "    \n",
    "    # drop columns with unnecessary information\n",
    "    df.drop(columns = {'id'},inplace=True)\n",
    " \n",
    "    \n",
    "    # categorical columns that will have dummy variables\n",
    "    dummy_columns=['gender', 'ever_married','work_type', 'residence_type','smoking_status']\n",
    "    \n",
    "    # use dummy function to get dummy columns\n",
    "    df = dummy(df, dummy_columns)\n",
    "    \n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb540d5f",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "df = data_prep(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1423f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "595787bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f2bed22",
   "metadata": {},
   "outputs": [],
   "source": [
    "def impute_bmi_median(train, validate, test):\n",
    "    '''\n",
    "    Takes in train, validate, and test, and uses train to identify the best value to replace nulls in embark_town\n",
    "    Imputes that value into all three sets and returns all three sets\n",
    "    '''\n",
    "    imputer = SimpleImputer(missing_values = np.nan, strategy='median')\n",
    "    train[['bmi']] = imputer.fit_transform(train[['bmi']])\n",
    "    validate[['bmi']] = imputer.transform(validate[['bmi']])\n",
    "    test[['bmi']] = imputer.transform(test[['bmi']])\n",
    "    return train, validate, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbecc92b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_and_impute_data(df, target):\n",
    "    '''\n",
    "    split_date takes in a dataframe  and target variable and splits into train , validate, test \n",
    "    and stratifies on target variable\n",
    "    \n",
    "    The split is 20% test 80% train/validate. Then 30% of 80% validate and 70% of 80% train.\n",
    "    Aproximately (train 56%, validate 24%, test 20%)\n",
    "    \n",
    "    returns train, validate, and test \n",
    "    '''\n",
    "    # split test data from train/validate\n",
    "    train_validate, test = train_test_split(df, test_size=.2, \n",
    "                                        random_state=123, \n",
    "                                        stratify=df[target])\n",
    "\n",
    "    # split train from validate\n",
    "    train, validate = train_test_split(train_validate, test_size=.3, \n",
    "                                   random_state=123, \n",
    "                                   stratify=train_validate[target])\n",
    "    # use impute_bmi_median function to fill in nulls in bmi columns after data split\n",
    "    train, validate, test =impute_bmi_median(train, validate, test)\n",
    "                                   \n",
    "    return train, validate, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51db4bb8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train, validate, test = split_and_impute_data(df, 'stroke')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5abcf41a",
   "metadata": {},
   "source": [
    "# Data Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f8da65",
   "metadata": {},
   "source": [
    "| Feature    | Description    | \n",
    "| :------------- | -------------: | \n",
    "|      id     |   unique identifier      | \n",
    "|   gender       |    Gender of patient Male or Female or Other     | \n",
    "| age|     age of the patient     | \n",
    "|      hypertension    |     If a patient has hypertension  (1 = yes, 0 = no)  | \n",
    "|      hear_disease     |     If a patient has any heart diseases  (1 = yes, 0 = no)  | \n",
    "|       ever_married   |   If a patient has ever been married (1 = yes, 0 = no)      | \n",
    "|    work_type       |    The work type of patient. *Children are under children category     | \n",
    "|  residence_type        |     If a patient residence is  rural of urban   | \n",
    "|   avg_glucose_level        |    average glucose level in blood     | \n",
    "|     bmi     |   body mass index of patient      | \n",
    "|   smoking_status       |    smoking status of patient * Unknown represent the information was unavailable     | \n",
    "|          |         | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "322c9696",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.shape, validate.shape, test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c2591cc",
   "metadata": {},
   "source": [
    "# Explore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a686a8d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "pal = sns.color_palette('Blues')\n",
    "pal.as_hex()[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "410dab8b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "pal = sns.color_palette('Blues')\n",
    "pal.as_hex()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f18f1eda",
   "metadata": {},
   "source": [
    "# 1. What is the percent of patients who have a stroke?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db51dca1",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(9, 7),facecolor='floralwhite')\n",
    "\n",
    "sizes = np.array([len(train[train.stroke == 0]), len(train[train.stroke ==1])])\n",
    "labels = [\"No Stroke\", \"Stroke Ocurred\"]\n",
    "explode = [0.25,0 ]\n",
    "colors = ['#bad6eb', '#2b7bba']\n",
    "\n",
    "# Capture each of the return elements.\n",
    "patches, texts, pcts = ax.pie(\n",
    "    sizes, labels=labels, autopct='%.2f%%', explode=explode,colors=colors,\n",
    "    wedgeprops={'linewidth': 3.0, 'edgecolor': 'white'},\n",
    "    textprops={'size': 16})\n",
    "# Style just the percent values.\n",
    "plt.setp(pcts, color='white', fontweight='bold')\n",
    "ax.set_title('Percent of patient who have suffer a stroke', fontsize=25,color='#0b559f')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d63ca489",
   "metadata": {},
   "source": [
    "***about 5 % of our patients have suffer a stroke***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23db6d6c",
   "metadata": {},
   "source": [
    "# 2. Does the presense of hypertension increase the risk of stroke?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55dfc7dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chi_square_test(df,target, feature):    \n",
    "    '''chi_squre_test takes in a dataframe, target variable and feature \n",
    "    to create a crosstab between the target variable and feature and\n",
    "    perform a chi square test\n",
    "    returns '''\n",
    "    alpha = 0.05\n",
    "\n",
    "    # Setup a crosstab of observed \n",
    "    observed = pd.crosstab(train[feature]== 1, train[target])\n",
    "\n",
    "    t_stat, p_val, degf, expected = stats.chi2_contingency(observed)\n",
    "\n",
    "\n",
    "    print(f' Chi-Square:{t_stat}')\n",
    "    print(f' p-value:{p_val}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb4d4c98",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(9, 7))\n",
    "ax=sns.barplot(x=\"hypertension\", y='stroke', data=train, palette='Blues',edgecolor='white',linewidth=3)\n",
    "mean_line = train.stroke.mean()\n",
    "plt.axhline(mean_line, label='Stroke Rate', color='#0b559f',linestyle='-.', linewidth=3)\n",
    "\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Hypertension', fontsize=16)\n",
    "ax.set_ylabel('Stroke Rate', fontsize=16)\n",
    "ax.set_title('Hypertension Population', fontsize=30,color='#0b559f')\n",
    "\n",
    "ax.set_xticklabels(['No','Yes'],fontsize=15)\n",
    "plt.text(-.1, .055, 'Average Stroke Rate of the Population', fontsize = 15,color='black',rotation=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bd7a1d1",
   "metadata": {},
   "source": [
    "***It appears that patients with hypertension tend to have a higher stroke rate thatn patients without hyprtension***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b7184d3",
   "metadata": {},
   "source": [
    "### I will now conduct a chi-square test to determine if there is an association between hypertension  and stroke.\n",
    "\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "\n",
    "$H_0$ : Hypertension is **independent**   of stroke.\n",
    "\n",
    "$H_a$: Hypertension is **dependent** of stroke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b45a6f3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "chi_square_test(train,'stroke', 'hypertension')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f609740",
   "metadata": {},
   "source": [
    "Since the p-value is less than alpha we reject the null hypothesis. There is evidence to support that hypertention has an association with stroke. I believe that hypertention is a driver of stroke. Adding an encoded version of this feature to the model will likely increase the mode's accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0109f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "observed = pd.crosstab(train['hypertension']==1, train.stroke)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8797cc00",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "observed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb02cd44",
   "metadata": {},
   "outputs": [],
   "source": [
    "chi2, p, degf, expected = stats.chi2_contingency(observed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ac6cdd0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "expected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "776f8f11",
   "metadata": {},
   "outputs": [],
   "source": [
    "Do patients with heart disease have a hi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "001b52b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(15, 7))\n",
    "\n",
    "plt.subplot(122)\n",
    "ax=sns.barplot(x=\"hypertension\", y='stroke', data=train, palette='Blues',edgecolor='white',linewidth=3)\n",
    "mean_line = train.stroke.mean()\n",
    "plt.axhline(mean_line, label='Stroke Rate', color='#0b559f',linestyle='-.', linewidth=3)\n",
    "\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Hypertension', fontsize=16)\n",
    "ax.set_ylabel('Stroke Rate', fontsize=16)\n",
    "ax.set_title('Hypertension Population', fontsize=30,color='#0b559f')\n",
    "ax.set_ylim(0, 0.200)\n",
    "ax.set_xticklabels(['No','Yes'],fontsize=15)\n",
    "plt.text(-.1, .055, 'Average Stroke Rate of the Population', fontsize = 15,color='black',rotation=0)\n",
    "\n",
    "\n",
    "plt.subplot(121)\n",
    "ax2=sns.barplot(x=\"heart_disease\", y='stroke', data=train, palette='Blues',edgecolor='white',linewidth=3)\n",
    "mean_line = train.stroke.mean()\n",
    "plt.axhline(mean_line, label='Stroke Rate', color='#0b559f',linestyle='-.', linewidth=3)\n",
    "\n",
    "ax2.set(facecolor='floralwhite')\n",
    "ax2.set_xlabel('Heart disease', fontsize=16)\n",
    "ax2.set_ylabel('Stroke Rate', fontsize=16)\n",
    "ax2.set_ylim(0, 0.200)\n",
    "ax2.set_title('HeartPopulation', fontsize=30,color='#0b559f')\n",
    "\n",
    "ax2.set_xticklabels(['No','Yes'],fontsize=15)\n",
    "plt.text(-.1, .055, 'Average Stroke Rate of the Population', fontsize = 15,color='black',rotation=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbbb5645",
   "metadata": {},
   "source": [
    "# 3. Controling for gender of a patient, does hypertension increases risk of stroke?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed99b93c",
   "metadata": {},
   "source": [
    "### * note\n",
    "subset female then subset male test \n",
    "\n",
    "hypertension vs stroke use female\n",
    "\n",
    "then male\n",
    "\n",
    "null_hypothesis = \"survival and pclass are independent for female passengers\"\n",
    "alternative_hypothesis = \"survival and pclass are dependent for female passengers\"\n",
    "\n",
    "alpha = 0.05\n",
    "observed = pd.crosstab(female_subset.survived, female_subset.pclass)\n",
    "chi2, p, degf, expected = stats.chi2_contingency(observed)\n",
    "\n",
    "if p < alpha:\n",
    "    print(\"We reject the null hypothesis that\", null_hypothesis)\n",
    "    print(\"Evidence suggests that\", alternative_hypothesis)\n",
    "else:\n",
    "    print(\"We fail to reject the null hypothesis\")\n",
    "    print(\"We find insufficient evidence to support the claim that\", alternative_hypothesis)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "949210ee",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train[train['gender_Male']==1].heart_disease.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a688fd7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train[train['gender_Male']==0].heart_disease.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f01fb56",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "train.gender.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c75a3d57",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.countplot(x='gender',data=train, hue = 'stroke')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44b9fe99",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "ax = sns.barplot(data=train, x='gender_Male', y='stroke',hue='hypertension',palette='Blues',\n",
    "                 edgecolor='white',linewidth=3)\n",
    "plt.text(0, .055, 'Average Stroke Rate of the Population', fontsize = 15,color='black',rotation=0)\n",
    "plt.axhline(mean_line, label='Stroke Rate', color='#0b559f',linestyle='-.', linewidth=3)\n",
    "\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Gender', fontsize=16)\n",
    "ax.set_ylabel('Stroke', fontsize=16)\n",
    "ax.set_title('Hypertension by gender', fontsize=30,color='#0b559f')\n",
    "ax.set_xticklabels(['Female','Male'],fontsize=15)\n",
    "#ax.set_yticklabels(labels=labels,fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7efcfd71",
   "metadata": {},
   "source": [
    "***It appears that males with hypertension have an above average stroke rate.\n",
    "Also males with hypertensio have a higher stroke rate than females***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "344cb661",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create subgroups for male and female\n",
    "male_subset = train[train.gender_Male==1]\n",
    "female_subset = train[train.gender_Male==0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1e5f58c",
   "metadata": {},
   "source": [
    "### I will now conduct a chi-square test  is the male population with hypertendion associated with stroke.\n",
    "\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "\n",
    "$H_0$ : Males with hypertension is **independent**   of stroke.\n",
    "\n",
    "$H_a$: Males with hypertension is **dependent** of stroke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb810a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "chi_square_test(male_subset,'stroke', 'hypertension')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9d41fc2",
   "metadata": {},
   "source": [
    "Since the p-value is less than alpha we reject the null Hypothesis. There is evidence to support that males hypertention has an association with stroke. I believe that hypertention is a driver of stroke. Adding an encoded version of this feature to the model will likely increase the mode's accuracy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "500d8e71",
   "metadata": {},
   "source": [
    "### I will now conduct a chi-square test  is the female population with hypertendion associated with stroke.\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "\n",
    "$H_0$ : Females with hypertension is **independent**   of stroke.\n",
    "\n",
    "$H_a$: Females with hypertension is **dependent** of stroke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6fb7d95",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "chi_square_test(female_subset,'stroke', 'hypertension')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a2d6d71",
   "metadata": {},
   "source": [
    "Since the p-value is less than alpha we reject the null Hypothesis. There is evidence to support that females with hypertention has an association with stroke. I believe that hypertention is a driver of stroke. Adding an encoded version of this feature to the model will likely increase the mode's accuracy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98ce3c1",
   "metadata": {},
   "source": [
    "### subgroups of males with hypertension and females and hypertension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97e59716",
   "metadata": {},
   "outputs": [],
   "source": [
    "male_subset_with_h = train[(train.gender_Male==1) & (train.hypertension==1)]\n",
    "female_subset_with_h = train[(train.gender_Male==0)& (train.hypertension==1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "415c735f",
   "metadata": {},
   "outputs": [],
   "source": [
    "chi_square_test(male_subset_with_h,'stroke', 'hypertension')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd9a3ed",
   "metadata": {},
   "source": [
    "# 4. Is age a driver of stroke?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf0945a3",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sns.stripplot(data=train,y='age',x='stroke', alpha=0.5,jitter=True )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77faee71",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b95281cd",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,5))\n",
    "\n",
    "plt.subplot(121)\n",
    "ax= sns.histplot(x='age', data=train, hue='stroke',multiple='dodge', kde= True, bins = 8,)\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Age', fontsize=16)\n",
    "ax.set_ylabel('Population Count', fontsize=16)\n",
    "ax.set_title('Population vs Age', fontsize=30,color='#0b559f')\n",
    "\n",
    "plt.subplot(122)\n",
    "ax2 = sns.stripplot(data=train,y='age',x='stroke', alpha=0.5,jitter=True )\n",
    "ax2.set(facecolor='floralwhite')\n",
    "ax2.set_xlabel('Stroke ', fontsize=16)\n",
    "#ax2.set_ylabel('Population Count', fontsize=16)\n",
    "ax2.set_title('Age vs Stroke', fontsize=30,color='#0b559f')\n",
    "#ax.set_yticklabels([0,100,200,300,400,500],fontsize=15)\n",
    "ax2.set_xticklabels(['No','Yes'],fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f2f1fce",
   "metadata": {},
   "source": [
    "***It seems that with as our patients age increases so does the instances the occurance of a stroke.***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5022836e",
   "metadata": {},
   "source": [
    "### I will conduct a t-test to determine if the population who has suffer a stroke has a higher mean age thatn the population who has not had a stoke occurance.\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "* This will be a two-tail Independent t-test\n",
    "\n",
    "$H_0$ : The mean age of patients who have suffer a stroke <= to the mean age of patients who have not suffer a stroke\n",
    "\n",
    "$H_a$: The mean age of patients who have suffer a stroke > to the mean age of patients who have not suffer a stroke\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93d4c515",
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_tail_ttest(df,target, continuous_feature):\n",
    "    \n",
    "    # create two independent sample group of customers: churn and not churn.\n",
    "    subset_feature =df[df[target]==1]\n",
    "    subset_no_feature = df[df[target] == 0]\n",
    "\n",
    "    # # stats Levene test - returns p value. small p-value means unequal variances\n",
    "    stat, pval =stats.levene( subset_feature[continuous_feature], subset_no_feature[continuous_feature])\n",
    " \n",
    "\n",
    "    # high p-value suggests that the populations have equal variances\n",
    "    if pval < 0.05:\n",
    "        variance = False\n",
    "\n",
    "    else:\n",
    "        variance = True\n",
    "\n",
    "    \n",
    "    # perform t-test\n",
    "    t_stat, p_val = stats.ttest_ind(subset_feature[continuous_feature], subset_no_feature[continuous_feature],\n",
    "                                    equal_var=variance,random_state=123)\n",
    "\n",
    "    # round  and print results\n",
    "    #t_stat = t_stat.round(4)\n",
    "    #p_val = (p_val.round(4))/2\n",
    "    print(f't-stat {t_stat}')\n",
    "    print(f'p-value {p_val/2}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6263cdaf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "two_tail_ttest(train,'stroke','age')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca72930f",
   "metadata": {},
   "source": [
    "Since the p-value/2 is less than alpha we reject the null Hypothesis. There is evidence to support that patients who suffer a stroke  on average are older than patients who have not suffer a stroke. Based on this statistical finding I believe that age is a driver of stroke. Adding an scaled version of this feature to the model will likely increase the model ability to predict home value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97162529",
   "metadata": {},
   "source": [
    "# 5. Is a higher level of glucose and indicator of stroke risk?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "626e5524",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,5))\n",
    "\n",
    "plt.subplot(121)\n",
    "ax= sns.histplot(x='avg_glucose_level', data=train, hue='stroke',multiple='dodge', kde= True, bins = 8,)\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('glucose', fontsize=16)\n",
    "ax.set_ylabel('Population Count', fontsize=16)\n",
    "ax.set_title('Population vs Avg Glucose Level', fontsize=24,color='#0b559f')\n",
    "#ax.set_yticklabels([0,100,200,300,400,500],fontsize=15)\n",
    "#ax.set_xticklabels([0,20,40,60,80],fontsize=15)\n",
    "\n",
    "plt.subplot(122)\n",
    "ax2 = sns.stripplot(data=train,y='avg_glucose_level',x='stroke', alpha=0.5,jitter=True )\n",
    "ax2.set(facecolor='floralwhite')\n",
    "ax2.set_xlabel('Stroke ', fontsize=16)\n",
    "ax2.set_ylabel('Average Glucose Level', fontsize=16)\n",
    "ax2.set_title('Glucose vs Stroke', fontsize=24,color='#0b559f')\n",
    "#ax.set_yticklabels([0,100,200,300,400,500],fontsize=15)\n",
    "ax2.set_xticklabels(['No','Yes'],fontsize=15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba64d3d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "\n",
    "ax= sns.boxplot(data= train, y='avg_glucose_level',x='stroke',palette='Blues')\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Stroke', fontsize=16)\n",
    "\n",
    "ax.set_ylabel('Average Glucose Level', fontsize=16)\n",
    "ax.set_title('Average Glucose Level', fontsize=30,color='#0b559f')\n",
    "#ax.set_yticklabels([0,50,100,150,200,250],fontsize=15)\n",
    "ax.set_xticklabels(['No','Yes'],fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0bd13e",
   "metadata": {},
   "source": [
    "### I will conduct a t-test to determine if the population who has suffer a stroke has a higher mean age thatn the population who has not had a stoke occurance.\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "* This will be a two-tail Independent t-test\n",
    "\n",
    "$H_0$ : The mean glucose level of patients who have suffer a stroke <= to the mean glucose level of patients who have not suffer a stroke\n",
    "\n",
    "$H_a$: The mean glucose level of patients who have suffer a stroke > to the mean glucose level of patients who have not suffer a stroke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e5d0cf5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "two_tail_ttest(train,'stroke','avg_glucose_level')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ed501d4",
   "metadata": {},
   "source": [
    "Since the p-value/2 is less than the alpha we reject the null Hypothesis. There is evidence to support that patients who suffer a stroke have on average  a higher mean glucose level. Based on this statistical finding I believe that age is a driver of stroke .Adding an scaled version of this feature to the model will likely increase the model ability to predict home value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bcf25a1",
   "metadata": {},
   "source": [
    "### note\n",
    "A blood sugar level less than 140 mg/dL (7.8 mmol/L) is normal. A reading of more than 200 mg/dL (11.1 mmol/L) after two hours means you have diabetes. A reading between 140 and 199 mg/dL (7.8 mmol/L and 11.0 mmol/L) means you have prediabetes.\n",
    "\n",
    "If your BMI is 18.5 to 24.9, it falls within the normal or Healthy Weight range. If your BMI is 25.0 to 29.9, it falls within the overweight range. If your BMI is 30.0 or higher, it falls within the obese range."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd68906",
   "metadata": {},
   "source": [
    "# 6. Do patients who have ever been married suffer more strokes than patients that have not been married"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "872e3885",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.ever_married_Yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85ce0b4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "\n",
    "\n",
    "ax= sns.countplot(data=train, x='ever_married_Yes', hue='stroke',palette='Blues')\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Ever Married', fontsize=16)\n",
    "\n",
    "ax.set_ylabel('Stroke Rate', fontsize=16)\n",
    "ax.set_title('Marriage vs Stroke', fontsize=30,color='#0b559f')\n",
    "#ax.set_yticklabels([0,50,100,150,200,250],fontsize=15)\n",
    "ax.set_xticklabels(['No','Yes'],fontsize=15);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b9fc3db",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "ax= sns.barplot(data=train, x='ever_married_Yes', y='stroke',palette='Blues')\n",
    "ax.set(facecolor='floralwhite')\n",
    "ax.set_xlabel('Ever Married', fontsize=16)\n",
    "\n",
    "ax.set_ylabel('Stroke Rate', fontsize=16)\n",
    "ax.set_title('Marriage vs Stroke', fontsize=30,color='#0b559f')\n",
    "#ax.set_yticklabels([0,50,100,150,200,250],fontsize=15)\n",
    "ax.set_xticklabels(['No','Yes'],fontsize=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8ddfed",
   "metadata": {},
   "source": [
    "***There seems to be a slight increase in stroke for those patients who have been married.***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c0ebb64",
   "metadata": {},
   "source": [
    "### I will now conduct a chi-square test  if patients who have been married is associated with stroke.\n",
    "\n",
    "* The confidence interval is 95%\n",
    "* Alpha is set to 0.05\n",
    "\n",
    "$H_0$ : Patients who have been married are **independent**   of stroke.\n",
    "\n",
    "$H_a$: Patients who have been married are not **dependent** of stroke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acb1e4e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "chi_square_test(train, 'stroke','ever_married_Yes')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e7772f",
   "metadata": {},
   "source": [
    "The p-value is less than alpha and we reject the null hypothesis. There is evidence to support that patients who have been married has an association with stroke. I believe that marriage is a driver of stroke. Adding an encoded version of this feature to the model will likely increase the mode's accuracy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5352f1e",
   "metadata": {},
   "source": [
    "# Do people who have no cronic disease suffer strokes less than the population?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9443b364",
   "metadata": {},
   "outputs": [],
   "source": [
    "healthy_subset = train[(train.hypertension==0)&(train.heart_disease==0)&(train.avg_glucose_level<140)& (train.smoking_status== 'never_smoked')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e2b410c",
   "metadata": {},
   "outputs": [],
   "source": [
    "healthy_subset.stroke.median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cff1511b",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.stroke.median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fac5d9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.histplot(x=healthy_subset.age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35bc87e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "unhealthy_subset = train[(train.hypertension==1)|(train.heart_disease==1)|(train.avg_glucose_level>200)| (train.smoking_status== 'smokes')| (train.smoking_status== 'formely_smokes')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2f9a7fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "healthy_subset.stroke.mean(),unhealthy_subset.stroke.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79172d7f",
   "metadata": {},
   "source": [
    "# Do healthy people suffer less strokes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d21125c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    " \n",
    "# create data\n",
    "\n",
    " \n",
    "# use the scatter function\n",
    "plt.scatter(data=train,x='stroke', y='heart_disease', s=1000, alpha=0.5)\n",
    "\n",
    "# show the graph\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "257a1034",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sns.stripplot(data=train,y='heart_disease',x='stroke', alpha=0.5,jitter=True )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ce5db26",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.title(\"What's the relationship of fare and survival?\")\n",
    "plt.hist(unhealthy_subset.stroke, label=\"chronic_disease\")\n",
    "plt.hist(healthy_subset.stroke, label=\"no_chronic_disease\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79593c52",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "234ecedc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pd.set_option('display.max_columns', None)\n",
    "train[train.bmi>30].describe()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1809344e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train[train.avg_glucose_level>200].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b258338",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "num_cols = train.columns\n",
    "for col in num_cols:\n",
    "    plt.hist(df[col],)\n",
    "    plt.title(col)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d49540f2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6be8223d",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = ['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',\n",
    "       'work_type', 'residence_type', 'avg_glucose_level',\n",
    "       'smoking_status','bmi']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57cce6a0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i in features:\n",
    "        sns.barplot(x=i, y='stroke', data = train)\n",
    "        plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f973de4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for columns in features:\n",
    "        sns.boxplot(x=columns, y='stroke', data = train)\n",
    "        plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9850ffd8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for columns in features:\n",
    "        sns.histplot(x=columns, data = train,hue='stroke', alpha=0.3)\n",
    "        plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "741569d7",
   "metadata": {},
   "source": [
    "# Columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12fea86",
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical = ['gender', 'hypertension', 'heart_disease', 'ever_married',\n",
    "       'work_type', 'residence_type', \n",
    "       'smoking_status', 'stroke']\n",
    "continuous =['age','avg_glucose_level', 'bmi']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55496df7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_variable_pair(df,columns):\n",
    "\n",
    "    for i, col in enumerate(columns):\n",
    "        sns.lmplot(data=df, x=col, y='stroke', line_kws={'color':'red'})\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e641672",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_variable_pair(train,continuous)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "649be13d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_categorical_and_continuous_vars2(df):\n",
    "    categorical =[]\n",
    "    numerical =[]\n",
    "    for i in train.columns.to_list():\n",
    "        if train[i].dtypes == 'O':\n",
    "            categorical.append(i)\n",
    "        else:\n",
    "            numerical.append(i)\n",
    "    for col in categorical:\n",
    "        for col2 in numerical:\n",
    "            fig, (ax1, ax2, ax3,ax4) = plt.subplots(1,4, figsize=(25,5))\n",
    "            fig.suptitle(f'{col} vs. {col2}')\n",
    "            sns.boxplot(data=df, x=col, y=col2, ax=ax1)\n",
    "            sns.violinplot(data=df, x=col, y=col2, ax=ax2)\n",
    "            sns.barplot(data=df, x=col, y=col2, ax=ax3)\n",
    "            sns.scatterplot(data=df, x=col, y=col2, ax=ax4)\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e24a4a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_categorical_and_continuous_vars2(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff7d827d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.violinplot(data=train, x='gender',y='age',hue='stroke')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37c017fd",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sns.boxplot(data=train, x='gender',y='age',hue='stroke')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2206629",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "sns.boxplot(data=train, x='ever_married',y='age',hue='stroke')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b460e047",
   "metadata": {},
   "source": [
    "# second set stroke as hue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "088918a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_categorical_and_continuous_vars(df, cat_vars, cont_vars):\n",
    "    for col in cat_vars:\n",
    "        for col2 in cont_vars:\n",
    "            fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(16,6))\n",
    "            fig.suptitle(f'{col} vs. {col2}')\n",
    "            sns.boxplot(data=df, x=col, y=col2, ax=ax1,hue='stroke')\n",
    "            sns.violinplot(data=df, x=col, y=col2, ax=ax2,hue='stroke')\n",
    "            sns.barplot(data=df, x=col, y=col2, ax=ax3,hue='stroke')\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "647d2b97",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_categorical_and_continuous_vars(train, categorical, continuous)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1df7b7b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('storke and age')\n",
    "sns.histplot(x='age', data=train, hue='stroke',multiple='dodge', kde= True, bins = 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a35c6f26",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.title('storke and age')\n",
    "sns.histplot(x='age', data=train, hue='stroke',multiple='dodge', kde= True, bins = 8,stat='percent')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2b0c1d",
   "metadata": {},
   "source": [
    "# Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44198ac5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# pearsonr r for continuous variables\n",
    "for i in continuous:\n",
    "    α =0.05\n",
    "    corr, p = stats.pearsonr(train[i], train.stroke)\n",
    "    print('_____________________________________________________')\n",
    "    print('HYPOTHESIS')\n",
    "    print(f'H0: There is no significant difference between stroke in different {i}')\n",
    "    print(f'Ha:(There is a significant difference between stroke in different {i}')\n",
    "    print(f'{i} correlation {corr}, p-val{p}')\n",
    "    if p < α:\n",
    "        print('We reject the null hypothesis.')\n",
    "        print(f'There is a correlation between stroke and {i}')\n",
    "    else:\n",
    "        print('We fail to reject the null hypothesis.')\n",
    "        print(f'There is no correlation between stroke and {i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d50760f",
   "metadata": {},
   "source": [
    "### BMI is not correlated with stroke, age and avg_glucose are correlated with stroke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "974ff233",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_chi_significance_level(train,variable):    \n",
    "    # Chi-Square test to compare two categorical variables (senior citizen status, churn)\n",
    "\n",
    "    alpha = 0.05\n",
    "\n",
    "    # Setup a crosstab of observed \n",
    "    observed = pd.crosstab(train[variable]== 1, train.stroke)\n",
    "\n",
    "    chi2, p, degf, expected = stats.chi2_contingency(observed)\n",
    "\n",
    "    chi2 = chi2\n",
    "    p = p\n",
    "    print(f' Chi-Square:{chi2}')\n",
    "    print(f' p-value:{1-p}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80c9f9ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_chi(train,variable):    \n",
    "    # Chi-Square test to compare two categorical variables (senior citizen status, churn)\n",
    "\n",
    "    alpha = 0.05\n",
    "\n",
    "    # Setup a crosstab of observed \n",
    "    observed = pd.crosstab(train[variable]== 1, train.stroke)\n",
    "\n",
    "    chi2, p, degf, expected = stats.chi2_contingency(observed)\n",
    "\n",
    "    chi2 = chi2\n",
    "    p = p\n",
    "    print(f' Chi-Square:{chi2}')\n",
    "    print(f' p-value:{p}')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a68caa4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99a0fba7",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.smoking_status_unknown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d1ec083",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "chi_columns =['gender', 'hypertension', 'heart_disease', 'ever_married',\n",
    "       'work_type', 'residence_type', \n",
    "       'smoking_status', 'stroke', 'gender_Female', 'gender_Male', 'gender_Other',\n",
    "       'ever_married_No', 'ever_married_Yes', 'work_type_Govt_job',\n",
    "       'work_type_Never_worked', 'work_type_Private',\n",
    "       'work_type_Self-employed', 'work_type_children', 'residence_type_Rural',\n",
    "       'residence_type_Urban', 'smoking_status_formely_smoked',\n",
    "       'smoking_status_never_smoked', 'smoking_status_smokes',\n",
    "       'smoking_status_unknown']\n",
    "\n",
    "for i in chi_columns:\n",
    "    print(i)\n",
    "    get_chi(train,i)\n",
    "    print('_____________')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e315805",
   "metadata": {},
   "source": [
    "### Columns that have a relationship with stroke\n",
    "hypertension, heart_disease,ever_married_No, ever_married_Yes,work_type_Self-employed, \n",
    "* work_type_children? not sure why being a child increases chances of stroke\n",
    "\n",
    "* smoking_status_(unknonw, formerly smoked, )\n",
    "\n",
    "### Columns that have no relationship with stroke\n",
    "gender,worktype(govt, never_worked, private),never_smoked\n",
    "smoking status_smokes is .999 so not related to stroke?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13f9bbb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "train[train.work_type_children==1].stroke.mean(),train[train.smoking_status_Unknown==1].stroke.mean(),train[train['smoking_status_formerly smoked']==1].stroke.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94eb2af2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd15f22f",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "chi_columns =['gender','hypertension', 'heart_disease', 'ever_married',\n",
    "       'work_type', 'Residence_type', \n",
    "       'smoking_status', 'stroke', 'gender_Female', 'gender_Male',\n",
    "       'gender_Other', 'ever_married_No', 'ever_married_Yes',\n",
    "       'work_type_Govt_job', 'work_type_Never_worked', 'work_type_Private',\n",
    "       'work_type_Self-employed', 'work_type_children', 'Residence_type_Rural',\n",
    "       'Residence_type_Urban', 'smoking_status_Unknown',\n",
    "       'smoking_status_formerly smoked', 'smoking_status_never smoked',\n",
    "       'smoking_status_smokes']\n",
    "\n",
    "for i in chi_columns:\n",
    "    print(i)\n",
    "    get_chi_significance_level(train,i)\n",
    "    print('_____________')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fba2bcfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37380e96",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d67c265",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0129333",
   "metadata": {},
   "outputs": [],
   "source": [
    "observed = pd.crosstab(train['hypertension']==1, train.stroke)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "096f9525",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "observed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa442cb2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3471379a",
   "metadata": {},
   "outputs": [],
   "source": [
    "observed = pd.crosstab(train['hypertension'], train.stroke)\n",
    "observed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eb38bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "chi2, p, degf, expected = stats.chi2_contingency(observed)\n",
    "\n",
    "chi2 = chi2.round(4)\n",
    "p = p.round(4)\n",
    "print(f' Chi-Square:{chi2}')\n",
    "print(f' p-value:{p}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37b8791e",
   "metadata": {},
   "source": [
    "# Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02a4a307",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3a9fa27",
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_prep(train,validate,test, features):\n",
    "    \n",
    "    ''' This function takes in data that has been split into train, validate and test and prepares for modeling \n",
    "        by removing features not used for modeling and seperating the target variable into its own dataframe.\n",
    "        The following features are keept for modeling: 'monthly_charges','senior_citizen','tenure', 'partner_No',\n",
    "        'partner_Yes','churn','contract_type_Month-to-month','contract_type_One year','contract_type_Two year', \n",
    "        Six data frames seperating the target variale from the selected features per train, validate and test \n",
    "        are returned\n",
    "    '''\n",
    "    \n",
    "    # drop unused columns and keep some features\n",
    "    features = features\n",
    "    train =train[features]\n",
    "    validate = validate[features]\n",
    "    test = test[features]\n",
    "        \n",
    "    #seperate target\n",
    "    x_train = train.drop(columns=['stroke'])\n",
    "    y_train = train.stroke\n",
    "\n",
    "    x_validate = validate.drop(columns=['stroke'])\n",
    "    y_validate = validate.stroke\n",
    "\n",
    "    x_test = test.drop(columns=['stroke'])\n",
    "    y_test = test.stroke\n",
    "        \n",
    "    # Convert binary categorical target variable to numeric\n",
    "    return x_train,y_train,x_validate,y_validate, x_test, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "364ee496",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.eve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d081cc30",
   "metadata": {},
   "outputs": [],
   "source": [
    "stat_features = ['age','avg_glucose_level','hypertension','heart_disease','ever_married_Yes',\n",
    "'work_type_Self-employed','smoking_status_formely_smoked', 'smoking_status_unknown','stroke']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be0cfb9a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train,y_train,X_validate,y_validate, X_test, y_test = model_prep(train,validate,test,stat_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa411091",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validate.shape,X_validate.shape,X_train.shape,y_train.shape,X_test.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c90f2cbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69dea715",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.stroke.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9171deaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "2649/ 2788"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f48841db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# baseline is 95% accuracy\n",
    "baseline = y_train.mode()\n",
    "baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7ab4cb4",
   "metadata": {},
   "source": [
    "X_train['baseline_prediction'] = int(baseline)\n",
    "X_train\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2662c464",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Loop for models\n",
    "for i in range(1, 21):\n",
    "    # Make the model\n",
    "    tree = DecisionTreeClassifier(max_depth=i,min_samples_split = 5, random_state=123)\n",
    "\n",
    "    # Fit the model (on train and only train)\n",
    "    tree = tree.fit(X_train, y_train)\n",
    "\n",
    "    # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "    y_predictions = tree.predict(X_train)\n",
    "\n",
    "    # Produce the classification report on the actual y values and this model's predicted y values\n",
    "    report = classification_report(y_train, y_predictions, output_dict=True)\n",
    "    print(f\"Tree with max depth of {i}\")\n",
    "    print(pd.DataFrame(report))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fb8c54d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2020a371",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_validate.shape,X_validate.shape,X_train.shape,y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59f65f15",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "metrics = []\n",
    "\n",
    "for i in range(1, 25):\n",
    "    # Make the model\n",
    "    tree = DecisionTreeClassifier(max_depth=i, random_state=123)\n",
    "\n",
    "    # Fit the model (on train and only train)\n",
    "    tree = tree.fit(X_train, y_train)\n",
    "    \n",
    "\n",
    "    \n",
    "    # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "    in_sample_accuracy = tree.score(X_train, y_train)\n",
    "    \n",
    "    \n",
    "    \n",
    "    out_of_sample_accuracy = tree.score(X_validate, y_validate)\n",
    "\n",
    "    # calculate recall train\n",
    "    y_pred = tree.predict(X_train)\n",
    "    in_sample_recall= recall_score(y_train, y_pred)  \n",
    "      \n",
    "    # calculate recall validate\n",
    "    y_pred = tree.predict(X_validate)\n",
    "    out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "    \n",
    "    output = {\n",
    "        \"max_depth\": i,\n",
    "        \"train_accuracy\": in_sample_accuracy,\n",
    "        \"validate_accuracy\": out_of_sample_accuracy,\n",
    "        'train_recall': in_sample_recall,\n",
    "        'validate_recall': out_of_sample_recall\n",
    "    }\n",
    "    \n",
    "    metrics.append(output)\n",
    "    \n",
    "df = pd.DataFrame(metrics)\n",
    "df[\"accuracy_difference\"] = df.train_accuracy - df.validate_accuracy\n",
    "df[\"recall_difference\"] = df.train_recall - df.validate_recall\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c4a73cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.sort_values(by=['recall_difference', 'train_recall'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "209392c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(df.max_depth, df.train_accuracy, marker = 'o', label = 'Train')\n",
    "plt.plot(df.max_depth, df.validate_accuracy, marker = 'o', label = 'Validate')\n",
    "\n",
    "\n",
    "#plt.plot(df_2.max_depth, df_2.validate_accuracy, marker = 'x', label = 'Validate')\n",
    "\n",
    "plt.title('Overfitting Occurs at Higher Values for Max Depth')\n",
    "plt.xlabel('Max Depth')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c201581c",
   "metadata": {},
   "source": [
    "\n",
    "# Random forest changing leaf\n",
    "\n",
    "for i in range(1, 21):\n",
    "  \n",
    "    # Make the model\n",
    "    random_forest = RandomForestClassifier(max_depth=10, min_samples_leaf = i , random_state=123)\n",
    "\n",
    "    # Fit the model (on train and only train)\n",
    "    random_forest = random_forest.fit(X_train, y_train)\n",
    "\n",
    "    # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "    y_pred = random_forest.predict(X_train)\n",
    "\n",
    "    # Produce the classification report on the actual y values and this model's predicted y values\n",
    "    report = classification_report(y_train, y_pred, output_dict=True)\n",
    "    print(f\"Tree with min sample leaf {i}\")\n",
    "    print(pd.DataFrame(report))\n",
    "    print()\n",
    "    \n",
    "    \n",
    "    # create data frame\n",
    "        # calculate recall train\n",
    "    y_pred = random_forest.predict(X_train)\n",
    "    in_sample_recall= recall_score(y_train, y_pred)\n",
    "    \n",
    "    # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "    in_sample_accuracy = random_forest.score(X_train, y_train)\n",
    "    \n",
    "    \n",
    "    \n",
    "    out_of_sample_accuracy = random_forest.score(X_validate, y_validate)\n",
    "\n",
    "    \n",
    "      \n",
    "    # calculate recall validate\n",
    "    y_pred = random_forest.predict(X_validate)\n",
    "    out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "    \n",
    "    output = {\n",
    "        \"max_depth\": i,\n",
    "        \"train_accuracy\": in_sample_accuracy,\n",
    "        \"validate_accuracy\": out_of_sample_accuracy,\n",
    "        'train_recall': in_sample_recall,\n",
    "        'validate_recall': out_of_sample_recall\n",
    "    }\n",
    "    \n",
    "    metrics.append(output)\n",
    "    \n",
    "df = pd.DataFrame(metrics)\n",
    "df[\"accuracy_difference\"] = df.train_accuracy - df.validate_accuracy\n",
    "df[\"recall_difference\"] = df.train_recall - df.validate_recall\n",
    "df\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78eda56c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Random forest changing max-depth and leaf\n",
    "metrics =[]\n",
    "for h in range(10,0,-1):\n",
    "    print(f'max depth {h}')\n",
    "    for i in range(1, 21):\n",
    "  \n",
    "        # Make the model\n",
    "        random_forest = RandomForestClassifier(max_depth=h, min_samples_leaf = i , random_state=123)\n",
    "\n",
    "        # Fit the model (on train and only train)\n",
    "        random_forest = random_forest.fit(X_train, y_train)\n",
    "\n",
    "        # Use the model\n",
    "        # We'll evaluate the model's performance on train, first\n",
    "        y_pred = random_forest.predict(X_train)\n",
    "        # calculate recall validate\n",
    "\n",
    "        in_sample_recall= recall_score(y_train, y_pred)     \n",
    "\n",
    "        # Produce the classification report on the actual y values and this model's predicted y values\n",
    "        report = classification_report(y_train, y_pred, output_dict=True)\n",
    "        print(f\"Tree with min sample leaf {i}\")\n",
    "        print(f'max depth {h}')\n",
    "        print(pd.DataFrame(report))\n",
    "        print()\n",
    "        \n",
    "        \n",
    "        # calculate recall validate\n",
    "        y_pred = random_forest.predict(X_validate)\n",
    "        out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "        \n",
    "        # Produce the classification report on the actual y values and this model's predicted y values\n",
    "        report = classification_report(y_validate, y_pred, output_dict=True)\n",
    "        print(f\"Tree with min sample leaf {i}\")\n",
    "        print(f'max depth {h}')\n",
    "        print(pd.DataFrame(report))\n",
    "        print()\n",
    "        \n",
    "        output = {\n",
    "            \"max_depth\": h,\n",
    "            'leaf_min':i,\n",
    "            \"train_accuracy\": in_sample_accuracy,\n",
    "            \"validate_accuracy\": out_of_sample_accuracy,\n",
    "            'train_recall': in_sample_recall,\n",
    "            'validate_recall': out_of_sample_recall\n",
    "        }\n",
    "\n",
    "        metrics.append(output)\n",
    "\n",
    "df2 = pd.DataFrame(metrics)\n",
    "df2[\"accuracy_difference\"] = df2.train_accuracy - df2.validate_accuracy\n",
    "df2[\"recall_difference\"] = df2.train_recall - df2.validate_recall\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cc5df77",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14e55944",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "metrics=[]\n",
    "for h in range(10,0,-1):\n",
    "   \n",
    "    print(f'max depth {h}')\n",
    "    \n",
    "    for i in range(1, 21):\n",
    "  \n",
    "    # Make the model\n",
    "        random_forest = RandomForestClassifier(max_depth=h, min_samples_leaf = i , random_state=123)\n",
    "    \n",
    "    # Fit the model (on train and only train)\n",
    "        random_forest.fit(X_train, y_train)\n",
    "        \n",
    "         # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "        in_sample_accuracy = random_forest.score(X_train, y_train)\n",
    "\n",
    "    # Use the model\n",
    "    # We'll evaluate the model's performance on train, first\n",
    "        y_pred = random_forest.predict(X_train)\n",
    "        \n",
    "        output = {\n",
    "        \"max_depth\": h,\n",
    "        \"min_samples_leaf\": i,\n",
    "        \"train_accuracy\": in_sample_accuracy,\n",
    "        #\"validate_accuracy\": y_pred\n",
    "    }\n",
    "\n",
    "        metrics.append(output)\n",
    "        \n",
    "        df = pd.DataFrame(metrics)\n",
    "df\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "395d4356",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.sort_values(by='train_accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb3feb08",
   "metadata": {},
   "source": [
    "# KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82e4c50b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# weights = ['uniform', 'density']\n",
    "knn = KNeighborsClassifier(n_neighbors=5, weights='uniform')\n",
    "knn.fit(X_train, y_train)\n",
    "y_pred = knn.predict(X_train)\n",
    "print('Accuracy of KNN classifier on training set: {:.3f}'\n",
    "     .format(knn.score(X_train, y_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bc4cf29",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics=[]\n",
    "for i in range(1,21):\n",
    "    # weights = ['uniform', 'density']\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, weights='uniform')\n",
    "    knn.fit(X_train, y_train)\n",
    "    y_pred = knn.predict(X_train)\n",
    "    \n",
    "\n",
    "    in_sample_accuracy =knn.score(X_train, y_train)\n",
    "\n",
    "    out_sample_accuracy =knn.score(X_validate, y_validate)\n",
    "\n",
    "    # calculate recall train\n",
    "    y_pred = knn.predict(X_train)\n",
    "    in_sample_recall= recall_score(y_train, y_pred)  \n",
    "\n",
    "    # calculate recall validate\n",
    "    y_pred = knn.predict(X_validate)\n",
    "    out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "\n",
    "    output = {\n",
    "        \"neighbor\": i,\n",
    "        \"train_accuracy\": in_sample_accuracy,\n",
    "        \"validate_accuracy\": out_of_sample_accuracy,\n",
    "        'train_recall': in_sample_recall,\n",
    "        'validate_recall': out_of_sample_recall\n",
    "    }\n",
    "\n",
    "    metrics.append(output)\n",
    "\n",
    "df = pd.DataFrame(metrics)\n",
    "df[\"accuracy_difference\"] = df.train_accuracy - df.validate_accuracy\n",
    "df[\"recall_difference\"] = df.train_recall - df.validate_recall\n",
    "df\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50bc2486",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.sort_values(by='validate_recall',ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e64945aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics=[]\n",
    "for i in range(1,21):\n",
    "    # weights = ['uniform', 'density']\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, weights='distance')\n",
    "    knn.fit(X_train, y_train)\n",
    "\n",
    "    in_sample_accuracy =knn.score(X_train, y_train)\n",
    "     \n",
    "    # calculate recall train\n",
    "    y_pred = knn.predict(X_train)\n",
    "    in_sample_recall= recall_score(y_train, y_pred)  \n",
    "\n",
    "    # calculate recall validate\n",
    "    y_pred = knn.predict(X_validate)\n",
    "    out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "\n",
    "    output = {\n",
    "        \"neighbor\": i,\n",
    "        \"train_accuracy\": in_sample_accuracy,\n",
    "        \"validate_accuracy\": out_of_sample_accuracy,\n",
    "        'train_recall': in_sample_recall,\n",
    "        'validate_recall': out_of_sample_recall\n",
    "    }\n",
    "\n",
    "    metrics.append(output)\n",
    "\n",
    "df = pd.DataFrame(metrics)\n",
    "df[\"accuracy_difference\"] = df.train_accuracy - df.validate_accuracy\n",
    "df[\"recall_difference\"] = df.train_recall - df.validate_recall\n",
    "df\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de01982",
   "metadata": {},
   "source": [
    "# Logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8317cbfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics=[]\n",
    "# from sklearn.linear_model import LogisticRegression\n",
    "logit = LogisticRegression(C=1, class_weight={0:1, 1:99}, random_state=123, intercept_scaling=1)\n",
    "logit.fit(X_train, y_train)\n",
    "\n",
    "in_sample_accuracy =logit.score(X_train, y_train)\n",
    "out_sample_accuracy=logit.score(X_validate, y_validate)\n",
    "\n",
    "# calculate recall train\n",
    "y_pred = logit.predict(X_train)\n",
    "in_sample_recall= recall_score(y_train, y_pred)  \n",
    "\n",
    "# calculate recall validate\n",
    "y_pred = logit.predict(X_validate)\n",
    "out_of_sample_recall= recall_score(y_validate, y_pred)\n",
    "\n",
    "output = {\n",
    " \n",
    "    \"train_accuracy\": in_sample_accuracy,\n",
    "    \"validate_accuracy\": out_of_sample_accuracy,\n",
    "    'train_recall': in_sample_recall,\n",
    "    'validate_recall': out_of_sample_recall\n",
    "}\n",
    "\n",
    "metrics.append(output)\n",
    "\n",
    "df2 = pd.DataFrame(metrics)\n",
    "df2[\"accuracy_difference\"] = df2.train_accuracy - df2.validate_accuracy\n",
    "df2[\"recall_difference\"] = df2.train_recall - df2.validate_recall\n",
    "df2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cbb602e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99d3e7a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ebba348",
   "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
}