workbook_stroke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e012d200",
   "metadata": {},
   "source": [
    "# workbook stroke 1st itteration"
   ]
  },
  {
   "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",
    "import explore_2 as e2\n",
    "import model_2 as m2\n",
    "import wrangle_2 as w2\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": "markdown",
   "id": "d990e24c",
   "metadata": {},
   "source": [
    "Source"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05a494f9",
   "metadata": {},
   "source": [
    "https://www.kaggle.com/datasets/fedesoriano/stroke-prediction-dataset/discussion?select=healthcare-dataset-stroke-data.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ad3278",
   "metadata": {},
   "source": [
    "https://www.cdc.gov/stroke/facts.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fd3dec",
   "metadata": {},
   "source": [
    "1) id: unique identifier\n",
    "\n",
    "2) gender: \"Male\", \"Female\" or \"Other\"\n",
    "\n",
    "3) age: age of the patient\n",
    "\n",
    "4) hypertension: 0 if the patient doesn't have hypertension, 1 if the patient has hypertension\n",
    "\n",
    "5) heart_disease: 0 if the patient doesn't have any heart diseases, 1 if the patient has a heart disease\n",
    "\n",
    "6) ever_married: \"No\" or \"Yes\"\n",
    "\n",
    "7) work_type: \"children\", \"Govt_jov\", \"Never_worked\", \"Private\" or \"Self-employed\"\n",
    "\n",
    "8) Residence_type: \"Rural\" or \"Urban\"\n",
    "\n",
    "9) avg_glucose_level: average glucose level in blood\n",
    "\n",
    "10) bmi: body mass index\n",
    "\n",
    "11) smoking_status: \"formerly smoked\", \"never smoked\", \"smokes\" or \"Unknown\"*\n",
    "\n",
    "12) stroke: 1 if the patient had a stroke or 0 if not\n",
    "\n",
    "*Note: \"Unknown\" in smoking_status means that the information is unavailable for this patient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b4faa9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad3e0375",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('healthcare-dataset-stroke-data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4365808",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9622131e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.smoking_status.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e46e752d",
   "metadata": {},
   "source": [
    "# Rename columns and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94f6e8b4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.smoking_status.replace({'never smoked': 'never_smoked', 'Unknown':'unknown','formerly smoked':'formely_smoked'},inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea94d621",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.rename(columns = {'Residence_type':'residence_type'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef46b79b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df = pd.read_csv('full_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "991ce3ff",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88989f2b",
   "metadata": {},
   "source": [
    "### there are 201 null values in bmi\n",
    "BMI will be imputed with average bmi after split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b4671a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# total of 3.9% of data is null will be imputed with median after split\n",
    "201/5110"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d69e589e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0098f7ec",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d28e693",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.bmi.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2b1c3a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45ba9a50",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.age.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab1f7606",
   "metadata": {},
   "source": [
    "### This dataset also contain children age ranges from 0 to 82"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0e02237",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.work_type.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5093133c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.work_type=='children'].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72953de6",
   "metadata": {},
   "source": [
    "### If worktype is children the age range is from 0 to 16\n",
    "worktype children means they are children"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "492fba54",
   "metadata": {},
   "source": [
    "# create Dummies"
   ]
  },
  {
   "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": "markdown",
   "id": "2ea0aac3",
   "metadata": {},
   "source": [
    "### create dummies for columns that are categorical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9745d332",
   "metadata": {},
   "outputs": [],
   "source": [
    "columns=['gender', 'ever_married',\n",
    "       'work_type', 'residence_type',\n",
    "       'smoking_status']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8bedb2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = dummy(df, columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b021216",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5f77e0e",
   "metadata": {},
   "source": [
    "# Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbecc92b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_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",
    "                                   \n",
    "    return train, validate, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc561606",
   "metadata": {},
   "outputs": [],
   "source": [
    "train, validate, test = split_data(df,'stroke')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08bf8208",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.bmi.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "770e4673",
   "metadata": {},
   "outputs": [],
   "source": [
    "train.bmi.median()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ea74a510",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2291b9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(train.bmi)"
   ]
  },
  {
   "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": "60e892b9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train, validate, test = impute_bmi_median(train, validate, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b78b0dd9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train, validate, test\n",
    "train.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2e94e45",
   "metadata": {},
   "source": [
    "# Explore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8349fcc6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b258338",
   "metadata": {
    "scrolled": true
   },
   "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": false
   },
   "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": "16f8144d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a04b1a17",
   "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": "c027c8e5",
   "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": "eeacf024",
   "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": "cf05a8bc",
   "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": "008111ca",
   "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": false
   },
   "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": "68b870c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics=[]\n",
    "# from sklearn.linear_model import LogisticRegression\n",
    "logit = LogisticRegression(C=1, class_weight={1:67, 1:99,1:80,1:45}, 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
}