homework3_svc_gridsearch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing neccesary lib\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing datasets\n",
    "df = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'winequality-white.csv'\n",
    "df_white = pd.read_csv(filename , delimiter=';')\n",
    "df_white['type'] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_red = pd.DataFrame()\n",
    "filename = 'winequality-red.csv'\n",
    "df_red = pd.read_csv(filename , delimiter=';')\n",
    "df_red['type'] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#merging the two wine datasets\n",
    "df = pd.concat([df_white , df_red])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#shuffling the rows so that the datasets row will have mix of red and white wine rows\n",
    "df = df.sample(frac = 1,random_state= 10).reset_index(drop = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For your binary classification problem, use gridsearch and cross-validation with SVC. What is the best kernel? Print the heat map of mean cross-validation score (hint: use the mglearn library), the ROC curve and report the AUC value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Here the red wine = 1 and white wine = 0. Using binary classification, we are going to predict the wine type(whether 0 or 1)\n",
    "x = np.array(df.drop(['type'],1))\n",
    "y = np.array(df['type'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import model_selection\n",
    "from sklearn import preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data pre processing scaling input features x\n",
    "scaler = preprocessing.StandardScaler().fit(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = scaler.transform(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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, test_size=0.33, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = [{'kernel': ['rbf'],\n",
    "'C': [0.0001, 0.001, 0.01, 0.1, 1, 10],\n",
    "'gamma': [0.0001, 0.001, 0.01, 0.1, 1, 10]},\n",
    "{'kernel': ['linear'],\n",
    "'C': [0.0001, 0.001, 0.01, 0.1, 1, 10]}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_svc = GridSearchCV(SVC(), param_grid, cv=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5, error_score='raise',\n",
       "       estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False),\n",
       "       fit_params=None, iid=True, n_jobs=1,\n",
       "       param_grid=[{'kernel': ['rbf'], 'C': [0.0001, 0.001, 0.01, 0.1, 1, 10], 'gamma': [0.0001, 0.001, 0.01, 0.1, 1, 10]}, {'kernel': ['linear'], 'C': [0.0001, 0.001, 0.01, 0.1, 1, 10]}],\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring=None, verbose=0)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid_svc.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set score: 0.99\n",
      "Best parameters: {'C': 1, 'gamma': 0.1, 'kernel': 'rbf'}\n",
      "Best cross-validation score: 1.00\n",
      "Best estimator:\n",
      "SVC(C=1, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma=0.1, kernel='rbf',\n",
      "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False)\n"
     ]
    }
   ],
   "source": [
    "print(\"Test set score: {:.2f}\".format(grid_svc.score(X_test, y_test)))\n",
    "print(\"Best parameters: {}\".format(grid_svc.best_params_))\n",
    "print(\"Best cross-validation score: {:.2f}\".format(grid_svc.best_score_))\n",
    "print(\"Best estimator:\\n{}\".format(grid_svc.best_estimator_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The best kernal is rbf. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PolyCollection at 0x1d1f5f7fb38>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#printing heatmap of mean cross-validation score\n",
    "import mglearn\n",
    "\n",
    "results = pd.DataFrame(grid_svc.cv_results_)\n",
    "for kernal in results.param_kernel.unique():                                          #using data filters for the kernal\n",
    "    kernal_filter = results.param_kernel == 'rbf'                                   #Choosing rbf kernal to display heatmap\n",
    "    results_filtered = results[kernal_filter]                               #because rbf kernal has been selected best estimator\n",
    "scores = np.array(results_filtered['mean_test_score']).reshape(6,6)\n",
    "#scores.shape\n",
    "C = [0.0001, 0.001, 0.01, 0.1, 1, 10]\n",
    "gamma =  [0.0001, 0.001, 0.01, 0.1, 1, 10]\n",
    "mglearn.tools.heatmap(scores, xlabel='gamma', xticklabels=gamma,ylabel='C', yticklabels=C, cmap=\"viridis\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1d1f5f0f828>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Printing ROC curve for SVC classifier\n",
    "from sklearn.metrics import roc_curve\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "svc = SVC(C = 0.01, cache_size=200, class_weight=None, coef0=0.0,\n",
    "  decision_function_shape='ovr', degree=3, gamma=0.1, kernel='rbf',\n",
    "  max_iter=-1, probability=True, random_state=None, shrinking=True,\n",
    "  tol=0.001, verbose=False)\n",
    "\n",
    "svc.fit(X_train,y_train)\n",
    "pred = svc.decision_function(X_test)\n",
    "fpr, tpr, threshold = roc_curve(y_test, pred)\n",
    "\n",
    "plt.plot(fpr, tpr, label=\"ROC Curve\")\n",
    "plt.xlabel(\"FPR\")\n",
    "plt.ylabel(\"TPR (recall)\")\n",
    "\n",
    "close_zero = np.argmin(np.abs(threshold))\n",
    "plt.plot(fpr[close_zero], tpr[close_zero], 'o', markersize=10,\n",
    "label=\"threshold zero\", fillstyle=\"none\", c='k', mew=2)\n",
    "plt.legend(loc=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The AUC value is 0.995\n"
     ]
    }
   ],
   "source": [
    "#Calculating the area under the curve.\n",
    "from sklearn.metrics import auc\n",
    "svc_auc = auc(fpr,tpr)\n",
    "print('The AUC value is %.3f' %svc_auc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC_ROC for SVC: 0.995\n"
     ]
    }
   ],
   "source": [
    "#Calculating the area under the ROC curve\n",
    "from sklearn.metrics import roc_auc_score\n",
    "svc_auc = roc_auc_score(y_test, svc.decision_function(X_test))\n",
    "print(\"AUC_ROC for SVC: {:.3f}\".format(svc_auc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For your binary classification model, repeat the gridsearch with cross validation step using AUC as the evaluation metric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "inner_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "grid = GridSearchCV(SVC(), param_grid=param_grid, scoring='roc_auc', cv=inner_cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=StratifiedKFold(n_splits=5, random_state=42, shuffle=True),\n",
       "       error_score='raise',\n",
       "       estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False),\n",
       "       fit_params=None, iid=True, n_jobs=1,\n",
       "       param_grid=[{'kernel': ['rbf'], 'C': [0.0001, 0.001, 0.01, 0.1, 1, 10], 'gamma': [0.0001, 0.001, 0.01, 0.1, 1, 10]}, {'kernel': ['linear'], 'C': [0.0001, 0.001, 0.01, 0.1, 1, 10]}],\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring='roc_auc', verbose=0)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Grid-Search with AUC\n",
      "Best parameters: {'C': 10, 'gamma': 0.1, 'kernel': 'rbf'}\n",
      "Best cross-validation score (AUC): 0.999\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nGrid-Search with AUC\")\n",
    "print(\"Best parameters:\", grid.best_params_)\n",
    "print(\"Best cross-validation score (AUC): {:.3f}\".format(grid.best_score_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set AUC: 0.998\n",
      "Test set accuracy: 0.998\n"
     ]
    }
   ],
   "source": [
    "print(\"Test set AUC: {:.3f}\".format(\n",
    "roc_auc_score(y_test, grid.decision_function(X_test))))\n",
    "print(\"Test set accuracy: {:.3f}\".format(grid.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The results have improved. Now the best parameters are C = 10 and gamma is 0.1. The best kernal is still Rbf"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}