{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "83708667-4fdc-1563-7b3a-06b6575d2865"
   },
   "source": [
    "\n",
    "\n",
    "# Classification-Master Template\n",
    "\n",
    "How do you work through a predictive modeling- Classification or Regression based Machine learning problem end-to-end? \n",
    "In this jupyter note you will work through a case study classication predictive modeling problem in Python\n",
    "including each step of the applied machine learning process. \n",
    "However, this notebook is applicable for Regression based case study as well. The Models, Grid Search and Evaluation Metrics will need to change for the regression based case study.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [1. Introduction](#0)\n",
    "* [2. Getting Started - Load Libraries and Dataset](#1)\n",
    "    * [2.1. Load Libraries](#1.1)    \n",
    "    * [2.2. Load Dataset](#1.2)\n",
    "* [3. Exploratory Data Analysis](#2)\n",
    "    * [3.1 Descriptive Statistics](#2.1)    \n",
    "    * [3.2. Data Visualisation](#2.2)\n",
    "* [4. Data Preparation](#3)\n",
    "    * [4.1 Data Cleaning](#3.1)\n",
    "    * [4.2.Handling Categorical Data](#3.2)\n",
    "    * [4.3.Feature Selection](#3.3)\n",
    "    * [4.3.Data Transformation](#3.4) \n",
    "        * [4.3.1 Rescaling ](#3.4.1)\n",
    "        * [4.3.2 Standardization](#3.4.2)\n",
    "        * [4.3.3 Normalization](#3.4.3)    \n",
    "* [5.Evaluate Algorithms and Models](#4)        \n",
    "    * [5.1. Train/Test Split](#4.1)\n",
    "    * [5.2. Test Options and Evaluation Metrics](#4.2)\n",
    "    * [5.3. Compare Models and Algorithms](#4.3)\n",
    "        * [5.3.1 Common Classification Models](#4.3.1)\n",
    "        * [5.3.2 Ensemble Models](#4.3.2)\n",
    "        * [5.3.3 Deep Learning Models](#4.3.3)    \n",
    "* [6. Model Tuning and Grid Search](#5)  \n",
    "* [7. Finalize the Model](#6)  \n",
    "    * [7.1. Results on test dataset](#6.1)\n",
    "    * [7.1. Variable Intuition/Feature Selection](#6.2) \n",
    "    * [7.3. Save model for later use](#6.3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='0'></a>\n",
    "# 1. Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our goal in this jupyter notebook is to under the following\n",
    "- How to work through a predictive modeling problem end-to-end. This notebook is applicable both for regression and classification problems.\n",
    "- How to use data transforms to improve model performance.\n",
    "- How to use algorithm tuning to improve model performance.\n",
    "- How to use ensemble methods and tuning of ensemble methods to improve model performance.\n",
    "- How to use deep Learning methods.\n",
    "\n",
    "The data is a subset of the German Default data (https://archive.ics.uci.edu/ml/datasets/statlog+(german+credit+data) with the following attributes. Age, Sex, Job, Housing, SavingAccounts, CheckingAccount, CreditAmount, Duration, Purpose\n",
    "- Following models are implemented and checked:  \n",
    "\n",
    "    * Logistic Regression\n",
    "    * Linear Discriminant Analysis\n",
    "    * K Nearest Neighbors \n",
    "    * Decision Tree (CART)\n",
    "    * Support Vector Machine \n",
    "    * Ada Boost\n",
    "    * Gradient Boosting Method\n",
    "    * Random Forest\n",
    "    * Extra Trees\n",
    "    * Neural Network - Shallow \n",
    "    * Deep Neural Network "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='1'></a>\n",
    "# 2. Getting Started- Loading the data and python packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='1.1'></a>\n",
    "## 2.1. Loading the python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "_cell_guid": "5d8fee34-f454-2642-8b06-ed719f0317e1"
   },
   "outputs": [],
   "source": [
    "# Load libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot\n",
    "from pandas import read_csv, set_option\n",
    "from pandas.plotting import scatter_matrix\n",
    "import seaborn as sns\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split, KFold, cross_val_score, GridSearchCV\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, RandomForestClassifier, ExtraTreesClassifier\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "\n",
    "#Libraries for Deep Learning Models\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from keras.optimizers import SGD\n",
    "\n",
    "#Libraries for Saving the Model\n",
    "from pickle import dump\n",
    "from pickle import load"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='1.2'></a>\n",
    "## 2.2. Loading the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "_cell_guid": "787e35f7-bf9e-0969-8d13-a54fa87f3519"
   },
   "outputs": [],
   "source": [
    "# load dataset\n",
    "dataset = read_csv('german_credit_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Diable the warnings\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "df6a4523-b385-69ee-c933-592826d81431"
   },
   "source": [
    "<a id='2'></a>\n",
    "# 3. Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='2.1'></a>\n",
    "## 3.1. Descriptive Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "_cell_guid": "52f85dc2-0f91-3c50-400e-ddc38bea966b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 10)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shape\n",
    "dataset.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>Job</th>\n",
       "      <th>Housing</th>\n",
       "      <th>SavingAccounts</th>\n",
       "      <th>CheckingAccount</th>\n",
       "      <th>CreditAmount</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Purpose</th>\n",
       "      <th>Risk</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>67</td>\n",
       "      <td>male</td>\n",
       "      <td>2</td>\n",
       "      <td>own</td>\n",
       "      <td>NaN</td>\n",
       "      <td>little</td>\n",
       "      <td>1169</td>\n",
       "      <td>6</td>\n",
       "      <td>radio/TV</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>22</td>\n",
       "      <td>female</td>\n",
       "      <td>2</td>\n",
       "      <td>own</td>\n",
       "      <td>little</td>\n",
       "      <td>moderate</td>\n",
       "      <td>5951</td>\n",
       "      <td>48</td>\n",
       "      <td>radio/TV</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Age     Sex  Job Housing SavingAccounts CheckingAccount  CreditAmount  Duration   Purpose  Risk\n",
       "0   67    male    2     own            NaN          little          1169         6  radio/TV  good\n",
       "1   22  female    2     own         little        moderate          5951        48  radio/TV   bad"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# peek at data\n",
    "set_option('display.width', 100)\n",
    "dataset.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "_cell_guid": "f36dd804-0c16-f0c9-05c9-d22b85a79e75"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Age                 int64\n",
       "Sex                object\n",
       "Job                 int64\n",
       "Housing            object\n",
       "SavingAccounts     object\n",
       "CheckingAccount    object\n",
       "CreditAmount        int64\n",
       "Duration            int64\n",
       "Purpose            object\n",
       "Risk               object\n",
       "dtype: object"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# types\n",
    "set_option('display.max_rows', 500)\n",
    "dataset.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "_cell_guid": "7bffeec0-5bbc-fffb-18f2-3da56b862ca3"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Age</th>\n",
       "      <th>Job</th>\n",
       "      <th>CreditAmount</th>\n",
       "      <th>Duration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1000.000</td>\n",
       "      <td>1000.000</td>\n",
       "      <td>1000.000</td>\n",
       "      <td>1000.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>35.546</td>\n",
       "      <td>1.904</td>\n",
       "      <td>3271.258</td>\n",
       "      <td>20.903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>11.375</td>\n",
       "      <td>0.654</td>\n",
       "      <td>2822.737</td>\n",
       "      <td>12.059</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>19.000</td>\n",
       "      <td>0.000</td>\n",
       "      <td>250.000</td>\n",
       "      <td>4.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>27.000</td>\n",
       "      <td>2.000</td>\n",
       "      <td>1365.500</td>\n",
       "      <td>12.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>33.000</td>\n",
       "      <td>2.000</td>\n",
       "      <td>2319.500</td>\n",
       "      <td>18.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>42.000</td>\n",
       "      <td>2.000</td>\n",
       "      <td>3972.250</td>\n",
       "      <td>24.000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>75.000</td>\n",
       "      <td>3.000</td>\n",
       "      <td>18424.000</td>\n",
       "      <td>72.000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Age       Job  CreditAmount  Duration\n",
       "count  1000.000  1000.000      1000.000  1000.000\n",
       "mean     35.546     1.904      3271.258    20.903\n",
       "std      11.375     0.654      2822.737    12.059\n",
       "min      19.000     0.000       250.000     4.000\n",
       "25%      27.000     2.000      1365.500    12.000\n",
       "50%      33.000     2.000      2319.500    18.000\n",
       "75%      42.000     2.000      3972.250    24.000\n",
       "max      75.000     3.000     18424.000    72.000"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# describe data\n",
    "set_option('precision', 3)\n",
    "dataset.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "_cell_guid": "565b36d1-0abc-e91c-47f5-c3153d54e265"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Housing\n",
       "free    108\n",
       "own     713\n",
       "rent    179\n",
       "dtype: int64"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# class distribution\n",
    "dataset.groupby('Housing').size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='2.2'></a>\n",
    "## 3.2. Data Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "_cell_guid": "16d50177-f93e-9d26-af7a-313d7ebe9fcf"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArgAAAKyCAYAAAA+W61JAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X2QZeldH/bvTwwRqxUWNqtcIgc0JsYgSMeAWpHkQtp27CTYiw1OKAGeAg2203EFOym743hsYSI7MSxJLbYr4KS6HMyLEMZgmxdPiHGldCVkJGItCWw5NrKRRggBA3pFvQiSxk/+6B7R25p+v7fv6d98PlVdM336nOd++8ytc79z7nPuqTFGAACgi2etOgAAACySggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgBwoqq6U1W/f//vf7Gq/taqM8FRFFyWrqrmVfWBqnr2qrMAdFZVf7Sq3lZVO1X1C1X1w1X1BYt+nDHG148x/sT+Y16vqlFV1+6TZ2P/Z//NojMsysHiTh8KLktVVdeTvCLJSPKHVxoGoLGq+rNJ/nqSr08yS/JpSf5mki++z7ofU0aX5NVJ3r//J1waBZdl+6okb03ybTlwgKuqT66qH6qqX6mqf1pV/31VvfnAzz+rqv5xVb2/qn66ql51+dEBroaqel6Sv5Lka8YYf3+M8fQY4/8bY/zQGOPPVdVrq+r7qup1VfUrSW5W1bOq6lZV/UxVva+q/m5V/bYDY35lVb1r/2evOfR4r62q1+1/+6b9Pz+4f+b45fvrPCfJlyb5miSfUVXrB7a/d9b3q6vq3fvv8v3JqnpJVf1UVX2wqr75wPrPqqqv3c/zS1X1Hfu/872zxD93KN/B6RSv3f/dvqOqPlxV/+xelqr6zuz9R+CH9rNP9kwzZ6PgsmxfleS79r/+46qa7S//liRPJ/mU7BXfg+X34ST/OMnrk/ybSb4iyd+sqs+5xNwAV8nLk3xCkn9wzDpfnOT7knxS9o7J/2WSL0nyaJIXJPlA9o7NqarPTvI/J/nK/Z99cpJ/+4hxX7n/5yeNMZ47xnjL/vf/aZKdJN+b5B9l7/XgsJcm+YwkX5a9s8+vSfL7k3xOkldV1aP7693c//q9ST49yXOTfHNO7w8n+Tv7v/sP3tt2jPGVSX42yR/az/4/nGFMJkzBZWn25329MMnfHWM8meRnkvzRqvq47B34/tsxxq+OMf6fJN9+YNMvSnJnjPG3xxi7Y4yfSPL3sncmAICP9clJ3jvG2D1mnbeMMb5/jPGvxxgfSfKfJ3nNGOPnxhi/nuS1Sb50f/rClyb5h2OMN+3/7C8l+ddnzPTqJN8zxviN7J2w+Iqq+vhD6/x3Y4xfG2P8SPZOenz3GOOXxhjvSfKjST5vf70bSb5pjPGOMcZOkr+Q5MvPMNXizWOM/20/y3cm+d1n/F24YhRclunVSX5kjPHe/e9fv7/s+UmuJXn3gXUP/v2FSV66/xbVB6vqg9k7uH3KJWQGuIrel+SREwrfuw99/8Ik/+DAcfafJ/mN7M3ffcHB9ccYT+8/xqlU1adm72zrd+0v+oHsnWF+7NCqdw/8/SP3+f65+39/QZJ3HfjZu7L3OjLL6fzigb//apJPuMR5yKyAf1yWoqoeSvKqJB9XVfcOLM/O3ttDsyS72Xu76+37P/vUA5u/O8kbxxj/4SXFBbjq3pLk17I35eD7jlhnHPr+3Un+2Bjjnxxesap+IcmLDnz/nOydJT7NuMne1IZnZW9u671ln5C9aQrff8Q4x/n57BXyez4te68jd7NXfp9zIOvHZe9EymndLz9XnDO4LMuXZO9MwGcn+dz9rxdl7y2nr0ry95O8tqqeU1WflWfOzfqHSX7X/gUOH7//9ZKqelEA+BhjjA8l+bok31JVX7J/bP34qvoDVXXUvNL/JclfraoXJklVPb+q7n3iwvcl+aKq+oKq+jeydwHbUZ3hl7M3feHTDyz7qiR/Ob95/P/c7E1Ne6yqjirKx/nuJH+mqn5HVT03e58U8T37UzLenr0zso/tT4H42uydUDmtu4ey04CCy7K8OsnfHmP87BjjF+99ZW9i/40kfyrJ87L3ttF3Zu/g9etJMsb4cJL/KMmXZ+9/7b+Y5BtztgMWwANljPFNSf5s9greL2fvDO2fytFnTP9G9i64+pGq+nD2PvHmpftj/bPsffrB65P8QvYuQPu5+w0yxvjVJH81yT/Zn+7wsiTXk3zLweP/GOMHk/yr7F04fFbfmr3XijcleWf2zlb/6f3H/1CS/yLJ30rynuzN5b1v1iN8Q5Kv3c/+X58jGxNUYzgzz+pV1Tcm+ZQxhs9KBAAuxBlcVmL/c27/vdrz7yf54zn+420AAE7FRWasyidmb1rCC5L8UpInsneVLQDAhZiiAABAK6YoAADQyoWnKDzyyCPj+vXrFw7y9NNP5+GHH77wOKtwlbMnVzu/7KsxxexPPvnke8cYZ/nsS87gNMf6KT4vppZJnpNNLdPU8iTTy3SZeU59rB9jXOjrxS9+8ViEN7zhDQsZZxWucvYxrnZ+2VdjitmTvG1c8Hjm62LH+ik+L6aWSZ6TTS3T1PKMMb1Ml5nntMd6UxQAAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaubbqAMt2/dbtpT/G1tpuNpb+KABXy2Ucf5PkzuOPXcrjAFeHM7gAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAK9fOs1FVbSbZTJLZbJb5fH7hIDs7OwsZ57Cttd2Fj3nY7KEsJftlWda+vwyyr8ZVzg5Af8cW3Kp6NMlPjTE+cHD5GGM7yXaSrK+vj42NjQsHmc/nWcQ4h928dXvhYx62tbabVy0h+2VZ1r6/DLKvxlXODkB/xxbcMcYbLysIAAAsgjm4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArVxbdQAApqmqNpNsJslsNst8Pj92/Z2dnWess7W2u8R0v+m4XIczrZo8J5tapqnlSaaXaWp5EgUX4IFXVb8nyc+MMe4eXD7G2E6ynSTr6+tjY2Pj2HHm83kOrnPz1u1FR72vOzc2jvzZ4UyrJs/JppZpanmS6WWaWp5EwQV44I0xfmzVGQAWyRxcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGjl2nE/rKqXJ3nHGOPuoeWbSTaTZDabZT6fXzjIzs7OQsY5bGttd+FjHjZ7KEvJflmWte8vg+yrcZWzA9DfsQV3jPGWI5ZvJ9lOkvX19bGxsXHhIPP5PIsY57Cbt24vfMzDttZ286olZL8sy9r3l0H21bjK2QHozxQFAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGjl2qoDdHH91u1Le6w7jz92aY8F9FdVr0jy9jHG3UPLN5NsJslsNst8Pj92nJ2dnWess7W2u+io93VcrsOZVk2ek00t09TyJNPLNLU8iYIL8MAbY/zoEcu3k2wnyfr6+tjY2Dh2nPl8noPr3Lyk//jfubFx5M8OZ1o1eU42tUxTy5NML9PU8iSmKAAA0IyCCwBAK6YoAHClHXcNxNba7kKnSrgGAq4GZ3ABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGjl2qoDcHbXb91e6Hhba7u5eZ8x7zz+2EIfBwDgMjiDCwBAKwouAACtKLgAALSi4AIA0Mq5LjKrqs0km0kym80yn88vHGRnZ2ch4xy2tba78DEPmz10OY+zLEflX8a/x6It63lzGWQHgOU4tuBW1SuTPDXG+MDB5WOM7STbSbK+vj42NjbO9KD3+xSArbXfyBNvfvpM45zO8j8oYmttN088dXU/kOKo/HdubFx+mDOaz+c56/NvKmQHgOU4tpWNMd50WUEAAGARzMEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWrm26gAArFZVvTzJO8YYdw8t30yymSSz2Szz+fzYcXZ2dp6xztba7qKjntnsocXmOGkfnOTwPlq1qeVJppdpanmS6WWaWp5EwQV44I0x3nLE8u0k20myvr4+NjY2jh1nPp/n4Do3b91eWMbz2lrbzRNPLe6l7s6NjQttf3gfrdrU8iTTyzS1PMn0Mk0tT2KKAgAAzSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCvXjvthVb0syTvHGHcPLd9Mspkks9ks8/n8TA+6tbb7MctmD91/+VVwlbMnR+c/67/rKuzs7FyJnPcjOwAsx7EFd4zx1iOWbyfZTpL19fWxsbFxpge9eev2xyzbWtvNE08dG2eyrnL25Oj8d25sXH6YM5rP5znr828qZAeA5TBFAQCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVq7u7bdYuuv3uePcstx5/LFLeywAoDdncAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaOXaqgNAkly/dftc222t7ebmGba98/hj53ocAODqcAYXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCglWurDgDANFXVZpLNJJnNZpnP58euv7Oz84x1ttZ2l5judGYPLTbHSfvgJIf30apNLU8yvUxTy5NML9PU8iQKLsADr6peluSdY4y7B5ePMbaTbCfJ+vr62NjYOHac+Xyeg+vcvHV70VHPbGttN088tbiXujs3Ni60/eF9tGpTy5NML9PU8iTTyzS1PImCC/DAG2O8ddUZrorrFyztW2u7pyr+dx5/7EKPAw86c3ABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVk78HNyqemmSOwc/APysd7c57H53lVn03WYu01XOnlzt/GfNPqU7rUzxzi+ndZWzA9DfiQV3jPHj91l2prvbHHa/D7le9N1mLtNVzp5c7fxnzX7RuxAt0hTv/HJaVzk7AP2ZogAAQCtX87QdADR20VsCn9bW2m42LuWR4HI5gwsAQCsKLgAArSi4AAC0ouACANCKi8x4oFzWhRtJcufxxy7tsQCA3+QMLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANCKggsAQCsKLgAArSi4AAC0ouACANDKtVUHgK6u37p97M+31nZz84R1TuPO449deAwA6MQZXAAAWlFwAQBoRcEFAKAVc3AB4AF20vUCi+J6AS6TggtX3GW9OCVeoAC4GkxRAACgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBW3KoXAFi6095WfGttNzcveAtytxXHGVwAAFpRcAEAaMUUBQCgldNOhziN46ZMmAoxXQoucGr3XjQWMUfuOF40ALgIUxQAAGjFGVwAgHNY5FSIk3hn62ycwQUAoBVncAEAJu7g2eJlXgfR5UyxM7gAALTiDC4AAEnON6/4PGeUl32muMYYJ69U9bIxxlsPfL+ZZHP/289M8tMLyPJIkvcuYJxVuMrZk6udX/bVmGL2F44xnr/qEFfV4eP8/rKzHuun+LyYWiZ5Tja1TFPLk0wv02XmOdWx/lQF9zJU1dvGGOurznEeVzl7crXzy74aVzk7yzPF58XUMslzsqllmlqeZHqZppYnMQcXAIBmFFwAAFqZUsHdXnWAC7jK2ZOrnV/21bjK2VmeKT4vppZJnpNNLdPU8iTTyzS1PNOZgwsAAIswpTO4AABwYQouAACtTKLgVtXnVdVs1TnOq6peclXzV9XnX+HsL72q2ZOrnb+qPuOqZmd5quplq85wT1U9WlUvXnWOg/YzvXTVOe6Z2j6qqlfuHxefveos9+zvo8+fSqb9ffTiqeRJPrqPXjmlTIk5uAAANDOJM7gAALAoCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioLLlVBVP1xVr151DgAupqpGVf3OVeegNwWXE1XVnar6SFV9uKo+WFU/VlV/sqqW8vypqtdW1esOLhtj/IExxrcv4/EAuLiqmlfVn1h1DkgUXE7vD40xPjHJC5M8nuTPJ/lfzzpIVV1bdDAAgIMUXM5kjPGhMcYPJvmyJK+uqn/38P/aq+pmVb35wPejqr6mqv5lkn+5v+xvVNW7q+pXqurJqnrF/vIvTPIXk3xZVe1U1U/uL//oY1TVs6rqa6vqXVX1S1X1HVX1vP2fXd9/vFdX1c9W1Xur6jWXtHsASFJV/1lV/auqen9V/WBVveDQKn+wqt6xf4z+H5f1jiAPLk8ozmWM8X8m+bkkrzjlJl+S5KVJPnv/+3+a5HOT/LYkr0/yvVX1CWOM/z3J1yf5njHGc8cYv/s+Y93c//q9ST49yXOTfPOhdb4gyWcm+X1Jvq6qXnTKnABcQFX9B0m+IcmrkvxbSd6V5O8cWu2PJFlP8vlJvjjJH7vMjPSn4HIRP5+9gnoa3zDGeP8Y4yNJMsZ43RjjfWOM3THGE0menb1Ceho3knzTGOMdY4ydJH8hyZcfmv7wl8cYHxlj/GSSn0xyv6IMwOLdSPKtY4yfGGP8evaO0S+vqusH1vnG/deEn03y15N8xeXHpDMFl4v47Unef8p1333wm6raqqp/XlUfqqoPJnlekkdOOdYLsndG4J53JbmWZHZg2S8e+PuvZu8sLwDL94xj9P6JiPdl7zXjnoOvCe/a3wYWRsHlXKrqJdk7WL05ydNJnnPgx59yn03GgW1fkb2L1F6V5LeOMT4pyYeS1OF1j/Dz2bvY7Z5PS7Kb5O4ZfgUAluMZx+iqejjJJyd5z4F1PvXA3z9tfxtYGAWXM6mq31JVX5S9+VSvG2M8leT/TvKfVNVz9j/b8I+fMMwnZq+Q/nKSa1X1dUl+y4Gf301y/ZiLDr47yZ+pqt9RVc/Nb87Z3T3/bwbAgrw+yVdX1edW1bOzd4z+8THGnQPr/Lmq+q1V9alJ/qsk37OCnDSm4HJaP1RVH87e20qvSfJNSb56/2d/Lcn/m71i+u1JvuuEsf5Rkh9O8vbsvTX1a3nm21Xfu//n+6rqJ+6z/bcm+c4kb0ryzv3t//QZfx8AFm+MMf6PJH8pyd9L8gtJ/p0kX35ovR9I8mT2TpDczjk+dhKOU2Oc9G4wAMDx9k9I/JUxxvevOgs4gwsAXEhVfU6SFyX5v1adBRIFFwC4gKr6xiQ/kuTPjzHeddL6cBlMUQAAoBVncAEAaOXayasc75FHHhnXr19fQJTFefrpp/Pwww+vOsZ9yXZ2U82VyHZey8j25JNPvneM8fyFDspHnedYP+Xn4P3Iu1zyLteDkvfUx/oxxoW+XvziF4+pecMb3rDqCEeS7eymmmsM2c5rGdmSvG1c8Hjma7HH+ik/B+9H3uWSd7kelLynPdabogAAQCvHTlGoqkeT/NQY4wOHlm8m2UyS2WyW+Xy+tIDnsbOzM7lM98h2dlPNlch2XlPOBsDVd2zBHWO88Yjl20m2k2R9fX1sbGwsPtkFzOfzTC3TPbKd3VRzJbKd15SzAXD1maIAAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArx97JjNO7fuv2qdbbWtvNzVOue5Q7jz92oe0BoLPTviYf5zSv116Pp8sZXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFaurToAAKtVVY8m+RdjjLuHlm8m2UyS2WyW+Xx+pnF3dnbOvM0qybtcl5l3a233wmPMHjp5nCntf8+HZ1JwAR5wY4w3HrF8O8l2kqyvr4+NjY0zjTufz3PWbVZJ3uW6zLw3b92+8Bhba7t54qnja9KdGxsXfpxF8Xx4JlMUAABoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKCVa+fZqKo2k2wmyWw2y3w+X2SmC9vZ2bn0TFtru6dab/bQ6dc9yrJ+t1Xst9OYaq5EtvOacjYArr5jC25VvSLJ28cYdw8uH2NsJ9lOkvX19bGxsbG0gOcxn89z2Zlu3rp9qvW21nbzxFPn+n/FR925sXGh7Y+yiv12GlPNlch2XlPOBsDVd2zTGmP86GUFAQCARTAHFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGhFwQUAoBUFFwCAVhRcAABaUXABAGjl2qoDADBNVbWZZDNJZrNZ5vP5mbbf2dk58zarJO9yXWberbXdC48xe+jkcaa0/z0fnknBBXjAVdWjSf7FGOPuweVjjO0k20myvr4+NjY2zjTufD7PWbdZJXmX6zLz3rx1+8JjbK3t5omnjq9Jd25sXPhxFsXz4ZkUXIAH3BjjjavOALBI5uACANCKggsAQCvtpyhcX8A8HAAArg5ncAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFo5140eqmozyWaSzGazzOfzRWa6sJ2dnY9m2lrbXW2YQ2YPXTzTsvb3wf02JVPNlch2XlPOBsDVd2zBrapHk/zUGOMDB5ePMbaTbCfJ+vr62NjYWFrA85jP57mX6ebE7mS2tbabJ5662A3k7tzYWEyYQw7utymZaq5EtvOacjYArr5jm9YY442XFQQAABbBHFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaOXaqgMAME1VtZlkM0lms1nm8/mZtt/Z2TnzNqsk73JdZt6ttd0LjzF76ORxprT/PR+eScEFeMBV1e9J8jNjjLsHl48xtpNsJ8n6+vrY2Ng407jz+Txn3WaV5F2uy8x789btC4+xtbabJ546vibdubFx4cdZFM+HZ1JwAR5wY4wfW3UGgEUyBxcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKCVc93o4aK3b1y2g7d/W8Tt+hbpNLf+O8my9vdUb/M31VyJbOc15WwAXH3HFtyqenmSdyz69o3LdvD2b4u4Xd8inebWfydZ1q0Bp3qbv6nmSmQ7rylnA+DqO7ZpjTHecllBAABgEczBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCgFQUXAIBWFFwAAFpRcAEAaEXBBQCglWureNDrt24vdfyttd3cXPJjAAAwTc7gAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK2s5HNwAZiOqnpFkrePMe4eWr6ZZDNJZrNZ5vP5mcbd2dk58zarJO9yXWberbXdC48xe+jkcaa0/z0fnknBBXjAjTF+9Ijl20m2k2R9fX1sbGycadz5fJ6zbrNK8i7XZeZdxM2ettZ288RTx9ekOzc2Lvw4i+L58EymKAAA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtHPsBb1X1yiRPjTE+cGj5hT78exEfwHyc03w486osItuyPhh5qh8SPdUPqll1AAAGHUlEQVRciWznNeVsAFx9xxbcMcabjlh+oQ//XsQHMB/nNB/OvCqLyLasD5ae6odETzVXItt5TTkbAFefKQoAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtXFt1AABWq6penuQdY4y7h5ZvJtlMktlslvl8fqZxd3Z2zrzNKk0p71Pv+dCJ68weSv6n7/qBCz/W2m9/3oXHOI3L3L9ba7sXHmP20MnjTOX5kkzr+Xsay86r4AI84MYYbzli+XaS7SRZX18fGxsbZxp3Pp/nrNus0pTy3rx1+8R1ttZ288RTF38Zv3Nj48JjnMZl7t/T7L+TnGb/Xta+O40pPX9PY9l5TVEAAKAVBRcAgFYUXAAAWlFwAQBo5djZ01X1siTvXPSVtYu4uvE4p7nycVUWkW1ZVx1O9QrMqeZKZDuvKWcD4Oo7tuCOMd56xPILXVm7iKsbj7OoK0uXYRHZlnXV5lSvwJxqrkS285pyNgCuPlMUAABoRcEFAKAVBRcAgFYUXAAAWlFwAQBoRcEFAKAVBRcAgFYUXAAAWlFwAQBoZZq3+2ISri/5jnMH3Xn8sUt7LACgN2dwAQBoRcEFAKAVBRcAgFYUXAAAWnGRGQAASS7vAvNv+8KHlzq+M7gAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALRybdUBOLvrt24vZdyttd3cXNLYAACXxRlcAABaUXABAGjFFAUeKIue3nHctI47jz+20MeCZamqlyV55xjj7qHlm0k2k2Q2m2U+n59p3J2dnTNvs0pTyru1tnviOrOHTrfeSS7rd77M/buI/XKa/TuV50uyuP27iH13Gst+Pii4AA+4McZbj1i+nWQ7SdbX18fGxsaZxp3P5znrNqs0pbynuR5ia203Tzx18ZfxOzc2LjzGaVzm/l3E9SSn2b+Xte9OY1H797Kuxfm2L3x4qc8HUxQAAGjlxP/6VdVLk9w5+NbVRd+2Wvbp70W9bbMMst3fcc+hRb6Nsejf77h9tuq3rqb0duthU84GwNV3YsEdY/z4fZZd6G2rZZ/+XtTbNssg2/0d9zbPIt/WWvRz77h9tuq3rqb0duthU84GwNVnigIAAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEArCi4AAK0ouAAAtKLgAgDQioILAEAr11YdAJLk+q3bR/5sa203N4/5OQDAQc7gAgDQioILAEArpijAFXfU9I5lTO248/hjCx0PAJZBwQVgKZ56z4cuZf68/3gBh5miAABAKwouAACtKLgAALSi4AIA0IqCCwBAKwouAACtKLgAALTic3BhSY66AQMAsFwKLnBqiyrtJ91lzQf3A3ARNcY4eaWql40x3nrg+80km/vffmaSn15OvHN7JMl7Vx3iCLKd3VRzJbKd1zKyvXCM8fwFj/nAOHyc31920WP9lJ+D9yPvcsm7XA9K3lMd609VcK+aqnrbGGN91TnuR7azm2quRLbzmnI2Fueq/TvLu1zyLpe8z+QiMwAAWlFwAQBopWvB3V51gGPIdnZTzZXIdl5TzsbiXLV/Z3mXS97lkveAlnNwAQB4cHU9gwsAwANKwQUAoJV2BbeqPquqZqvOcT9V9XkTzvaSCWf7/Alne6lsZ1dVnzHVbCxGVb1y1RnOoqoeXXWGs7B/l+uq5U32jvmrznAWy97H5uACANBKuzO4AAA82BRcAABaUXABAGhFwQUAoBUFFwCAVv5/jpDfCggRqAQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# histograms\n",
    "dataset.hist(sharex=False, sharey=False, xlabelsize=1, ylabelsize=1, figsize=(12,12))\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "_cell_guid": "ca420570-fce1-e2ff-8511-50691e099d69"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# density\n",
    "dataset.plot(kind='density', subplots=True, layout=(3,3), sharex=False, legend=True, fontsize=1, figsize=(15,15))\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Box and Whisker Plots\n",
    "dataset.plot(kind='box', subplots=True, layout=(3,3), sharex=False, sharey=False, figsize=(15,15))\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x139ec1fa6a0>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# correlation\n",
    "correlation = dataset.corr()\n",
    "pyplot.figure(figsize=(15,15))\n",
    "pyplot.title('Correlation Matrix')\n",
    "sns.heatmap(correlation, vmax=1, square=True,annot=True,cmap='cubehelix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Scatterplot Matrix\n",
    "from pandas.plotting import scatter_matrix\n",
    "pyplot.figure(figsize=(15,15))\n",
    "scatter_matrix(dataset,figsize=(12,12))\n",
    "pyplot.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3'></a>\n",
    "## 4. Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.1'></a>\n",
    "## 4.1. Data Cleaning\n",
    "Check for the NAs in the rows, either drop them or fill them with the mean of the column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null Values = True\n"
     ]
    }
   ],
   "source": [
    "#Checking for any null values and removing the null values'''\n",
    "print('Null Values =',dataset.isnull().values.any())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given that there are null values drop the rown contianing the null values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop the rows containing NA\n",
    "dataset = dataset.dropna(axis=0)\n",
    "# Fill na with 0\n",
    "#dataset.fillna('0')\n",
    "\n",
    "#Filling the NAs with the mean of the column.\n",
    "#dataset['col'] = dataset['col'].fillna(dataset['col'].mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.2'></a>\n",
    "## 4.2. Handling Categorical Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "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>Sex</th>\n",
       "      <th>Sex_Code</th>\n",
       "      <th>Housing</th>\n",
       "      <th>Housing_Code</th>\n",
       "      <th>Risk_Code</th>\n",
       "      <th>Risk</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>own</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>free</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>free</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>rent</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>own</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>rent</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>rent</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>own</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>male</td>\n",
       "      <td>1</td>\n",
       "      <td>own</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>female</td>\n",
       "      <td>0</td>\n",
       "      <td>rent</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Sex  Sex_Code Housing  Housing_Code  Risk_Code  Risk\n",
       "1   female         0     own             1          0   bad\n",
       "3     male         1    free             0          1  good\n",
       "4     male         1    free             0          0   bad\n",
       "7     male         1    rent             2          1  good\n",
       "9     male         1     own             1          0   bad\n",
       "10  female         0    rent             2          0   bad\n",
       "11  female         0    rent             2          0   bad\n",
       "12  female         0     own             1          1  good\n",
       "13    male         1     own             1          0   bad\n",
       "14  female         0    rent             2          1  good"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "lb_make = LabelEncoder()\n",
    "dataset[\"Sex_Code\"] = lb_make.fit_transform(dataset[\"Sex\"])\n",
    "dataset[\"Housing_Code\"] = lb_make.fit_transform(dataset[\"Housing\"])\n",
    "dataset[\"SavingAccount_Code\"] = lb_make.fit_transform(dataset[\"SavingAccounts\"].fillna('0'))\n",
    "dataset[\"CheckingAccount_Code\"] = lb_make.fit_transform(dataset[\"CheckingAccount\"].fillna('0'))\n",
    "dataset[\"Purpose_Code\"] = lb_make.fit_transform(dataset[\"Purpose\"])\n",
    "dataset[\"Risk_Code\"] = lb_make.fit_transform(dataset[\"Risk\"])\n",
    "dataset[[\"Sex\", \"Sex_Code\",\"Housing\",\"Housing_Code\",\"Risk_Code\",\"Risk\"]].head(10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dropping the old features\n",
    "dataset.drop(['Sex','Housing','SavingAccounts','CheckingAccount','Purpose','Risk'],axis=1,inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "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>Age</th>\n",
       "      <th>Job</th>\n",
       "      <th>CreditAmount</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Sex_Code</th>\n",
       "      <th>Housing_Code</th>\n",
       "      <th>SavingAccount_Code</th>\n",
       "      <th>CheckingAccount_Code</th>\n",
       "      <th>Purpose_Code</th>\n",
       "      <th>Risk_Code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>22</td>\n",
       "      <td>2</td>\n",
       "      <td>5951</td>\n",
       "      <td>48</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>45</td>\n",
       "      <td>2</td>\n",
       "      <td>7882</td>\n",
       "      <td>42</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>53</td>\n",
       "      <td>2</td>\n",
       "      <td>4870</td>\n",
       "      <td>24</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>35</td>\n",
       "      <td>3</td>\n",
       "      <td>6948</td>\n",
       "      <td>36</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>28</td>\n",
       "      <td>3</td>\n",
       "      <td>5234</td>\n",
       "      <td>30</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Age  Job  CreditAmount  Duration  Sex_Code  Housing_Code  SavingAccount_Code  \\\n",
       "1   22    2          5951        48         0             1                   0   \n",
       "3   45    2          7882        42         1             0                   0   \n",
       "4   53    2          4870        24         1             0                   0   \n",
       "7   35    3          6948        36         1             2                   0   \n",
       "9   28    3          5234        30         1             1                   0   \n",
       "\n",
       "   CheckingAccount_Code  Purpose_Code  Risk_Code  \n",
       "1                     1             5          0  \n",
       "3                     0             4          1  \n",
       "4                     0             1          0  \n",
       "7                     1             1          1  \n",
       "9                     1             1          0  "
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.3'></a>\n",
    "## 4.3. Feature Selection\n",
    "Statistical tests can be used to select those features that have the strongest relationship with the output variable.The scikit-learn library provides the SelectKBest class that can be used with a suite of different statistical tests to select a specific number of features.\n",
    "The example below uses the chi-squared (chi²) statistical test for non-negative features to select 10 of the best features from the Dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SelectKBest(k=5, score_func=<function chi2 at 0x00000139EC248B70>)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "\n",
    "bestfeatures = SelectKBest(score_func=chi2, k=5)\n",
    "bestfeatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  Specs      Score\n",
      "2          CreditAmount  45853.601\n",
      "3              Duration    327.508\n",
      "6    SavingAccount_Code     14.395\n",
      "7  CheckingAccount_Code      7.096\n",
      "0                   Age      6.534\n",
      "8          Purpose_Code      1.902\n",
      "4              Sex_Code      0.671\n",
      "1                   Job      0.318\n",
      "5          Housing_Code      0.007\n"
     ]
    }
   ],
   "source": [
    "Y= dataset[\"Risk_Code\"]\n",
    "X = dataset.loc[:, dataset.columns != 'Risk_Code']\n",
    "fit = bestfeatures.fit(X,Y)\n",
    "dfscores = pd.DataFrame(fit.scores_)\n",
    "dfcolumns = pd.DataFrame(X.columns)\n",
    "#concat two dataframes for better visualization \n",
    "featureScores = pd.concat([dfcolumns,dfscores],axis=1)\n",
    "featureScores.columns = ['Specs','Score']  #naming the dataframe columns\n",
    "print(featureScores.nlargest(10,'Score'))  #print 10 best features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As it can be seem from the numbers above Credit Amount is the most important feature followed by duration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.4'></a>\n",
    "## 4.4. Data Transformation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.4.1'></a>\n",
    "### 4.4.1. Rescale Data\n",
    "When your data is comprised of attributes with varying scales, many machine learning algorithms\n",
    "can benefit from rescaling the attributes to all have the same scale. Often this is referred to\n",
    "as normalization and attributes are often rescaled into the range between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.054</td>\n",
       "      <td>0.667</td>\n",
       "      <td>0.313</td>\n",
       "      <td>0.636</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.464</td>\n",
       "      <td>0.667</td>\n",
       "      <td>0.419</td>\n",
       "      <td>0.545</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.607</td>\n",
       "      <td>0.667</td>\n",
       "      <td>0.253</td>\n",
       "      <td>0.273</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.286</td>\n",
       "      <td>1.000</td>\n",
       "      <td>0.368</td>\n",
       "      <td>0.455</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.161</td>\n",
       "      <td>1.000</td>\n",
       "      <td>0.273</td>\n",
       "      <td>0.364</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.143</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0      1      2      3    4    5    6    7      8\n",
       "0  0.054  0.667  0.313  0.636  0.0  0.5  0.0  0.5  0.714\n",
       "1  0.464  0.667  0.419  0.545  1.0  0.0  0.0  0.0  0.571\n",
       "2  0.607  0.667  0.253  0.273  1.0  0.0  0.0  0.0  0.143\n",
       "3  0.286  1.000  0.368  0.455  1.0  1.0  0.0  0.5  0.143\n",
       "4  0.161  1.000  0.273  0.364  1.0  0.5  0.0  0.5  0.143"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "X = dataset.loc[:, dataset.columns != 'Risk_Code']\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "rescaledX = pd.DataFrame(scaler.fit_transform(X))\n",
    "# summarize transformed data\n",
    "rescaledX.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.4.2'></a>\n",
    "### 4.4.2. Standardize Data\n",
    "Standardization is a useful technique to transform attributes with a Gaussian distribution and\n",
    "differing means and standard deviations to a standard Gaussian distribution with a mean of\n",
    "0 and a standard deviation of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.094</td>\n",
       "      <td>0.183</td>\n",
       "      <td>0.913</td>\n",
       "      <td>2.139</td>\n",
       "      <td>-1.452</td>\n",
       "      <td>-0.145</td>\n",
       "      <td>-0.451</td>\n",
       "      <td>0.557</td>\n",
       "      <td>1.063</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.859</td>\n",
       "      <td>0.183</td>\n",
       "      <td>1.573</td>\n",
       "      <td>1.658</td>\n",
       "      <td>0.689</td>\n",
       "      <td>-1.900</td>\n",
       "      <td>-0.451</td>\n",
       "      <td>-0.958</td>\n",
       "      <td>0.561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.538</td>\n",
       "      <td>0.183</td>\n",
       "      <td>0.544</td>\n",
       "      <td>0.214</td>\n",
       "      <td>0.689</td>\n",
       "      <td>-1.900</td>\n",
       "      <td>-0.451</td>\n",
       "      <td>-0.958</td>\n",
       "      <td>-0.944</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.009</td>\n",
       "      <td>1.648</td>\n",
       "      <td>1.254</td>\n",
       "      <td>1.176</td>\n",
       "      <td>0.689</td>\n",
       "      <td>1.611</td>\n",
       "      <td>-0.451</td>\n",
       "      <td>0.557</td>\n",
       "      <td>-0.944</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.585</td>\n",
       "      <td>1.648</td>\n",
       "      <td>0.668</td>\n",
       "      <td>0.695</td>\n",
       "      <td>0.689</td>\n",
       "      <td>-0.145</td>\n",
       "      <td>-0.451</td>\n",
       "      <td>0.557</td>\n",
       "      <td>-0.944</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0      1      2      3      4      5      6      7      8\n",
       "0 -1.094  0.183  0.913  2.139 -1.452 -0.145 -0.451  0.557  1.063\n",
       "1  0.859  0.183  1.573  1.658  0.689 -1.900 -0.451 -0.958  0.561\n",
       "2  1.538  0.183  0.544  0.214  0.689 -1.900 -0.451 -0.958 -0.944\n",
       "3  0.009  1.648  1.254  1.176  0.689  1.611 -0.451  0.557 -0.944\n",
       "4 -0.585  1.648  0.668  0.695  0.689 -0.145 -0.451  0.557 -0.944"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "X = dataset.loc[:, dataset.columns != 'Risk_Code']\n",
    "scaler = StandardScaler().fit(X)\n",
    "StandardisedX = pd.DataFrame(scaler.fit_transform(X))\n",
    "# summarize transformed data\n",
    "StandardisedX.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='3.4.3'></a>\n",
    "### 4.4.1. Normalize Data\n",
    "Normalizing in scikit-learn refers to rescaling each observation (row) to have a length of 1 (called\n",
    "a unit norm or a vector with the length of 1 in linear algebra)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.004</td>\n",
       "      <td>3.361e-04</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.008</td>\n",
       "      <td>0.000e+00</td>\n",
       "      <td>1.680e-04</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.680e-04</td>\n",
       "      <td>8.402e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.006</td>\n",
       "      <td>2.537e-04</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.005</td>\n",
       "      <td>1.269e-04</td>\n",
       "      <td>0.000e+00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000e+00</td>\n",
       "      <td>5.075e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.011</td>\n",
       "      <td>4.106e-04</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.005</td>\n",
       "      <td>2.053e-04</td>\n",
       "      <td>0.000e+00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000e+00</td>\n",
       "      <td>2.053e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.005</td>\n",
       "      <td>4.318e-04</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.005</td>\n",
       "      <td>1.439e-04</td>\n",
       "      <td>2.878e-04</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.439e-04</td>\n",
       "      <td>1.439e-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.005</td>\n",
       "      <td>5.732e-04</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.006</td>\n",
       "      <td>1.911e-04</td>\n",
       "      <td>1.911e-04</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.911e-04</td>\n",
       "      <td>1.911e-04</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0          1    2      3          4          5    6          7          8\n",
       "0  0.004  3.361e-04  1.0  0.008  0.000e+00  1.680e-04  0.0  1.680e-04  8.402e-04\n",
       "1  0.006  2.537e-04  1.0  0.005  1.269e-04  0.000e+00  0.0  0.000e+00  5.075e-04\n",
       "2  0.011  4.106e-04  1.0  0.005  2.053e-04  0.000e+00  0.0  0.000e+00  2.053e-04\n",
       "3  0.005  4.318e-04  1.0  0.005  1.439e-04  2.878e-04  0.0  1.439e-04  1.439e-04\n",
       "4  0.005  5.732e-04  1.0  0.006  1.911e-04  1.911e-04  0.0  1.911e-04  1.911e-04"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import Normalizer\n",
    "X = dataset.loc[:, dataset.columns != 'Risk_Code']\n",
    "scaler = Normalizer().fit(X)\n",
    "NormalizedX = pd.DataFrame(scaler.fit_transform(X))\n",
    "# summarize transformed data\n",
    "NormalizedX.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4'></a>\n",
    "# 5. Evaluate Algorithms and Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.1'></a>\n",
    "## 5.1. Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split out validation dataset for the end\n",
    "Y= dataset[\"Risk_Code\"]\n",
    "X = dataset.loc[:, dataset.columns != 'Risk_Code']\n",
    "scaler = StandardScaler().fit(X)\n",
    "StandardisedX = pd.DataFrame(scaler.fit_transform(X))\n",
    "validation_size = 0.2\n",
    "seed = 7\n",
    "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.2'></a>\n",
    "## 5.2. Test Options and Evaluation Metrics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "_cell_guid": "5702bc31-06bf-8b6a-42de-366a6b3311a8"
   },
   "outputs": [],
   "source": [
    "# test options for classification\n",
    "num_folds = 10\n",
    "seed = 7\n",
    "scoring = 'accuracy'\n",
    "#scoring ='neg_log_loss'\n",
    "#scoring = 'roc_auc'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.3'></a>\n",
    "## 5.3. Compare Models and Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.3.1'></a>\n",
    "### 5.3.1. Common Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "_cell_guid": "772802f7-f4e4-84ee-6377-6464ab2e5da4"
   },
   "outputs": [],
   "source": [
    "# spot check the algorithms\n",
    "models = []\n",
    "models.append(('LR', LogisticRegression()))\n",
    "models.append(('LDA', LinearDiscriminantAnalysis()))\n",
    "models.append(('KNN', KNeighborsClassifier()))\n",
    "models.append(('CART', DecisionTreeClassifier()))\n",
    "models.append(('NB', GaussianNB()))\n",
    "models.append(('SVM', SVC()))\n",
    "#Neural Network\n",
    "models.append(('NN', MLPClassifier()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.3.2'></a>\n",
    "### 5.3.2. Ensemble Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ensable Models \n",
    "# Boosting methods\n",
    "models.append(('AB', AdaBoostClassifier()))\n",
    "models.append(('GBM', GradientBoostingClassifier()))\n",
    "# Bagging methods\n",
    "models.append(('RF', RandomForestClassifier()))\n",
    "models.append(('ET', ExtraTreesClassifier()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='4.3.3'></a>\n",
    "### 5.3.3. Deep Learning Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing the Deep Learning Classifier in case the Deep Learning Flag is Set to True\n",
    "#Set the following Flag to 0 if the Deep LEarning Models Flag has to be enabled\n",
    "EnableDLModelsFlag = 1\n",
    "if EnableDLModelsFlag == 1 :   \n",
    "    # Function to create model, required for KerasClassifier\n",
    "    def create_model(neurons=12, activation='relu', learn_rate = 0.01, momentum=0):\n",
    "        # create model\n",
    "        model = Sequential()\n",
    "        model.add(Dense(neurons, input_dim=X_train.shape[1], activation=activation))\n",
    "        model.add(Dense(2, activation=activation))\n",
    "        model.add(Dense(1, activation='sigmoid'))\n",
    "        # Compile model\n",
    "        optimizer = SGD(lr=learn_rate, momentum=momentum)\n",
    "        model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "        return model    \n",
    "    models.append(('DNN', KerasClassifier(build_fn=create_model, epochs=10, batch_size=10, verbose=1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### K-folds cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "_cell_guid": "a784ab4a-eb59-98cc-76cf-b55f382d057a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR: 0.626074 (0.064426)\n",
      "LDA: 0.611614 (0.055923)\n",
      "KNN: 0.529791 (0.063048)\n",
      "CART: 0.563763 (0.097660)\n",
      "NB: 0.611324 (0.061465)\n",
      "SVM: 0.592102 (0.077275)\n",
      "NN: 0.503775 (0.059635)\n",
      "AB: 0.621138 (0.045846)\n",
      "GBM: 0.633159 (0.076016)\n",
      "RF: 0.618815 (0.077372)\n",
      "ET: 0.582753 (0.074896)\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 136us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 128us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 152us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 147us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 156us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 146us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 161us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 144us/step - loss: 9.0691 - acc: 0.4373\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 142us/step - loss: 9.0691 - acc: 0.4373\n",
      "42/42 [==============================] - 1s 16ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 113us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 126us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 115us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 119us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 112us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 6.8871 - acc: 0.5680\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 113us/step - loss: 6.8871 - acc: 0.5680\n",
      "42/42 [==============================] - 1s 15ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 2s 4ms/step - loss: 0.6925 - acc: 0.5733\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 108us/step - loss: 0.6914 - acc: 0.5787\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 115us/step - loss: 0.6902 - acc: 0.5787\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 120us/step - loss: 0.6892 - acc: 0.5787\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 125us/step - loss: 0.6883 - acc: 0.5787\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 151us/step - loss: 0.6875 - acc: 0.5787\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 200us/step - loss: 0.6868 - acc: 0.5787\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 223us/step - loss: 0.6862 - acc: 0.5787\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 122us/step - loss: 0.6856 - acc: 0.5787\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 133us/step - loss: 0.6851 - acc: 0.5787\n",
      "42/42 [==============================] - 1s 12ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 103us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 114us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 110us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 107us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 104us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 106us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 103us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 106us/step - loss: 7.0997 - acc: 0.5547\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 105us/step - loss: 7.0997 - acc: 0.5547\n",
      "42/42 [==============================] - 1s 12ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 4.6803 - acc: 0.4880\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 112us/step - loss: 1.5742 - acc: 0.4533\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 104us/step - loss: 1.2508 - acc: 0.4507\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 1.1772 - acc: 0.4373\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 106us/step - loss: 1.2157 - acc: 0.4613\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 112us/step - loss: 0.8980 - acc: 0.4533\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 105us/step - loss: 1.0351 - acc: 0.5147\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 101us/step - loss: 0.9598 - acc: 0.4853\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 101us/step - loss: 0.9366 - acc: 0.5067\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 105us/step - loss: 0.8666 - acc: 0.5387\n",
      "42/42 [==============================] - 1s 12ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 0.6928 - acc: 0.5520\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 157us/step - loss: 0.6917 - acc: 0.5733\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 119us/step - loss: 0.6907 - acc: 0.5733\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 103us/step - loss: 0.6898 - acc: 0.5733\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 108us/step - loss: 0.6891 - acc: 0.5733\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 110us/step - loss: 0.6884 - acc: 0.5733\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 110us/step - loss: 0.6877 - acc: 0.5733\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 102us/step - loss: 0.6871 - acc: 0.5733\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 106us/step - loss: 0.6867 - acc: 0.5733\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 101us/step - loss: 0.6863 - acc: 0.5733\n",
      "42/42 [==============================] - 1s 13ms/step\n",
      "Epoch 1/10\n",
      "375/375 [==============================] - 1s 4ms/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 2/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 3/10\n",
      "375/375 [==============================] - 0s 103us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 4/10\n",
      "375/375 [==============================] - 0s 109us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 5/10\n",
      "375/375 [==============================] - 0s 103us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 6/10\n",
      "375/375 [==============================] - 0s 105us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 7/10\n",
      "375/375 [==============================] - 0s 112us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 8/10\n",
      "375/375 [==============================] - 0s 104us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 9/10\n",
      "375/375 [==============================] - 0s 107us/step - loss: 9.1981 - acc: 0.4293\n",
      "Epoch 10/10\n",
      "375/375 [==============================] - 0s 106us/step - loss: 9.1981 - acc: 0.4293\n",
      "42/42 [==============================] - 1s 13ms/step\n",
      "Epoch 1/10\n",
      "376/376 [==============================] - 2s 4ms/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 2/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 3/10\n",
      "376/376 [==============================] - 0s 107us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 4/10\n",
      "376/376 [==============================] - 0s 113us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 5/10\n",
      "376/376 [==============================] - 0s 111us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 6/10\n",
      "376/376 [==============================] - 0s 113us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 7/10\n",
      "376/376 [==============================] - 0s 109us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 8/10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "376/376 [==============================] - 0s 108us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 9/10\n",
      "376/376 [==============================] - 0s 106us/step - loss: 9.2165 - acc: 0.4282\n",
      "Epoch 10/10\n",
      "376/376 [==============================] - 0s 108us/step - loss: 9.2165 - acc: 0.4282\n",
      "41/41 [==============================] - 1s 15ms/step\n",
      "Epoch 1/10\n",
      "376/376 [==============================] - 2s 4ms/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 2/10\n",
      "376/376 [==============================] - 0s 109us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 3/10\n",
      "376/376 [==============================] - 0s 112us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 4/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 5/10\n",
      "376/376 [==============================] - 0s 107us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 6/10\n",
      "376/376 [==============================] - 0s 108us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 7/10\n",
      "376/376 [==============================] - 0s 107us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 8/10\n",
      "376/376 [==============================] - 0s 107us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 9/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 6.7416 - acc: 0.5771\n",
      "Epoch 10/10\n",
      "376/376 [==============================] - 0s 106us/step - loss: 6.7416 - acc: 0.5771\n",
      "41/41 [==============================] - 1s 14ms/step\n",
      "Epoch 1/10\n",
      "376/376 [==============================] - 2s 4ms/step - loss: 5.4531 - acc: 0.5346\n",
      "Epoch 2/10\n",
      "376/376 [==============================] - 0s 113us/step - loss: 3.4579 - acc: 0.5665\n",
      "Epoch 3/10\n",
      "376/376 [==============================] - 0s 108us/step - loss: 3.3328 - acc: 0.5452\n",
      "Epoch 4/10\n",
      "376/376 [==============================] - 0s 106us/step - loss: 2.5059 - acc: 0.5000\n",
      "Epoch 5/10\n",
      "376/376 [==============================] - 0s 108us/step - loss: 2.8887 - acc: 0.5771\n",
      "Epoch 6/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 2.0510 - acc: 0.5532\n",
      "Epoch 7/10\n",
      "376/376 [==============================] - 0s 107us/step - loss: 1.8155 - acc: 0.5904\n",
      "Epoch 8/10\n",
      "376/376 [==============================] - 0s 111us/step - loss: 1.4380 - acc: 0.6144\n",
      "Epoch 9/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 1.5659 - acc: 0.6250\n",
      "Epoch 10/10\n",
      "376/376 [==============================] - 0s 110us/step - loss: 1.5057 - acc: 0.6117\n",
      "41/41 [==============================] - 1s 15ms/step\n",
      "DNN: 0.522648 (0.095039)\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "names = []\n",
    "for name, model in models:\n",
    "    kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "    cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)\n",
    "    results.append(cv_results)\n",
    "    names.append(name)\n",
    "    msg = \"%s: %f (%f)\" % (name, cv_results.mean(), cv_results.std())\n",
    "    print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "_cell_guid": "67873e9d-bc9b-6963-f594-805f1efbfbb3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# compare algorithms\n",
    "fig = pyplot.figure()\n",
    "fig.suptitle('Algorithm Comparison')\n",
    "ax = fig.add_subplot(111)\n",
    "pyplot.boxplot(results)\n",
    "ax.set_xticklabels(names)\n",
    "fig.set_size_inches(15,8)\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='5'></a>\n",
    "# 6. Model Tuning and Grid Search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "848ca488-b0fd-8e93-2e68-23d32c71d89c"
   },
   "source": [
    "Algorithm Tuning: Although some of the models show the most promising options. the grid search for Gradient Bossting Classifier is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.616376 using {'C': 1.0, 'penalty': 'l2'}\n",
      "#8 nan (nan) with: {'C': 0.001, 'penalty': 'l1'}\n",
      "#7 0.572880 (0.067966) with: {'C': 0.001, 'penalty': 'l2'}\n",
      "#9 nan (nan) with: {'C': 0.01, 'penalty': 'l1'}\n",
      "#6 0.611324 (0.055957) with: {'C': 0.01, 'penalty': 'l2'}\n",
      "#10 nan (nan) with: {'C': 0.1, 'penalty': 'l1'}\n",
      "#5 0.611440 (0.040460) with: {'C': 0.1, 'penalty': 'l2'}\n",
      "#11 nan (nan) with: {'C': 1.0, 'penalty': 'l1'}\n",
      "#1 0.616376 (0.056352) with: {'C': 1.0, 'penalty': 'l2'}\n",
      "#12 nan (nan) with: {'C': 10.0, 'penalty': 'l1'}\n",
      "#1 0.616376 (0.056352) with: {'C': 10.0, 'penalty': 'l2'}\n",
      "#13 nan (nan) with: {'C': 100.0, 'penalty': 'l1'}\n",
      "#1 0.616376 (0.056352) with: {'C': 100.0, 'penalty': 'l2'}\n",
      "#14 nan (nan) with: {'C': 1000.0, 'penalty': 'l1'}\n",
      "#1 0.616376 (0.056352) with: {'C': 1000.0, 'penalty': 'l2'}\n"
     ]
    }
   ],
   "source": [
    "# 1. Grid search : Logistic Regression Algorithm \n",
    "'''\n",
    "penalty : str, ‘l1’, ‘l2’, ‘elasticnet’ or ‘none’, optional (default=’l2’)\n",
    "\n",
    "C : float, optional (default=1.0)\n",
    "Inverse of regularization strength; must be a positive float.Smaller values specify stronger regularization.\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "grid={\"C\":np.logspace(-3,3,7), \"penalty\":[\"l1\",\"l2\"]}# l1 lasso l2 ridge\n",
    "C= np.logspace(-3,3,7)\n",
    "penalty = [\"l1\",\"l2\"]# l1 lasso l2 ridge\n",
    "param_grid = dict(C=C,penalty=penalty )\n",
    "model = LogisticRegression()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.611614 using {'n_components': 1}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 1}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 3}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 5}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 7}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 9}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 11}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 13}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 15}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 17}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 19}\n",
      "#1 0.611614 (0.055923) with: {'n_components': 600}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search : LDA Algorithm \n",
    "'''\n",
    "n_components : int, optional (default=None)\n",
    "Number of components for dimensionality reduction. If None, will be set to min(n_classes - 1, n_features).\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "components  = [1,3,5,7,9,11,13,15,17,19,600]\n",
    "param_grid = dict(n_components=components)\n",
    "model = LinearDiscriminantAnalysis()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.633275 using {'n_neighbors': 21, 'weights': 'distance'}\n",
      "#20 0.575436 (0.053977) with: {'n_neighbors': 1, 'weights': 'uniform'}\n",
      "#20 0.575436 (0.053977) with: {'n_neighbors': 1, 'weights': 'distance'}\n",
      "#22 0.573403 (0.072922) with: {'n_neighbors': 3, 'weights': 'uniform'}\n",
      "#18 0.585250 (0.069232) with: {'n_neighbors': 3, 'weights': 'distance'}\n",
      "#17 0.587979 (0.076811) with: {'n_neighbors': 5, 'weights': 'uniform'}\n",
      "#9 0.597271 (0.055041) with: {'n_neighbors': 5, 'weights': 'distance'}\n",
      "#19 0.580778 (0.082174) with: {'n_neighbors': 7, 'weights': 'uniform'}\n",
      "#15 0.590302 (0.083559) with: {'n_neighbors': 7, 'weights': 'distance'}\n",
      "#16 0.590302 (0.062168) with: {'n_neighbors': 9, 'weights': 'uniform'}\n",
      "#7 0.604530 (0.046160) with: {'n_neighbors': 9, 'weights': 'distance'}\n",
      "#11 0.592451 (0.053386) with: {'n_neighbors': 11, 'weights': 'uniform'}\n",
      "#5 0.611731 (0.044295) with: {'n_neighbors': 11, 'weights': 'distance'}\n",
      "#14 0.592393 (0.067668) with: {'n_neighbors': 13, 'weights': 'uniform'}\n",
      "#11 0.592451 (0.058359) with: {'n_neighbors': 13, 'weights': 'distance'}\n",
      "#13 0.592451 (0.059463) with: {'n_neighbors': 15, 'weights': 'uniform'}\n",
      "#10 0.597271 (0.059064) with: {'n_neighbors': 15, 'weights': 'distance'}\n",
      "#8 0.604413 (0.050579) with: {'n_neighbors': 17, 'weights': 'uniform'}\n",
      "#6 0.609292 (0.049731) with: {'n_neighbors': 17, 'weights': 'distance'}\n",
      "#4 0.616492 (0.054053) with: {'n_neighbors': 19, 'weights': 'uniform'}\n",
      "#3 0.626132 (0.042168) with: {'n_neighbors': 19, 'weights': 'distance'}\n",
      "#2 0.628397 (0.060939) with: {'n_neighbors': 21, 'weights': 'uniform'}\n",
      "#1 0.633275 (0.055367) with: {'n_neighbors': 21, 'weights': 'distance'}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search KNN algorithm tuning\n",
    "'''\n",
    "n_neighbors : int, optional (default = 5)\n",
    "    Number of neighbors to use by default for kneighbors queries.\n",
    "\n",
    "weights : str or callable, optional (default = ‘uniform’)\n",
    "    weight function used in prediction. Possible values: ‘uniform’, ‘distance’\n",
    "\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "\n",
    "neighbors = [1,3,5,7,9,11,13,15,17,19,21]\n",
    "weights = ['uniform', 'distance']\n",
    "param_grid = dict(n_neighbors=neighbors, weights = weights )\n",
    "model = KNeighborsClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.625900 using {'max_depth': 5}\n",
      "#8 0.589663 (0.073560) with: {'max_depth': 2}\n",
      "#4 0.609001 (0.054688) with: {'max_depth': 3}\n",
      "#2 0.618931 (0.072490) with: {'max_depth': 4}\n",
      "#1 0.625900 (0.050793) with: {'max_depth': 5}\n",
      "#4 0.609001 (0.058113) with: {'max_depth': 6}\n",
      "#7 0.594890 (0.087547) with: {'max_depth': 7}\n",
      "#6 0.606678 (0.067640) with: {'max_depth': 8}\n",
      "#3 0.614402 (0.079824) with: {'max_depth': 9}\n",
      "#23 0.570848 (0.079580) with: {'max_depth': 10}\n",
      "#21 0.573403 (0.072913) with: {'max_depth': 11}\n",
      "#10 0.587340 (0.079431) with: {'max_depth': 12}\n",
      "#17 0.575784 (0.076352) with: {'max_depth': 13}\n",
      "#11 0.585308 (0.072910) with: {'max_depth': 14}\n",
      "#12 0.582927 (0.058242) with: {'max_depth': 15}\n",
      "#24 0.568409 (0.081411) with: {'max_depth': 16}\n",
      "#19 0.575610 (0.070155) with: {'max_depth': 17}\n",
      "#18 0.575668 (0.086685) with: {'max_depth': 18}\n",
      "#22 0.570964 (0.063675) with: {'max_depth': 19}\n",
      "#28 0.558943 (0.087051) with: {'max_depth': 20}\n",
      "#9 0.587573 (0.070178) with: {'max_depth': 21}\n",
      "#26 0.563705 (0.087570) with: {'max_depth': 22}\n",
      "#13 0.582753 (0.065708) with: {'max_depth': 23}\n",
      "#20 0.575610 (0.059003) with: {'max_depth': 24}\n",
      "#14 0.580546 (0.073619) with: {'max_depth': 25}\n",
      "#25 0.565970 (0.065811) with: {'max_depth': 26}\n",
      "#27 0.561208 (0.080136) with: {'max_depth': 27}\n",
      "#15 0.580314 (0.086072) with: {'max_depth': 28}\n",
      "#16 0.577991 (0.069566) with: {'max_depth': 29}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search : CART Algorithm \n",
    "'''\n",
    "max_depth : int or None, optional (default=None)\n",
    "    The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure \n",
    "    or until all leaves contain less than min_samples_split samples.\n",
    "\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "max_depth = np.arange(2, 30)\n",
    "param_grid = dict(max_depth=max_depth)\n",
    "model = DecisionTreeClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grid Search : NB algorithm tuning\n",
    "#GaussianNB only accepts priors as an argument so unless you have some priors to set for your model ahead of time \n",
    "#you will have nothing to grid search over.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.657143 using {'C': 1.0, 'kernel': 'rbf'}\n",
      "#8 0.613705 (0.033500) with: {'C': 0.1, 'kernel': 'linear'}\n",
      "#23 0.587515 (0.076731) with: {'C': 0.1, 'kernel': 'poly'}\n",
      "#24 0.570499 (0.062319) with: {'C': 0.1, 'kernel': 'rbf'}\n",
      "#18 0.608943 (0.044223) with: {'C': 0.3, 'kernel': 'linear'}\n",
      "#22 0.601800 (0.066519) with: {'C': 0.3, 'kernel': 'poly'}\n",
      "#7 0.628281 (0.060724) with: {'C': 0.3, 'kernel': 'rbf'}\n",
      "#11 0.611324 (0.046564) with: {'C': 0.5, 'kernel': 'linear'}\n",
      "#18 0.608943 (0.062315) with: {'C': 0.5, 'kernel': 'poly'}\n",
      "#2 0.656969 (0.068917) with: {'C': 0.5, 'kernel': 'rbf'}\n",
      "#8 0.613705 (0.048677) with: {'C': 0.7, 'kernel': 'linear'}\n",
      "#8 0.613705 (0.061995) with: {'C': 0.7, 'kernel': 'poly'}\n",
      "#6 0.645006 (0.062413) with: {'C': 0.7, 'kernel': 'rbf'}\n",
      "#11 0.611324 (0.046564) with: {'C': 0.9, 'kernel': 'linear'}\n",
      "#16 0.611208 (0.068144) with: {'C': 0.9, 'kernel': 'poly'}\n",
      "#3 0.654704 (0.064995) with: {'C': 0.9, 'kernel': 'rbf'}\n",
      "#11 0.611324 (0.046564) with: {'C': 1.0, 'kernel': 'linear'}\n",
      "#20 0.608827 (0.066562) with: {'C': 1.0, 'kernel': 'poly'}\n",
      "#1 0.657143 (0.064634) with: {'C': 1.0, 'kernel': 'rbf'}\n",
      "#11 0.611324 (0.046564) with: {'C': 1.3, 'kernel': 'linear'}\n",
      "#21 0.604123 (0.073433) with: {'C': 1.3, 'kernel': 'poly'}\n",
      "#4 0.650058 (0.065888) with: {'C': 1.3, 'kernel': 'rbf'}\n",
      "#11 0.611324 (0.046564) with: {'C': 1.5, 'kernel': 'linear'}\n",
      "#17 0.609001 (0.074297) with: {'C': 1.5, 'kernel': 'poly'}\n",
      "#5 0.645296 (0.075887) with: {'C': 1.5, 'kernel': 'rbf'}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search: SVM algorithm tuning\n",
    "'''\n",
    "C : float, optional (default=1.0)\n",
    "Penalty parameter C of the error term.\n",
    "\n",
    "kernel : string, optional (default=’rbf’)\n",
    "Specifies the kernel type to be used in the algorithm. \n",
    "It must be one of ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ or a callable. \n",
    "Parameters of SVM are C and kernel. \n",
    "Try a number of kernels with various values of C with less bias and more bias (less than and greater than 1.0 respectively\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "c_values = [0.1, 0.3, 0.5, 0.7, 0.9, 1.0, 1.3, 1.5]\n",
    "kernel_values = ['linear', 'poly', 'rbf']\n",
    "param_grid = dict(C=c_values, kernel=kernel_values)\n",
    "model = SVC()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.614053 using {'n_estimators': 100}\n",
      "#2 0.609350 (0.062495) with: {'n_estimators': 10}\n",
      "#1 0.614053 (0.058883) with: {'n_estimators': 100}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search: Ada boost Algorithm Tuning \n",
    "'''\n",
    "n_estimators : integer, optional (default=50)\n",
    "    The maximum number of estimators at which boosting is terminated. \n",
    "    In case of perfect fit, the learning procedure is stopped early.\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "n_estimators = [10, 100]\n",
    "param_grid = dict(n_estimators=n_estimators)\n",
    "model = AdaBoostClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.632811 using {'max_depth': 3, 'n_estimators': 180}\n",
      "#4 0.613937 (0.068854) with: {'max_depth': 3, 'n_estimators': 20}\n",
      "#1 0.632811 (0.094400) with: {'max_depth': 3, 'n_estimators': 180}\n",
      "#2 0.628339 (0.084035) with: {'max_depth': 5, 'n_estimators': 20}\n",
      "#3 0.625900 (0.068561) with: {'max_depth': 5, 'n_estimators': 180}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search: GradientBoosting Tuning\n",
    "'''\n",
    "n_estimators : int (default=100)\n",
    "    The number of boosting stages to perform. \n",
    "    Gradient boosting is fairly robust to over-fitting so a large number usually results in better performance.\n",
    "max_depth : integer, optional (default=3)\n",
    "    maximum depth of the individual regression estimators. \n",
    "    The maximum depth limits the number of nodes in the tree. \n",
    "    Tune this parameter for best performance; the best value depends on the interaction of the input variables.\n",
    "\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "n_estimators = [20,180]\n",
    "max_depth= [3,5]\n",
    "param_grid = dict(n_estimators=n_estimators, max_depth=max_depth)\n",
    "model = GradientBoostingClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.649710 using {'criterion': 'gini', 'max_depth': 5, 'n_estimators': 20}\n",
      "#1 0.649710 (0.093241) with: {'criterion': 'gini', 'max_depth': 5, 'n_estimators': 20}\n",
      "#6 0.626016 (0.079640) with: {'criterion': 'gini', 'max_depth': 5, 'n_estimators': 80}\n",
      "#8 0.606911 (0.063889) with: {'criterion': 'gini', 'max_depth': 10, 'n_estimators': 20}\n",
      "#4 0.628455 (0.069711) with: {'criterion': 'gini', 'max_depth': 10, 'n_estimators': 80}\n",
      "#7 0.614053 (0.076060) with: {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 20}\n",
      "#2 0.630720 (0.057585) with: {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 80}\n",
      "#5 0.626074 (0.071196) with: {'criterion': 'entropy', 'max_depth': 10, 'n_estimators': 20}\n",
      "#3 0.628513 (0.068331) with: {'criterion': 'entropy', 'max_depth': 10, 'n_estimators': 80}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search: Random Forest Classifier\n",
    "'''\n",
    "n_estimators : int (default=100)\n",
    "    The number of boosting stages to perform. \n",
    "    Gradient boosting is fairly robust to over-fitting so a large number usually results in better performance.\n",
    "max_depth : integer, optional (default=3)\n",
    "    maximum depth of the individual regression estimators. \n",
    "    The maximum depth limits the number of nodes in the tree. \n",
    "    Tune this parameter for best performance; the best value depends on the interaction of the input variables    \n",
    "criterion : string, optional (default=”gini”)\n",
    "    The function to measure the quality of a split. \n",
    "    Supported criteria are “gini” for the Gini impurity and “entropy” for the information gain. \n",
    "    \n",
    "'''   \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "n_estimators = [20,80]\n",
    "max_depth= [5,10]\n",
    "criterion = [\"gini\",\"entropy\"]\n",
    "param_grid = dict(n_estimators=n_estimators, max_depth=max_depth, criterion = criterion )\n",
    "model = RandomForestClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.642451 using {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 20}\n",
      "#4 0.611672 (0.089702) with: {'criterion': 'gini', 'max_depth': 5, 'n_estimators': 20}\n",
      "#3 0.632985 (0.053067) with: {'criterion': 'gini', 'max_depth': 5, 'n_estimators': 80}\n",
      "#6 0.597735 (0.096033) with: {'criterion': 'gini', 'max_depth': 10, 'n_estimators': 20}\n",
      "#8 0.597387 (0.095569) with: {'criterion': 'gini', 'max_depth': 10, 'n_estimators': 80}\n",
      "#1 0.642451 (0.077588) with: {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 20}\n",
      "#2 0.633101 (0.062141) with: {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 80}\n",
      "#5 0.604297 (0.067871) with: {'criterion': 'entropy', 'max_depth': 10, 'n_estimators': 20}\n",
      "#7 0.597561 (0.096830) with: {'criterion': 'entropy', 'max_depth': 10, 'n_estimators': 80}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search: ExtraTreesClassifier()\n",
    "'''\n",
    "n_estimators : int (default=100)\n",
    "    The number of boosting stages to perform. \n",
    "    Gradient boosting is fairly robust to over-fitting so a large number usually results in better performance.\n",
    "max_depth : integer, optional (default=3)\n",
    "    maximum depth of the individual regression estimators. \n",
    "    The maximum depth limits the number of nodes in the tree. \n",
    "    Tune this parameter for best performance; the best value depends on the interaction of the input variables    \n",
    "criterion : string, optional (default=”gini”)\n",
    "    The function to measure the quality of a split. \n",
    "    Supported criteria are “gini” for the Gini impurity and “entropy” for the information gain. \n",
    "'''   \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "n_estimators = [20,80]\n",
    "max_depth= [5,10]\n",
    "criterion = [\"gini\",\"entropy\"]\n",
    "param_grid = dict(n_estimators=n_estimators, max_depth=max_depth, criterion = criterion )\n",
    "model = ExtraTreesClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.635366 using {'hidden_layer_sizes': (20,)}\n",
      "#1 0.635366 (0.052710) with: {'hidden_layer_sizes': (20,)}\n",
      "#4 0.604413 (0.050579) with: {'hidden_layer_sizes': (50,)}\n",
      "#3 0.609059 (0.043019) with: {'hidden_layer_sizes': (20, 20)}\n",
      "#2 0.633217 (0.066650) with: {'hidden_layer_sizes': (20, 30, 20)}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search : NN algorithm tuning\n",
    "'''\n",
    "hidden_layer_sizes : tuple, length = n_layers - 2, default (100,)\n",
    "    The ith element represents the number of neurons in the ith hidden layer.\n",
    "Other Parameters that can be tuned\n",
    "    learning_rate_init : double, optional, default 0.001\n",
    "        The initial learning rate used. It controls the step-size in updating the weights. Only used when solver=’sgd’ or ‘adam’.\n",
    "    max_iter : int, optional, default 200\n",
    "        Maximum number of iterations. The solver iterates until convergence (determined by ‘tol’) or this number of iterations. For stochastic solvers (‘sgd’, ‘adam’), note that this determines the number of epochs (how many times each data point will be used), not the number of gradient steps.\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "hidden_layer_sizes=[(20,), (50,), (20,20), (20, 30, 20)]\n",
    "param_grid = dict(hidden_layer_sizes=hidden_layer_sizes)\n",
    "model = MLPClassifier()\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.625726 using {'neurons': 15}\n",
      "#4 0.590128 (0.042692) with: {'neurons': 1}\n",
      "#3 0.604065 (0.039938) with: {'neurons': 5}\n",
      "#2 0.613879 (0.055881) with: {'neurons': 10}\n",
      "#1 0.625726 (0.069088) with: {'neurons': 15}\n"
     ]
    }
   ],
   "source": [
    "# Grid Search : Deep Neural Network algorithm tuning\n",
    "'''\n",
    "neurons: int\n",
    "    Number of patterns shown to the network before the weights are updated.     \n",
    "batch_size: int\n",
    "    Number of observation to read at a time and keep in memory.\n",
    "epochs: int\n",
    "    Number of times that the entire training dataset is shown to the network during training.\n",
    "activation:\n",
    "    The activation function controls the non-linearity of individual neurons and when to fire.\n",
    "learn_rate :int\n",
    "    controls how much to update the weight at the end of each batch\n",
    "momentum : int\n",
    "     momentum controls how much to let the previous update influence the current weight update\n",
    "''' \n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "#Hyperparameters that can be modified\n",
    "neurons = [1, 5, 10, 15]\n",
    "batch_size = [10, 20, 40, 60, 80, 100]\n",
    "epochs = [10, 50, 100]\n",
    "activation = ['softmax', 'softplus', 'softsign', 'relu', 'tanh', 'sigmoid', 'hard_sigmoid', 'linear']\n",
    "learn_rate = [0.001, 0.01, 0.1, 0.2, 0.3]\n",
    "momentum = [0.0, 0.2, 0.4, 0.6, 0.8, 0.9]\n",
    "\n",
    "#Changing only Neurons for the sake of simplicity\n",
    "param_grid = dict(neurons=neurons)\n",
    "model = KerasClassifier(build_fn=create_model, epochs=50, batch_size=10, verbose=0)\n",
    "kfold = KFold(n_splits=num_folds, random_state=seed)\n",
    "grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)\n",
    "grid_result = grid.fit(rescaledX, Y_train)\n",
    "\n",
    "#Print Results\n",
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "means = grid_result.cv_results_['mean_test_score']\n",
    "stds = grid_result.cv_results_['std_test_score']\n",
    "params = grid_result.cv_results_['params']\n",
    "ranks = grid_result.cv_results_['rank_test_score']\n",
    "for mean, stdev, param, rank in zip(means, stds, params, ranks):\n",
    "    print(\"#%d %f (%f) with: %r\" % (rank, mean, stdev, param))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='6'></a>\n",
    "# 7. Finalise the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the details above GBM might be worthy of further study, but for now SVM shows a lot of promise as a low complexity and stable model for this problem.\n",
    "\n",
    "Finalize Model with best parameters found during tuning step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='6.1'></a>\n",
    "## 7.1. Results on the Test Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(ccp_alpha=0.0, criterion='friedman_mse', init=None,\n",
       "                           learning_rate=0.1, loss='deviance', max_depth=5,\n",
       "                           max_features=None, max_leaf_nodes=None,\n",
       "                           min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                           min_samples_leaf=1, min_samples_split=2,\n",
       "                           min_weight_fraction_leaf=0.0, n_estimators=20,\n",
       "                           n_iter_no_change=None, presort='deprecated',\n",
       "                           random_state=None, subsample=1.0, tol=0.0001,\n",
       "                           validation_fraction=0.1, verbose=0,\n",
       "                           warm_start=False)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# prepare model\n",
    "scaler = StandardScaler().fit(X_train)\n",
    "rescaledX = scaler.transform(X_train)\n",
    "model = GradientBoostingClassifier(n_estimators=20, max_depth=5) # rbf is default kernel\n",
    "model.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "_cell_guid": "f9725666-3c21-69d1-ddf6-45e47d982444"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "[[30 22]\n",
      " [13 40]]\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.70      0.58      0.63        52\n",
      "           1       0.65      0.75      0.70        53\n",
      "\n",
      "    accuracy                           0.67       105\n",
      "   macro avg       0.67      0.67      0.66       105\n",
      "weighted avg       0.67      0.67      0.66       105\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# estimate accuracy on validation set\n",
    "rescaledValidationX = scaler.transform(X_validation)\n",
    "predictions = model.predict(X_validation)\n",
    "print(accuracy_score(Y_validation, predictions))\n",
    "print(confusion_matrix(Y_validation, predictions))\n",
    "print(classification_report(Y_validation, predictions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n",
       "       0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n",
       "       0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1,\n",
       "       1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0,\n",
       "       1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "998    0\n",
       "989    1\n",
       "664    1\n",
       "474    0\n",
       "601    0\n",
       "918    0\n",
       "114    1\n",
       "7      1\n",
       "593    0\n",
       "201    1\n",
       "946    0\n",
       "156    1\n",
       "375    0\n",
       "513    1\n",
       "177    1\n",
       "89     0\n",
       "466    0\n",
       "537    1\n",
       "634    0\n",
       "927    0\n",
       "454    0\n",
       "648    0\n",
       "938    0\n",
       "530    1\n",
       "818    1\n",
       "498    1\n",
       "197    0\n",
       "961    1\n",
       "405    0\n",
       "432    1\n",
       "806    1\n",
       "35     0\n",
       "531    0\n",
       "334    0\n",
       "652    0\n",
       "22     1\n",
       "677    0\n",
       "605    1\n",
       "515    1\n",
       "51     1\n",
       "145    1\n",
       "729    1\n",
       "475    0\n",
       "313    0\n",
       "252    0\n",
       "97     1\n",
       "969    1\n",
       "88     1\n",
       "501    1\n",
       "38     1\n",
       "273    0\n",
       "793    1\n",
       "576    1\n",
       "479    1\n",
       "442    1\n",
       "320    0\n",
       "212    0\n",
       "172    0\n",
       "917    0\n",
       "812    0\n",
       "207    1\n",
       "72     1\n",
       "727    0\n",
       "491    0\n",
       "849    0\n",
       "919    0\n",
       "328    1\n",
       "834    0\n",
       "835    0\n",
       "721    0\n",
       "711    0\n",
       "347    1\n",
       "896    1\n",
       "831    0\n",
       "521    0\n",
       "930    1\n",
       "832    0\n",
       "623    1\n",
       "684    1\n",
       "666    1\n",
       "458    1\n",
       "157    1\n",
       "602    0\n",
       "284    1\n",
       "714    0\n",
       "107    1\n",
       "422    1\n",
       "653    0\n",
       "730    1\n",
       "416    0\n",
       "293    1\n",
       "923    1\n",
       "876    1\n",
       "191    0\n",
       "892    1\n",
       "709    1\n",
       "814    0\n",
       "471    0\n",
       "398    0\n",
       "506    1\n",
       "597    0\n",
       "44     0\n",
       "34     1\n",
       "840    0\n",
       "47     1\n",
       "Name: Risk_Code, dtype: int32"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='6.2'></a>\n",
    "## 7.2. Variable Intuition/Feature Importance\n",
    "Looking at the details above GBM might be worthy of further study, but for now SVM shows a lot of promise as a low complexity and stable model for this problem.\n",
    "Let us look into the Feature Importance of the GBM model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.14559042 0.02828504 0.45990366 0.23325303 0.00326138 0.02257884\n",
      " 0.03420548 0.02710298 0.04581917]\n"
     ]
    },
    {
     "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": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "model = GradientBoostingClassifier()\n",
    "model.fit(rescaledX,Y_train)\n",
    "print(model.feature_importances_) #use inbuilt class feature_importances of tree based classifiers\n",
    "#plot graph of feature importances for better visualization\n",
    "feat_importances = pd.Series(model.feature_importances_, index=X.columns)\n",
    "feat_importances.nlargest(10).plot(kind='barh')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='6.3'></a>\n",
    "## 7.3. Save Model for Later Use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save Model Using Pickle\n",
    "from pickle import dump\n",
    "from pickle import load\n",
    "\n",
    "# save the model to disk\n",
    "filename = 'finalized_model.sav'\n",
    "dump(model, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7047619047619048\n"
     ]
    }
   ],
   "source": [
    "# some time later...\n",
    "# load the model from disk\n",
    "loaded_model = load(open(filename, 'rb'))\n",
    "# estimate accuracy on validation set\n",
    "rescaledValidationX = scaler.transform(X_validation)\n",
    "predictions = model.predict(rescaledValidationX)\n",
    "result = accuracy_score(Y_validation, predictions)\n",
    "print(result)"
   ]
  }
 ],
 "metadata": {
  "_change_revision": 206,
  "_is_fork": false,
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}