Logistic Regression Advanced Case Study.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hide": true
   },
   "source": [
    "# Springboard: Logistic Regression Advanced Case Study\n",
    "\n",
    "In this case study we introduce the <b>Logistic Regression</b> algorithm, which can be used to build models that are  simple and yet effecive--in some cases. This algorithm can be used to build useful baseline models for classification problems that can be easily interpreted. For these reasons, <b>Logistic Regression</b> is considered as one of the fundamental Machine Learning algorithms associated with classification problems.\n",
    "\n",
    "Here is a list of the main concepts covered in this notebook:\n",
    "\n",
    "### Table of Contents\n",
    "* [Classification](#Classification)\n",
    "* [Citing references and data](#Citing-references-and-data)\n",
    "* [About the dataset](#About-the-dataset)\n",
    "* [The Data Science Process](#The-Data-Science-Process)\n",
    "* [Libraries that will be used](#Libraries-that-will-be-used)\n",
    "* [Loading the Data](#Loading-the-data)\n",
    "* [\"Minimal EDA\"](#\"Minimal-EDA\")\n",
    "    * [Transformaton of categorical features](#Transformation-of-categorical-features)\n",
    "    * [Proportion of classes](#Proportion-of-classes)\n",
    "    * [Side Bar: Balanced and Imbalanced Classes](#Side-Bar:-Balanced-and-Imbalanced-Classes)\n",
    "* [Optional: Building a Logistic Regression Model with Only Two Features](#Optional:-Building-a-Logistic-Regression-Model-with-Only-Two-Features)\n",
    "    * [The model building cycle](#The-model-building-cycle)\n",
    "    * [Some Comments on this Result](#Some-Comments-on-this-Result)\n",
    "* [Building a Logistic Regression Model with all Features](#Building-a-Logistic-Regression-Model-with-all-Features)\n",
    "    * [(a) Define X and y](#(a)-Define-X-and-y)\n",
    "    * [(b) Perform train/test split on $(X, y)$](#(b)-Perform-train/test-split-on-$(X,-y)$)\n",
    "    * [(c) Create an object of the class associated with the algorithm to be used--in this case LogisticRegression](#(c)-Create-an-object-of-the-class-associated-with-the-algorithm-to-be-used--in-this-case-LogisticRegression)\n",
    "    * [(d) Build an actual model using the fit method from the class associated with the algorithm to be used (using the training set)](#(d)-Build-an-actual-model-using-the-fit-method-from-the-class-associated-with-the-algorithm-to-be-used-(using-the-training-set))\n",
    "    * [(e) Predict with the built model using the predict method from the class (training set and test set)](#(e)-Predict-with-the-built-model-using-the-predict-method-from-the-class-(training-set-and-test-set))\n",
    "    * [(f) Compute performance metrics (in this case, accuracy) for the training and test predictions. In general, the metrics to be used and their interpretation will depend on the application at hand](#(f)-Compute-performance-metrics-(in-this-case,-accuracy)-for-the-training-and-test-predictions.-In-general,-the-metrics-to-be-used-and-their-interpretation-will-depend-on-the-application-at-hand)\n",
    "    * [(g) Determine if the model can be improved--repeat as needed with additional algorithms and/or by applying hyper-parameter tuning](#(g)-Determine-if-the-model-can-be-improved--repeat-as-needed-with-additional-algorithms-and/or-by-applying-hyper-parameter-tuning)\n",
    "    * [Side-Bar: NEVER EVER use just Accuracy to Measure the Performance of a Classification Algorithm!](#Side-Bar:-NEVER-EVER-use-just-Accuracy-to-Measure-the-Performance-of-a-Classification-Algorithm!)\n",
    "* [Logistic Regression Parameters in scikit-learn](#Logistic-Regression-Parameters-in-scikit-learn)\n",
    "    * [Tuning the Model](#Tuning-the-Model)\n",
    "    * [Side-Bar: Cross Validation](#Side-Bar:-Cross-Validation)\n",
    "    * [Black Box Grid Search in sklearn](#Black-Box-Grid-Search-in-sklearn)\n",
    "* [Summary](#Summary)    \n",
    "* [Optional: Appendix](#Optional:-Appendix)\n",
    "    * [A Walkthrough of the Math Behind Logistic Regression](#A-Walkthrough-of-the-Math-Behind-Logistic-Regression)\n",
    "    * [The Probabalistic Interpretation](#The-Probabalistic-Interpretation)\n",
    "    * [Maximizing the Probability of the Training Set](#Maximizing-the-Probability-of-the-Training-Set)\n",
    "    * [Discriminative vs Generative Classifiers](#Discriminative-vs-Generative-Classifiers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Credits  \n",
    "  \n",
    "We've adapted some parts of this Case Study from [Lab 5 in the CS109 course](https://github.com/cs109/2015lab5) course. Please feel free to check out the original lab, both for more exercises, as well as some ideas for this project.  \n",
    "  \n",
    "Blaine Bateman--Data Scientist, Springboard DSC TA, updated & formatted  \n",
    "  \n",
    "AJ Sanchez--Data Scientist & Software Engineer, Springboard DSC Mentor, reviewed & suggested improvements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classification tries to predict which of a set of classes an observation belongs to, where classes are things like \"dog or cat\". Mathematically, the aim is to find a model $G(X, y)$ where $X$ is a matrix of features constructed from the data, and $y$ is a vector of class labels associated with each row (instance) in $X$, such that the model $G$ does a good job predicting classes given new data $X'$. For instance, consider a doctor trying to assess whether a paitent has heart disease and needs treatment. In this case, the classes are \"has heart disease\" or \"does not have heart disease\". To have a machine do this well, we would typically feed the machine a set of data about prior patients along with whether they had heart disease (determined by some other examinations or tests), and *train* the model with the *features* (things observed about the patients, like age, weight, etc.) and the *labels* (whether the patient had heart disease). Then, given the same observations (i.e. the same features) for a *new* patient, the trained model returns the class associated with such observations, which can be used as a predictor of whether the person has heart disease or not.\n",
    "\n",
    "The main idea on which the Logistic Regression algorithm is based is shown schematically in the image below, for a simple case of two features (a.k.a. 2-D feature space). In its simpler form, the algorithm tries to find a line that divides \"things\" of two different types in this 2-D feature space. Such a line is usually called a decision boundary, but in general, the decision boundary might have a more complex form, and be in a higher dimensional space (that isn't easily represented in a 2-D chart). Of course, in reality most problems are more complex and are modeled with more than 2 dimensions, as we will see in this Case Study.\n",
    "\n",
    "![Splitting using a single line](images/onelinesplit.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Case Study Problem Definition: Predicting Heart Disease"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use a dataset containing anonymous health information to build models to predict the presence or absence of heart disease from facts and measurements on a group of adults to hone our understanding of classifiers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Citing references and data\n",
    "It's a good idea to cite the sources when you use code and data from somewhere else.  In this case, the data we will use was adapted from:  \n",
    "  \n",
    "https://archive.ics.uci.edu/ml/datasets/heart+disease"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### About the dataset\n",
    "\n",
    "There are multiple datasets available at the link, for this study we started with the processed Cleveland data (see [UCI heart disease Cleveland data](https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data)).  We updated the column names to be more self-explanatory, and removed a small number of observations missing one or more values. Please feel free to review the information and references on the UCI site to learn more about the data, as well as see versions with more features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Data Science Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should recall from the Guided Capstone, that we are following the Data Science Process:\n",
    " - Step One: Problem Identification\n",
    " - Step Two: Data Wrangling\n",
    " - Step Three: Exploratory Data Analysis\n",
    " - Step Four: Pre-processing and Training Data Development\n",
    " - Step Five: Modeling\n",
    " - Step Six: Documentation\n",
    " \n",
    "In this Case Study, we **won't complete all the steps**, but you should keep them in mind as you progress through the remainder of the project. For example, we have already completed Step One--the problem is to use machine learning to help doctors asses whether a paitent has heart disease or not, using information from examinations. Also, we noted we removed some cases with missing values, as a brief version of Step Two. Importantly, we've will highly abbreviate Step Three--EDA. In most projects you would want to spend considerable time on EDA. Step Four will be addressed as we deal with categorial variables later and split the data into training, validation, and test sets. Most of your time in the Case Study will be spend on Step Five, Modeling. In a complete project, you would often prepare a report or some presentation materials for Step Six, but will not do that here.\n",
    "\n",
    "We suggest you discuss with your mentor how these various steps can be fully addressed, and consider developing them for \"extra credit\" 😉."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this study we are going to use scikit-learn to build classification models, and we need a few other modules to visualize data and manipulate the data before modeling. Here, load the needed modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install openpyxl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Libraries that will be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Libraries\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "#\n",
    "# data manipulation and math\n",
    "#\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "#\n",
    "# plotting and visualization\n",
    "#\n",
    "import matplotlib as mpl\n",
    "import matplotlib.cm as cm\n",
    "from matplotlib.colors import ListedColormap\n",
    "import matplotlib.pyplot as plt\n",
    "#\n",
    "import seaborn as sns\n",
    "#\n",
    "# modeling\n",
    "#\n",
    "from sklearn.preprocessing import OneHotEncoder as OHE\n",
    "import sklearn.model_selection\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, f1_score\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "#\n",
    "print(\"Loaded Libraries\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note**  \n",
    "It is a good practice to put all module imports in one cell near the top of the notebook, or a group of cells near the top.  This makes it easier for another person to use your notebook later--they can see what might be needed in their Python envioronment before getting far into the notebook and having a failed import.  As you find needed modules while you develop your code, add them to a common cell near the top."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to set some options in Jupyter and for Matplotlib, Pandas and Seaborn. Don't worry if you are familiar with all the settings here--you can look them up easily if you want to customize them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "#\n",
    "plt.rcParams['figure.figsize'] = (3, 3)\n",
    "plt.style.use('seaborn-pastel')\n",
    "plt.rcParams['figure.dpi'] = 150      \n",
    "#\n",
    "c0 = sns.color_palette()[0]\n",
    "c1 = sns.color_palette()[1]\n",
    "c2 = sns.color_palette()[2]\n",
    "#\n",
    "cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])\n",
    "cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])\n",
    "cm = plt.cm.RdBu\n",
    "cm_bright = ListedColormap(['#FF0000', '#0000FF'])\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a final step of preparations, we provide two utility functions we will use to illustrate the concepts of classification using logistic regresssion. \n",
    "\n",
    "Putting this code in functions makes it efficient to re-use, as well as easier to maintain and fine-tune over time. Feel free to come back to the code for these functions and understand what they do when you use them later in the Case Study."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def points_plot(ax, Xtr, Xte, ytr, yte, \n",
    "                clf, \n",
    "                mesh = True, colorscale = cmap_light, cdiscrete = cmap_bold, \n",
    "                alpha = 0.1, psize = 10, \n",
    "                zfunc = False, predicted = False):\n",
    "#\n",
    "# note: this function only works for X.shape = (:, 2)\n",
    "# it is intended to illustrate the classifier boundary\n",
    "#\n",
    "# get the column names if they exist to apply\n",
    "# to the meshed data generated below\n",
    "#\n",
    "    try:\n",
    "        feature_names = Xtr.columns\n",
    "    except:\n",
    "        feature_names = None\n",
    "#        \n",
    "    Xtrain = np.array(Xtr)\n",
    "    Xtest = np.array(Xte)\n",
    "#\n",
    "    h = 0.02\n",
    "#\n",
    "# create a uniform grid spanning the range of the X values\n",
    "# note that y here is NOT the target, it is the 2nd\n",
    "# dimension of the desired plot\n",
    "#\n",
    "    X = np.concatenate((Xtrain, Xtest))\n",
    "    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5\n",
    "    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5\n",
    "    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),\n",
    "                         np.linspace(y_min, y_max, 100))\n",
    "#\n",
    "# predict the target value at each point in the grid\n",
    "#\n",
    "# this method uses the probabilities from the classifier\n",
    "# and applies a function to determine the class\n",
    "#\n",
    "    if zfunc:\n",
    "        mesh_data = np.c_[xx.ravel(), yy.ravel()]\n",
    "        if feature_names is not None:\n",
    "            mesh_data = pd.DataFrame(mesh_data, \n",
    "                         columns = feature_names)\n",
    "        p0 = clf.predict_proba(mesh_data)[:, 0]\n",
    "        p1 = clf.predict_proba(mesh_data)[:, 1]\n",
    "        Z = zfunc(p0, p1)\n",
    "#\n",
    "# this method uses the classifier to predict the classes directly\n",
    "#\n",
    "    else:\n",
    "        mesh_data = np.c_[xx.ravel(), yy.ravel()]\n",
    "        if feature_names is not None:\n",
    "            mesh_data = pd.DataFrame(mesh_data, \n",
    "                                     columns = feature_names)\n",
    "        Z = clf.predict(mesh_data)\n",
    "    ZZ = Z.reshape(xx.shape)\n",
    "#\n",
    "# plt.pcolormesh() creates a shaded result over the grid\n",
    "#\n",
    "    if mesh:\n",
    "        plt.pcolormesh(xx, yy, ZZ, \n",
    "                       cmap = cmap_light, \n",
    "                       alpha = alpha, \n",
    "                       axes = ax, \n",
    "                       shading = 'auto')\n",
    "#\n",
    "# add the points to the plot\n",
    "# these can be the original target values\n",
    "# or the predicted values\n",
    "#\n",
    "    if predicted:\n",
    "        showtr = clf.predict(Xtr)\n",
    "        showte = clf.predict(Xte)\n",
    "    else:\n",
    "        showtr = ytr\n",
    "        showte = yte\n",
    "#\n",
    "# plot training points\n",
    "#\n",
    "    ax.scatter(Xtrain[:, 0], Xtrain[:, 1], \n",
    "               c = showtr - 1, \n",
    "               cmap = cmap_bold, \n",
    "               s = psize, \n",
    "               alpha = alpha, \n",
    "               edgecolor = \"k\")\n",
    "#    \n",
    "# plot testing points\n",
    "#\n",
    "    ax.scatter(Xtest[:, 0], Xtest[:, 1],\n",
    "               c = showte - 1, \n",
    "               cmap = cmap_bold, \n",
    "               s = psize + 10,\n",
    "               alpha = alpha, \n",
    "               marker = \"s\")\n",
    "    ax.set_xlim(xx.min(), xx.max())\n",
    "    ax.set_ylim(yy.min(), yy.max())\n",
    "#\n",
    "    return ax, xx, yy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def points_plot_prob(ax, Xtr, Xte, ytr, yte, \n",
    "                     clf, colorscale = cmap_light, cdiscrete = cmap_bold, \n",
    "                     ccolor = cm, \n",
    "                     alpha = 0.1, psize = 10):\n",
    "    try:\n",
    "        feature_names = Xtr.columns\n",
    "    except:\n",
    "        feature_names = None\n",
    "#        \n",
    "    Xtrain = np.array(Xtr)\n",
    "    Xtest = np.array(Xte)\n",
    "#    \n",
    "    ax, xx, yy = points_plot(ax, Xtr, Xte, ytr, yte,\n",
    "                         clf,\n",
    "                         mesh = False, \n",
    "                         colorscale = colorscale, cdiscrete = cdiscrete, \n",
    "                         psize = psize, alpha = alpha,\n",
    "                         predicted = True) \n",
    "    mesh_data = np.c_[xx.ravel(), yy.ravel()]\n",
    "    if feature_names is not None:\n",
    "        mesh_data = pd.DataFrame(mesh_data, \n",
    "                     columns = feature_names)    \n",
    "    Z = clf.predict_proba(mesh_data)[:, 1]\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    plt.contourf(xx, yy, Z, cmap = ccolor, alpha = 0.2)\n",
    "    cs2 = plt.contour(xx, yy, Z, cmap = ccolor, alpha = 0.6)\n",
    "    plt.clabel(cs2, fmt = '%2.1f', colors = 'k', fontsize = 12)\n",
    "#\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a first step, read in the data and view all the columns, and display the top of the DataFrame using head()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data have  270  rows and  14  columns\n",
      "\n",
      "column names: \n",
      "\n",
      "age_yr\n",
      "sex_M_F\n",
      "chest_pain_value\n",
      "resting_BP_mm_Hg\n",
      "cholesterol_mg_dl\n",
      "fasting_blood_sugar_high\n",
      "ECG_value\n",
      "max_HR\n",
      "exercise_angina\n",
      "ST_depresssion_exercise\n",
      "ST_slope_peak\n",
      "number_vessels_involved\n",
      "defect_diag\n",
      "heart_disease\n"
     ]
    }
   ],
   "source": [
    "dflog = pd.read_excel('heart.xlsx')\n",
    "#\n",
    "print('The data have ', dflog.shape[0], ' rows and ', dflog.shape[1], ' columns\\n')\n",
    "print('column names: \\n')\n",
    "print('\\n'.join(list(dflog.columns)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### \"Minimal EDA\"\n",
    "\n",
    "Earlier we reviewed the Data Science Process and noted we would not fully complete all steps here, and in particular much more time would normally be spent on Exploratory Data Analysis (EDA). Here, we look at the first few rows of the data, plot the variables to get a feel for the data, then apply some necessary transformations followed by inspecting the distribution of the two result classes (heart disease present or not present)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age_yr</th>\n",
       "      <th>sex_M_F</th>\n",
       "      <th>chest_pain_value</th>\n",
       "      <th>resting_BP_mm_Hg</th>\n",
       "      <th>cholesterol_mg_dl</th>\n",
       "      <th>fasting_blood_sugar_high</th>\n",
       "      <th>ECG_value</th>\n",
       "      <th>max_HR</th>\n",
       "      <th>exercise_angina</th>\n",
       "      <th>ST_depresssion_exercise</th>\n",
       "      <th>ST_slope_peak</th>\n",
       "      <th>number_vessels_involved</th>\n",
       "      <th>defect_diag</th>\n",
       "      <th>heart_disease</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>70</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>130</td>\n",
       "      <td>322</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>109</td>\n",
       "      <td>0</td>\n",
       "      <td>2.4</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>67</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>115</td>\n",
       "      <td>564</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>160</td>\n",
       "      <td>0</td>\n",
       "      <td>1.6</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>57</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>124</td>\n",
       "      <td>261</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>141</td>\n",
       "      <td>0</td>\n",
       "      <td>0.3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>64</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>128</td>\n",
       "      <td>263</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>105</td>\n",
       "      <td>1</td>\n",
       "      <td>0.2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>74</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>120</td>\n",
       "      <td>269</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>121</td>\n",
       "      <td>1</td>\n",
       "      <td>0.2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   age_yr  sex_M_F  chest_pain_value  resting_BP_mm_Hg  cholesterol_mg_dl  \\\n",
       "0      70        1                 4               130                322   \n",
       "1      67        0                 3               115                564   \n",
       "2      57        1                 2               124                261   \n",
       "3      64        1                 4               128                263   \n",
       "4      74        0                 2               120                269   \n",
       "\n",
       "   fasting_blood_sugar_high  ECG_value  max_HR  exercise_angina  \\\n",
       "0                         0          2     109                0   \n",
       "1                         0          2     160                0   \n",
       "2                         0          0     141                0   \n",
       "3                         0          0     105                1   \n",
       "4                         0          2     121                1   \n",
       "\n",
       "   ST_depresssion_exercise  ST_slope_peak  number_vessels_involved  \\\n",
       "0                      2.4              2                        3   \n",
       "1                      1.6              2                        0   \n",
       "2                      0.3              1                        0   \n",
       "3                      0.2              2                        1   \n",
       "4                      0.2              1                        1   \n",
       "\n",
       "   defect_diag  heart_disease  \n",
       "0            3              1  \n",
       "1            7              0  \n",
       "2            7              1  \n",
       "3            7              0  \n",
       "4            3              0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dflog.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdQAAAGzCAYAAACW1uaOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABcSAAAXEgFnn9JSAAAwNUlEQVR4nO3debwkVXnw8d/DvgwIsrgEUETUiEEFN3BDRdFXjIrEJUZEgq/GXTGKEQ2KbxJcUNyToIxoXBBBRdwQBQSRRTZZRBhEFsUgw8gwwCDwvH/Uaafp6e67nbrd997f9/PpT92uc06d09VV9dyqOnU6MhNJkjQza4y6AZIkzQcGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA+o8FBFrRsTbIuK8iFgREVleLxh12waJiMWljYtH3ZaZioiDy2c5eRTlR6lrW9tt1G3RKhFxcvleDh5F+QmWPW+2mbVG3QC14mPAG8rfdwB/KH/fPtsNKTvJbsBVmbl4tuuXpNniGeo8ExEbAa8pb98BrJeZ9y2v74+gSbsB/wrsO0G+3wOXlamk8XI1zf75x1E3ZJx5hjr/PAxYu/z9mczMUTZmsjLzXcC7Rt0OSavLzH1G3Ya5wDPU+WeDzh+ZecsoGyJJC4kBdZ6IiH0jIoGTu+Zl1+vkMm/LiNgvIo6NiEsj4k8RcVtEXBERR0TEDhPUs0cpe21E3BERN0fElRHxw4h4e0Tcu+R7YGnPv5aiT+1pT0bEvl3LHdgpqbtDRDReHRFnlrqXR8QZEfEPE7R77Yh4a0ScXzpqLS3L3bu3jonX9tRExIsj4pRS54qI+EVEvCEi1pzBMh8dEUdFxG8j4vaIuCkifhYRb4mIdScoe9+I+FBEXBwRt5Q2XRwRH4yI+0xQdtNSdkmp9/cR8fWI2Hm6n2WC+l4cEd+LiD9ExJ8jYllEXB4R346I10fEej35J/weJ+r0VbaxV5XtannZR86MiP9b0oZtq9Pev7qXW+rZPyJOi4gbe/eXmZjOPjTReq21f0XERhHxgYj4VVlvN0bEdyLi8TP5zLMmM33NgxfwEuB6YCmQ5XV91+vYkm9xV3oCfwL+3PX+duBFA+p4b0/ZFcDynnm7lbxbl3pvKfPv6GnP9cBLupbdadfiPvWeXNIOAb5Z/v5zaXt33e8b0O4NgVO68t1Z1tPd5f2/d9VxcIXv4uCyrJOBQ8vfd5c67+pqx/eBdYeVH7D8t3S1PYFlZf123l8A3G9A2acCN/V8h7d0vV8KPGlA2QcCV3XlXdn1HawE/rZ3O5jhevxcz/e7vLS3e94DB2wrA7/HYesXWBP4atfye7+3L0+wrS7uad9U9q9O2S8AXy9/39VV/74zWJed9TLdfWjgemWG+1dXuZcBl5e/b+v5ru8A9pjpNtX2a+QN8FX5C206ASWQA9L/texUjwI2LPPWAHYAvlTK3gLcv6fcA7oOKh/pTgfuBTwJ+BSwc0+5gQevnnzDDlKdnXEpTfB4JbB+SdsK+HbXwWf7PuU/25X+DmBRmb85cHhJ6wSZgyt8B53PvKxMPwFsUdI2Bg7qOtgcNqT8ausM2LPrIPNNYNsyfx3gFcDNJe10YM2eslt3fc6LgSd2pT0Z+FVJuxH4q56yawJnd30PfwesVdIeDpzKPQP1bjNch0/q+c7u3ZW2GfCsss30bqedbWXg9zjB+j2w6zN8BNis63t7F6sC7KBtdVr7V88+sJwm2B0AbFzSFjHgn6RJrs/OepnuPjRwvTLD/atrfS8t2+XTyjoL4LFd2+VVwBoz3T/bfI28Ab4qf6ETBNRJlP9OKX9Qz/wXl/mXTXF5Aw9ePfk6B5PFfdI6O3MCT+uTvi5wXUl/d0/aNqz6R+CgCequHVATOGpAnkNYdZbQGxQGrrNywEngp/QEzJL+vK669+5J+0zXgeu+fcpuxaozlk8O+P4TeEafshsAV3Tl2W2G6/AdZTk/mGK5gQf+idZv+Qydz3/EJL7b1bbVSbSv7/7VZzt840y3wwHrZcr70LD1WmP/6kr7X2DLPul/05XniRN91lG+vIeqXieU6ZN65i8r040iYsPZa849nJ6ZP+mdmZkrgR+Utzv2JL+I5r/dW4GPDljuIdVauLr3D5j/IZrLWmvRtHFCEbEjzdkgwCGZeVdvnsw8HjirvH1ZV9mgCYoAn83M6/uUvZbmbAPgpT3JnfenZ+ZJfcreCnxwMp9jkpaV6RYzudc8RXvQnIkC/L8BeT5Csy1N16D9q9tNwH/OoI5hprMPDVNz//qvzPzfPm37JfCbabRt1hlQF6CIeGREfDoiLiydEu4uHQYS+HTJtlVPsbNonkG7H3Bm6VTzsHKgni1nDkn7XZneu2f+TmV6Tmau6FcwM5cA18ywbf1ck5lXDKjzZuAX5e1jJrm8Tr47ae5ZDXJin+Vuy6p186NJlN0sIrbtU/ePh5QdljZVP6K53/ho4KcR8Y897WlDZ1u5OjN/0y9DZi5n1ffW1zT3r25nZ+YdU2795ExnHxqm5v5Vu22zzoC6wETEG4BzgX+iuZSyiOYy1x/K6+aS9R5noZm5jOaM5waa+0GfAC4Fbio9Lv8hItamXcuHpN1Zpr1t2KJMf8dw102rRTNbZid9y0kur5Pvj+WMYpBr+yy3++9h7bq26+9+5SdbdkYy80pgf5r7jbsARwBXRsT/RsTXIuL5LfwzN+NtZbr7V4/VztIqms4+NEzN/at222adAXUBiYi/phmWcA2aXoSPoxlJadMsoykBb+tk7y2fmT+iOdPZh6Yn4uU0HZKeB3wROC8i/qrtzzFFnc+Rk8xX00R1tr3cQflmUn5Y2aqfNzP/h6Yz3GuBr9Gc5WxBc+n6m8ApEbHxwAVM3Yy2lZnuX11Wu5Q/xka5f40dA+rCsjdNb81LgZdmZr9LS/cdtoDMXJGZX8zMfTPzITSXrt5Jc3muc+Y6Tjr/7d9/gnwTpU/HsMt6AJ1/PiZ7RtLJt0UMf9a0U+8NfcpC09t3orKDyg/7TBN93inLzKWZ+Z+Z+dLM3AZ4MPAfNAfwJ9N0EurWOZNZj8HuNWD+TLeVGe9fc9Ao96+xY0BdWDoH0gsy8+4BeXafygIz87rM/CBNZw2AZ/Zk6dQzqv9Qzy3TxwzqTBURD2J4kJmurSNiuwF1bgR0BkM4Z5LL6+Rbi+Z50kE63+HZXfN+Q9O7F+AZkyh7Y899xE7dTxtS9ulD0qrIzCXZDFP55TKrd3u7qUyHfZ+DBgnobCsPiIgH9ssQEYtY9b31qr5/zQGj3L/GjgF1YflTmf5Nv/tPEfEcmsduVjPBGRE0PVZh9ctVnXtGm0yuidUdSxPUNwTePCDPu1us/z0D5h8ArE9zRnXsZBaUmRcCl5S3B/Xr/RoR/4dVAeMrXWWT5rIpwGsiYrUzpYi4P6t+WOErPcmdsk+KPj+zFRHrA/88mc8xGTPY3i4o0z36HeAj4uk092T7+SGrttd/GZDnrXQN79lj2vvXHDbq/WusGFAXls6vzewAfCpWDRO4YUS8BjiG5qH+ft4ZzRBwr4iIv1zai4h1I+LFrDqYfren3EWdOiNi1yqfYgoy87c0I+4AvD+a4REXAUTEZhFxGLAfqx7TqOlPwCsj4vCI2LzUuVFE/AurAu2nMnMqHaLeWaZPBo7p9HwtQ7+9nFWB8Gc09xm7/RvN57w38KPu7yMinkjTs3YTmjPZ/+gp+w1WnY18IyJe1Ano5d7h95h856rJ+GREHF3q+ctyI2JRRLyW5j4+rL69HU1zgN8M+EpnW42I9SPilcBxrDpTv4fSS/XQ8vbV0QzF2NlHNoqId9JcYr6pX3lmtn/NSSPev8bPqB+E9VX3xcQjJX2lk86qEUzuLH+fQ/M7qknz+6Xd5Q7uKXcrzcGhewi8S+gZMIDm8uSvuvIspRnx5Cq6Bh5gcgM7HDzkc3fad3KftEU0AyF02tA7NNohrBo67cAK38Ff2sKqoQfvKuvrzq52nEjTaWXSn6Wkv7Vnvd9EM/Rf5/2F9BmJp5R9KqtGcEqaXrS39CzryQPKPojmZ7w6eW/vWlbVoQdZfQi/5dxzJKYs3+mGfcq+vyffMlYN/3ccqwbV6LetrMWqYf8639vSru/tKJoOeUnzPG+V/WuifaDCNnkyM9uHBpZnhvvXZLaZybR/HF6eoS48L6cZC/ZCmoPgmsAvaYZVeyLNwbWf/wL+L80B4yKagLoxzQHjp2WZO2XPgAGZeSfNPbsjaILohjQ9Nx9AsyO2Lptf3XkGzVn0hTTjggbNTr5XZr6HVZekl1Wu+500gyKcTnNF6A7gfJrLY8/OzCn/6HtmfpTmudAv0fR83YDmEujPaXqRPi4z+z7GkJmn0PzE30doOs90hni7FPgw8NeZ+dMBZa+kGVLvMJp7skETVI8Bds3Mb0/1swxxCPAmmgD4K5qD9CKaTjAn0pz17JZ9nn3MzPfSDMP4c5rxYNekWeevBfZiSC/asr2+mOaRnbNYNfjGOcD+2fyM2SYl+7I+i5ju/jVnjXL/GjdRor+0YJVLVDfSjIf7lEEBRSr3Rq+m6dG8T2Z+ccRNGnsLaf/yDFVqzurWoblMdfYEebWwvYImmN4JrDYEo/paMPuXAVXzXulQ8tWIeHZEbNI1/wER8SFWPcv4selcgtX8EhFfiYi9Ox3Jyrz7RMSBwH+XWUcNuqy+0Lh/reIlX817ZSfv7pnZGeJso65536B5GP9OtKBFxDJWDf5wK02Hpu7BIH4K7JnNeMwLnvvXKgZUzXsRsRbN85XPBB5BM3zd+jSD/Z9D03PzG9m1M0TE24G3T7GqD2fmh6s0ep6IiGOBqT4utVdm/qyN9kxGROwDPIdmYP4taTpDLaPp2PRV4IuZ+ecRtGss1+V09q/5aq1RN0BqW/mv+FPlNVmLgPtMsapZ6bU8x9ybqa/HddpoyGRl5lE0QWDcjOW6nOb+NS95hipJUgV2SpIkqQIDqiRJFRhQJUmqwIAqSVIF9vIdAxFxPc14rNeMui2SNM9tDdyamdV/7N1evmMgIm5ed911N9puu76/RS1JqmTJkiWsXLlyeWZuXHvZnqGOh2u22267h1988cWjbockzWs77LADl1xySStXA72HKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQJ/vm2e+MQZo6v7jbuMrm5JGheeoUqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpArmZECNiA0i4gUR8bmIuDAibo6IFRFxQUS8NyIWDSm7T0ScFRG3RMTSiPhuROw6QX27lnxLS7mzIuKV9T+ZJGmumpMBFfh74DhgP5rP8H3gp8C2wPuAsyNiy95CEXEY8AXgEcCPgLOAZwKnRsQL+1VU5p8KPBu4sNS1PbC4LE+SpDkbUO8APgM8JDMfkZkvzsxnAw8FzgMeBnysu0BEPB14K3Aj8MjMfEEp8xTgLuDIiNi0p8ymwJHAmsDemblbZu5dln8F8NaIeFqLn1OSNEfMyYCamUdl5usy8/Ke+b8HXl/e7hUR63QlH1CmH+gul5lnAJ8F7kVzxttt/zL/W5l5bFeZPwDvKG/fNtPPI0ma++ZkQJ3ABWW6LrAZQESsBzyjzD+mT5nOvOf1zN9zSJkTgNuB3cvyJUkL2HwMqA8q0z8DS8vfD6MJsDdk5rV9ypxbpjv2zN+xJ/0vMvMO4CJgPZpLzZKkBWytUTegBW8u0+9n5sry9zZl2i+YkpkrImIZsGlEbJSZyyNiY2CTYeXK/MeU5V8wIM9fRMTFA5K2m6isJGm8zasz1Ij4P8A/0pydvqcrqfMYza1Diq/oydv96M2gcr1lJEkL1Lw5Q42Ivwa+BATwz5nZfcYYZZrDFjHB+8mUGSozd+i7kObM9eFTWZYkabzMizPUiNiK5vnQTYHDMvPwnizLy3TDIYvZoExv6SnTnTZRGUnSAjXnA2pEbA6cSHMf80jg7X2yXV2mWw1YxoY090uXZeZygMy8GfjTsHJd868ekC5JWiDmdECNiI2A79H04j0WeHVm9rusexmwEtiinM322qlML+yZf0FPenfda9OMuLSyLF+StIDN2YAaEesC36LpZfsD4GWZeVe/vJl5G/Dj8nbvPlk6877TM/+EIWX2pHlk5qTMvH0KTZckzUNzMqBGxJrAV4Cn0Yzhu1d5LnSYzri7B0XE9l3L2gV4DXAz8LmeMkeU+c+PiL26ymwJfLBnuZKkBWyu9vJ9A9AZzP6PwKcj+na4fXtm/hEgM38UEYfTPKd6fkScCKxDMzj+GsDLM3Npd+HMXBoR+wFHA8dExCmlvt1p7rl+PDNPqv3hJElzz1wNqN2D2Pf9lZjiYJoACEBmviUizqcJyM+keV71JJrxfU/rt4DM/EZEPAU4CHgCTRC+FPhUZh45g88gSZpH5mRAzcyDaYLldMouBhZPsczpwHOmU58kaWGYk/dQJUkaNwZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAqqB9SI+PuIWKf2ciVJGmdtnKF+CfhdRHw0Ih7RwvIBiIidI+LAiDg2Iq6LiIyI24fkP7jkGfT6jyFld42I70bE0oi4JSLOiohXtvPJJElz0VotLPMLwN7Am4E3RcTPgf8Gjs7MWyvW8x7g+dModzpwRZ/5v+iXOSJeCHyd5p+PU4E/As8AFkfEIzPzbdNogyRpnqkeUDPzVRHxJuDlwP7ALsATgI9FxJeBIzLz3ApVnQFcAJxdXtdPstwRmbl4MhkjYlPgSGBN4EWZeWyZfx/gNOCtEXF8Zv5kim2XJM0zrXRKyszlmfnZzHwMsBPwn0ACrwXOjohzI+I1EbHRDOo4NDP/NTO/k5l/qNT0XvsD9wK+1Qmmpe4/AO8obz1DlSS138s3M8/PzNcB9wP2BX4GPAr4NPD7iPhcROzcdjumac8yPaZP2gnA7cDuEbHe7DVJkjSOZvOxmTWBdYB1y/sof78KOCsivh4RG89CO54eER+LiM9GxEETBPMdy3S1S9SZeQdwEbAe8NAW2ilJmkPa6JR0DxHxOODVwEuADYG7gW/RXAY+BXghzeXTvYBbgbZ7z76i5/0hEfENYN/MvKWr3RsDm5S31w5Y1rXAY4BtaO7nDhURFw9I2m6ispKk8dZKQI2ITWgC1/7AI2jORq8FPkzTKeh3Xdm/HBFHA+cBz22jPcUVwNuB7wG/BTYFngJ8EHgRzRn0C7vyL+r6e1Dv5BV98kqSFqDqATUivkgToNal6Yj0fZqz0e9k5t39ymTmnRFxNi2enWbml3pmraAJ5j8Bfgm8ICJ2zcyflfSYxGInk6e7DTv0XUhz5vrwqSxLkjRe2riH+nJgGfDvwHaZ+dzM/PagYNrlOOD9LbRnqMz8Pc2jMQB7dCUt7/p7gwHFO/NvGZAuSVog2rjk+2Lgm5l551QKZebxwPEttGcyLi/T+3VmZObNEfEnmsdmtgIu6VNuqzK9ut3mSZLGXfUz1Mw8ZqrBdAxsWqa9Z5qdjkY79RaIiLVp7g+vBC5rr2mSpLmgjcHxd42Iz0fELpPI8/ja9U9VRASrOiP1Dj94Qpnu3afonjSPzJyUmQPHEJYkLQxt3EN9Pc0jMpcOyXMp8FLgdS3Uv5qI2Dwi9omIdXvmLwI+AzyeZujC43qKHgHcDDw/IvbqKrclTe9ggMNaa7gkac5o4x7qE4DzMnPZoAyZeVNEnAs8cbqVRMRzaQbI77ZOGYy/45DMPIHmsZYvAJ+IiEtp7nluQnMpdzOaTlR79w7en5lLI2I/4GjgmIg4hWZw/N1L+Y9n5knT/QySpPmjjYB6f+DMSeS7Gnj0DOrZgubMslv0zNuiTG8EDqUJ9g+mGfrwLuA3wGLgo5l5Xb9KMvMbEfEU4KBSfh2aM+xPZeaR/cpIkhaeNgLqCmDzSeTbHLhjupWUX4xZPMm8y4EDZ1DX6cBzpltekjT/tXEP9QLgSRGx1aAMJe3JwIUt1C9J0qxrI6B+nqb36/ERsdol3TLv2zSXTj/fQv2SJM26Nn5g/H8i4gU0ww+eXTofLaEZhvDBNB2B1gCOy8wv1K5fkqRRaOvXZl4C/AvNj28/prw6lgEfBf6tpbolSZp1rQTUMm7vByLiUJpgunVJugY4JzP/3Ea9kiSNSqu/h1oC5xnlJUnSvNVGpyRJkhactn5gfF3gZTQ/4H0/mt9G7Scz8xlttEGSpNnUxg+M/xVwErA9E/8Ad9auX5KkUWjjDPVDwEOAnwEfAX6NP8AtSZrn2gioe9CM07u7P2smSVoo2uiUtC5wtsFUkrSQtBFQfwkMHMdXkqT5qI2Aeijw2Ih4agvLliRpLLVxD/Vcms5Ix0fEYcCJwLUM6NGbmVe30AZJkmZVGwH1KprgGcB7ymuQbKkNkiTNqjaC2an4fKkkaYFp4+fbdqu9TEmSxp1j+UqSVEHr9y8jYntgc+DGzPx12/VJkjQKrZyhRsT6EXFoRNwI/Ao4DTiwK/1VEXFuRDyqjfolSZpt1QNqRGwInAK8HVgJnMDqg+SfCjwKeEnt+iVJGoU2zlDfCTwG+G9g28z8294MmbmE5sx19xbqlyRp1rURUF9C8yzq6zNz5ZB8v8UhCiVJ80QbAXUb4BeZedcE+W4GNm2hfkmSZl0bAXUFTa/eiWwL3NhC/ZIkzbo2AuovgMdFxNaDMkTEDsCjgTNaqF+SpFnXRkD9JLA+cGxEPLg3MSIeABxV6v5kC/VLkjTrqgfUzDwe+CiwM3BZRFxEM7bvsyLiHOBymrPTD2bmybXrlyRpFFoZ2CEzDwBeSvNj4w+neQ71/sBOwBLgFZn5rjbqliRpFFobejAzjwaOjogtgAcAawLXZuZ1bdUpSdKotD6Wb2beANzQdj2SJI2SvzYjSVIF1c9QI+LHU8iemfmM2m2QJGm2tXHJd7dJ5EmajkrZQv2SJM26NgLqtgPmrwFsDewBvBn4FPDpFuqXJGnWVQ+omfnbIcm/AU6NiJ8A3wN+TjNIviRJc9pIOiVl5o9ohig8cKK8kiTNBaPs5XsNsMMI65ckqZqRBNSIWB94LHD7KOqXJKm2Nh6b2WZI8iLgIcABNB2UvlK7fkmSRqGNXr5XMfHjMAFcBvxzC/VLkjTr2giopzI4oN4B/B44BfhKZnrJV5I0L7Tx2MxutZcpSdK4cyxfSZIqMKBKklRBG718Pz+D4pmZ/1itMZIkzZI2OiXtW6adjknRkz5ofifNgCpJmnPaCKhPA14M/BPwM+CrwNUlbRvgZcAuwGeAo1uoX5KkWddGQN0QeA2wf2b2u/z7yYh4FfDfwHcz84QW2iBJ0qxqo1PSu4GzBgRTADLzSOCskleSpDmvjYC6I83PtE3kN8DftFC/JEmzro2AuhLYaViGiIiSZ2UL9UuSNOvaCKgnAg+JiI+XX5W5hzLvYzSD5J/YQv2SJM26NgLqgcAfgdcD10TEURHxgYg4JCKOovkd1DcANwDvmm4lEbFzRBwYEcdGxHURkREx4djAEbFPRJwVEbdExNKI+G5E7DpBmV1LvqWl3FkR8crptl2SNP+0MZbvbyOi81jMM4F/6JPtJOCfMvOqGVT1HuD5UykQEYcBbwVuA34IrFfa+KyI+LvMPK5PmRcCX6f55+NUmn8WngEsjohHZubbZvAZJEnzRBuPzZCZVwJ7RMSDgCcC96cZyOF3wOmZuaRCNWcAFwBnl9f1wzJHxNNpgumNwC6ZeXmZvwtwMnBkRJycmTd1ldkUOBJYE3hRZh5b5t8HOA14a0Qcn5k/qfB5JElzWCsBtaME1itbWvah3e+bfk5DHVCmH+gE07KcMyLis8CbgP2Aj3SV2R+4F/CtTjAtZf4QEe8AjgXeBhhQJWmBa31w/IjYPiJ2iYiHtF3XkDasR3OZFuCYPlk6857XM3/PIWVOAG4Hdi/LlyQtYK0E1IhYPyIOjYgbgV/RXB49sCv9VRFxbkQ8qo36+3gYsC5wQ2Ze2yf93DLdsWf+jj3pf5GZdwAX0dyHfWildkqS5qjqATUiNgROAd5O85zpCaw+EP6pwKOAl9Suf4BtyrRfMCUzVwDLgE0jYiOAiNgY2GRYua752wxIv4eIuLjfC9huMuUlSeOrjTPUdwKPoRmrd9vM/NveDKVT0q+A3Vuov59FZXrrkDwrevIu6kobVK63jCRpgWqjU9JLgKuA12fmXUPy/ZbmLHU2dM6QcxJ5Br2fTJmhMnOHvgtpzlIfPpVlSZLGSxtnqNsAv5ggmALcDGzaQv39LC/TDYfk2aBMb+kp0502URlJ0gLVRkBdAWw+iXzb0jwTOhs6v8e6Vb/Ect93E2BZZi4HyMybgT8NK9c1/+oB6ZKkBaKNgPoL4HERsfWgDBGxA/BomsEZZsNlNB2ktoiIfsGxM5j/hT3zL+hJ/4uIWBt4RFnuZZXaKUmao9oIqJ8E1geOjYgH9yZGxAOAo0rdn2yh/tVk5m3Aj8vbvftk6cz7Ts/8E3rSu+1J88jMSZk54RjCkqT5rXpAzczjgY8COwOXRcRFNJ2BnhUR5wCX05ydfjAzT65d/xCHlelBEbF9Z2YZevA1NPd0P9dT5ogy//kRsVdXmS2BD/YsV5K0gLUysENmHgC8FPglTe/VoBnPdydgCfCKzJz2L80ARMRzI+LnnVeZvU73vIh4blebfgQcDmwGnB8R34yI79I8E7s2sF9mLu35HEtphiO8GzgmIn4SEV+nucT7YODjmXnSTD6HJGl+qP7YTBkQITPzaODoiNgCeADNAPPXZuZ1laraAnh8b/U987boTszMt0TE+TQ/H/dM4M80v3zzgcw8rV8lmfmNiHgKcBDwBGAd4FLgU5l5ZIXPIUmaB9p4DnUZcCawC0Bm3kDz26dVZeZiYPFslMvM04HnTLUuSdLC0cYl3z/R0i/MSJI0rtoIqOfh2LSSpAWmjYB6KPDYiOj3qIkkSfNSG/dQb6N53ORrEfEd4HiakYT6PquZmae20AZJkmZVGwH1ZJrnToPmB7v3HJq76f0rSdKc1kZAPYrhv+oiSdK8Uz2gZua+tZcpSdK4m3GnpIj4cUS8Y0DaxhGx3kzrkCRp3NXo5bsb8LABaTcBn6pQhyRJY62VsXy7RHlJkjSvtR1QJUlaEAyokiRVYECVJKkCA6okSRXUCqivjIi7el80Azz0TSuvOyvVL0nSSNUa2GG6PXntASxJmhdmHFAz08vGkqQFz2AoSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoWVECNiJMjIoe8nj2g3D4RcVZE3BIRSyPiuxGx62y3X5I0vtYadQNG5BvALX3mX9c7IyIOA94K3Ab8EFgPeCbwrIj4u8w8rs2GSpLmhoUaUN+emVdNlCkink4TTG8EdsnMy8v8XYCTgSMj4uTMvKnFtkqS5oAFdcl3Gg4o0w90gilAZp4BfBa4F7DfKBomSRovBtQBImI94Bnl7TF9snTmPW92WiRJGmcL9ZLvP0bEZsDdwK+Bb2bm1T15HgasC9yQmdf2Wca5Zbpje82UJM0VCzWgHtTz/sMRcUhmHtI1b5sy7RdMycwVEbEM2DQiNsrM5RNVGhEXD0jabqKykqTxttAu+Z4KvIImgG0APBR4N3An8P6IeHNX3kVleuuQ5a3oyStJWqAW1BlqZr63Z9avgX+LiHOAHwDvi4j/yszbgOgUG7LIGJLWr/4d+i6kOXN9+FSWJUkaLwvtDLWvzPwhcA5Nr90nlNmdS7gbDim6QZn2e6ZVkrSAGFBX6TwWc78y7XRS2qpf5ojYENgEWDaZ+6eSpPnNgLrKpmXaOdu8DFgJbBER/YLqTmV6YdsNkySNPwMqEBFbAE8ub88FKPdRf1zm7d2nWGfed9ptnSRpLlgwATUinhART4uI6Jn/QOA4mnul3+555vSwMj0oIrbvKrML8BrgZuBzrTZckjQnLKRevg8DjgR+HxG/Bq6nuT+6M82A9xcDr+4ukJk/iojDgTcD50fEicA6NIPjrwG8PDOXzt5HkCSNq4UUUM8EPgM8nuYRlSfSPEd6PvB14DPlMu89ZOZbIuJ84A00gfTPwEk04/ueNistlySNvQUTUDPzUuB10yy7GFhcsz2SpPllwdxDlSSpTQZUSZIqMKBKklSBAVWSpAoWTKckSVI9nzhjtPW/cZfR1t+PZ6iSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiSJFVgQJUkqQIDqiRJFRhQJUmqwIAqSVIFBlRJkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQFVkqQKDKiTEBHrRcT7IuLXEXF7RPwuIj4fEVuNum2SpPFgQJ1ARKwHnAS8F1gEfAu4BngVcG5EbDfC5kmSxoQBdWL/AuwKnAE8JDNfkpmPBw4AtgA+P8rGSZLGgwF1iIhYG3hjefv6zLylk5aZhwEXAk+JiJ1H0T5J0vgwoA73JGATYElmntcn/Zgyfd6stUiSNJYMqMM9skzPHZB+bk8+SdICtdaoGzDmtinTawekX9uTb6iIuHhA0sOWLFnCDjvsMJW23cPS26ZddMY+u/7o6pY0GqM85sD0jztLliwB2LpmWzoMqMMtKtNbB6Sv6Mk3XXevXLlyxSWXXHLNNMt3ehovmWE7puX6UVRaz0jX3Rznups+193MbFeOO9NZf1sz+Jg+IwbU4aJMc4L0ScnM6Z+CDtE5821r+fOZ6276XHfT57qbmXFdf95DHW55mW44IH2DMr1lQLokaYEwoA53dZkOGhFpq558kqQFyoA63AVlutOA9M78C2ehLZKkMWZAHe504E/AdhHx6D7pe5fpd2avSZKkcWRAHSIz7wA+Wd5+MiL+ci81It4G7Aiclplnj6J9kqTxEZmDOrAK/jI4/snA44HfAz8FHlDe3wg8ITOvGFkDJUljwYA6CRGxPvAu4O9pnmG6Cfg+8J7MnO6zo5KkecSAKklSBd5DlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKjCgSpJUgQF1RCJivYh4X0T8OiJuj4jfRcTnI2LQQPzDlrVJRHwsIn4bESvL9PCI2GRImTUi4i0R8cuIuC0iboiIr0fEw2f0wWZBjXVX1tnfR8SXI+KSiFgREcsj4syIeHNErD2g3OKIyCGv19b7pPXV2u4i4qoJ1sPDBpRb6NvdvhOst85rn55yc3272zkiDoyIYyPiutLm22ewvLE85vkc6giU0ZdOAnZl1ehLDwQeB9wA7JKZk/rh3IjYDDgD2B64EjgH2KG8rqAZyenGnjIBHE0zFvGy0pbNgacAtwNPy8wzZ/IZ21Jr3UXEB4B3A3cD59Gsqy2AJwLrAqcBe2TmrT3lFgOvBH5A/99W/0Jm/mQaH611lbe7q2hGDPvCgCzvyszf95Rxu4t4ErD/gOR7AS8of2+XmVd2lVvMHN3uACLim8Dze2avzMz1prGs8T3mZaavWX4B76f50fKfAYu65r+tzD9lCss6qpT5BrBW1/yPl/lf6FNmv5L2a+A+XfNfVOZf0b2scXrVWnfAgcD/A/6qZ/72wG/Lsv6tT7nFJW23Ua+LEW93VzWHjynVv+C3uwnq+KeyrNP6pM3Z7a60/53A+4A9gfuUz3L7NJc1tse8ka/ohfYC1qYZujCBR/dJv6Ck7TyJZd0XuAu4o3sjKWnrAv8L3Nkn7eJSxwv6LPNbJe1Fo15Xba67Cep5WVnOb/qkzckDW+11N82A6nY3vJ7Ty3Je0ydtTm53Qz7rtALquB/zvIc6+54EbAIsyczz+qQfU6bPm8SynkNzH/zUzPxDd0JmrgSOB9Ys+QCIiG2BhwO3ASfMsP7ZVnPdDdP5Hdz7z3A542S21l1fbnfDlfWzK02gOHq6y1kAxvqYt9ZMF6Ape2SZnjsg/dyefDNd1n49y+r8fVFm/nmG9c+2mutumAeVab97VR17RcSLaHbe3wDHZ+avZlhvm1pZdxHxz8B2wEqas4DjMvOGIfW73fX3D2V6QmbeNCTfXNvuahvrY54BdfZtU6bXDki/tidf7WXVrH+2zVbb31ym3xqS54097w+NiM8Ab87MO2dYfxvaWncf7Hn/0Yh4U2Z+bpbqnw2z0faXl+kXJ8g317a72sb6mOcl39m3qExvHZC+oidf7WXVrH+2td728vjB7jQ9Af+jT5bzgNcCDwE2oDmbfX3J/zrgQ9Otu2W11923gb1oevpuADwCOIzmPtYREfGCluufTa22PSIeBzyU5j5tv0uSMHe3u9rG+pjnGersizLNCdLbWtZEZcZZzXW3euGIpwKHl+Xvl5m/682TmYf3zPoN8OmIOBX4BfDGiDgsx+93cquuu8x8U8+si4EDIuIy4D+BQ4FvTqH+cdbqdseqy71fy8w7+mWYw9tdbWN9zPMMdfYtL9MNB6RvUKa3tLSsicp05k+m/tlWc93dQ0TsSBMA1qG5fHbcVMpn5kU0Z21r0pzhjpvW1l2PI2h6Wj6kdAaZbP0LdbtbC3hJeTvR5d7VzIHtrraxPuYZUGff1WU6aHSVrXry1V5WzfpnWyttj4jtaB6Y3wQ4ODM/Ma3WweVler9plm/TrHzvmXk30BngoHs9uN319yxgS+DKzPzZNMrDeG93tY31Mc+AOvs6j2TsNCC9M//ClpbVKfOIAcPrTaX+2VZz3QEQEfcHTqR5vu3wzHzf9JvHpmU6jmdZ1dfdEP3Wg9tdf53LvV+aRtmOcd7uahvvY96oH/BdaC+aS4rLmPgh8cdOYln3o3nIeSWwZU9a5yHnu4D79qRdwsQPOf/dqNdVm+uu5N8U+GUp83nKUJzTbNu6NP/hJvDEUa+rttfdkHp2oBnOcQWwjtvd0OUuKuspge3n43Y3pN3THdhhrI95I1+xC/EFfKB8gacDG3bN7wxj9tOe/G8AfgX8e59lfamUOYZ7DsPV6VzzxT5l9mfVMFxbds3fq8y/Elh71OupzXVHc6/ljFLma8Cak6j7oTTjka7ZM38L4LiyrPOZQWCeI+tuD/qMCgTs2HXgOtztrv8+25Vnn1L2jPm83Q34TEMD6lw95o18xS7EF7Ae8PPyRf6uHNA77/8IPLgn/8ElbXGfZW1OMw5llulXWXXWdQWweZ8yawDHljxLga8DP6E5s7gN2HXU66jtdQd8tMy/E/gfmqHdVnv1lNmtq57TSt0/AW4u868BHjLqdTQL664z/yqaQca/CpwJ/LnMPxnYwO2u/z7bleeHJc/rJqh7Tm935TM8t6yvn3ett7t75j13MuuPMT7mjXxFL9QXsD7NgNtX0Fy+uL4cxLfuk3fozklz6fLjNJd+VpbpJ4B7D6l/TZr/ri8qG9QfaQab3mHU62Y21h2rxkYd+uopc3+aQHwGzS+O3EHTg/AXpZ5NR71uZmnd7QJ8juae0x9pAumN5QC1P0PO9hf6dteVfl+af+buADaboN75sN3tO4n9bd8prL+xPOb5822SJFVgL19JkiowoEqSVIEBVZKkCgyokiRVYECVJKkCA6okSRUYUCVJqsCAKklSBQZUSZIqMKBKklSBAVWSpAoMqJIkVWBAlSSpAgOqJEkVGFAlSarAgCpJUgUGVEmSKvj/ga98d4D2Ex8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for col in list(dflog.columns):\n",
    "    dflog[col].plot(kind = 'hist', title = col)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without completing a full EDA, we can see that some variables take on values that denote classes or categories (such as sex_M_F, fasting_blood_sugar_high), and thus are categorical, and some take on values that are a measure (such as age, blood pressure, cholesterol) and therefore are non-categorical.  Depending upon the models you choose to apply to these data, some additional preparation might be in order, such as ensuring the non-categorical values are all in sensible ranges (such as, what is a feasbile maximum value for cholesterol?), possibly scaling some of the variables, and generally ensuring you understand the data and they are suitable for a given model, to mention only a few.  Here, we will need to transform the categorical values to use them in a logistic regression model, which we will come to shortly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before moving on to modeling, let's look at some of the features of the dataset.\n",
    "\n",
    "> **Note**  \n",
    "Moving forward, we might use the terms \"variable\" and \"feature\" interchageably, to represent the concept of the independent or $\\textbf{X}$ data. In general, there might be nuanced differences in these concepts, such as variable referring to the orignal data and feature referring to a transformed version of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first 6 lines of age data:\n",
      " 0    70\n",
      "1    67\n",
      "2    57\n",
      "3    64\n",
      "4    74\n",
      "5    65\n",
      "Name: age_yr, dtype: int64\n",
      "\n",
      "summary statistics of age:\n",
      " count    270.000000\n",
      "mean      54.433333\n",
      "std        9.109067\n",
      "min       29.000000\n",
      "25%       48.000000\n",
      "50%       55.000000\n",
      "75%       61.000000\n",
      "max       77.000000\n",
      "Name: age_yr, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# extract the age as a Series, and inspect the values\n",
    "#\n",
    "x = dflog['age_yr']\n",
    "print('first 6 lines of age data:\\n', x.head(6))\n",
    "print('\\nsummary statistics of age:\\n', x.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first six lines of blood pressure data:\n",
      " 0    130\n",
      "1    115\n",
      "2    124\n",
      "3    128\n",
      "4    120\n",
      "5    120\n",
      "Name: resting_BP_mm_Hg, dtype: int64\n",
      "\n",
      "summary statistics of blood pressure:\n",
      " count    270.000000\n",
      "mean     131.344444\n",
      "std       17.861608\n",
      "min       94.000000\n",
      "25%      120.000000\n",
      "50%      130.000000\n",
      "75%      140.000000\n",
      "max      200.000000\n",
      "Name: resting_BP_mm_Hg, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# do the same for the resting blood pressure\n",
    "#\n",
    "y = dflog['resting_BP_mm_Hg']\n",
    "print('first six lines of blood pressure data:\\n', y.head(6))\n",
    "print('\\nsummary statistics of blood pressure:\\n', y.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Transformation of categorical features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, categorical features need to be transformed or *encoded* to be used in some machine learning models, as is the case for Logistic Regression. A common transformation is so-called *dummy encoding*, where each possible value of a feature becomes a new column, and a 1 is placed in that column if the data instance (a row of the data) contained that value, and a 0 is placed in that column otherwise.  \n",
    "\n",
    "For example, suppose we had a column in a hypothetical data set called species, and it contained one of two values, \"cat\" or \"dog\". The column might look like this:\n",
    "```\n",
    "species\n",
    "cat\n",
    "cat\n",
    "dog\n",
    "dog\n",
    "cat\n",
    "dog\n",
    "...\n",
    "```\n",
    "\n",
    "Dummy encoding would replace this with two columns:\n",
    "```\n",
    "species_cat   species_dog\n",
    "    1              0\n",
    "    1              0\n",
    "    0              1\n",
    "    0              1\n",
    "    1              0\n",
    "    0              1\n",
    "   ...            ...\n",
    "```\n",
    "This method extends to as many unique values there are in a given feature. Here we use the Pandas method get_dummies() (*) to transform a subset of columns. Note how we can specify which columns we want to be transformed, so we make a list of them first. If the columns are not specified, Pandas will decide which columns are categorical based on the Pandas type, and convert those. This can be convenient but is not always what is desired. For clarity, we explicitly define them here.\n",
    "\n",
    "---\n",
    " (*) [pandas.get_dummies()](https://pandas.pydata.org/docs/reference/api/pandas.get_dummies.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data have  270  rows and  24  columns\n",
      "\n",
      "column names: \n",
      "\n",
      "age_yr\n",
      "resting_BP_mm_Hg\n",
      "cholesterol_mg_dl\n",
      "fasting_blood_sugar_high\n",
      "max_HR\n",
      "exercise_angina\n",
      "ST_depresssion_exercise\n",
      "number_vessels_involved\n",
      "heart_disease\n",
      "sex_M_F_0\n",
      "sex_M_F_1\n",
      "chest_pain_value_1\n",
      "chest_pain_value_2\n",
      "chest_pain_value_3\n",
      "chest_pain_value_4\n",
      "ECG_value_0\n",
      "ECG_value_1\n",
      "ECG_value_2\n",
      "ST_slope_peak_1\n",
      "ST_slope_peak_2\n",
      "ST_slope_peak_3\n",
      "defect_diag_3\n",
      "defect_diag_6\n",
      "defect_diag_7\n"
     ]
    }
   ],
   "source": [
    "categorical_features = ['sex_M_F',\n",
    "                        'chest_pain_value',\n",
    "                        'ECG_value',\n",
    "                        'ST_slope_peak',\n",
    "                        'defect_diag']\n",
    "dflog = pd.get_dummies(dflog, columns = categorical_features)\n",
    "print('The data have ', dflog.shape[0], ' rows and ', dflog.shape[1], ' columns\\n')\n",
    "print('column names: \\n')\n",
    "print('\\n'.join(list(dflog.columns)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Proportion of classes\n",
    "When building classification models, it is always a good idea to know right away the number of samples per class, proportionally to the total number of samples. First we get the counts of each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    150\n",
       "1    120\n",
       "Name: heart_disease, dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_counts = dflog['heart_disease'].value_counts()\n",
    "class_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that class_counts is a Pandas Series object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(class_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily compute the relative frequencies (percentages) to better quantify differences in the incidences of the classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    55.555556\n",
       "1    44.444444\n",
       "dtype: float64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_percentages = pd.Series([(x / dflog.shape[0]) * 100.00 for x in class_counts])\n",
    "class_percentages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use the percentages as labels and plot the distribution of the two classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.bar(class_counts.index, class_counts)\n",
    "ax.set_xticks([0, 1])\n",
    "ax.set_xticklabels(class_percentages.index.astype(str) + '\\n' + ' ' +\n",
    "                   class_percentages.round(0).astype(str) + '%')\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_xlabel('Heart Disease')\n",
    "ax.set_title('Heart Disease class distribution\\nwhere 1 means presence of heart disease',\n",
    "              fontsize = 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code above can be easily generalized to handle multiple classes, and we invite you to give it a try, in consulation with your mentor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Side-Bar: Balanced and Imbalanced Classes\n",
    "For a binary classification problem (two classes), the problem is called *balanced* if the number of elements of each class is about the same--in other words, each class would have a size that is about 50% of the total number of elements in the dataset. In this particular case study, one would say that this problem is slightly imbalanced, since the difference in the percentages is about 10%. When there is a imbalance among the classes in a binary classification problem, one usually refers to them as the *minority class*, and the *majority class*.\n",
    "\n",
    "In practice, *Imbalanced Classification Problems* (ICP) are very common in situations where one is modeling events that are not common, and thus these events would be instances of the *minority* class. Examples of these problems include: study of diseases such as Cancer, study of processes such as fraud, and--in general--the study of rare anomalies within a system. It is common to find instances of these problems where the difference in the percentages is 80% or more.\n",
    "\n",
    "There are two important challenges posed by ICPs:\n",
    "\n",
    "- The difference in the size of the classes is *inherent* to the problem under study. This means that one cannot pave this difference by adding more elements to the minority class.\n",
    "\n",
    "- Classification algorithms are usually negatively affected by the lack of sufficient samples of the minority class, in that the models built with them are practically unable to differentiate the minority class from the majority class, where the former is the one of interest. For instance, imagine a model built to compute the likelihod of a patient developing Cancer that nearly always predicts a small likelihood for this class (meaning, that the model predicts NO Cancer, when it should have predicted Cancer in some cases).\n",
    "\n",
    "Since this particular case study deals with a slight imbalance among the classes, we might be able to build useful models with the given dataset--without introducing additional interventions. One general approach to deal with ICP is by either generating sythetic data (a.k.a. *oversampling*), or by generating a set of smaller \"majority classes\" by taking chunks from the original majority class (a.k.a. *undersampling*). In general, these approaches are collectively referred to as *resampling*.\n",
    "\n",
    "We will not practice these concepts in this case study, but you might have the opportinity to do so in your capstone projects. Discuss this possibility with your mentor if/when applicable.\n",
    "\n",
    "Finally, the concepts discussed above can be easily generalized to ICPs with a number of classes greater than 2 (*Imbalanced Multi-Class Classification Problems*--IMCP)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bGHuU_GXHumg"
   },
   "source": [
    "<div class=\"span5 alert alert-info\">\n",
    "<h3>Checkup Exercise Set I</h3>\n",
    "\n",
    "<ul>\n",
    "  <li> <b>Exercise:</b> Create a scatter plot of Blood Pressure vs. Cholesterol Level\n",
    "  <li> <b>Exercise:</b> Color the points differently by the Presence of Heart Disease\n",
    "</ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x750 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 911.542x750 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,5))\n",
    "sns.relplot(x='resting_BP_mm_Hg', y='cholesterol_mg_dl', data=dflog, kind=\"scatter\", hue='heart_disease')\n",
    "plt.title('Blood Pressure vs. Cholesterol Level by Presence of Heart Disease')\n",
    "plt.legend(['Normal', 'Heart Disease'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vyozMZQ4HunB"
   },
   "source": [
    "#### Optional: Building a Logistic Regression Model with Only Two Features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to demonstrate a simple case where $X$ has only two dimensions and therefore we can plot the classification results in an x-y plot. The utility function we provided will shade the classifier results for the two target classes, on a plot of the two $X$ features. To do this, we'll choose just two of the features of the heart disease data.\n",
    "\n",
    "Recall our features are:\n",
    "```\n",
    "age_yr\n",
    "resting_BP_mm_Hg\n",
    "choleterol_mg_dl\n",
    "fasting_blood_sugar_high\n",
    "max_HR\n",
    "exercise_angina\n",
    "ST_depresssion_exercise\n",
    "number_vessels_involved\n",
    "heart_disease\n",
    "sex_M_F_0\n",
    "sex_M_F_1\n",
    "chest_pain_value_1\n",
    "chest_pain_value_2\n",
    "chest_pain_value_3\n",
    "chest_pain_value_4\n",
    "ECG_value_0\n",
    "ECG_value_1\n",
    "ECG_value_2\n",
    "ST_slope_peak_1\n",
    "ST_slope_peak_2\n",
    "ST_slope_peak_3\n",
    "defect_diag_3\n",
    "defect_diag_6\n",
    "defect_diag_7\n",
    "```\n",
    "\n",
    "...of which we are choosing for this example: ``cholesterol`` and ``blood pressure``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The model building cycle\n",
    " \n",
    "Now we apply the pattern that should be familiar to you:\n",
    "\n",
    "> (a) train/test split  \n",
    "> (b) create an object of the class associated with the algorithm to be\n",
    " used--in this case LogisticRegression  \n",
    "> (c) build an actual model using the \"fit\" method from the class (applied to the training set)  \n",
    "> (d) predict with the built model using the \"predict\" method from the class (training set and test set)  \n",
    "> (e) compute performance metrics (in this case, accuracy) for the training and test predictions  \n",
    "\n",
    "consider\n",
    "\n",
    "> (a) how the parameters passed to train_test_split are computed \"on-the-fly\", what their types are expected to be, and what are the values of the parameters that are not passed explicitly, which will take the default values per the documentation of the method train_test_split ...  \n",
    "\n",
    "> The documentation can be viewed at: [sklearn.model_selection.train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) or you can run ``help(train_test_split)`` in a notebook cell after the module has been imported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function train_test_split in module sklearn.model_selection._split:\n",
      "\n",
      "train_test_split(*arrays, test_size=None, train_size=None, random_state=None, shuffle=True, stratify=None)\n",
      "    Split arrays or matrices into random train and test subsets.\n",
      "    \n",
      "    Quick utility that wraps input validation and\n",
      "    ``next(ShuffleSplit().split(X, y))`` and application to input data\n",
      "    into a single call for splitting (and optionally subsampling) data in a\n",
      "    oneliner.\n",
      "    \n",
      "    Read more in the :ref:`User Guide <cross_validation>`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    *arrays : sequence of indexables with same length / shape[0]\n",
      "        Allowed inputs are lists, numpy arrays, scipy-sparse\n",
      "        matrices or pandas dataframes.\n",
      "    \n",
      "    test_size : float or int, default=None\n",
      "        If float, should be between 0.0 and 1.0 and represent the proportion\n",
      "        of the dataset to include in the test split. If int, represents the\n",
      "        absolute number of test samples. If None, the value is set to the\n",
      "        complement of the train size. If ``train_size`` is also None, it will\n",
      "        be set to 0.25.\n",
      "    \n",
      "    train_size : float or int, default=None\n",
      "        If float, should be between 0.0 and 1.0 and represent the\n",
      "        proportion of the dataset to include in the train split. If\n",
      "        int, represents the absolute number of train samples. If None,\n",
      "        the value is automatically set to the complement of the test size.\n",
      "    \n",
      "    random_state : int, RandomState instance or None, default=None\n",
      "        Controls the shuffling applied to the data before applying the split.\n",
      "        Pass an int for reproducible output across multiple function calls.\n",
      "        See :term:`Glossary <random_state>`.\n",
      "    \n",
      "    shuffle : bool, default=True\n",
      "        Whether or not to shuffle the data before splitting. If shuffle=False\n",
      "        then stratify must be None.\n",
      "    \n",
      "    stratify : array-like, default=None\n",
      "        If not None, data is split in a stratified fashion, using this as\n",
      "        the class labels.\n",
      "        Read more in the :ref:`User Guide <stratification>`.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    splitting : list, length=2 * len(arrays)\n",
      "        List containing train-test split of inputs.\n",
      "    \n",
      "        .. versionadded:: 0.16\n",
      "            If the input is sparse, the output will be a\n",
      "            ``scipy.sparse.csr_matrix``. Else, output type is the same as the\n",
      "            input type.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> import numpy as np\n",
      "    >>> from sklearn.model_selection import train_test_split\n",
      "    >>> X, y = np.arange(10).reshape((5, 2)), range(5)\n",
      "    >>> X\n",
      "    array([[0, 1],\n",
      "           [2, 3],\n",
      "           [4, 5],\n",
      "           [6, 7],\n",
      "           [8, 9]])\n",
      "    >>> list(y)\n",
      "    [0, 1, 2, 3, 4]\n",
      "    \n",
      "    >>> X_train, X_test, y_train, y_test = train_test_split(\n",
      "    ...     X, y, test_size=0.33, random_state=42)\n",
      "    ...\n",
      "    >>> X_train\n",
      "    array([[4, 5],\n",
      "           [0, 1],\n",
      "           [6, 7]])\n",
      "    >>> y_train\n",
      "    [2, 0, 3]\n",
      "    >>> X_test\n",
      "    array([[2, 3],\n",
      "           [8, 9]])\n",
      "    >>> y_test\n",
      "    [1, 4]\n",
      "    \n",
      "    >>> train_test_split(y, shuffle=False)\n",
      "    [[0, 1, 2], [3, 4]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(train_test_split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain, Xtest, ytrain, ytest = train_test_split(dflog[['cholesterol_mg_dl','resting_BP_mm_Hg']],\n",
    "                                                dflog['heart_disease'],\n",
    "                                                train_size = 0.80,\n",
    "                                                random_state = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> (b) create an object of the class associated with the algorithm to be used--in this case LogisticRegression: also, compare the parameters passed against the expected parameters, and default parameters being used per the documentation of the constructor of class LogisticRegression\n",
    "\n",
    "> The documentation can be viewed at: [sklearn.linear_model.LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) or you can run ``help(LogisticRegression)`` in a notebook cell after the module has been imported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = LogisticRegression(solver = 'liblinear', max_iter = 500, C = 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> (c) create an actual model using the \"fit\" method for the class applied to the training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1000, max_iter=500, solver='liblinear')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.fit(Xtrain, ytrain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> (e.1) compute performance metrics (in this case, accuracy) for the training and test predictions... notice how accuracy_score receives the result from classifier.predict(Xtrain), and compares it with ytrain to produce the training accuracy \n",
    "\n",
    "> the documentation can be viewed at: [sklearn.metrics.accuracy_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html) or you can run ``help(accuracy_score)`` in a notebook cell after the module has been imported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function accuracy_score in module sklearn.metrics._classification:\n",
      "\n",
      "accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None)\n",
      "    Accuracy classification score.\n",
      "    \n",
      "    In multilabel classification, this function computes subset accuracy:\n",
      "    the set of labels predicted for a sample must *exactly* match the\n",
      "    corresponding set of labels in y_true.\n",
      "    \n",
      "    Read more in the :ref:`User Guide <accuracy_score>`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    y_true : 1d array-like, or label indicator array / sparse matrix\n",
      "        Ground truth (correct) labels.\n",
      "    \n",
      "    y_pred : 1d array-like, or label indicator array / sparse matrix\n",
      "        Predicted labels, as returned by a classifier.\n",
      "    \n",
      "    normalize : bool, default=True\n",
      "        If ``False``, return the number of correctly classified samples.\n",
      "        Otherwise, return the fraction of correctly classified samples.\n",
      "    \n",
      "    sample_weight : array-like of shape (n_samples,), default=None\n",
      "        Sample weights.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    score : float\n",
      "        If ``normalize == True``, return the fraction of correctly\n",
      "        classified samples (float), else returns the number of correctly\n",
      "        classified samples (int).\n",
      "    \n",
      "        The best performance is 1 with ``normalize == True`` and the number\n",
      "        of samples with ``normalize == False``.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    balanced_accuracy_score : Compute the balanced accuracy to deal with\n",
      "        imbalanced datasets.\n",
      "    jaccard_score : Compute the Jaccard similarity coefficient score.\n",
      "    hamming_loss : Compute the average Hamming loss or Hamming distance between\n",
      "        two sets of samples.\n",
      "    zero_one_loss : Compute the Zero-one classification loss. By default, the\n",
      "        function will return the percentage of imperfectly predicted subsets.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    In binary classification, this function is equal to the `jaccard_score`\n",
      "    function.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> from sklearn.metrics import accuracy_score\n",
      "    >>> y_pred = [0, 2, 1, 3]\n",
      "    >>> y_true = [0, 1, 2, 3]\n",
      "    >>> accuracy_score(y_true, y_pred)\n",
      "    0.5\n",
      "    >>> accuracy_score(y_true, y_pred, normalize=False)\n",
      "    2\n",
      "    \n",
      "    In the multilabel case with binary label indicators:\n",
      "    \n",
      "    >>> import numpy as np\n",
      "    >>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))\n",
      "    0.5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(accuracy_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on training data: 0.61\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy on training data: {accuracy_score(classifier.predict(Xtrain), ytrain):.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> (e.2) compute performance metrics (in this case, accuracy) for the training and test predictions... notice how accuracy_score receives the result from classifier.predict(Xtest), and compares it with ytest to produce the testing accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data: 0.59\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy on test data: {accuracy_score(classifier.predict(Xtest), ytest):.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as mentioned above, we can now see graphically how the model is differentiating elements of both classes after being built with only two features (Cholesterol Level, and Resting Blood Pressure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.set_ylabel('Resting blood pressure (mm Hg)')\n",
    "ax.set_xlabel('Cholesterol level (mg/dl)')\n",
    "ax.set_title('Computed Decision Boundary:\\n ' +\n",
    "             'Cholesterol Level (mg/dl) VS Resting Blood Pressure (mm Hg)' +\n",
    "             '\\n Red: Heart Disease | Blue: No Heart Disease' +\n",
    "             '\\n Circles: Training Set | Squares: Testing Set\\n',\n",
    "            fontsize = 10)\n",
    "_ = points_plot(ax, Xtrain, Xtest, ytrain, ytest, classifier, alpha = 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can (and should) use sklearn's classification_report() function to see more details about what the classifier is actually doing.  You should be familiar with these additional metrics. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report for Training Data\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.61      0.78      0.68       117\n",
      "           1       0.61      0.40      0.48        99\n",
      "\n",
      "    accuracy                           0.61       216\n",
      "   macro avg       0.61      0.59      0.58       216\n",
      "weighted avg       0.61      0.61      0.59       216\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Report for Training Data\")\n",
    "print(classification_report(ytrain, classifier.predict(Xtrain)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report for Test Data\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.63      0.82      0.71        33\n",
      "           1       0.45      0.24      0.31        21\n",
      "\n",
      "    accuracy                           0.59        54\n",
      "   macro avg       0.54      0.53      0.51        54\n",
      "weighted avg       0.56      0.59      0.56        54\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Report for Test Data\")\n",
    "print(classification_report(ytest, classifier.predict(Xtest)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some Comments on this Result\n",
    "\n",
    "In the figure, class 0 (no heart disease) is shaded red, and class 1 (heart disease) is shaded blue.  The train labels are plotted as circles, using the same color scheme, while the test data are plotted as squares.  Some points that are evident for this simple classifier:\n",
    "\n",
    "- The classifier tends to suggest heart disease as either blood pressure or choleterol increase.  This seems intuitively correct.\n",
    "- The classifier isn't very good!  The accuracy on the training data is only 61%, and the accuracy on the testing data is barely better than random chance (59%)--where random chance if 50%.  This isn't surprising since we are using only two features.\n",
    "- Moreover, notice that the classification report shows that the model performs poorly when trying to recognize inputs that belong to class 1 (*the class of interest*), which is indicated by the poor values of precision, recall, and f1-score for class 1--for the training set and test set.\n",
    "- The \"decision boundary\" is a line. As we add more features, we won't be able to represent the boundary this way. The boundary becomes what is called a hyperplane, which is the generalization of a line into 3 or more dimensions. But here, a patient measured with a combination of cholesterol and blood pressure to the right of the line (in the blue region) would be classified as likely having heart disease.\n",
    "\n",
    "We now move on to investigate how to get a better classifier that is optimized on the data and will perform well in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a Logistic Regression Model with all Features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After having seen the results of a model built with only two features, we are now going to turn our attention to building a full-fledged model using all the features, and will compare this model with the previous one, with respect to several performance metrics. \n",
    "\n",
    "\n",
    "<b>We will follow the same pattern we used before, only this time we are explicitly defining two objects ``X`` and ``y``, which were defined implicitly when we built the first model</b>. \n",
    "\n",
    "    \n",
    "Thus, pattern defined above can be expanded as follows:\n",
    "\n",
    "> (a) Define ``X`` and ``y``  \n",
    "\n",
    "> (b) Perform train/test split on ``(X, y)``  \n",
    "\n",
    "> (c) Create an object of the class associated with the algorithm to be used--in this case ``LogisticRegression``  \n",
    "\n",
    "> (d) Build an actual model using the``fit`` method from the class associated with the algorithm \n",
    "to be used (using the training set)  \n",
    "\n",
    "> (e) Predict with the built model using the``predict`` method from the class (training set and test set)  \n",
    "\n",
    "> (f) Compute performance metrics (in this case, accuracy) for the training and test predictions. The metrics to be used and their interpretation will depend on the application at hand  \n",
    "\n",
    "> (g) Determine if the model can be improved--repeat as needed with additional algorithms and/or by applying hyper-parameter tuning  \n",
    "\n",
    "> (h) Compare and Combine all best models as needed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (a) Define ``X`` and ``y``  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "X contains the independent variables--a.k.a. features, but not the target. X is usually referred to as the \"Design Matrix\", in this case it will be represented as a data frame.\n",
    "\n",
    "The following is a very convenient way to express this using Pandas--indeed, the .drop(...), means \"remove the column 'heart_disease' ...\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:  <class 'pandas.core.frame.DataFrame'> (270, 23)\n"
     ]
    }
   ],
   "source": [
    "X = dflog.drop(columns = ['heart_disease'])\n",
    "print(\"X: \", type(X), X.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that ``X`` is a ``pandas`` DataFrame with 270 rows and 23 columns (a.k.a. a matrix)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that the form of data we will use always is\n",
    "\n",
    "<img src=\"images/dataform.jpg\" alt=\"data form\" style=\"width: 600px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y is the dependent variable, sometimes known as the response, target, or labels. In this case, it is the presence or absence of heart disease."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y:  <class 'pandas.core.series.Series'> (270,)\n"
     ]
    }
   ],
   "source": [
    "y = dflog['heart_disease']\n",
    "print(\"y: \", type(y), y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "notice that, by construction, y will have value True (1) in positions where  the value for the heart_disease column of the dataframe is 1, otherwise it will be False (0)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the \"response\" $y$ is a plain array of 0s and 1s for binary classification. \n",
    "\n",
    "`y = [1,1,0,0,0,1,0,1,0....]`.\n",
    "\n",
    "Sometimes we will also see -1 and +1 instead. There are also *multiclass* classifiers that can assign an observation to one of $K > 2$ classes and the labe may then be an integer, but we will not be discussing those here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exactly as expected, $y$, is a pandas Series, aka a vector of 270 components. Moreover, we invite you to check that the following relationship holds between $X$ and $y$:\n",
    "\n",
    "1. They have the same number of rows\n",
    "2. For a given row $i$ of matrix $X$, the label that corresponds to that data point is exactly the value of vector $y$ at that row\n",
    "3. The number of rows of $X$ is the number of data points in the dataset\n",
    "4. The number of columns of $X$ is the number of features of each data point in the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and ... we can check that the columns contain all the features but not the target in this case, we can do it visually, but think about how to do it in Python, for cases were the number of columns is too large to check visually:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['age_yr',\n",
       " 'resting_BP_mm_Hg',\n",
       " 'cholesterol_mg_dl',\n",
       " 'fasting_blood_sugar_high',\n",
       " 'max_HR',\n",
       " 'exercise_angina',\n",
       " 'ST_depresssion_exercise',\n",
       " 'number_vessels_involved',\n",
       " 'sex_M_F_0',\n",
       " 'sex_M_F_1',\n",
       " 'chest_pain_value_1',\n",
       " 'chest_pain_value_2',\n",
       " 'chest_pain_value_3',\n",
       " 'chest_pain_value_4',\n",
       " 'ECG_value_0',\n",
       " 'ECG_value_1',\n",
       " 'ECG_value_2',\n",
       " 'ST_slope_peak_1',\n",
       " 'ST_slope_peak_2',\n",
       " 'ST_slope_peak_3',\n",
       " 'defect_diag_3',\n",
       " 'defect_diag_6',\n",
       " 'defect_diag_7']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(X.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***All classification problems can be represented, as shown above, with a matrix $X$ and a vector  $y$, satisfying the conditions 1-4 above***. When the number of unique values of $y$ is 2, the problem is called a binary classification problem. When this number is greater than 2, the problem is called a multi-class classification problem. In this Case Study we are dealing with the former."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (b) Perform train/test split on $(X, y)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training split has  202  rows\n",
      " and the corresponding labels have an equal number of values. (202)\n",
      "Test split has  68  rows\n",
      " and the corresponding labels have an equal number of values. (68)\n"
     ]
    }
   ],
   "source": [
    "Xlr, Xtestlr, ylr, ytestlr = train_test_split(X, y, random_state = 2)\n",
    "print('Training split has ', Xlr.shape[0], ' rows\\n',\n",
    "      'and the corresponding labels have an equal number of values.', \n",
    "      '(' + str(len(ylr))+ ')')\n",
    "print('Test split has ', Xtestlr.shape[0], ' rows\\n',\n",
    "      'and the corresponding labels have an equal number of values.', \n",
    "      '(' + str(len(ytestlr)) + ')')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice the following:\n",
    "\n",
    "- This time we did not include the split parameter in the call to ``train_test_split``, and thus it computed a 75% / 25% split of the data as we verified above. This is the deafult split as per the documentation of this method (*).\n",
    "\n",
    "\n",
    "- We used a different value for ``random_state`` to indicate that if we were to call ``train_test_split`` with the same arguments ``X`` and ``y``, the function would return the same split as the first time--which would be useful in cases where identical splits need to be used. Notice that this is not guaranteed to happen across notebooks; but if this were the case, we could persist the split (that is, saving it to the local storage--e.g., hard disk) ``Xlr, Xtestlr, ylr, ytestlr`` (e.g., using Pickle or other methods (+)).\n",
    "\n",
    "\n",
    "- When we built our first model, we talked about the importance of exploring the proportion among the classes in terms of their sizes, but we did not talk about what could happen to that proportion after the train/test split is executed. In our case, we saw before that the proportion between classes ``0`` (no heart disease), and ``1`` (heart disease) is about 56% for class ``0``, and 44% for class ``1``--and thus, this is a slightly imbalanced classification problem, where class ``1`` is the minority class. So, it makes sense to ask whether this proportion is preserved in ``ylr, ytestlr``.\n",
    "\n",
    "\n",
    "The code below investigates this question. \n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "(*) [sklearn.model_selection.train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)\n",
    "\n",
    "(+) [docs.python.org pickle](https://docs.python.org/3/library/pickle.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we define a function to plot the class ratios between two splits of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def plot_y_ratios(y, ytest):\n",
    "    fig, ax = plt.subplots(2, sharex = True)\n",
    "    ax[0].bar(x = [0, 1], height = [y[y == 0].count(), \n",
    "                                    y[y == 1].count()])\n",
    "    ax[0].set_ylabel('train', fontsize = 8)\n",
    "    ax[0].set_ylim(0, 125)\n",
    "    ax[1].bar(x = [0, 1], height = [ytest[ytest == 0].count(),\n",
    "                                    ytest[ytest == 1].count()])\n",
    "    ax[1].set_ylabel('test', fontsize = 8)\n",
    "    ax[1].set_ylim(0, 125)\n",
    "    ax[1].set_xticks([0, 1])\n",
    "    ax[0].tick_params(which = 'both', labelsize = 8)\n",
    "    ax[1].tick_params(which = 'both', labelsize = 8)\n",
    "    ax[1].set_xlabel('heart disease\\n(0 = no disease)', fontsize = 8)\n",
    "    ax[0].set_title('% heart disease (where 1 means presence of heart diseases):\\n' +\n",
    "                    'train: ' + str(round(100 * (y[y ==1].count()/y.shape[0]), 0)) +\n",
    "                    '\\ntest: ' + str(round(100 * (ytest[ytest ==1].count()/ytest.shape[0]), 0)),\n",
    "                   fontsize = 10)\n",
    "    plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can inpsect the train response data (ylr) compared to the test response data (ytestlr)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_y_ratios(ylr, ytestlr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that ```ytestlr``` has a lower percentage of heart disease (38%), compared to the percentage in the original dataset (44%). Thus, the way we used train/test split made the imbalance (however mild) a little worse. As discussed before, we would like to perform a split preserving the original proportions among the classes, so we do not have to worry about the possibility of getting poor results due to this fact.\n",
    "\n",
    "It turns out that ```train_test_split``` provides a way to compute splits that try to preserve (as much as it might be possible) the proportions among the classes in the original dataset. More specifically, the *stratify* parameter takes an *array-like* object that describes all the classes (*). Thus, we can use the target as this parameter. Below we specify to stratify according to ``y``, and then inspect the resulting split. Notice that this method works for multiple classes as well (i.e., number of classes greater than 2).\n",
    "\n",
    "---\n",
    "(*) [sklearn.model_selection.train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Xlrstrat, Xtestlrstrat, ylrstrat, ytestlrstrat = train_test_split(X, y, \n",
    "                                                                  random_state = 2, \n",
    "                                                                  stratify = y)\n",
    "plot_y_ratios(ylrstrat, ytestlrstrat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nearly perfect!  As noted earlier, in a more complete project you should do EDA on the X-variables as well, and consider if the distributions there are of a concern, before moving on to modeling. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> To recap ... </b>, the binary classification problem has been represented as:\n",
    "\n",
    "- A *design matrix* $X$, with as many rows as there are rows in the dataset, and\n",
    "as many columns as there are features in the dataset\n",
    "\n",
    "\n",
    "- A *target vector* $y$, with as many elements as there are rows in the dataset, and it is\n",
    "such that the i-th value of $y$ is the value of the target associated with \n",
    "row i of $X$.\n",
    "\n",
    "A very important fact to consider is this:\n",
    "\n",
    "*Any <b>supervised</b> problem can be represented by a pair $(X, y)$, where $X$ is a\n",
    "design matrix, and $y$ is a target vector*.\n",
    "\n",
    "- The values in $y$ may be *imbalanced*, and in general it's good practice to ensure the data splits have similar distributions of the target.\n",
    "\n",
    "Morevover: \n",
    "\n",
    "- When the target vector takes non-categorical values, ``(X, y)`` represents a *<b>regression</b>* problem.\n",
    "\n",
    "- When the target vector takes categorical values, ``(X, y)`` represents a *<b>classification</b>* problem.\n",
    "\n",
    "$Note$: there are *unsupervised* problems which are represented by a design matrix $X$ but there is no corresponding $y$. We don't further address *unsupervised* problems in this Case Study."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are ready to continue building a model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (c) Create an object of the class associated with the algorithm to be used--in this case LogisticRegression\n",
    "\n",
    "Construct the LogisticRegression object, setting some basic parameters (more on this later). See (*) for more details, and discuss with your mentor the meaning of each parameter, and the implications associated with using default values\n",
    "\n",
    "---\n",
    " (*) [sklearn.linear_model.LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = LogisticRegression(solver = 'newton-cg', max_iter = 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (d) Build an actual model using the ``fit `` method from the class associated with the algorithm to be used (using the training set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(max_iter=500, solver='newton-cg')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(Xlrstrat, ylrstrat) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (e) Predict with the built model using the ``predict`` method from the class (training set and test set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_predict_test = clf.predict(Xtestlrstrat)\n",
    "y_predict_training = clf.predict(Xlrstrat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (f) Compute performance metrics (in this case, accuracy) for the training and test predictions. In general, the metrics to be used and their interpretation will depend on the application at hand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test] Accuracy score (y_predict_test, ytestlrstrat): 0.81\n"
     ]
    }
   ],
   "source": [
    "print(\"[Test] Accuracy score (y_predict_test, ytestlrstrat):\",\n",
    "      f'{accuracy_score(y_predict_test, ytestlrstrat):.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the order in which the parameters should be passed according to the documentation ... although in this case there is no difference since it is a one-to-one comparison\n",
    "\n",
    "ref: [sklearn.metrics.accuracy_score](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html)\n",
    "\n",
    "Re-compute with switched order to confirm what we expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Test] Accuracy score: (ytestlrstrat, y_predict_test) [**note reversed order] 0.81\n"
     ]
    }
   ],
   "source": [
    "print(\"[Test] Accuracy score: (ytestlrstrat, y_predict_test) [**note reversed order]\", \n",
    "      f'{accuracy_score(ytestlrstrat, y_predict_test):.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And compute the metric on the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Training] Accuracy score: (ylrstrat, y_predict_training) 0.89\n"
     ]
    }
   ],
   "source": [
    "print(\"[Training] Accuracy score: (ylrstrat, y_predict_training)\", \n",
    "      f'{accuracy_score(ylrstrat, y_predict_training):.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (g) Determine if the model can be improved--repeat as needed with additional algorithms and/or by applying hyper-parameter tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is common practice to show--when applicable--performance metrics for both the training set and the test set. This means that the model is fitted with the training set, and once fitted, predictions are generated using the training set and the test set, and the corresponding performance metrics are shown (as above), and analyzed. \n",
    "\n",
    "\n",
    "*NOTE*: you might want to discuss with your mentor examples of cases when this comparison would *not* be applicable. \n",
    "\n",
    "\n",
    "*Hint*: consider tree-based algorithms such as Random Forest Classifiers. (*)\n",
    "\n",
    "Since the model's **training accuracy** (``0.89``) is pretty good (meaning, close to 1--or 100%), then one says there is only a small \"bias\" in the model.\n",
    "\n",
    "Since the model's **test accuracy** (``0.81``) is decently close to the training accuracy, we would say that there is a small \"variance\" between the training accuracy and the test accuracy. This is an indication that the model will \"generalize well\", which means that the model will be well-behaved when new data is presented to it.\n",
    "\n",
    "Since the gap between training and testing accuracy is about 8%, one might say that the model is slightly over-fitting the data. Thus, in general, one says that a model is *over-fitting* (or just overfitting), when there is an important gap between its training performance and its test performance.\n",
    "\n",
    "Notice two points of nuance in the definition of overfitting: (a) the quantification of *important* depends on the application; and (b) the comparison of training versus test performance can be done (in many cases) across mulriple performance metrics \n",
    "\n",
    "These properties are important and desirable.\n",
    "\n",
    "In this particular case study, however, there are two possible avenues that we might want to investigate:\n",
    "\n",
    "\n",
    "- Whether the mild imbalance in the dataset might be affecting the algorithm (and thus the model computed with it.)\n",
    "\n",
    "\n",
    "- Whether the observed mild overfitting can be diminished\n",
    "\n",
    "\n",
    "Below we explore the second bullet. Feel free to consult with your mentor for resources associated with exploring the first bullet.\n",
    "\n",
    "---\n",
    "(*) [sklearn.ensemble.RandomForestClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Side-Bar: NEVER EVER use just Accuracy to Measure the Performance of a Classification Algorithm!\n",
    "\n",
    "Note however that focusing only on accuracy is not a good practice since in some cases it can be misleading. In particular, if the dataset is highly imbalanced (as defined before), then accuracy becomes a poor indicator of model performance.  For example, suppose we were given a data sample of 1000 instances, and 900 of them were class ``1``, and 100 were class ``0``.  \n",
    "\n",
    "If we defined a model that always predicts class ``1``, such model would have 90% accuracy! But we would be mis-classifying 100% of the class 0 samples--although 10% of the time, with respect to the whole dataset.  \n",
    "\n",
    "A good way to avoid this trap is by always generating a confusion matrix for a classification result.  The confusion matrix is simply a table with the true class labels on one axis, and the predicted labels on the other axis.  The counts for each combination of true vs. predicted are put in each cell of the table.  For our hypothetical case, the confusion matrix is:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"images/Confusion_Matrix.jpg\" alt = \"confusion matrix\" style=\"width: 400px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the diagonal intersections of the classes are the \"correct\" predictions (i.e. Predicted 0 intersection wiht Actual 0, and Predicted 1 intersection with Actual 1), and in this case since the model never predicts 0, there are no \"correct\" predictions for that case. It is easy to see that the model isn't working well, even thought the accuracy score would be 90%.  The confusion matrix in this case provides much more information in an easy-to-interpret format.  ``sklearn`` provides the ``confusion_matrix`` and ``ConfusionMatrixDisplay`` methods to generate the results for us.  Here we apply them to the previous model results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x23ca4700670>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(ytestlrstrat, y_predict_test, labels = clf.classes_)\n",
    "_, ax = plt.subplots()\n",
    "display_cm = ConfusionMatrixDisplay(confusion_matrix = cm, \n",
    "                                    display_labels = ['no heart disease', 'heart disease'])\n",
    "ax.set_xticks([0, 1])\n",
    "ax.set_yticks([0, 1])\n",
    "ax.set_xticklabels(labels = ['no heart disease', 'heart disease'], fontsize = 8)\n",
    "ax.set_yticklabels(labels = ['no heart disease', 'heart disease'], fontsize = 8)\n",
    "display_cm.plot(ax = ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the ability to add human readable labels (as compared to just 0 or 1). From the chart we can see that while the overall accuracy was 81%, when we predict heart disease, 20% (6 of 29) of the time we are predicting a false positive, while the false negatives (predicting no disease when in fact there is heart disease) is about 18% (7 of 39). This information can be discussed with stakeholders to decide which is more important, reducing false positives or false negatives, assuming overall accuracy is acceptable. We can also use the ``classification_report`` method from earlier on this case--and notice that all the metrics in the report (precision, recall, and f1-score) can be computed from the values in the confusion matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.93      0.90       112\n",
      "           1       0.90      0.84      0.87        90\n",
      "\n",
      "    accuracy                           0.89       202\n",
      "   macro avg       0.89      0.89      0.89       202\n",
      "weighted avg       0.89      0.89      0.89       202\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(ylrstrat, y_predict_training))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.82      0.84      0.83        38\n",
      "           1       0.79      0.77      0.78        30\n",
      "\n",
      "    accuracy                           0.81        68\n",
      "   macro avg       0.81      0.80      0.81        68\n",
      "weighted avg       0.81      0.81      0.81        68\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(ytestlrstrat, y_predict_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the training accuracy is good, the test accuracy is somewhat worse than the training result. In such a case, as we introduced earlier, the model is slightly \"overfitting\" the training set. When there is evidence of overfitting, one must analyze the situation and suggest the course of action, typically aimed at \"relaxing\" the model--i.e., making it less strict.  This can seem counterintuitive at first!\n",
    "\n",
    "Typically, the test accuracy, even when it is close to the training accuracy, tends to be smaller (worse) than the training accuracy (better).\n",
    "\n",
    "When the test accuracy is significally better than the training accuracy, this would justify a review of the code to see if there is a bug. In such a case, plotting the performance results with multiple (random) splits of the same data would be one way to start investigating.\n",
    "\n",
    "The code below shows one simple way to do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#\n",
    "# here we try multiple splits and see the effects, with the same proportion 75% train and 25% test\n",
    "#\n",
    "# keep lists for training accuracy, \n",
    "#                test accuracy, \n",
    "#                and the difference between the latter and the former\n",
    "#\n",
    "training_accuracy = []\n",
    "test_accuracy = []\n",
    "accuracy_difference = []\n",
    "#\n",
    "# define number of trials\n",
    "#\n",
    "n_splits = 25\n",
    "#\n",
    "# define LogisticRegression object\n",
    "#\n",
    "clf = LogisticRegression(solver = 'newton-cg', max_iter = 500)\n",
    "#\n",
    "# loop over multiple trials\n",
    "#\n",
    "for i in range(0, n_splits):\n",
    "#\n",
    "# perform a split for this iteration, \n",
    "# using different random_state for every iteration\n",
    "# this ensures each split is likely to be unique\n",
    "#\n",
    "    Xlr, Xtestlr, ylr, ytestlr = train_test_split(X, y, stratify = y, random_state = i)\n",
    "#    \n",
    "# fit the Classifier on the training set\n",
    "#\n",
    "    clf.fit(Xlr, ylr)\n",
    "#\n",
    "# predict the labels for the training data\n",
    "#\n",
    "    y_predict_training = clf.predict(Xlr)\n",
    "#\n",
    "# predict the labels for the test data\n",
    "#\n",
    "    y_predict_test = clf.predict(Xtestlr)\n",
    "#\n",
    "# save training set accuracy for this split\n",
    "#\n",
    "    tr_accuracy = accuracy_score(y_predict_training, ylr)\n",
    "    training_accuracy.append(tr_accuracy)\n",
    "#\n",
    "# save test set accuracy for this split\n",
    "#\n",
    "    tst_accuracy = accuracy_score(y_predict_test, ytestlr)\n",
    "    test_accuracy.append(tst_accuracy)\n",
    "#\n",
    "# save difference between the two acuracy values\n",
    "#\n",
    "    accuracy_difference.append(tst_accuracy - tr_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code generates 25 unique experiments varying the train-test split indices within the original data.  Now we plot all the trials for both the training and test data, to compare the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(range(len(training_accuracy)),\n",
    "           training_accuracy, \n",
    "           color = 'blue', \n",
    "           alpha = 0.5,\n",
    "           label = 'Train data results')\n",
    "ax.plot(range(len(training_accuracy)),\n",
    "        training_accuracy, \n",
    "        color = 'blue', \n",
    "        linestyle = '-.',\n",
    "        linewidth = 0.5)\n",
    "ax.scatter(range(len(test_accuracy)),\n",
    "           test_accuracy, \n",
    "           color = 'red', \n",
    "           alpha = 0.35, \n",
    "           label = 'Test data results')\n",
    "ax.plot(range(len(test_accuracy)),\n",
    "        test_accuracy, \n",
    "        color = 'red', \n",
    "        linestyle = '-.',\n",
    "        linewidth = 0.5)\n",
    "ax.legend(fontsize = 8, loc = \"lower right\")\n",
    "ax.set_ylabel('Training vs Test Accuracy')\n",
    "ax.set_ylim(0, 1)\n",
    "ax.set_xlabel('trial number')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the accuracy on the train split is relatively constant. This is generally expected since the model is given the train data to fit. On the other hand, the test results vary somewhat more. Another way to look at these results is to plot the difference between the test accuracy and the train accuracy, which is done here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(range(len(accuracy_difference)),\n",
    "           accuracy_difference, \n",
    "           color = 'green', \n",
    "           label = 'Difference in Accuracy [test - train]')\n",
    "ax.plot([0, len(accuracy_difference)], [0, 0], 'red')\n",
    "ax.legend(fontsize = 6)\n",
    "ax.set_ylabel('Test/Training Accuracy Difference')\n",
    "ax.set_ylim(-0.25, 0.25)\n",
    "ax.set_xlabel('trial number')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the test accuracy is sometimes better, but not by very much--a maximum difference of no more than 0.15 units.  We've already noted that accuracy isn't always a good measure of model performance, and shown the use of the confusion matrix. Additional performance measures are provided by sklearn in the ``classifcation_report`` method (ref: [sklearn.metrics.classification_report](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html), including ``precision``, ``recall``, and ``f1-score``.  Note that if desired, we could graph multiple classification performance metrics similarly to the accuracy difference plot above. We won't do a deep dive on metrics here, but below we use the ``classification_report`` method to demonstrate the additional metrics. Note that since we didn't store the intermediate models, the following outputs results from the last of the 25 trials performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Training Classification Report]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.91      0.89       112\n",
      "           1       0.88      0.84      0.86        90\n",
      "\n",
      "    accuracy                           0.88       202\n",
      "   macro avg       0.88      0.88      0.88       202\n",
      "weighted avg       0.88      0.88      0.88       202\n",
      "\n",
      "[Test Classification Report]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.86      0.95      0.90        38\n",
      "           1       0.92      0.80      0.86        30\n",
      "\n",
      "    accuracy                           0.88        68\n",
      "   macro avg       0.89      0.87      0.88        68\n",
      "weighted avg       0.89      0.88      0.88        68\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"[Training Classification Report]\")\n",
    "print(classification_report(ylr, y_predict_training))\n",
    "#\n",
    "print(\"[Test Classification Report]\")\n",
    "print(classification_report(ytestlr, y_predict_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the more detailed classification report, we see that the metrics are similar for the training and test sets. If you look back at the two plots, you will notice the last points for train and test are more or less on top of each other. The [ISLR book](http://www-bcf.usc.edu/~gareth/ISL/) has explanations of the meaning of these performance metrics, and the Wikipedia entries for them are also quite good (see [Precision and Recall](https://en.wikipedia.org/wiki/Precision_and_recall))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression Parameters in scikit-learn\n",
    "\n",
    "It's a good habit to get into to use help(object) in Python to see details of the object.  If the object is a class from a large package like scikit-learn, you generally will get a version of the documentation similar to what you might find searching the web. By using help(), you are sure to get the information for the exact version you are using.  Here, use help(LogisticRegression) to get information about this class from scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class LogisticRegression in module sklearn.linear_model._logistic:\n",
      "\n",
      "class LogisticRegression(sklearn.linear_model._base.LinearClassifierMixin, sklearn.linear_model._base.SparseCoefMixin, sklearn.base.BaseEstimator)\n",
      " |  LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)\n",
      " |  \n",
      " |  Logistic Regression (aka logit, MaxEnt) classifier.\n",
      " |  \n",
      " |  In the multiclass case, the training algorithm uses the one-vs-rest (OvR)\n",
      " |  scheme if the 'multi_class' option is set to 'ovr', and uses the\n",
      " |  cross-entropy loss if the 'multi_class' option is set to 'multinomial'.\n",
      " |  (Currently the 'multinomial' option is supported only by the 'lbfgs',\n",
      " |  'sag', 'saga' and 'newton-cg' solvers.)\n",
      " |  \n",
      " |  This class implements regularized logistic regression using the\n",
      " |  'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. **Note\n",
      " |  that regularization is applied by default**. It can handle both dense\n",
      " |  and sparse input. Use C-ordered arrays or CSR matrices containing 64-bit\n",
      " |  floats for optimal performance; any other input format will be converted\n",
      " |  (and copied).\n",
      " |  \n",
      " |  The 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization\n",
      " |  with primal formulation, or no regularization. The 'liblinear' solver\n",
      " |  supports both L1 and L2 regularization, with a dual formulation only for\n",
      " |  the L2 penalty. The Elastic-Net regularization is only supported by the\n",
      " |  'saga' solver.\n",
      " |  \n",
      " |  Read more in the :ref:`User Guide <logistic_regression>`.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  penalty : {'l1', 'l2', 'elasticnet', 'none'}, default='l2'\n",
      " |      Specify the norm of the penalty:\n",
      " |  \n",
      " |      - `'none'`: no penalty is added;\n",
      " |      - `'l2'`: add a L2 penalty term and it is the default choice;\n",
      " |      - `'l1'`: add a L1 penalty term;\n",
      " |      - `'elasticnet'`: both L1 and L2 penalty terms are added.\n",
      " |  \n",
      " |      .. warning::\n",
      " |         Some penalties may not work with some solvers. See the parameter\n",
      " |         `solver` below, to know the compatibility between the penalty and\n",
      " |         solver.\n",
      " |  \n",
      " |      .. versionadded:: 0.19\n",
      " |         l1 penalty with SAGA solver (allowing 'multinomial' + L1)\n",
      " |  \n",
      " |  dual : bool, default=False\n",
      " |      Dual or primal formulation. Dual formulation is only implemented for\n",
      " |      l2 penalty with liblinear solver. Prefer dual=False when\n",
      " |      n_samples > n_features.\n",
      " |  \n",
      " |  tol : float, default=1e-4\n",
      " |      Tolerance for stopping criteria.\n",
      " |  \n",
      " |  C : float, default=1.0\n",
      " |      Inverse of regularization strength; must be a positive float.\n",
      " |      Like in support vector machines, smaller values specify stronger\n",
      " |      regularization.\n",
      " |  \n",
      " |  fit_intercept : bool, default=True\n",
      " |      Specifies if a constant (a.k.a. bias or intercept) should be\n",
      " |      added to the decision function.\n",
      " |  \n",
      " |  intercept_scaling : float, default=1\n",
      " |      Useful only when the solver 'liblinear' is used\n",
      " |      and self.fit_intercept is set to True. In this case, x becomes\n",
      " |      [x, self.intercept_scaling],\n",
      " |      i.e. a \"synthetic\" feature with constant value equal to\n",
      " |      intercept_scaling is appended to the instance vector.\n",
      " |      The intercept becomes ``intercept_scaling * synthetic_feature_weight``.\n",
      " |  \n",
      " |      Note! the synthetic feature weight is subject to l1/l2 regularization\n",
      " |      as all other features.\n",
      " |      To lessen the effect of regularization on synthetic feature weight\n",
      " |      (and therefore on the intercept) intercept_scaling has to be increased.\n",
      " |  \n",
      " |  class_weight : dict or 'balanced', default=None\n",
      " |      Weights associated with classes in the form ``{class_label: weight}``.\n",
      " |      If not given, all classes are supposed to have weight one.\n",
      " |  \n",
      " |      The \"balanced\" mode uses the values of y to automatically adjust\n",
      " |      weights inversely proportional to class frequencies in the input data\n",
      " |      as ``n_samples / (n_classes * np.bincount(y))``.\n",
      " |  \n",
      " |      Note that these weights will be multiplied with sample_weight (passed\n",
      " |      through the fit method) if sample_weight is specified.\n",
      " |  \n",
      " |      .. versionadded:: 0.17\n",
      " |         *class_weight='balanced'*\n",
      " |  \n",
      " |  random_state : int, RandomState instance, default=None\n",
      " |      Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the\n",
      " |      data. See :term:`Glossary <random_state>` for details.\n",
      " |  \n",
      " |  solver : {'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'},             default='lbfgs'\n",
      " |  \n",
      " |      Algorithm to use in the optimization problem. Default is 'lbfgs'.\n",
      " |      To choose a solver, you might want to consider the following aspects:\n",
      " |  \n",
      " |          - For small datasets, 'liblinear' is a good choice, whereas 'sag'\n",
      " |            and 'saga' are faster for large ones;\n",
      " |          - For multiclass problems, only 'newton-cg', 'sag', 'saga' and\n",
      " |            'lbfgs' handle multinomial loss;\n",
      " |          - 'liblinear' is limited to one-versus-rest schemes.\n",
      " |  \n",
      " |      .. warning::\n",
      " |         The choice of the algorithm depends on the penalty chosen:\n",
      " |         Supported penalties by solver:\n",
      " |  \n",
      " |         - 'newton-cg'   -   ['l2', 'none']\n",
      " |         - 'lbfgs'       -   ['l2', 'none']\n",
      " |         - 'liblinear'   -   ['l1', 'l2']\n",
      " |         - 'sag'         -   ['l2', 'none']\n",
      " |         - 'saga'        -   ['elasticnet', 'l1', 'l2', 'none']\n",
      " |  \n",
      " |      .. note::\n",
      " |         'sag' and 'saga' fast convergence is only guaranteed on\n",
      " |         features with approximately the same scale. You can\n",
      " |         preprocess the data with a scaler from :mod:`sklearn.preprocessing`.\n",
      " |  \n",
      " |      .. seealso::\n",
      " |         Refer to the User Guide for more information regarding\n",
      " |         :class:`LogisticRegression` and more specifically the\n",
      " |         `Table <https://scikit-learn.org/dev/modules/linear_model.html#logistic-regression>`_\n",
      " |         summarazing solver/penalty supports.\n",
      " |         <!--\n",
      " |         # noqa: E501\n",
      " |         -->\n",
      " |  \n",
      " |      .. versionadded:: 0.17\n",
      " |         Stochastic Average Gradient descent solver.\n",
      " |      .. versionadded:: 0.19\n",
      " |         SAGA solver.\n",
      " |      .. versionchanged:: 0.22\n",
      " |          The default solver changed from 'liblinear' to 'lbfgs' in 0.22.\n",
      " |  \n",
      " |  max_iter : int, default=100\n",
      " |      Maximum number of iterations taken for the solvers to converge.\n",
      " |  \n",
      " |  multi_class : {'auto', 'ovr', 'multinomial'}, default='auto'\n",
      " |      If the option chosen is 'ovr', then a binary problem is fit for each\n",
      " |      label. For 'multinomial' the loss minimised is the multinomial loss fit\n",
      " |      across the entire probability distribution, *even when the data is\n",
      " |      binary*. 'multinomial' is unavailable when solver='liblinear'.\n",
      " |      'auto' selects 'ovr' if the data is binary, or if solver='liblinear',\n",
      " |      and otherwise selects 'multinomial'.\n",
      " |  \n",
      " |      .. versionadded:: 0.18\n",
      " |         Stochastic Average Gradient descent solver for 'multinomial' case.\n",
      " |      .. versionchanged:: 0.22\n",
      " |          Default changed from 'ovr' to 'auto' in 0.22.\n",
      " |  \n",
      " |  verbose : int, default=0\n",
      " |      For the liblinear and lbfgs solvers set verbose to any positive\n",
      " |      number for verbosity.\n",
      " |  \n",
      " |  warm_start : bool, default=False\n",
      " |      When set to True, reuse the solution of the previous call to fit as\n",
      " |      initialization, otherwise, just erase the previous solution.\n",
      " |      Useless for liblinear solver. See :term:`the Glossary <warm_start>`.\n",
      " |  \n",
      " |      .. versionadded:: 0.17\n",
      " |         *warm_start* to support *lbfgs*, *newton-cg*, *sag*, *saga* solvers.\n",
      " |  \n",
      " |  n_jobs : int, default=None\n",
      " |      Number of CPU cores used when parallelizing over classes if\n",
      " |      multi_class='ovr'\". This parameter is ignored when the ``solver`` is\n",
      " |      set to 'liblinear' regardless of whether 'multi_class' is specified or\n",
      " |      not. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`\n",
      " |      context. ``-1`` means using all processors.\n",
      " |      See :term:`Glossary <n_jobs>` for more details.\n",
      " |  \n",
      " |  l1_ratio : float, default=None\n",
      " |      The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only\n",
      " |      used if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent\n",
      " |      to using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent\n",
      " |      to using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a\n",
      " |      combination of L1 and L2.\n",
      " |  \n",
      " |  Attributes\n",
      " |  ----------\n",
      " |  \n",
      " |  classes_ : ndarray of shape (n_classes, )\n",
      " |      A list of class labels known to the classifier.\n",
      " |  \n",
      " |  coef_ : ndarray of shape (1, n_features) or (n_classes, n_features)\n",
      " |      Coefficient of the features in the decision function.\n",
      " |  \n",
      " |      `coef_` is of shape (1, n_features) when the given problem is binary.\n",
      " |      In particular, when `multi_class='multinomial'`, `coef_` corresponds\n",
      " |      to outcome 1 (True) and `-coef_` corresponds to outcome 0 (False).\n",
      " |  \n",
      " |  intercept_ : ndarray of shape (1,) or (n_classes,)\n",
      " |      Intercept (a.k.a. bias) added to the decision function.\n",
      " |  \n",
      " |      If `fit_intercept` is set to False, the intercept is set to zero.\n",
      " |      `intercept_` is of shape (1,) when the given problem is binary.\n",
      " |      In particular, when `multi_class='multinomial'`, `intercept_`\n",
      " |      corresponds to outcome 1 (True) and `-intercept_` corresponds to\n",
      " |      outcome 0 (False).\n",
      " |  \n",
      " |  n_features_in_ : int\n",
      " |      Number of features seen during :term:`fit`.\n",
      " |  \n",
      " |      .. versionadded:: 0.24\n",
      " |  \n",
      " |  feature_names_in_ : ndarray of shape (`n_features_in_`,)\n",
      " |      Names of features seen during :term:`fit`. Defined only when `X`\n",
      " |      has feature names that are all strings.\n",
      " |  \n",
      " |      .. versionadded:: 1.0\n",
      " |  \n",
      " |  n_iter_ : ndarray of shape (n_classes,) or (1, )\n",
      " |      Actual number of iterations for all classes. If binary or multinomial,\n",
      " |      it returns only 1 element. For liblinear solver, only the maximum\n",
      " |      number of iteration across all classes is given.\n",
      " |  \n",
      " |      .. versionchanged:: 0.20\n",
      " |  \n",
      " |          In SciPy <= 1.0.0 the number of lbfgs iterations may exceed\n",
      " |          ``max_iter``. ``n_iter_`` will now report at most ``max_iter``.\n",
      " |  \n",
      " |  See Also\n",
      " |  --------\n",
      " |  SGDClassifier : Incrementally trained logistic regression (when given\n",
      " |      the parameter ``loss=\"log\"``).\n",
      " |  LogisticRegressionCV : Logistic regression with built-in cross validation.\n",
      " |  \n",
      " |  Notes\n",
      " |  -----\n",
      " |  The underlying C implementation uses a random number generator to\n",
      " |  select features when fitting the model. It is thus not uncommon,\n",
      " |  to have slightly different results for the same input data. If\n",
      " |  that happens, try with a smaller tol parameter.\n",
      " |  \n",
      " |  Predict output may not match that of standalone liblinear in certain\n",
      " |  cases. See :ref:`differences from liblinear <liblinear_differences>`\n",
      " |  in the narrative documentation.\n",
      " |  \n",
      " |  References\n",
      " |  ----------\n",
      " |  \n",
      " |  L-BFGS-B -- Software for Large-scale Bound-constrained Optimization\n",
      " |      Ciyou Zhu, Richard Byrd, Jorge Nocedal and Jose Luis Morales.\n",
      " |      http://users.iems.northwestern.edu/~nocedal/lbfgsb.html\n",
      " |  \n",
      " |  LIBLINEAR -- A Library for Large Linear Classification\n",
      " |      https://www.csie.ntu.edu.tw/~cjlin/liblinear/\n",
      " |  \n",
      " |  SAG -- Mark Schmidt, Nicolas Le Roux, and Francis Bach\n",
      " |      Minimizing Finite Sums with the Stochastic Average Gradient\n",
      " |      https://hal.inria.fr/hal-00860051/document\n",
      " |  \n",
      " |  SAGA -- Defazio, A., Bach F. & Lacoste-Julien S. (2014).\n",
      " |      SAGA: A Fast Incremental Gradient Method With Support\n",
      " |      for Non-Strongly Convex Composite Objectives\n",
      " |      https://arxiv.org/abs/1407.0202\n",
      " |  \n",
      " |  Hsiang-Fu Yu, Fang-Lan Huang, Chih-Jen Lin (2011). Dual coordinate descent\n",
      " |      methods for logistic regression and maximum entropy models.\n",
      " |      Machine Learning 85(1-2):41-75.\n",
      " |      https://www.csie.ntu.edu.tw/~cjlin/papers/maxent_dual.pdf\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  >>> from sklearn.datasets import load_iris\n",
      " |  >>> from sklearn.linear_model import LogisticRegression\n",
      " |  >>> X, y = load_iris(return_X_y=True)\n",
      " |  >>> clf = LogisticRegression(random_state=0).fit(X, y)\n",
      " |  >>> clf.predict(X[:2, :])\n",
      " |  array([0, 0])\n",
      " |  >>> clf.predict_proba(X[:2, :])\n",
      " |  array([[9.8...e-01, 1.8...e-02, 1.4...e-08],\n",
      " |         [9.7...e-01, 2.8...e-02, ...e-08]])\n",
      " |  >>> clf.score(X, y)\n",
      " |  0.97...\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      LogisticRegression\n",
      " |      sklearn.linear_model._base.LinearClassifierMixin\n",
      " |      sklearn.base.ClassifierMixin\n",
      " |      sklearn.linear_model._base.SparseCoefMixin\n",
      " |      sklearn.base.BaseEstimator\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  fit(self, X, y, sample_weight=None)\n",
      " |      Fit the model according to the given training data.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : {array-like, sparse matrix} of shape (n_samples, n_features)\n",
      " |          Training vector, where `n_samples` is the number of samples and\n",
      " |          `n_features` is the number of features.\n",
      " |      \n",
      " |      y : array-like of shape (n_samples,)\n",
      " |          Target vector relative to X.\n",
      " |      \n",
      " |      sample_weight : array-like of shape (n_samples,) default=None\n",
      " |          Array of weights that are assigned to individual samples.\n",
      " |          If not provided, then each sample is given unit weight.\n",
      " |      \n",
      " |          .. versionadded:: 0.17\n",
      " |             *sample_weight* support to LogisticRegression.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self\n",
      " |          Fitted estimator.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The SAGA solver supports both float64 and float32 bit arrays.\n",
      " |  \n",
      " |  predict_log_proba(self, X)\n",
      " |      Predict logarithm of probability estimates.\n",
      " |      \n",
      " |      The returned estimates for all classes are ordered by the\n",
      " |      label of classes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Vector to be scored, where `n_samples` is the number of samples and\n",
      " |          `n_features` is the number of features.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      T : array-like of shape (n_samples, n_classes)\n",
      " |          Returns the log-probability of the sample for each class in the\n",
      " |          model, where classes are ordered as they are in ``self.classes_``.\n",
      " |  \n",
      " |  predict_proba(self, X)\n",
      " |      Probability estimates.\n",
      " |      \n",
      " |      The returned estimates for all classes are ordered by the\n",
      " |      label of classes.\n",
      " |      \n",
      " |      For a multi_class problem, if multi_class is set to be \"multinomial\"\n",
      " |      the softmax function is used to find the predicted probability of\n",
      " |      each class.\n",
      " |      Else use a one-vs-rest approach, i.e calculate the probability\n",
      " |      of each class assuming it to be positive using the logistic function.\n",
      " |      and normalize these values across all the classes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Vector to be scored, where `n_samples` is the number of samples and\n",
      " |          `n_features` is the number of features.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      T : array-like of shape (n_samples, n_classes)\n",
      " |          Returns the probability of the sample for each class in the model,\n",
      " |          where classes are ordered as they are in ``self.classes_``.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._base.LinearClassifierMixin:\n",
      " |  \n",
      " |  decision_function(self, X)\n",
      " |      Predict confidence scores for samples.\n",
      " |      \n",
      " |      The confidence score for a sample is proportional to the signed\n",
      " |      distance of that sample to the hyperplane.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : {array-like, sparse matrix} of shape (n_samples, n_features)\n",
      " |          The data matrix for which we want to get the confidence scores.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scores : ndarray of shape (n_samples,) or (n_samples, n_classes)\n",
      " |          Confidence scores per `(n_samples, n_classes)` combination. In the\n",
      " |          binary case, confidence score for `self.classes_[1]` where >0 means\n",
      " |          this class would be predicted.\n",
      " |  \n",
      " |  predict(self, X)\n",
      " |      Predict class labels for samples in X.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : {array-like, sparse matrix} of shape (n_samples, n_features)\n",
      " |          The data matrix for which we want to get the predictions.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      y_pred : ndarray of shape (n_samples,)\n",
      " |          Vector containing the class labels for each sample.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.base.ClassifierMixin:\n",
      " |  \n",
      " |  score(self, X, y, sample_weight=None)\n",
      " |      Return the mean accuracy on the given test data and labels.\n",
      " |      \n",
      " |      In multi-label classification, this is the subset accuracy\n",
      " |      which is a harsh metric since you require for each sample that\n",
      " |      each label set be correctly predicted.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Test samples.\n",
      " |      \n",
      " |      y : array-like of shape (n_samples,) or (n_samples, n_outputs)\n",
      " |          True labels for `X`.\n",
      " |      \n",
      " |      sample_weight : array-like of shape (n_samples,), default=None\n",
      " |          Sample weights.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      score : float\n",
      " |          Mean accuracy of ``self.predict(X)`` wrt. `y`.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sklearn.base.ClassifierMixin:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.linear_model._base.SparseCoefMixin:\n",
      " |  \n",
      " |  densify(self)\n",
      " |      Convert coefficient matrix to dense array format.\n",
      " |      \n",
      " |      Converts the ``coef_`` member (back) to a numpy.ndarray. This is the\n",
      " |      default format of ``coef_`` and is required for fitting, so calling\n",
      " |      this method is only required on models that have previously been\n",
      " |      sparsified; otherwise, it is a no-op.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self\n",
      " |          Fitted estimator.\n",
      " |  \n",
      " |  sparsify(self)\n",
      " |      Convert coefficient matrix to sparse format.\n",
      " |      \n",
      " |      Converts the ``coef_`` member to a scipy.sparse matrix, which for\n",
      " |      L1-regularized models can be much more memory- and storage-efficient\n",
      " |      than the usual numpy.ndarray representation.\n",
      " |      \n",
      " |      The ``intercept_`` member is not converted.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self\n",
      " |          Fitted estimator.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For non-sparse models, i.e. when there are not many zeros in ``coef_``,\n",
      " |      this may actually *increase* memory usage, so use this method with\n",
      " |      care. A rule of thumb is that the number of zero elements, which can\n",
      " |      be computed with ``(coef_ == 0).sum()``, must be more than 50% for this\n",
      " |      to provide significant benefits.\n",
      " |      \n",
      " |      After calling this method, further fitting with the partial_fit\n",
      " |      method (if any) will not work until you call densify.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sklearn.base.BaseEstimator:\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __repr__(self, N_CHAR_MAX=700)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  get_params(self, deep=True)\n",
      " |      Get parameters for this estimator.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      deep : bool, default=True\n",
      " |          If True, will return the parameters for this estimator and\n",
      " |          contained subobjects that are estimators.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      params : dict\n",
      " |          Parameter names mapped to their values.\n",
      " |  \n",
      " |  set_params(self, **params)\n",
      " |      Set the parameters of this estimator.\n",
      " |      \n",
      " |      The method works on simple estimators as well as on nested objects\n",
      " |      (such as :class:`~sklearn.pipeline.Pipeline`). The latter have\n",
      " |      parameters of the form ``<component>__<parameter>`` so that it's\n",
      " |      possible to update each component of a nested object.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      **params : dict\n",
      " |          Estimator parameters.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self : estimator instance\n",
      " |          Estimator instance.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(LogisticRegression)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see in the help documentation all the paramters for which you can assign values to affect the behavior of the class when you use it.  In the above output, you are shown (among others--below we've omitted ones not of interest here--but feel free to experiment!).\n",
    "  \n",
    "penalty = 'l2'  \n",
    "C = 1.0  \n",
    "fit_intercept = True  \n",
    "  \n",
    "The values given after the equal sign are the default values; farther down in the documentation each parameter is defined and the possible / allowed values are detailed.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lTKK3xCDH7GK"
   },
   "source": [
    "### Tuning the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0c_CvQWMH7GL"
   },
   "source": [
    "We've just seen that the scikit-learn logistic regression model has some adjustable parameters (*hyperparameters*) we can tune to optimize performance. Keep in mind that optimizing performance means we want to minimize the gap between the model performance on the training set and the test/validation set. It's possible to get a very good score on the training set but do poorly on the test set, due to what is called \"overfitting'.  Overfitting refers to the case where the training performance is significantly higer than the test performance--this is caused by the model \"memorizing\" the training data. For tuning the parameters of your model, you will use a mix of *cross-validation* and *grid search*. In Logistic Regression, the most important parameter to tune is the *regularization parameter* ``C``. The regularization parameter is used to control for unlikely high regression coefficients, by adding a \"penalty\" to the loss term when the coefficients get larger.  For sklearn ``LogisticRegression``, ``C`` is the \"inverse regularization strength\", meaning smaller ``C`` constrains the paramters more. Also note that the actual penalty is determined by the \"penalty\" paramter, which defaults to ``l2``. l2 regularization uses a value ($\\lambda$) multipled by the sum of the squares of the model coefficients.  l1 regularization multiples $\\lambda$ by the sum of the absolute values of the weights. l2 is also called Ridge regularization (see section 3.4 and equation 3.41 in [The Elements of Statistical Learning](https://hastie.su.domains/Papers/ESLII.pdf)) and l1 is called Lasso regularization (see section 3.4 and equation 3.52, ibid).  So by default, smaller values of ``C`` will result in l2 regularization with larger $\\lambda$ and a greater penalty on the larger model coefficients. Lastly, note that the default value for ``C`` is 1, and along with the default penaly l2, means scikit-learn Logistic Regression *always* uses regularization. If you would like to build Logistic Regression models without regularization, you can use statsmodels (*).\n",
    "\n",
    "You will now implement some code to perform model tuning and selecting the regularization parameter ``C``.  \n",
    "  \n",
    "---\n",
    "(*) [statsmodels.discrete.discrete_model.Logit](https://www.statsmodels.org/stable/discretemod.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Side-Bar: Cross Validation\n",
    "\n",
    "Cross Validation refers to using a procedure to split the data into multiple train/validation splits, fitting a model using the training split, computing the performance metrics for the validation split over multiple splits. The metrics are typically averaged and the average value is reported as hopefully representative of what the model will do in the future on new data. Recall earlier we showed that across 25 splits the train and the test scores varied; a key idea behind cross validation is to avoid choosing a \"lucky\" split that happens to give great performance on the data at hand but does more poorly later.  Since the scores vary across random splits, it's assumed that the best score or the worst score aren't as likely to represent the future as an average. Some Data Scientists also report the standard deviation of the cv scores as a further measure of how confident they are in the score.\n",
    "\n",
    "<b>To summarize</b>:\n",
    "- the data are split multiple times (training/validation)\n",
    "- a model is fit to the train data on each split\n",
    "- the model is scored on the validation data on each split\n",
    "- the average (and sometimes standard deviation) of the score is reported as the cv score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EzrmOosaH7GL"
   },
   "source": [
    "We use the following `cv_score` function to perform K-fold cross-validation and apply a scoring function to each test fold. A *fold* in this case just means a different split of the data, in this case random splits. The function generates five different splits (i.e. 5-fold validation), fits a classifier each time (note that the classifier is passed as a parameter to the function, so we can define it as anything that has a ``fit`` and ``predict`` method), and computes the \"score\", which by default is ``accuracy_score``. (Note the use of accuracy as the scoring metric--do you think this is the best approach for this problem?) Kfold is used to return sets of indices vs. the actual data, so the indices are generated, split, and passed as the vectors train, test to define the actual x and y data used on each pass. The scores are summed up in ``result``, and then the average is returned.\n",
    "\n",
    "Please do not confuse the train/test split that is done in the cv_score function with the initial train/test split that one does before building the model. As you will notice below, when cv_score is called, the actual parameters that will be bound to the formal parameters x, y are X_train, and y_train, which come from the original split of (X, y)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c77hT32VH7GM"
   },
   "outputs": [],
   "source": [
    "def cv_score(clf, x, y, score_func = accuracy_score):\n",
    "    result = 0\n",
    "    nfold = 5\n",
    "    x.reset_index(drop = True, inplace = True)\n",
    "    y.index = x.index\n",
    "    for train, test in KFold(nfold, shuffle = True,\n",
    "                             random_state = 42).split(x):\n",
    "        clf.fit(x.loc[train, :], y[train])\n",
    "        result += score_func(clf.predict(x.loc[test, :]), y[test])\n",
    "    return result / nfold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jwrPgto2H7GO"
   },
   "source": [
    "Below is an example of using the `cv_score` function for a basic logistic regression model without regularization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jtFdwvEbH7GP",
    "outputId": "dd089907-d94e-4c3f-fc91-e6a315bb186e",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.83\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(solver = 'liblinear', max_iter = 500)\n",
    "score = cv_score(clf, Xlr, ylr)\n",
    "print(f'{score:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's very important to understand this result. Earlier we showed that with different random splits, the train and test score would vary, and in our case the test score varied more than the train score. The key idea of cross-validation is to peform multiple splits. In this case, we defined our cv_score() function to return the average score across all splits. This is intended to be an estimate of the most likely performance of the model on unseen data. However, the actual results will still vary. Note that in this case the value is in between what we obtained with a single split for the train set and the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kODxGyOxH7GR"
   },
   "source": [
    "<div class=\"span5 alert alert-info\">\n",
    "<h3>Checkup Exercise Set II</h3>\n",
    "\n",
    "<b>Exercise:</b> Implement the following search procedure to find a good model\n",
    "<ul>\n",
    "<li> You are given a list of possible values of `C` below\n",
    "<li> For each `C`:\n",
    "  <ol>\n",
    "  <li> Create a logistic regression model with that value of `C`\n",
    "  <li> Find the average score for this model using the `cv_score` function **only on the training set** `(Xlr, ylr)`\n",
    "  </ol>\n",
    "<li> Pick the `C` with the highest average score\n",
    "</ul><br>\n",
    "Your goal is to find the best model parameters based *only* on the training set, without showing the model test set at all (which is why the test set is also called a *hold-out* set).  \n",
    "\n",
    "Comment on the value of the score using the best `C` vs. what we had before.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best C is 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.67743902, 0.82646341, 0.83634146, 0.83670732, 0.82695122])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the grid of parameters to search over\n",
    "Cs = [0.001, 0.1, 1, 10, 100]\n",
    "\n",
    "# your turn\n",
    "def tune_Cs(x, y, Cs=[0.001, 0.1, 1, 10, 100], score_func=accuracy_score):\n",
    "    Cs = Cs\n",
    "    cscores = np.empty(len(Cs))\n",
    "    for i, C in enumerate(Cs):\n",
    "        clf = LogisticRegression(C=C)\n",
    "        avg_score = cv_score(clf, x, y, score_func=score_func)\n",
    "        cscores[i] = avg_score\n",
    "    maxC = Cs[np.argmax(cscores)]\n",
    "    print(\"Best C is\", maxC)\n",
    "    return cscores\n",
    "\n",
    "tune_Cs(Xlr, ylr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Best C is 10 = 0.83670732"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sXRC8rlbH7GV"
   },
   "source": [
    "<div class=\"span5 alert alert-info\">\n",
    "<h3>Checkup Exercise Set III</h3><br>\n",
    "    <b>Exercise:</b> Now you want to estimate how this model will predict on unseen data in the following way:\n",
    "<ol>\n",
    "    <li> Use the <i>C</i> you obtained from the procedure earlier and train a Logistic Regression on the training data\n",
    "<li> Calculate the accuracy on the test data\n",
    "</ol>\n",
    "\n",
    "You may notice that this particular value of <i>C</i> may or may not do as well as simply running the default model on a random train-test split.\n",
    "\n",
    "<ul>\n",
    "<li> Do you think that's a problem? \n",
    "<li> Why do we need to do this whole cross-validation and grid search stuff anyway?\n",
    "</ul>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8823529411764706\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "# your turn\n",
    "clf = LogisticRegression(C=10)\n",
    "clf.fit(Xlr, ylr)\n",
    "print(accuracy_score(clf.predict(Xtestlr), ytestlr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8VNaKmftH7Gb"
   },
   "source": [
    "### Black Box Grid Search in `sklearn`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8LWn47nCH7Gc"
   },
   "source": [
    "Scikit-learn, as with many other Python packages, provides utilities to perform common operations so you do not have to implement them yourself. It is important to understand the mechanics of each operation, but at a certain point, you will want to use the utility instead to save time..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8FGPwNBPH7Gd"
   },
   "source": [
    "<div class=\"span5 alert alert-info\">\n",
    "<h3>Checkup Exercise Set IV</h3>\n",
    "\n",
    "<b>Exercise:</b> Use scikit-learn's [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html) tool to perform cross validation and grid search. \n",
    "\n",
    "* Instead of writing your own loops above to iterate over the model parameters, can you use GridSearchCV to find the best model over the training set? \n",
    "* Does it give you the same best value of C?\n",
    "* How does this model you've obtained perform on the test set?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Emine\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train score: 0.8712871287128713\n",
      "Test score: 0.9117647058823529\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'C': 0.1}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# your turn\n",
    "clf = sklearn.model_selection.GridSearchCV(LogisticRegression(), {'C': Cs}, cv=5)\n",
    "clf.fit(Xlr, ylr)\n",
    "print(\"Train score:\", clf.score(Xlr, ylr))\n",
    "print(\"Test score:\", clf.score(Xtestlr, ytestlr))\n",
    "clf.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train score: 0.8712871287128713\n",
    "Test score: 0.9117647058823529\n",
    "{'C': 0.1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So in a few lines of code, utilizing the functionality provied by scikit-learn, you can reproduce what took about 20 lines of code \"from scratch\". The goal here was to illustrate how to understand what is occurring when you use these advanced features.  It's always a good idea to do some experimenting and exploring to ensure you understand the tools you are using!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This case study has introduced using the Logistic Regression algorithm to classify a binary outcome, in this case the presence or absence of heart disease. You have seen how to tune a hyperparamter *C*, the  \"inverse regularization strength\" to get a model that has a good average cross-vaidation score on the held-out data.  \n",
    "\n",
    "Logistic regression is an excellent choice for a \"baseline\" classifier, even when you plan to test more complicated algorithms on a problem. Have a well-performing baseline makes it more clear when using a more complex method adds value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MCmALJTwH7Gi"
   },
   "source": [
    "## Optional: Appendix  \n",
    "#### Note: \n",
    "Most of the following material is taken verbatim from the Logistic Regression section of the CS109 tutorial found at https://github.com/cs109/2015lab5/blob/master/Classification.ipynb\n",
    "\n",
    "### A Walkthrough of the Math Behind Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could approach classification as linear regression, where the class, 0 or 1, is the target variable $y$. But this ignores the fact that our output $y$ is discrete valued, and futhermore, the $y$ predicted by linear regression will in general take on values less than 0 and greater than 1. Thus this does not seem like a very good idea.\n",
    "\n",
    "But what if we could change the form of our hypotheses $h(x)$ instead?\n",
    "\n",
    "The idea behind logistic regression is very simple. We want to draw a line in feature space that divides the '1' samples from the '0' samples, just like in the diagram above. In other words, we wish to find the \"regression\" line which divides the samples. Now, a line has the form $w_1 x_1 + w_2 x_2 + w_0 = 0$ in 2-dimensions. On one side of this line we have \n",
    "\n",
    "$$w_1 x_1 + w_2 x_2 + w_0 \\ge 0,$$\n",
    "\n",
    "and on the other side we have \n",
    "\n",
    "$$w_1 x_1 + w_2 x_2 + w_0 < 0.$$ \n",
    "\n",
    "Our classification rule then becomes:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "y = 1\\;\\; &if&\\; \\textbf{w}\\cdot\\textbf{x} \\ge 0\\\\\n",
    "y = 0\\;\\; &if&\\; \\textbf{w}\\cdot\\textbf{x} < 0\n",
    "\\end{eqnarray*}\n",
    "\n",
    "where $ \\textbf{x}$ is the vector $\\{1,x_1, x_2,...,x_n\\}$ where we have also generalized to more than 2 features.\n",
    "\n",
    "What hypotheses $h$ can we use to achieve this? One way to do so is to use the **sigmoid** function:\n",
    "\n",
    "$$h(z) = \\frac{1}{1 + e^{-z}}.$$\n",
    "\n",
    "Notice that at $z=0$ this function has the value 0.5. If $z > 0$, $h > 0.5$ and as $z \\to \\infty$, $h \\to 1$. If $z < 0$, $h < 0.5$ and as $z \\to -\\infty$, $h \\to 0$. As long as we identify any value of $y > 0.5$ as 1, and any $y < 0.5$ as 0, we can achieve what we wished above.\n",
    "\n",
    "This function is plotted below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GW9tbwaqH7Gs",
    "outputId": "372a82a7-5a65-4647-c660-3e982960e7ad",
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "h = lambda z: 1. / (1 + np.exp(-z))\n",
    "zs = np.arange(-5, 5, 0.1)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(zs, h(zs), alpha=0.5)\n",
    "ax.set_ylabel('Sigmoid Output')\n",
    "ax.set_xlabel('Sigmoid Input')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WxuHhldPH7Gw"
   },
   "source": [
    "You can see the effect of the Sigmoid function is to \"squash\" the input values to between 0 and 1, and because of the steep slope in the middle, it will tend to output values towards 0 or 1 if the input is somewhat different than 0.\n",
    "\n",
    "So we then come up with our rule by identifying:\n",
    "\n",
    "$$z = \\textbf{w}\\cdot\\textbf{x}.$$\n",
    "\n",
    "Then $h(\\textbf{w}\\cdot\\textbf{x}) \\ge 0.5$ if $\\textbf{w}\\cdot\\textbf{x} \\ge 0\\;$  and  $\\;h(\\textbf{w}\\cdot\\textbf{x}) \\lt 0.5$ if $\\textbf{w}\\cdot\\textbf{x} \\lt 0$, and:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "y = 1 \\;\\; &if&\\; h(\\textbf{w}\\cdot\\textbf{x}) \\ge 0.5\\\\\n",
    "y = 0 \\;\\; &if&\\; h(\\textbf{w}\\cdot\\textbf{x}) \\lt 0.5.\n",
    "\\end{eqnarray*}\n",
    "\n",
    "We will show soon that this identification can be achieved by minimizing a loss in the ERM framework called the **log loss** :\n",
    "\n",
    "$$ R_{\\cal{D}}(\\textbf{w}) = - \\sum_{y_i \\in \\cal{D}} \\left ( y_i \\log(h(\\textbf{w}\\cdot\\textbf{x})) + ( 1 - y_i) \\log(1 - h(\\textbf{w}\\cdot\\textbf{x})) \\right )$$\n",
    "\n",
    "We will also add a regularization term:\n",
    "\n",
    "$$ R_{\\cal{D}}(\\textbf{w}) = - \\sum_{y_i \\in \\cal{D}} \\left ( y_i \\log(h(\\textbf{w}\\cdot\\textbf{x})) + ( 1 - y_i) \\log(1 - h(\\textbf{w}\\cdot\\textbf{x})) \\right ) + \\frac{1}{C} \\textbf{w}\\cdot\\textbf{w},$$\n",
    "\n",
    "where $C$ is the regularization strength (equivalent to $1/\\alpha$ from the Ridge case), and smaller values of $C$ mean stronger regularization. As before, the regularization tries to prevent features from having terribly high weights, thus implementing a form of feature selection. \n",
    "\n",
    "How did we come up with this loss? We'll come back to that, but let us see how logistic regression works out. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7q7uV37WHunX"
   },
   "source": [
    "### The Probabalistic Interpretation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VW4XoUruHunX"
   },
   "source": [
    "Remember we said earlier that if $h > 0.5$ we ought to identify the sample with $y=1$? One way of thinking about this is to identify $h({w}\\cdot{x})$ with the probability that the sample is a '1'  $\\;$($y=1$). Then we have the intuitive notion that lets identify a sample as 1 if we find that the probabilty of being a '1' is $\\;\\ge 0.5$.\n",
    "\n",
    "So suppose we say then that the probability of $y=1$ for a given $\\textbf{x}$ is given by $h(\\textbf{w}\\cdot\\textbf{x})$?\n",
    "\n",
    "Then, the conditional probabilities of $y=1$ or $y=0$ given a particular sample's features $\\v{x}$ are:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "P(y=1 | \\textbf{x}) &=& h(\\textbf{w}\\cdot\\textbf{x}) \\\\\n",
    "P(y=0 | \\textbf{x}) &=& 1 - h(\\textbf{w}\\cdot\\textbf{x}).\n",
    "\\end{eqnarray*}\n",
    "\n",
    "These two can be written together as\n",
    "\n",
    "$$P(y|\\textbf{x}, \\textbf{w}) = h(\\textbf{w}\\cdot\\textbf{x})^y \\left(1 - h(\\textbf{w}\\cdot\\textbf{x}) \\right)^{(1-y)} $$\n",
    "\n",
    "Then multiplying over the samples we get the probability of the training $y$ given $\\textbf{w}$ and the $\\textbf{x}$:\n",
    "\n",
    "$$P(y|\\textbf{x},\\textbf{w}) = P(\\{y_i\\} | \\{\\textbf{x}_i\\}, \\textbf{w}) = \\prod_{y_i \\in \\cal{D}} P(y_i|\\textbf{x_i}, \\textbf{w}) = \\prod_{y_i \\in \\cal{D}} h(\\textbf{w}\\cdot\\textbf{x_i})^{y_i} \\left(1 - h(\\textbf{w}\\cdot\\textbf{x_i}) \\right)^{(1-y_i)}$$\n",
    "\n",
    "Why use probabilities? Earlier, we talked about how the regression function $f(x)$ never gives us the $y$ exactly, because of noise. This hold for classification too. Even with identical features, a different sample may be classified differently. \n",
    "\n",
    "We said that another way to think about a noisy $y$ is to imagine that our data $\\mathcal{D}$ was generated from  a joint probability distribution $P(x,y)$. Thus we need to model $y$ at a given $x$, written as $P(y|x)$, and since $P(x)$ is also a probability distribution, we have:\n",
    "\n",
    "$$P(x,y) = P(y | x) P(x)$$\n",
    "\n",
    "and can obtain our joint probability $P(x, y)$.\n",
    "\n",
    "Indeed its important to realize that a particular training set can be thought of as a draw from some \"true\" probability distribution (just as we did when showing the hairy variance diagram). If for example the probability of classifying a test sample as a '0' was 0.1, and it turns out that the test sample was a '0', it does not mean that this model was necessarily wrong. After all, in roughly a 10th of the draws, this new sample would be classified as a '0'! But, of-course its more unlikely than its likely, and having good probabilities means that we'll be likely right most of the time, which is what we want to achieve in classification. And furthermore, we can quantify this accuracy.\n",
    "\n",
    "Thus its desirable to have probabilistic, or at the very least, ranked models of classification where you can tell which sample is more likely to be classified as a '1'. There are business reasons for this too. Consider the example of customer \"churn\": you are a cell-phone company and want to know, based on some of my purchasing habit and characteristic \"features\" if I am a likely defector. If so, you'll offer me an incentive not to defect. In this scenario, you might want to know which customers are most likely to defect, or even more precisely, which are most likely to respond to incentives. Based on these probabilities, you could then spend a finite marketing budget wisely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KPOA3PdeHunY"
   },
   "source": [
    "### Maximizing the Probability of the Training Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3VlYAPRnHunY"
   },
   "source": [
    "Now if we maximize $P(y|\\textbf{x},\\textbf{w})$, we will maximize the chance that each point is classified correctly, which is what we want to do. While this is not exactly the same thing as maximizing the 1-0 training risk, it is a principled way of obtaining the highest probability classification. This process is called **maximum likelihood** estimation since we are maximising the **likelihood of the training data y**, \n",
    "\n",
    "$$\\mathcal{L} = P(y|\\textbf{x},\\textbf{w}).$$ \n",
    "\n",
    "Maximum likelihood is one of the corenerstone methods in statistics, and is used to estimate probabilities of data. \n",
    "\n",
    "We can equivalently maximize \n",
    "\n",
    "$$\\ell = \\log{P(y|\\textbf{x},\\textbf{w})}$$ \n",
    "\n",
    "since the natural logarithm $\\log$ is a monotonic function. This is known as maximizing the **log-likelihood**. Thus we can equivalently *minimize* a risk that is the negative of  $\\log(P(y|\\textbf{x},\\textbf{w}))$:\n",
    "\n",
    "$$R_{\\cal{D}}(h(x)) = -\\ell = -\\log \\mathcal{L} = -\\log{P(y|\\textbf{x},\\textbf{w})}$$\n",
    "\n",
    "\n",
    "Thus\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "R_{\\cal{D}}(h(x)) &=& -\\log\\left(\\prod_{y_i \\in \\cal{D}} h(\\textbf{w}\\cdot\\textbf{x_i})^{y_i} \\left(1 - h(\\textbf{w}\\cdot\\textbf{x_i}) \\right)^{(1-y_i)}\\right)\\\\\n",
    "                  &=& -\\sum_{y_i \\in \\cal{D}} \\log\\left(h(\\textbf{w}\\cdot\\textbf{x_i})^{y_i} \\left(1 - h(\\textbf{w}\\cdot\\textbf{x_i}) \\right)^{(1-y_i)}\\right)\\\\                  \n",
    "                  &=& -\\sum_{y_i \\in \\cal{D}} \\log\\,h(\\textbf{w}\\cdot\\textbf{x_i})^{y_i} + \\log\\,\\left(1 - h(\\textbf{w}\\cdot\\textbf{x_i}) \\right)^{(1-y_i)}\\\\\n",
    "                  &=& - \\sum_{y_i \\in \\cal{D}} \\left ( y_i \\log(h(\\textbf{w}\\cdot\\textbf{x})) + ( 1 - y_i) \\log(1 - h(\\textbf{w}\\cdot\\textbf{x})) \\right )\n",
    "\\end{eqnarray*}\n",
    "                  \n",
    "This is exactly the risk we had above, leaving out the regularization term (which we shall return to later) and was the reason we chose it over the 1-0 risk. \n",
    "\n",
    "Notice that this little process we carried out above tells us something very interesting: **Probabilistic estimation using maximum likelihood is equivalent to Empiricial Risk Minimization using the negative log-likelihood**, since all we did was to minimize the negative log-likelihood over the training samples.\n",
    "\n",
    "`sklearn` will return the probabilities for our samples, or for that matter, for any input vector set $\\{\\textbf{x}_i\\}$, i.e. $P(y_i | \\textbf{x}_i, \\textbf{w})$:\n",
    "\n",
    "Let us plot the probabilities obtained from `predict_proba`, overlayed on the samples with their true labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7T9bA2tyHunZ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.086999  , 0.913001  ],\n",
       "       [0.04091492, 0.95908508],\n",
       "       [0.10795374, 0.89204626],\n",
       "       [0.26829599, 0.73170401],\n",
       "       [0.719824  , 0.280176  ],\n",
       "       [0.75156004, 0.24843996],\n",
       "       [0.91550726, 0.08449274],\n",
       "       [0.62301811, 0.37698189],\n",
       "       [0.62814608, 0.37185392],\n",
       "       [0.90229823, 0.09770177],\n",
       "       [0.45927709, 0.54072291],\n",
       "       [0.57185607, 0.42814393],\n",
       "       [0.86665247, 0.13334753],\n",
       "       [0.75273001, 0.24726999],\n",
       "       [0.90009058, 0.09990942],\n",
       "       [0.22809457, 0.77190543],\n",
       "       [0.03617764, 0.96382236],\n",
       "       [0.90846889, 0.09153111],\n",
       "       [0.78510014, 0.21489986],\n",
       "       [0.14147399, 0.85852601],\n",
       "       [0.02666008, 0.97333992],\n",
       "       [0.72341951, 0.27658049],\n",
       "       [0.34593481, 0.65406519],\n",
       "       [0.13489071, 0.86510929],\n",
       "       [0.06002952, 0.93997048],\n",
       "       [0.67075443, 0.32924557],\n",
       "       [0.93850288, 0.06149712],\n",
       "       [0.89523622, 0.10476378],\n",
       "       [0.73822702, 0.26177298],\n",
       "       [0.35549009, 0.64450991],\n",
       "       [0.86810207, 0.13189793],\n",
       "       [0.44940874, 0.55059126],\n",
       "       [0.19774806, 0.80225194],\n",
       "       [0.10101851, 0.89898149],\n",
       "       [0.79429829, 0.20570171],\n",
       "       [0.84904501, 0.15095499],\n",
       "       [0.65125999, 0.34874001],\n",
       "       [0.06030377, 0.93969623],\n",
       "       [0.33665356, 0.66334644],\n",
       "       [0.84091997, 0.15908003],\n",
       "       [0.62956439, 0.37043561],\n",
       "       [0.10874163, 0.89125837],\n",
       "       [0.59418634, 0.40581366],\n",
       "       [0.91619136, 0.08380864],\n",
       "       [0.65061354, 0.34938646],\n",
       "       [0.52195083, 0.47804917],\n",
       "       [0.76148093, 0.23851907],\n",
       "       [0.95936638, 0.04063362],\n",
       "       [0.05551194, 0.94448806],\n",
       "       [0.23952803, 0.76047197],\n",
       "       [0.91422386, 0.08577614],\n",
       "       [0.75440727, 0.24559273],\n",
       "       [0.6818125 , 0.3181875 ],\n",
       "       [0.89538191, 0.10461809],\n",
       "       [0.10563288, 0.89436712],\n",
       "       [0.7506826 , 0.2493174 ],\n",
       "       [0.92932064, 0.07067936],\n",
       "       [0.88342646, 0.11657354],\n",
       "       [0.88765257, 0.11234743],\n",
       "       [0.18129603, 0.81870397],\n",
       "       [0.5873988 , 0.4126012 ],\n",
       "       [0.90009927, 0.09990073],\n",
       "       [0.04164395, 0.95835605],\n",
       "       [0.84708296, 0.15291704],\n",
       "       [0.72725337, 0.27274663],\n",
       "       [0.89185396, 0.10814604],\n",
       "       [0.17778823, 0.82221177],\n",
       "       [0.03168736, 0.96831264]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.predict_proba(Xtestlr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To illustrate further, we return to our simplistic two-feature classifier we created earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yE3BTqqNHund"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1000, max_iter=500, solver='liblinear')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Xtrain, Xtest, ytrain, ytest = \\\n",
    "    train_test_split(dflog[['cholesterol_mg_dl','resting_BP_mm_Hg']],\n",
    "                     dflog['heart_disease'],\n",
    "                     train_size = 0.80,\n",
    "                     random_state = 42)\n",
    "classifier = LogisticRegression(solver = 'liblinear', max_iter = 500, C = 1000)\n",
    "classifier.fit(Xtrain, ytrain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we will use the other function we defined, to label the points using the *predicted* values (earlier we labeled them with their actual values) and label the probabilities output by the classifier. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 450x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.set_ylabel('Resting blood pressure (mm Hg)')\n",
    "ax.set_xlabel('Cholesterol level (mg/dl)')\n",
    "_ = points_plot_prob(ax, Xtrain, Xtest, ytrain, ytest, classifier, psize = 20, alpha = 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_jOAibq0Hung"
   },
   "source": [
    "Notice that lines of equal probability, as might be expected are stright lines. What the classifier does is very intuitive: if the probability is greater than 0.5, it classifies the sample as type '1' (has heart disease), otherwise it classifies the sample to be class '0' (no heart disease). Thus in the diagram above, where we have plotted predicted values rather than actual labels of samples, there is a clear demarcation at the 0.5 probability line.\n",
    "\n",
    "Again, this notion of trying to obtain the line or boundary of demarcation is what is called a **discriminative** classifier. The algorithm tries to find a decision boundary that separates those who have heart disease from those who do not. To classify a new sample, it checks on which side of the decision boundary the sample falls, and makes a prediction. In other words we are asking, given $\\textbf{x}$, what is the probability of a given $y$, or, what is the likelihood $P(y|\\textbf{x},\\textbf{w})$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cohgzM2BHunc"
   },
   "source": [
    "### Discriminative vs Generative Classifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WBf2j5fRHunc"
   },
   "source": [
    "Logistic regression is what is known as a **discriminative classifier** as we learn a soft boundary between/among classes. Another paradigm is the **generative classifier** where we learn the distribution of each class. For more examples of generative classifiers, look [here](https://en.wikipedia.org/wiki/Generative_model). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": 4
}