module-3/day-5-knn/knn-classification-enkeboll.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# K Nearest Neighbor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objective: \n",
    "- To be able to implement a KNN classification model, and utilize a visualization to identify the best value of K."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Agenda\n",
    "\n",
    "- What is the **K-nearest neighbors** classification model?\n",
    "- How do you use the sklearn grid search function?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## K-nearest neighbors (KNN) classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Lazy learning** or **Instance-based (IB)** learning methods simply store the training examples and postpone the generalization (building a model) until a new instance must be classified or prediction made."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Non-parametric models** assume that the data distribution cannot be defined in\n",
    "terms of such a finite set of parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.ufunc size changed, may indicate binary incompatibility. Expected 192 from C header, got 216 from PyObject\n",
      "  return f(*args, **kwds)\n",
      "/opt/anaconda3/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.ufunc size changed, may indicate binary incompatibility. Expected 192 from C header, got 216 from PyObject\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Variance</th>\n",
       "      <th>Skewness</th>\n",
       "      <th>Curtosis</th>\n",
       "      <th>Entropy</th>\n",
       "      <th>Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.62160</td>\n",
       "      <td>8.6661</td>\n",
       "      <td>-2.8073</td>\n",
       "      <td>-0.44699</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>4.54590</td>\n",
       "      <td>8.1674</td>\n",
       "      <td>-2.4586</td>\n",
       "      <td>-1.46210</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>3.86600</td>\n",
       "      <td>-2.6383</td>\n",
       "      <td>1.9242</td>\n",
       "      <td>0.10645</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.45660</td>\n",
       "      <td>9.5228</td>\n",
       "      <td>-4.0112</td>\n",
       "      <td>-3.59440</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.32924</td>\n",
       "      <td>-4.4552</td>\n",
       "      <td>4.5718</td>\n",
       "      <td>-0.98880</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Variance  Skewness  Curtosis  Entropy  Class\n",
       "0   3.62160    8.6661   -2.8073 -0.44699      0\n",
       "1   4.54590    8.1674   -2.4586 -1.46210      0\n",
       "2   3.86600   -2.6383    1.9242  0.10645      0\n",
       "3   3.45660    9.5228   -4.0112 -3.59440      0\n",
       "4   0.32924   -4.4552    4.5718 -0.98880      0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bankdata = pd.read_csv('https://raw.githubusercontent.com/matbesancon/BankNotes/master/data_banknote_authentication.txt', header=None)\n",
    "bankdata.head()\n",
    "\n",
    "# our data doesn't have header, so we will manually add that on \n",
    "headers = [\"Variance\", \"Skewness\", \"Curtosis\", \"Entropy\", \"Class\"]\n",
    "bankdata.columns = headers\n",
    "\n",
    "bankdata.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr = LogisticRegression()\n",
    "lr.fit(bankdata.drop(columns='Class'), bankdata.Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.73883455])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3.36496558, -1.88765064, -2.30699401, -0.08893876]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### What should the grey point be?\n",
    "\n",
    "<img src='img/scenario.png' width=400/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## KNN has the following basic steps:\n",
    "\n",
    "<img src='img/knn-process.png' width=700/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Voting\n",
    "\n",
    "How to break ties:\n",
    "\n",
    "1. When doing a binary classification, often use a odd $K$ to avoid ties.\n",
    "2. Multiple approaches for Multiclass problems:\n",
    "    - Reduce the $K$ by 1 to see who wins.\n",
    "    - Weight the votes based on the distance of the neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example training data\n",
    "\n",
    "This example uses a multi-class problem and each color represents a different class. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### KNN classification map (K=1)\n",
    "\n",
    "![1NN classification map](img/04_1nn_map.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### KNN classification map (K=5)\n",
    "\n",
    "![5NN classification map](img/04_5nn_map.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A bit more math\n",
    "\n",
    "### Euclidean Distance\n",
    "\n",
    "**Euclidean distance** refers to the distance between two points. These points can be in different dimensional space and are represented by different forms of coordinates. In one-dimensional space, the points are just on a straight number line.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A bit more math\n",
    "### Measuring distance in a 2-d Space\n",
    "\n",
    "In two-dimensional space, the coordinates are given as points on the x- and y-axes\n",
    "\n",
    "![alt text](img/euclidean-distance.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A bit more math\n",
    "### Measuring distance in a 3-d Space\n",
    "\n",
    "In three-dimensional space, x-, y- and z-axes are used. \n",
    "\n",
    "$$\\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2 +  (z_1-z_2)^2}$$\n",
    "![alt text](img/vectorgraph.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A bit more math\n",
    "### Euclidean Distance Equation\n",
    "![alt text](img/euclidean-equation.png)\n",
    "\n",
    "The source of this formula is in the Pythagorean theorem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Implementing the KNN Classifier with SKlearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loading the data\n",
    "\n",
    "\n",
    "[following this analysis for part of this section](https://www.kaggle.com/shrutimechlearn/step-by-step-diabetes-classification-knn-detailed)\n",
    "\n",
    "- Can minimum value of below listed columns be zero (0)?\n",
    "- On these columns, a value of zero does not make sense and thus indicates missing value.\n",
    "\n",
    "Following columns or variables have an invalid zero value:\n",
    "\n",
    "- Glucose\n",
    "- BloodPressure\n",
    "- SkinThickness\n",
    "- Insulin\n",
    "- BMI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "diabetes = pd.read_csv('data/diabetes.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0            6      148             72             35        0  33.6   \n",
       "1            1       85             66             29        0  26.6   \n",
       "2            8      183             64              0        0  23.3   \n",
       "3            1       89             66             23       94  28.1   \n",
       "4            0      137             40             35      168  43.1   \n",
       "\n",
       "   DiabetesPedigreeFunction  Age  Outcome  \n",
       "0                     0.627   50        1  \n",
       "1                     0.351   31        0  \n",
       "2                     0.672   32        1  \n",
       "3                     0.167   21        0  \n",
       "4                     2.288   33        1  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diabetes.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 768 entries, 0 to 767\n",
      "Data columns (total 9 columns):\n",
      "Pregnancies                 768 non-null int64\n",
      "Glucose                     768 non-null int64\n",
      "BloodPressure               768 non-null int64\n",
      "SkinThickness               768 non-null int64\n",
      "Insulin                     768 non-null int64\n",
      "BMI                         768 non-null float64\n",
      "DiabetesPedigreeFunction    768 non-null float64\n",
      "Age                         768 non-null int64\n",
      "Outcome                     768 non-null int64\n",
      "dtypes: float64(2), int64(7)\n",
      "memory usage: 54.1 KB\n"
     ]
    }
   ],
   "source": [
    "diabetes.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero_cols = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']\n",
    "diabetes[zero_cols] = diabetes[zero_cols].replace(0, np.NaN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 768 entries, 0 to 767\n",
      "Data columns (total 9 columns):\n",
      "Pregnancies                 768 non-null int64\n",
      "Glucose                     763 non-null float64\n",
      "BloodPressure               733 non-null float64\n",
      "SkinThickness               541 non-null float64\n",
      "Insulin                     394 non-null float64\n",
      "BMI                         757 non-null float64\n",
      "DiabetesPedigreeFunction    768 non-null float64\n",
      "Age                         768 non-null int64\n",
      "Outcome                     768 non-null int64\n",
      "dtypes: float64(6), int64(3)\n",
      "memory usage: 54.1 KB\n"
     ]
    }
   ],
   "source": [
    "diabetes.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x111372290>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x12e9057d0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x11170f550>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x111746d50>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x12ea02590>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x12ea38d90>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x12ea775d0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x12eaa9dd0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x12eab5950>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Using distributions to impute missing values\n",
    "%matplotlib inline\n",
    "diabetes.hist(figsize=(20,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_resamp = diabetes.dropna().copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    262\n",
       "1    130\n",
       "Name: Outcome, dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db_resamp.Outcome.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0153846153846153"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "262/130"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "diabetes['Glucose'].fillna(diabetes['Glucose'].mean(), inplace=True)\n",
    "diabetes['BloodPressure'].fillna(diabetes['BloodPressure'].mean(), inplace=True)\n",
    "diabetes['SkinThickness'].fillna(diabetes['SkinThickness'].median(), inplace=True)\n",
    "diabetes['Insulin'].fillna(diabetes['Insulin'].median(), inplace=True)\n",
    "diabetes['BMI'].fillna(diabetes['BMI'].median(), inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    500\n",
       "1    268\n",
       "Name: Outcome, dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diabetes.Outcome.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8656716417910448"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "500/268"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "ss = StandardScaler()\n",
    "X = pd.DataFrame(ss.fit_transform(diabetes.drop([\"Outcome\"],axis=1)),\n",
    "                 columns=['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',\n",
    "                          'BMI', 'DiabetesPedigreeFunction', 'Age'])\n",
    "\n",
    "y = diabetes.Outcome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_dropped = pd.DataFrame(ss.fit_transform(db_resamp.drop([\"Outcome\"],axis=1)),\n",
    "                 columns=['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',\n",
    "                          'BMI', 'DiabetesPedigreeFunction', 'Age'])\n",
    "\n",
    "y_dropped = db_resamp.Outcome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Use x and y variables to split the training data into train and test set\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_dropped, X_test_dropped, y_train_dropped, y_test_dropped = train_test_split(X_dropped, y_dropped, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## scikit-learn 4-step modeling pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"img/sklearnsteps.png\" width=500>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Step 1:** Import the class you plan to use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.ufunc size changed, may indicate binary incompatibility. Expected 192 from C header, got 216 from PyObject\n",
      "  return f(*args, **kwds)\n",
      "/opt/anaconda3/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.ufunc size changed, may indicate binary incompatibility. Expected 192 from C header, got 216 from PyObject\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Step 2:** \"Instantiate\" the \"estimator\"\n",
    "\n",
    "- \"Estimator\" is scikit-learn's term for model\n",
    "- \"Instantiate\" means \"make an instance of\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_dropped = KNeighborsClassifier(n_neighbors=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Class specifications**\n",
    "- Name of the object does not matter\n",
    "- Can specify tuning parameters (aka \"hyperparameters\") during this step\n",
    "- All parameters not specified are set to their defaults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNeighborsClassifier(n_neighbors=3)\n"
     ]
    }
   ],
   "source": [
    "print(knn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Step 3:** Fit the model with data (aka \"model training\")\n",
    "\n",
    "- Model is learning the relationship between X and y\n",
    "- Occurs in-place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(n_neighbors=3)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(n_neighbors=3)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn_dropped.fit(X_train_dropped, y_train_dropped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Step 4:** Predict the response for a new observation\n",
    "\n",
    "- New observations are called \"out-of-sample\" data\n",
    "- Uses the information it learned during the model training process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# make class predictions for the testing set\n",
    "y_pred_class = knn.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:0.7604166666666666\n",
      "F1: 0.6515151515151516\n"
     ]
    }
   ],
   "source": [
    "# calculate accuracy\n",
    "from sklearn import metrics\n",
    "print('Accuracy:' + str(metrics.accuracy_score(y_test, y_pred_class)))\n",
    "print('F1: ' + str(metrics.f1_score(y_test, y_pred_class)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# make class predictions for the testing set\n",
    "y_pred_class_dropped = knn_dropped.predict(X_test_dropped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:0.7142857142857143\n",
      "F1: 0.5483870967741935\n"
     ]
    }
   ],
   "source": [
    "# calculate accuracy\n",
    "from sklearn import metrics\n",
    "print('Accuracy:' + str(metrics.accuracy_score(y_test_dropped, y_pred_class_dropped)))\n",
    "print('F1: ' + str(metrics.f1_score(y_test_dropped, y_pred_class_dropped)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "warnings.filterwarnings('ignore')\n",
    "plt.rcParams[\"figure.figsize\"] = [10, 5]\n",
    "\n",
    "# from https://scikit-learn.org/0.18/auto_examples/model_selection/plot_confusion_matrix.html\n",
    "\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion Matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.79844961, 0.31746032],\n",
       "       [0.20155039, 0.68253968]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test, y_pred_class)\n",
    "classes = ['Perished', 'Survived']\n",
    "cm / sum(cm)\n",
    "# plot_confusion_matrix(cm, classes,\n",
    "#                       normalize=False,\n",
    "#                       title='Confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.8030303, 0.46875  ],\n",
       "       [0.1969697, 0.53125  ]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test_dropped, y_pred_class_dropped)\n",
    "classes = ['Perished', 'Survived']\n",
    "cm / sum(cm)\n",
    "# plot_confusion_matrix(cm, classes,\n",
    "#                       normalize=False,\n",
    "#                       title='Confusion matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using a different value for K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# instantiate the model (using the value K=5)\n",
    "knn = KNeighborsClassifier(n_neighbors=5)\n",
    "\n",
    "# fit the model with data\n",
    "knn.fit(X_train, y_train)\n",
    "\n",
    "# make class predictions for the testing set\n",
    "y_pred_class = knn.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:0.796875\n",
      "F1: 0.6929133858267716\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy:' + str(metrics.accuracy_score(y_test, y_pred_class)))\n",
    "print('F1: ' + str(metrics.f1_score(y_test, y_pred_class)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.81      0.89      0.85       123\n",
      "           1       0.76      0.64      0.69        69\n",
      "\n",
      "    accuracy                           0.80       192\n",
      "   macro avg       0.79      0.76      0.77       192\n",
      "weighted avg       0.79      0.80      0.79       192\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report  \n",
    "\n",
    "print(classification_report(y_test, y_pred_class))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion Matrix, without normalization\n",
      "[[109  14]\n",
      " [ 25  44]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(y_test,y_pred_class)\n",
    "classes = ['Perished', 'Survived']\n",
    "plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Search for an optimal value of K for KNN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6893187638226052, 0.6854678699436763, 0.7578237734487735, 0.7394207376808283, 0.7924252811054261, 0.7505092169284525, 0.7557373046875, 0.7255773932063819, 0.7498458515885904, 0.7347953216374269, 0.7788825757575757, 0.7807133204633204, 0.7885372501514234, 0.7903262545556492, 0.7924252811054261, 0.7723011363636364, 0.7700164092664092, 0.7688212550228949, 0.7604907089677994]\n"
     ]
    }
   ],
   "source": [
    "k_range = list(range(1, 20))\n",
    "k_scores = []\n",
    "for k in k_range:\n",
    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
    "    knn.fit(X_train, y_train)\n",
    "    y_predict = knn.predict(X_test)\n",
    "    score = metrics.f1_score(y_test, y_predict, average='weighted')\n",
    "    k_scores.append( score)\n",
    "print(k_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Visual comparison of different $K$s\n",
    "\n",
    "This is not an ROC curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt  \n",
    "\n",
    "plt.figure(figsize=(12, 6))  \n",
    "plt.plot(k_range, k_scores, color='red', linestyle='dashed', marker='o',  \n",
    "         markerfacecolor='blue', markersize=10)\n",
    "plt.title('F1 score by K Value')  \n",
    "plt.xlabel('K Value')  \n",
    "plt.ylabel('F1 Score') \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What value of K performs best on our Test data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here we use F score, what other metrics could we use?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### How do you think K size relates to our concepts of bias and variance?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"img/K-NN_Neighborhood_Size_print.png\" width=500>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Resources\n",
    "\n",
    "- [Nearest Neighbors](http://scikit-learn.org/stable/modules/neighbors.html) (user guide), [KNeighborsClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) (class documentation)\n",
    "\n",
    "- [Videos from An Introduction to Statistical Learning](http://www.dataschool.io/15-hours-of-expert-machine-learning-videos/)\n",
    "    - Classification Problems and K-Nearest Neighbors (Chapter 2)\n",
    "    - Introduction to Classification (Chapter 4)\n",
    "    - Logistic Regression and Maximum Likelihood (Chapter 4)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}