10_eval-cv/10_eval-cv_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "STAT 479: Machine Learning (Fall 2018)  \n",
    "Instructor: Sebastian Raschka (sraschka@wisc.edu)  \n",
    "Course website: http://pages.stat.wisc.edu/~sraschka/teaching/stat479-fs2018/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L10: Model Evaluation 3 -- Cross-Validation and Model Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sebastian Raschka \n",
      "last updated: 2018-11-08 \n",
      "\n",
      "CPython 3.6.7\n",
      "IPython 6.5.0\n",
      "\n",
      "numpy 1.15.1\n",
      "mlxtend 0.14.0dev\n",
      "matplotlib 3.0.1\n",
      "sklearn 0.20.0\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -u -d -v -p numpy,mlxtend,matplotlib,sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- note to students: with matplotlib 3.0 you don't need `%matplotlib inline` in the notebook anymore; for older matplotlib versions you need to add that though to display the results in the notebook (so, please check via watermark when you are running this)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "## K-fold Cross-Validation in Scikit-Learn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Simple demonstration of using a cross-validation iterator in scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([2, 3, 4, 5, 6, 7, 8, 9]), array([0, 1]))\n",
      "(array([0, 1, 4, 5, 6, 7, 8, 9]), array([2, 3]))\n",
      "(array([0, 1, 2, 3, 6, 7, 8, 9]), array([4, 5]))\n",
      "(array([0, 1, 2, 3, 4, 5, 8, 9]), array([6, 7]))\n",
      "(array([0, 1, 2, 3, 4, 5, 6, 7]), array([8, 9]))\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "\n",
    "rng = np.random.RandomState(123)\n",
    "\n",
    "y = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])\n",
    "X = rng.random_sample((y.shape[0], 4))\n",
    "\n",
    "\n",
    "cv = KFold(n_splits=5)\n",
    "\n",
    "for k in cv.split(X, y):\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- In practice, we are usually interested in shuffling the dataset, because if the data records are ordered by class label, this would result in cases where the classes are not well represented in the training and test folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([1, 2, 3, 5, 6, 7, 8, 9]), array([0, 4]))\n",
      "(array([0, 1, 2, 3, 4, 6, 8, 9]), array([5, 7]))\n",
      "(array([0, 1, 2, 4, 5, 6, 7, 9]), array([3, 8]))\n",
      "(array([0, 2, 3, 4, 5, 7, 8, 9]), array([1, 6]))\n",
      "(array([0, 1, 3, 4, 5, 6, 7, 8]), array([2, 9]))\n"
     ]
    }
   ],
   "source": [
    "cv = KFold(n_splits=5, random_state=123, shuffle=True)\n",
    "\n",
    "for k in cv.split(X, y):\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Note that the `KFold` iterator only provides us with the array indices; in practice, we are actually interested in the array values (feature values and class labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train labels with shuffling [0 0 0 1 1 1 1 1]\n",
      "train labels with shuffling [0 0 0 0 0 1 1 1]\n",
      "train labels with shuffling [0 0 0 0 1 1 1 1]\n",
      "train labels with shuffling [0 0 0 0 1 1 1 1]\n",
      "train labels with shuffling [0 0 0 0 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "cv = KFold(n_splits=5, random_state=123, shuffle=True)\n",
    "\n",
    "for train_idx, valid_idx in cv.split(X, y):\n",
    "    print('train labels with shuffling', y[train_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- As discussed in the lecture, it's important to stratify the splits (very crucial for small datasets!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train labels [0 0 0 0 1 1 1 1]\n",
      "train labels [0 0 0 0 1 1 1 1]\n",
      "train labels [0 0 0 0 1 1 1 1]\n",
      "train labels [0 0 0 0 1 1 1 1]\n",
      "train labels [0 0 0 0 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "cv = StratifiedKFold(n_splits=5, random_state=123, shuffle=True)\n",
    "\n",
    "for train_idx, valid_idx in cv.split(X, y):\n",
    "    print('train labels', y[train_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- After the illustrations of cross-validation above, the next cell demonstrates how we can actually use the iterators provided through scikit-learn to fit and evaluate a learning algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kfold Accuracy: 95.06%\n",
      "Test Accuracy: 95.65%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from mlxtend.data import iris_data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "X, y = iris_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123, test_size=0.15, \n",
    "                                                    shuffle=True, stratify=y)\n",
    "\n",
    "\n",
    "\n",
    "cv = StratifiedKFold(n_splits=10, random_state=123, shuffle=True)\n",
    "\n",
    "kfold_acc = 0.\n",
    "for train_idx, valid_idx in cv.split(X_train, y_train):\n",
    "    clf = DecisionTreeClassifier(random_state=123, max_depth=3).fit(X_train[train_idx], y_train[train_idx])\n",
    "    y_pred = clf.predict(X_train[valid_idx])\n",
    "    acc = np.mean(y_pred == y_train[valid_idx])*100\n",
    "    kfold_acc += acc\n",
    "kfold_acc /= 10\n",
    "    \n",
    "clf = DecisionTreeClassifier(random_state=123, max_depth=3).fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)\n",
    "test_acc = np.mean(y_pred == y_test)*100\n",
    "    \n",
    "print('Kfold Accuracy: %.2f%%' % kfold_acc)\n",
    "print('Test Accuracy: %.2f%%' % test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Usually, a more convenient way to use cross-validation through scikit-learn is to use the `cross_val_score` function (note that it performs stratifies splitting for classification by default)\n",
    "- (remember to ask students about whitespaces according to pep8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kfold Accuracy: 96.83%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "\n",
    "cv_acc = cross_val_score(estimator=DecisionTreeClassifier(random_state=123, max_depth=3),\n",
    "                         X=X_train,\n",
    "                         y=y_train,\n",
    "                         cv=10,\n",
    "                         n_jobs=-1)\n",
    "\n",
    "print('Kfold Accuracy: %.2f%%' % (np.mean(cv_acc)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- `cross_val_score` has unfortunately no way to specify a random seed; this is not an issue in regular use cases, but it is not useful if you want to do \"repeated cross-validation\"\n",
    "- The next cell illustrates how we can provide our own cross-validation iterator for convenience (note that the results match or \"manual\" `StratifiedKFold` approach we performed earlier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kfold Accuracy: 95.06%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "\n",
    "cv_acc = cross_val_score(estimator=DecisionTreeClassifier(random_state=123, max_depth=3),\n",
    "                         X=X_train,\n",
    "                         y=y_train,\n",
    "                         cv=StratifiedKFold(n_splits=10, random_state=123, shuffle=True),\n",
    "                         n_jobs=-1)\n",
    "\n",
    "print('Kfold Accuracy: %.2f%%' % (np.mean(cv_acc)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "##  Bootstrap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Recall Bootstrapping from 2 lectures ago? Here I is an iterator I implemented analogous to `KFold`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 2 1 3] [0]\n",
      "[2 3 1 1 0] [4]\n",
      "[1 1 0 0 1] [2 3 4]\n",
      "[3 4 0 0 4] [1 2]\n",
      "[1 3 2 4 2] [0]\n"
     ]
    }
   ],
   "source": [
    "from mlxtend.evaluate import BootstrapOutOfBag\n",
    "\n",
    "oob = BootstrapOutOfBag(n_splits=5, random_seed=123)\n",
    "for train, test in oob.split(np.array([1, 2, 3, 4, 5])):\n",
    "    print(train, test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Analagous the `KFold` iterator, we can use it in the `cross_val_score` function for convenience"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOB Bootstrap Accuracy: 95.05%\n"
     ]
    }
   ],
   "source": [
    "cv_acc = cross_val_score(estimator=DecisionTreeClassifier(random_state=123, max_depth=3),\n",
    "                         X=X_train,\n",
    "                         y=y_train,\n",
    "                         cv=BootstrapOutOfBag(n_splits=200, random_seed=123),\n",
    "                         n_jobs=-1)\n",
    "\n",
    "print('OOB Bootstrap Accuracy: %.2f%%' % (np.mean(cv_acc)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Analagous to the `cross_val_score` method, you can use the `bootstrap_point632_score`, which implements the .632-Bootstrap method (which is less pesimistically biased than the out-of-bag bootstrap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OOB Bootstrap Accuracy: 96.34%\n"
     ]
    }
   ],
   "source": [
    "from mlxtend.evaluate import bootstrap_point632_score\n",
    "\n",
    "\n",
    "cv_acc = bootstrap_point632_score(estimator=DecisionTreeClassifier(random_state=123, max_depth=3),\n",
    "                                  X=X_train,\n",
    "                                  y=y_train,\n",
    "                                  random_seed=123)\n",
    "\n",
    "print('OOB Bootstrap Accuracy: %.2f%%' % (np.mean(cv_acc)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "\n",
    "## GridSearch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- For hyperparameter tuning and model selection, `GridSearchCV` is really useful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy: 96.83%\n",
      "Best Params: {'criterion': 'gini', 'max_depth': 3}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "param_grid = [{'max_depth': [1, 2, 3, 4, 5, 6, None],\n",
    "               'criterion': ['gini', 'entropy']}]\n",
    "\n",
    "gs = GridSearchCV(estimator=DecisionTreeClassifier(random_state=123),\n",
    "                  param_grid=param_grid,\n",
    "                  iid=False,\n",
    "                  refit=True,\n",
    "                  n_jobs=-1,\n",
    "                  cv=10)\n",
    "\n",
    "gs.fit(X_train, y_train)\n",
    "\n",
    "print('Best Accuracy: %.2f%%' % (gs.best_score_*100))\n",
    "print('Best Params:', gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6692307692307693 {'criterion': 'gini', 'max_depth': 1}\n",
      "0.9123076923076923 {'criterion': 'gini', 'max_depth': 2}\n",
      "0.9683333333333334 {'criterion': 'gini', 'max_depth': 3}\n",
      "0.9533333333333334 {'criterion': 'gini', 'max_depth': 4}\n",
      "0.9616666666666666 {'criterion': 'gini', 'max_depth': 5}\n",
      "0.9616666666666666 {'criterion': 'gini', 'max_depth': 6}\n",
      "0.9616666666666666 {'criterion': 'gini', 'max_depth': None}\n",
      "0.6692307692307693 {'criterion': 'entropy', 'max_depth': 1}\n",
      "0.9123076923076923 {'criterion': 'entropy', 'max_depth': 2}\n",
      "0.9606410256410255 {'criterion': 'entropy', 'max_depth': 3}\n",
      "0.9456410256410257 {'criterion': 'entropy', 'max_depth': 4}\n",
      "0.9462820512820512 {'criterion': 'entropy', 'max_depth': 5}\n",
      "0.9539743589743589 {'criterion': 'entropy', 'max_depth': 6}\n",
      "0.9539743589743589 {'criterion': 'entropy', 'max_depth': None}\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(gs.cv_results_['mean_test_score'])):\n",
    "    print(gs.cv_results_['mean_test_score'][i], gs.cv_results_['params'][i]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- After running `GridSearchCV`, we would fit a model with the best settings (hyperparameters on the whole training set\n",
    "- By default, `GridSearchCV` already does this for us (unless, we set `refit=False`), so that we can evaluate the performance of the model on the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.65%\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy: %.2f%%' % (gs.best_estimator_.score(X_test, y_test)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if we do not set refit=True, we would have to manually refit the model based on the best parameter values, like illustrated below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.65%\n"
     ]
    }
   ],
   "source": [
    "gs = GridSearchCV(estimator=DecisionTreeClassifier(random_state=123),\n",
    "                  param_grid=param_grid,\n",
    "                  iid=False,\n",
    "                  refit=False,\n",
    "                  n_jobs=-1,\n",
    "                  cv=10)\n",
    "\n",
    "gs.fit(X_train, y_train)\n",
    "tree = DecisionTreeClassifier(random_state=123, **gs.best_params_)\n",
    "tree.fit(X_train, y_train)\n",
    "\n",
    "print('Accuracy: %.2f%%' % (tree.score(X_test, y_test)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- `GridSearchCV` is also compatible with the .632-Bootstrap iterator we defined earlier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy: 95.12%\n",
      "Best Params: {'criterion': 'entropy', 'max_depth': 3}\n",
      "Accuracy: 95.65%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "param_grid = [{'max_depth': [1, 2, 3, 4, 5, 6, None],\n",
    "               'criterion': ['gini', 'entropy']}]\n",
    "\n",
    "gs = GridSearchCV(estimator=DecisionTreeClassifier(random_state=123),\n",
    "                  param_grid=param_grid,\n",
    "                  iid=False,\n",
    "                  refit=True,\n",
    "                  cv=BootstrapOutOfBag(n_splits=200, random_seed=123))\n",
    "\n",
    "gs.fit(X_train, y_train)\n",
    "print('Best Accuracy: %.2f%%' % (gs.best_score_*100))\n",
    "print('Best Params:', gs.best_params_)\n",
    "print('Accuracy: %.2f%%' % (gs.best_estimator_.score(X_test, y_test)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Note that feature scaling is unnecessary when we are using decsion trees, however it DOES matter in most other learning algorithms, including k-Nearest-Neighbors\n",
    "- To avoid introducing bias, we have to compute the parameters for scaling (e.g., the mean and standard deviation in context of z-score normalization) on the training fold to scale the training AND test fold in a given iteration\n",
    "- To make this more convenient, this is where scikit-learn's `Pipeline` class (or `make_pipeline` function) comes in handy as the next cell demonstrates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy: 94.78%\n",
      "Best Params: {'kneighborsclassifier__n_neighbors': 12, 'kneighborsclassifier__p': 1}\n",
      "Accuracy: 91.30%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "\n",
    "pipe = make_pipeline(StandardScaler(), \n",
    "                     KNeighborsClassifier())\n",
    "\n",
    "param_grid = [{'kneighborsclassifier__n_neighbors': list(range(1, 16)),\n",
    "               'kneighborsclassifier__p': [1, 2]}]\n",
    "\n",
    "\n",
    "gs = GridSearchCV(estimator=pipe,\n",
    "                  param_grid=param_grid,\n",
    "                  iid=False,\n",
    "                  n_jobs=-1,\n",
    "                  refit=True,\n",
    "                  cv=BootstrapOutOfBag(n_splits=200, random_seed=123))\n",
    "\n",
    "gs.fit(X_train, y_train)\n",
    "\n",
    "print('Best Accuracy: %.2f%%' % (gs.best_score_*100))\n",
    "print('Best Params:', gs.best_params_)\n",
    "print('Accuracy: %.2f%%' % (gs.best_estimator_.score(X_test, y_test)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy: 96.00%\n",
      "Best Params: {'kneighborsclassifier__n_neighbors': 14, 'kneighborsclassifier__p': 1}\n",
      "Accuracy: 91.30%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from scipy.stats import randint as sp_randint\n",
    "\n",
    "\n",
    "np.random.seed(123)\n",
    "\n",
    "pipe = make_pipeline(StandardScaler(), \n",
    "                     KNeighborsClassifier())\n",
    "\n",
    "param_dist = {'kneighborsclassifier__n_neighbors': sp_randint(1, 21),\n",
    "              'kneighborsclassifier__p': [1, 2]}\n",
    "\n",
    "\n",
    "gs = RandomizedSearchCV(estimator=pipe,\n",
    "                        param_distributions=param_dist,\n",
    "                        n_iter=1000,\n",
    "                        iid=False,\n",
    "                        n_jobs=-1,\n",
    "                        refit=True,\n",
    "                        cv=10)\n",
    "\n",
    "gs.fit(X_train, y_train)\n",
    "\n",
    "print('Best Accuracy: %.2f%%' % (gs.best_score_*100))\n",
    "print('Best Params:', gs.best_params_)\n",
    "print('Accuracy: %.2f%%' % (gs.best_estimator_.score(X_test, y_test)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "\n",
    "## K-fold and standard deviation (1-standard error method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Below is an application of the 1-standard error method we discussed in class (to select hyperparameters according to the \"Law of Parsimony\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import make_circles\n",
    "\n",
    "\n",
    "X, y = make_circles(n_samples=300, random_state=1, noise=0.275, factor=0.2)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                    test_size=0.3, \n",
    "                                                    random_state=12345,\n",
    "                                                    stratify=y)\n",
    "\n",
    "plt.scatter(X_train[y_train==0, 0], X_train[y_train==0, 1], \n",
    "            marker='s', color='red', edgecolor='k', alpha=0.6, s=25)\n",
    "plt.scatter(X_train[y_train==1, 0], X_train[y_train==1, 1], \n",
    "            marker='^', color='blue', edgecolor='k', alpha=0.6, s=25)\n",
    "plt.xlabel('X1', fontsize=14.5)\n",
    "plt.ylabel('X2', fontsize=14.5)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "params = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0, 10000.0]\n",
    "cv_acc, cv_std, cv_stderr = [], [], []\n",
    "\n",
    "\n",
    "cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)\n",
    "\n",
    "for c in params:\n",
    "\n",
    "    clf = SVC(C=10.0, \n",
    "              kernel='rbf', \n",
    "              degree=1, \n",
    "              gamma=c, \n",
    "              coef0=0.0, \n",
    "              shrinking=True, \n",
    "              probability=False, \n",
    "              tol=0.001, \n",
    "              cache_size=200, \n",
    "              class_weight=None, \n",
    "              verbose=False, \n",
    "              max_iter=-1, \n",
    "              decision_function_shape=None, \n",
    "              random_state=0)\n",
    "\n",
    "    \n",
    "    all_acc = []\n",
    "    for train_index, valid_index in cv.split(X_train, y_train):\n",
    "        pred = clf.fit(X_train[train_index], y_train[train_index])\\\n",
    "               .predict(X_train[valid_index])\n",
    "        acc = np.mean(y_train[valid_index] == pred)\n",
    "        all_acc.append(acc)\n",
    "\n",
    "    all_acc = np.array(all_acc)\n",
    "    y_pred_cv10_mean = all_acc.mean()\n",
    "    y_pred_cv10_std = all_acc.std()\n",
    "    y_pred_cv10_stderr = y_pred_cv10_std / np.sqrt(10)\n",
    "\n",
    "    cv_acc.append(y_pred_cv10_mean) \n",
    "    cv_std.append(y_pred_cv10_std)\n",
    "    cv_stderr.append(y_pred_cv10_stderr)\n",
    "    \n",
    "\n",
    "## PLOTTING\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "ax.set_xscale('log')\n",
    "ax.errorbar(params, cv_acc, yerr=cv_std, fmt='--o', ecolor='black', elinewidth=2)\n",
    "\n",
    "\n",
    "plt.ylim([0.0, 1.0])\n",
    "plt.xlim([0.0001, 100000.0])\n",
    "plt.grid()\n",
    "plt.xlabel('$\\\\gamma$')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- Below is a visualization of the decision boundary of the \"most parsimonious\" hyperparameter choice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mlxtend.plotting import plot_decision_regions\n",
    "import matplotlib.gridspec as gridspec\n",
    "import itertools\n",
    "\n",
    "\n",
    "gspec = gridspec.GridSpec(2, 2)\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "\n",
    "for c, grd in zip([0.01, 0.1, 1.0, 10.], itertools.product([0, 1], repeat=2)):\n",
    "\n",
    "    clf = SVC(C=10.0, \n",
    "              kernel='rbf', \n",
    "              degree=1, \n",
    "              gamma=c, \n",
    "              coef0=0.0, \n",
    "              shrinking=True, \n",
    "              probability=False, \n",
    "              tol=0.001, \n",
    "              cache_size=200, \n",
    "              class_weight=None, \n",
    "              verbose=False, \n",
    "              max_iter=-1, \n",
    "              decision_function_shape=None, \n",
    "              random_state=0)\n",
    "\n",
    "    clf.fit(X_train, y_train)\n",
    "    ax = plt.subplot(gspec[grd[0], grd[1]])\n",
    "    fig = plot_decision_regions(X=X, y=y, clf=clf)\n",
    "    plt.title('gamma=%f' % c)\n",
    "\n",
    "\n",
    "plt.xlabel('X1') \n",
    "plt.ylabel('X2')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>\n",
    "\n",
    "- The following cells in this section repeat the procedure of choosing the most parsimonious hyperparameter using decision trees and two features of the Iris dataset (petal length and petal width)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlxtend.data import iris_data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "X, y = iris_data()\n",
    "X = X[:, [2, 3]]\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123, test_size=0.15, \n",
    "                                                    shuffle=True, stratify=y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "\n",
    "params = range(1, 11)\n",
    "cv_acc, cv_std, cv_stderr = [], [], []\n",
    "\n",
    "\n",
    "cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)\n",
    "\n",
    "for c in params:\n",
    "\n",
    "    clf = DecisionTreeClassifier(random_state=123, max_depth=c)\n",
    "\n",
    "    \n",
    "    all_acc = []\n",
    "    for train_index, valid_index in cv.split(X_train, y_train):\n",
    "        pred = clf.fit(X_train[train_index], y_train[train_index])\\\n",
    "               .predict(X_train[valid_index])\n",
    "        acc = np.mean(y_train[valid_index] == pred)\n",
    "        all_acc.append(acc)\n",
    "\n",
    "    all_acc = np.array(all_acc)\n",
    "    y_pred_cv10_mean = all_acc.mean()\n",
    "    y_pred_cv10_std = all_acc.std()\n",
    "    y_pred_cv10_stderr = y_pred_cv10_std / np.sqrt(10)\n",
    "\n",
    "    cv_acc.append(y_pred_cv10_mean) \n",
    "    cv_std.append(y_pred_cv10_std)\n",
    "    cv_stderr.append(y_pred_cv10_stderr)\n",
    "    \n",
    "\n",
    "## PLOTTING\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "ax.errorbar(params, cv_acc, yerr=cv_stderr, fmt='--o', ecolor='black', elinewidth=2)\n",
    "\n",
    "\n",
    "plt.grid()\n",
    "plt.xlabel('max_depth')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mlxtend.plotting import plot_decision_regions\n",
    "import matplotlib.gridspec as gridspec\n",
    "import itertools\n",
    "\n",
    "\n",
    "gspec = gridspec.GridSpec(2, 2)\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "\n",
    "for c, grd in zip([1, 2, 3, 4], itertools.product([0, 1], repeat=2)):\n",
    "\n",
    "    clf = DecisionTreeClassifier(random_state=123, max_depth=c)\n",
    "\n",
    "    clf.fit(X_train, y_train)\n",
    "    ax = plt.subplot(gspec[grd[0], grd[1]])\n",
    "    fig = plot_decision_regions(X=X, y=y, clf=clf)\n",
    "    plt.title('max_depth=%d' % c)\n",
    "\n",
    "\n",
    "plt.xlabel('X1') \n",
    "plt.ylabel('X2')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"margin-bottom:5cm;\"></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeated k-fold\n",
    "\n",
    "- The following code compares \"single\" k-fold runs with repeated k-fold cross-validation (repeating k-fold 50 times with different random seeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SINGLE RUN\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "params = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0, 10000.0]\n",
    "cv_acc, cv_std, cv_stderr = [], [], []\n",
    "\n",
    "\n",
    "cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=1)\n",
    "\n",
    "for c in params:\n",
    "\n",
    "    clf = SVC(C=10.0, \n",
    "              kernel='rbf', \n",
    "              degree=1, \n",
    "              gamma=c, \n",
    "              coef0=0.0, \n",
    "              shrinking=True, \n",
    "              probability=False, \n",
    "              tol=0.001, \n",
    "              cache_size=200, \n",
    "              class_weight=None, \n",
    "              verbose=False, \n",
    "              max_iter=-1, \n",
    "              decision_function_shape=None, \n",
    "              random_state=0)\n",
    "\n",
    "    \n",
    "    all_acc = []\n",
    "    for train_index, valid_index in cv.split(X_train, y_train):\n",
    "        pred = clf.fit(X_train[train_index], y_train[train_index])\\\n",
    "               .predict(X_train[valid_index])\n",
    "        acc = np.mean(y_train[valid_index] == pred)\n",
    "        all_acc.append(acc)\n",
    "\n",
    "    all_acc = np.array(all_acc)\n",
    "    y_pred_cv10_mean = all_acc.mean()\n",
    "    y_pred_cv10_std = all_acc.std()\n",
    "    y_pred_cv10_stderr = y_pred_cv10_std / np.sqrt(10)\n",
    "\n",
    "    cv_acc.append(y_pred_cv10_mean) \n",
    "    cv_std.append(y_pred_cv10_std)\n",
    "    cv_stderr.append(y_pred_cv10_stderr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "\n",
    "rng = np.random.RandomState(seed=12345)\n",
    "seeds = np.arange(10**5)\n",
    "rng.shuffle(seeds)\n",
    "seeds = seeds[:50]\n",
    "\n",
    "\n",
    "params = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0, 10000.0]\n",
    "cv_acc_rep, cv_std_rep, cv_stderr_rep = [], [], []\n",
    "\n",
    "for c in params:\n",
    "\n",
    "    clf = SVC(C=10.0, \n",
    "              kernel='rbf', \n",
    "              degree=1, \n",
    "              gamma=c, \n",
    "              coef0=0.0, \n",
    "              shrinking=True, \n",
    "              probability=False, \n",
    "              tol=0.001, \n",
    "              cache_size=200, \n",
    "              class_weight=None, \n",
    "              verbose=False, \n",
    "              max_iter=-1, \n",
    "              decision_function_shape=None, \n",
    "              random_state=0)\n",
    "\n",
    "\n",
    "    ###########################\n",
    "    ## 50 RUNS, aggregated\n",
    "    ###########################\n",
    "\n",
    "\n",
    "    all_acc = []\n",
    "\n",
    "    for r in range(50):\n",
    "\n",
    "        cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=seeds[r])\n",
    "\n",
    "        for train_index, valid_index in cv.split(X_train, y_train):\n",
    "            pred = clf.fit(X_train[train_index], y_train[train_index])\\\n",
    "                   .predict(X_train[valid_index])\n",
    "            acc = np.mean(pred == y_train[valid_index])\n",
    "            all_acc.append(acc)\n",
    "\n",
    "    all_acc = np.array(all_acc)\n",
    "\n",
    "    cv_acc_rep.append(np.mean(all_acc))\n",
    "    cv_std_rep.append(np.std(all_acc))\n",
    "    cv_stderr_rep.append(np.std(all_acc) / np.sqrt(all_acc.shape[0]))\n",
    "\n",
    "    \n",
    "## PLOTTING\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "ax.set_xscale('log')\n",
    "ax.plot(params, cv_acc, label='1 run')\n",
    "ax.plot(params, cv_acc_rep, label='average over 50 runs')\n",
    "\n",
    "\n",
    "\n",
    "plt.ylim([0.0, 1.0])\n",
    "plt.xlim([0.0001, 100000.0])\n",
    "plt.grid()\n",
    "plt.legend(loc='lower right')\n",
    "plt.xlabel('$\\\\gamma$')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}