Model evaluation and Hyperparameter tuning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>22</th>\n",
       "      <th>23</th>\n",
       "      <th>24</th>\n",
       "      <th>25</th>\n",
       "      <th>26</th>\n",
       "      <th>27</th>\n",
       "      <th>28</th>\n",
       "      <th>29</th>\n",
       "      <th>30</th>\n",
       "      <th>31</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>842302</td>\n",
       "      <td>M</td>\n",
       "      <td>17.99</td>\n",
       "      <td>10.38</td>\n",
       "      <td>122.80</td>\n",
       "      <td>1001.0</td>\n",
       "      <td>0.11840</td>\n",
       "      <td>0.27760</td>\n",
       "      <td>0.3001</td>\n",
       "      <td>0.14710</td>\n",
       "      <td>...</td>\n",
       "      <td>25.38</td>\n",
       "      <td>17.33</td>\n",
       "      <td>184.60</td>\n",
       "      <td>2019.0</td>\n",
       "      <td>0.1622</td>\n",
       "      <td>0.6656</td>\n",
       "      <td>0.7119</td>\n",
       "      <td>0.2654</td>\n",
       "      <td>0.4601</td>\n",
       "      <td>0.11890</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>842517</td>\n",
       "      <td>M</td>\n",
       "      <td>20.57</td>\n",
       "      <td>17.77</td>\n",
       "      <td>132.90</td>\n",
       "      <td>1326.0</td>\n",
       "      <td>0.08474</td>\n",
       "      <td>0.07864</td>\n",
       "      <td>0.0869</td>\n",
       "      <td>0.07017</td>\n",
       "      <td>...</td>\n",
       "      <td>24.99</td>\n",
       "      <td>23.41</td>\n",
       "      <td>158.80</td>\n",
       "      <td>1956.0</td>\n",
       "      <td>0.1238</td>\n",
       "      <td>0.1866</td>\n",
       "      <td>0.2416</td>\n",
       "      <td>0.1860</td>\n",
       "      <td>0.2750</td>\n",
       "      <td>0.08902</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>84300903</td>\n",
       "      <td>M</td>\n",
       "      <td>19.69</td>\n",
       "      <td>21.25</td>\n",
       "      <td>130.00</td>\n",
       "      <td>1203.0</td>\n",
       "      <td>0.10960</td>\n",
       "      <td>0.15990</td>\n",
       "      <td>0.1974</td>\n",
       "      <td>0.12790</td>\n",
       "      <td>...</td>\n",
       "      <td>23.57</td>\n",
       "      <td>25.53</td>\n",
       "      <td>152.50</td>\n",
       "      <td>1709.0</td>\n",
       "      <td>0.1444</td>\n",
       "      <td>0.4245</td>\n",
       "      <td>0.4504</td>\n",
       "      <td>0.2430</td>\n",
       "      <td>0.3613</td>\n",
       "      <td>0.08758</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>84348301</td>\n",
       "      <td>M</td>\n",
       "      <td>11.42</td>\n",
       "      <td>20.38</td>\n",
       "      <td>77.58</td>\n",
       "      <td>386.1</td>\n",
       "      <td>0.14250</td>\n",
       "      <td>0.28390</td>\n",
       "      <td>0.2414</td>\n",
       "      <td>0.10520</td>\n",
       "      <td>...</td>\n",
       "      <td>14.91</td>\n",
       "      <td>26.50</td>\n",
       "      <td>98.87</td>\n",
       "      <td>567.7</td>\n",
       "      <td>0.2098</td>\n",
       "      <td>0.8663</td>\n",
       "      <td>0.6869</td>\n",
       "      <td>0.2575</td>\n",
       "      <td>0.6638</td>\n",
       "      <td>0.17300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>84358402</td>\n",
       "      <td>M</td>\n",
       "      <td>20.29</td>\n",
       "      <td>14.34</td>\n",
       "      <td>135.10</td>\n",
       "      <td>1297.0</td>\n",
       "      <td>0.10030</td>\n",
       "      <td>0.13280</td>\n",
       "      <td>0.1980</td>\n",
       "      <td>0.10430</td>\n",
       "      <td>...</td>\n",
       "      <td>22.54</td>\n",
       "      <td>16.67</td>\n",
       "      <td>152.20</td>\n",
       "      <td>1575.0</td>\n",
       "      <td>0.1374</td>\n",
       "      <td>0.2050</td>\n",
       "      <td>0.4000</td>\n",
       "      <td>0.1625</td>\n",
       "      <td>0.2364</td>\n",
       "      <td>0.07678</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 32 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         0  1      2      3       4       5        6        7       8   \\\n",
       "0    842302  M  17.99  10.38  122.80  1001.0  0.11840  0.27760  0.3001   \n",
       "1    842517  M  20.57  17.77  132.90  1326.0  0.08474  0.07864  0.0869   \n",
       "2  84300903  M  19.69  21.25  130.00  1203.0  0.10960  0.15990  0.1974   \n",
       "3  84348301  M  11.42  20.38   77.58   386.1  0.14250  0.28390  0.2414   \n",
       "4  84358402  M  20.29  14.34  135.10  1297.0  0.10030  0.13280  0.1980   \n",
       "\n",
       "        9    ...        22     23      24      25      26      27      28  \\\n",
       "0  0.14710   ...     25.38  17.33  184.60  2019.0  0.1622  0.6656  0.7119   \n",
       "1  0.07017   ...     24.99  23.41  158.80  1956.0  0.1238  0.1866  0.2416   \n",
       "2  0.12790   ...     23.57  25.53  152.50  1709.0  0.1444  0.4245  0.4504   \n",
       "3  0.10520   ...     14.91  26.50   98.87   567.7  0.2098  0.8663  0.6869   \n",
       "4  0.10430   ...     22.54  16.67  152.20  1575.0  0.1374  0.2050  0.4000   \n",
       "\n",
       "       29      30       31  \n",
       "0  0.2654  0.4601  0.11890  \n",
       "1  0.1860  0.2750  0.08902  \n",
       "2  0.2430  0.3613  0.08758  \n",
       "3  0.2575  0.6638  0.17300  \n",
       "4  0.1625  0.2364  0.07678  \n",
       "\n",
       "[5 rows x 32 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import dataset\n",
    "import pandas as pd\n",
    "df = pd.read_csv(\"G:\\Machine Learning\\python machine learning\\python machine learning code\\code\\ch06\\wdbc.data\",header = None)\n",
    "'''\n",
    "column 0,1——ID 和病症（Malignant or benign\n",
    "column 2-31 特征集 用于诊断病症\n",
    "'''\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['B', 'M'], dtype=object)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# assign 30 features into numpy array \n",
    "# transform \"M\" and \"B\" into integers using LabelEncoder\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "X = df.loc[:,2:].values # X includes all features\n",
    "y = df.loc[:,1].values  # y is the result of prediction\n",
    "#transform M and B into integers\n",
    "le = LabelEncoder()\n",
    "y = le.fit_transform(y)\n",
    "le.classes_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0], dtype=int64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "le.transform(['M','B'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split( X, y ,\n",
    "                                                    test_size = 0.20, \n",
    "                                                    stratify = y, \n",
    "                                                    random_state = 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 0.956\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "pipe_lr = make_pipeline(StandardScaler(),\n",
    "                        PCA(n_components = 2),\n",
    "                        LogisticRegression(random_state = 1))\n",
    "pipe_lr.fit(X_train,y_train)\n",
    "pipe_lr.predict(X_test)\n",
    "print('Test Accuracy: %.3f' % pipe_lr.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold:  1, Class dist.: [256 153], Acc: 0.935\n",
      "Fold:  2, Class dist.: [256 153], Acc: 0.935\n",
      "Fold:  3, Class dist.: [256 153], Acc: 0.957\n",
      "Fold:  4, Class dist.: [256 153], Acc: 0.957\n",
      "Fold:  5, Class dist.: [256 153], Acc: 0.935\n",
      "Fold:  6, Class dist.: [257 153], Acc: 0.956\n",
      "Fold:  7, Class dist.: [257 153], Acc: 0.978\n",
      "Fold:  8, Class dist.: [257 153], Acc: 0.933\n",
      "Fold:  9, Class dist.: [257 153], Acc: 0.956\n",
      "Fold: 10, Class dist.: [257 153], Acc: 0.956\n",
      "\n",
      "CV accuracy: 0.950 +/- 0.014\n"
     ]
    }
   ],
   "source": [
    "# stratified k-fold cv\n",
    "import numpy as np\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "Kfold = StratifiedKFold(n_splits = 10, \n",
    "                        random_state = 1).split(X_train, y_train)\n",
    "scores = []\n",
    "for k ,(train, test) in enumerate (Kfold):\n",
    "    pipe_lr.fit(X_train[train], y_train[train])\n",
    "    score = pipe_lr.score(X_train[test], y_train[test])\n",
    "    scores.append(score)\n",
    "    print('Fold: %2d, Class dist.: %s, Acc: %.3f' % (k+1, np.bincount(y_train[train]), score))\n",
    "    \n",
    "print('\\nCV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV accuracy scores:\n",
      "\n",
      " [0.93478261 0.93478261 0.95652174 0.95652174 0.93478261 0.95555556\n",
      " 0.97777778 0.93333333 0.95555556 0.95555556] \n",
      "\n",
      "CV accuracy: 0.950 +/- 0.014\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "scores  = cross_val_score(estimator = pipe_lr, \n",
    "                          X = X_train,\n",
    "                          y = y_train, \n",
    "                          cv = 10, \n",
    "                          n_jobs = 1)\n",
    "print('CV accuracy scores:\\n\\n %s \\n' % scores)\n",
    "print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2846c5c9e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# learning curve\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import learning_curve\n",
    "pipe_lr = make_pipeline(StandardScaler(), \n",
    "                        LogisticRegression(penalty = 'l2', \n",
    "                                           random_state = 1))\n",
    "train_sizes, train_scores, test_scores = learning_curve(estimator = pipe_lr,\n",
    "                                                     X = X_train, \n",
    "                                                     y = y_train,\n",
    "                                                     train_sizes = np.linspace(0.1, 1.0, 10), #从0.1到1 一共10个间隔相同的数\n",
    "                                                     cv = 10, \n",
    "                                                     n_jobs = 1)\n",
    "\n",
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "plt.plot(train_sizes, train_mean,\n",
    "         color='blue', marker='o',\n",
    "         markersize=5, label='training accuracy')\n",
    "\n",
    "plt.fill_between(train_sizes,\n",
    "                 train_mean + train_std,\n",
    "                 train_mean - train_std,\n",
    "                 alpha=0.15, color='blue')\n",
    "\n",
    "plt.plot(train_sizes, test_mean,\n",
    "         color='green', linestyle='--',\n",
    "         marker='s', markersize=5,\n",
    "         label='validation accuracy')\n",
    "\n",
    "\n",
    "plt.fill_between(train_sizes,\n",
    "                 test_mean + test_std,\n",
    "                 test_mean - test_std,\n",
    "                 alpha=0.15, color='green')\n",
    "\n",
    "\n",
    "plt.grid()\n",
    "plt.xlabel('Number of training samples')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.ylim([0.8, 1.03])\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x284925c518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# validation curve\n",
    "from sklearn.model_selection import validation_curve\n",
    "param_range = [0.001,0.01, 0.1, 1.0, 10.0, 100.0]\n",
    "train_scores, test_scores = validation_curve(estimator = pipe_lr, \n",
    "                                             X = X_train, \n",
    "                                             y = y_train, \n",
    "                                             param_name = 'logisticregression__C', \n",
    "                                             param_range = param_range,\n",
    "                                             cv = 10)\n",
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "plt.plot(param_range, train_mean, \n",
    "         color='blue', marker='o', \n",
    "         markersize=5, label='training accuracy')\n",
    "\n",
    "plt.fill_between(param_range, train_mean + train_std,\n",
    "                 train_mean - train_std, alpha=0.15,\n",
    "                 color='blue')\n",
    "\n",
    "plt.plot(param_range, test_mean, \n",
    "         color='green', linestyle='--', \n",
    "         marker='s', markersize=5, \n",
    "         label='validation accuracy')\n",
    "\n",
    "plt.fill_between(param_range, \n",
    "                 test_mean + test_std,\n",
    "                 test_mean - test_std, \n",
    "                 alpha=0.15, color='green')\n",
    "\n",
    "plt.grid()\n",
    "plt.xscale('log')\n",
    "plt.legend(loc='lower right')\n",
    "plt.xlabel('Parameter C')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim([0.8, 1.0])\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9846153846153847\n",
      "{'svc__C': 100.0, 'svc__gamma': 0.001, 'svc__kernel': 'rbf'}\n"
     ]
    }
   ],
   "source": [
    "# grid search\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.svm import SVC\n",
    "pipe_svc = make_pipeline(StandardScaler(),\n",
    "                         SVC(random_state = 1))\n",
    "param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]\n",
    "\n",
    "param_grid = [{'svc__C' : param_range,\n",
    "               'svc__kernel' : ['linear']},\n",
    "              {'svc__C' :  param_range,\n",
    "               'svc__kernel':  ['rbf'],\n",
    "               'svc__gamma' : param_range}]\n",
    "\n",
    "gs = GridSearchCV(estimator = pipe_svc, \n",
    "                  param_grid = param_grid, \n",
    "                  scoring = 'accuracy', \n",
    "                  cv = 10,\n",
    "                  n_jobs = 1)\n",
    "gs.fit(X_train, y_train)\n",
    "print(gs.best_score_)\n",
    "print(gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.974\n"
     ]
    }
   ],
   "source": [
    "clf = gs.best_estimator_\n",
    "clf.fit(X_train, y_train)\n",
    "print('Test accuracy: %.3f' % clf.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV accuracy: 0.974 +/- 0.015\n"
     ]
    }
   ],
   "source": [
    "# nested CV \n",
    "gs = GridSearchCV(estimator=pipe_svc,\n",
    "                  param_grid=param_grid,\n",
    "                  scoring='accuracy',\n",
    "                  cv=2)\n",
    "\n",
    "scores = cross_val_score(gs, X_train, y_train, \n",
    "                         scoring='accuracy', cv=5)\n",
    "print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores),\n",
    "                                      np.std(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV accuracy: 0.934 +/- 0.016\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "gs = GridSearchCV(estimator=DecisionTreeClassifier(random_state=0),\n",
    "                  param_grid=[{'max_depth': [1, 2, 3, 4, 5, 6, 7, None]}],\n",
    "                  scoring='accuracy',\n",
    "                  cv=2)\n",
    "\n",
    "scores = cross_val_score(gs, X_train, y_train, \n",
    "                         scoring='accuracy', cv=5)\n",
    "print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), \n",
    "                                      np.std(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[71  1]\n",
      " [ 1 41]]\n"
     ]
    }
   ],
   "source": [
    "#confusion matrix\n",
    "from sklearn .metrics import confusion_matrix\n",
    "pipe_lr.fit(X_train, y_train)\n",
    "y_pred = pipe_lr.predict(X_test)\n",
    "confmat = confusion_matrix(y_true = y_test, y_pred = y_pred)\n",
    "print(confmat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x283d8b5d68>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot confusion matrix\n",
    "fig, ax = plt.subplots(figsize = (2.5, 2.5))\n",
    "ax.matshow(confmat, cmap = plt.cm.Blues, alpha = 0.3)\n",
    "for i in range(confmat.shape[0]):\n",
    "    for j in range(confmat.shape[1]):\n",
    "        ax.text(x = j, y = i,          #ax.text()在轴上添加文本\n",
    "                s = confmat[i, j], \n",
    "                va = 'center', \n",
    "                ha = 'center')\n",
    "plt.xlabel('Predicted label')\n",
    "plt.ylabel('True label')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.976\n",
      "Recall: 0.976\n",
      "F1: 0.976\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score, f1_score\n",
    "print('Precision: %.3f' % precision_score(y_true=y_test, y_pred=y_pred))\n",
    "print('Recall: %.3f' % recall_score(y_true=y_test, y_pred=y_pred))\n",
    "print('F1: %.3f' % f1_score(y_true=y_test, y_pred=y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9862021456964396\n",
      "{'svc__C': 10.0, 'svc__gamma': 0.01, 'svc__kernel': 'rbf'}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import make_scorer\n",
    "\n",
    "scorer = make_scorer(f1_score, pos_label=0)\n",
    "\n",
    "c_gamma_range = [0.01, 0.1, 1.0, 10.0]\n",
    "\n",
    "param_grid = [{'svc__C': c_gamma_range,\n",
    "               'svc__kernel': ['linear']},\n",
    "              {'svc__C': c_gamma_range,\n",
    "               'svc__gamma': c_gamma_range,\n",
    "               'svc__kernel': ['rbf']}]\n",
    "\n",
    "gs = GridSearchCV(estimator=pipe_svc,\n",
    "                  param_grid=param_grid,\n",
    "                  scoring=scorer,\n",
    "                  cv=10,\n",
    "                  n_jobs=-1)\n",
    "gs = gs.fit(X_train, y_train)\n",
    "print(gs.best_score_)\n",
    "print(gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x283d87c780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ROC curve\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from scipy import interp\n",
    "\n",
    "# LR pipeline \n",
    "pipe_lr = make_pipeline(StandardScaler(),\n",
    "                        PCA(n_components=2),\n",
    "                        LogisticRegression(penalty='l2', \n",
    "                                           random_state=1, \n",
    "                                           C=100.0))\n",
    "\n",
    "X_train2 = X_train[:, [4, 14]]\n",
    "    \n",
    "\n",
    "cv = list(StratifiedKFold(n_splits=3, \n",
    "                          random_state=1).split(X_train, y_train))\n",
    "\n",
    "fig = plt.figure(figsize=(7, 5))\n",
    "\n",
    "mean_tpr = 0.0\n",
    "mean_fpr = np.linspace(0, 1, 100)\n",
    "all_tpr = []\n",
    "\n",
    "for i, (train, test) in enumerate(cv):\n",
    "    probas = pipe_lr.fit(X_train2[train],\n",
    "                         y_train[train]).predict_proba(X_train2[test])\n",
    "\n",
    "    fpr, tpr, thresholds = roc_curve(y_train[test],\n",
    "                                     probas[:, 1],\n",
    "                                     pos_label=1)\n",
    "    mean_tpr += interp(mean_fpr, fpr, tpr)\n",
    "    mean_tpr[0] = 0.0\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    plt.plot(fpr,\n",
    "             tpr,\n",
    "             label='ROC fold %d (area = %0.2f)'\n",
    "                   % (i+1, roc_auc))\n",
    "\n",
    "plt.plot([0, 1],\n",
    "         [0, 1],\n",
    "         linestyle='--',\n",
    "         color=(0.6, 0.6, 0.6),\n",
    "         label='random guessing')\n",
    "\n",
    "mean_tpr /= len(cv)\n",
    "mean_tpr[-1] = 1.0\n",
    "mean_auc = auc(mean_fpr, mean_tpr)\n",
    "plt.plot(mean_fpr, mean_tpr, 'k--',\n",
    "         label='mean ROC (area = %0.2f)' % mean_auc, lw=2)\n",
    "plt.plot([0, 0, 1],\n",
    "         [0, 1, 1],\n",
    "         linestyle=':',\n",
    "         color='black',\n",
    "         label='perfect performance')\n",
    "\n",
    "plt.xlim([-0.05, 1.05])\n",
    "plt.ylim([-0.05, 1.05])\n",
    "plt.xlabel('false positive rate')\n",
    "plt.ylabel('true positive rate')\n",
    "plt.legend(loc=\"lower right\")\n",
    "\n",
    "plt.tight_layout()\n",
    "# plt.savefig('images/06_10.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}