Upload 318 files

.gitattributes

@@ -52,3 +52,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+AdultNoteBook/Kernels/AdaBoost/.ipynb_checkpoints/1-adult-income-checkpoint.ipynb filter=lfs diff=lfs merge=lfs -text
+AdultNoteBook/Kernels/AdaBoost/1-adult-income.ipynb filter=lfs diff=lfs merge=lfs -text

AdultNoteBook/Kernels/AdaBoost/.ipynb_checkpoints/1-adult-income-checkpoint.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eda7055d163932c8aba0b99ad0452eb0bf5e43234a9bdc3ca785e7fea7620a3c
+size 17587341

AdultNoteBook/Kernels/AdaBoost/.ipynb_checkpoints/2-boosting-algorithms-model-for-adult-census-income-checkpoint.ipynb

@@ -0,0 +1,2165 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:00.573511Z",
+     "iopub.status.busy": "2021-03-19T05:38:00.572716Z",
+     "iopub.status.idle": "2021-03-19T05:38:02.804511Z",
+     "shell.execute_reply": "2021-03-19T05:38:02.803821Z"
+    },
+    "papermill": {
+     "duration": 2.263268,
+     "end_time": "2021-03-19T05:38:02.804744",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:00.541476",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.preprocessing import OneHotEncoder\n",
+    "import category_encoders as ce\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.compose import ColumnTransformer\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, StratifiedKFold, cross_val_score\n",
+    "\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier\n",
+    "from xgboost.sklearn import XGBClassifier\n",
+    "from sklearn.metrics import classification_report, f1_score, plot_roc_curve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aif360.datasets import StandardDataset\n",
+    "from aif360.metrics import BinaryLabelDatasetMetric, ClassificationMetric\n",
+    "import matplotlib.patches as patches\n",
+    "from aif360.algorithms.preprocessing import Reweighing\n",
+    "#from packages import *\n",
+    "#from ml_fairness import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "\n",
+    "\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:02.853355Z",
+     "iopub.status.busy": "2021-03-19T05:38:02.852585Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.027399Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.026828Z"
+    },
+    "papermill": {
+     "duration": 0.200945,
+     "end_time": "2021-03-19T05:38:03.027547",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:02.826602",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "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>workclass</th>\n",
+       "      <th>fnlwgt</th>\n",
+       "      <th>education</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>24505</th>\n",
+       "      <td>51</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>173987</td>\n",
+       "      <td>9th</td>\n",
+       "      <td>5</td>\n",
+       "      <td>Married-civ-spouse</td>\n",
+       "      <td>Sales</td>\n",
+       "      <td>Husband</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Male</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       age workclass  fnlwgt education  education.num      marital.status  \\\n",
+       "24505   51   Private  173987       9th              5  Married-civ-spouse   \n",
+       "\n",
+       "      occupation relationship   race   sex  capital.gain  capital.loss  \\\n",
+       "24505      Sales      Husband  White  Male             0             0   \n",
+       "\n",
+       "       hours.per.week native.country income  \n",
+       "24505              40  United-States  <=50K  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult = pd.read_csv('../../Data/adult.csv')\n",
+    "adult.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.108677Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.108008Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.125920Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.125335Z"
+    },
+    "papermill": {
+     "duration": 0.076114,
+     "end_time": "2021-03-19T05:38:03.126077",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.049963",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 32561 entries, 0 to 32560\n",
+      "Data columns (total 15 columns):\n",
+      " #   Column          Non-Null Count  Dtype \n",
+      "---  ------          --------------  ----- \n",
+      " 0   age             32561 non-null  int64 \n",
+      " 1   workclass       32561 non-null  object\n",
+      " 2   fnlwgt          32561 non-null  int64 \n",
+      " 3   education       32561 non-null  object\n",
+      " 4   education.num   32561 non-null  int64 \n",
+      " 5   marital.status  32561 non-null  object\n",
+      " 6   occupation      32561 non-null  object\n",
+      " 7   relationship    32561 non-null  object\n",
+      " 8   race            32561 non-null  object\n",
+      " 9   sex             32561 non-null  object\n",
+      " 10  capital.gain    32561 non-null  int64 \n",
+      " 11  capital.loss    32561 non-null  int64 \n",
+      " 12  hours.per.week  32561 non-null  int64 \n",
+      " 13  native.country  32561 non-null  object\n",
+      " 14  income          32561 non-null  object\n",
+      "dtypes: int64(6), object(9)\n",
+      "memory usage: 3.7+ MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "adult.info()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022213,
+     "end_time": "2021-03-19T05:38:03.171196",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.148983",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*In this info detail, indicate that there is no missing value at all. But if you see the whole data carefully, you will find **missing value with '?'**.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023501,
+     "end_time": "2021-03-19T05:38:03.217098",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.193597",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# PreProcessing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022005,
+     "end_time": "2021-03-19T05:38:03.261561",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.239556",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Preprocessing scheme:*\n",
+    "* Encode all columns\n",
+    "* Drop education because it's already encoded on education.num\n",
+    "* Drop fnlwgt because it's unique"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022184,
+     "end_time": "2021-03-19T05:38:03.306152",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.283968",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Handling Missing Value In Pipeline*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.356440Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.355434Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.361557Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.362164Z"
+    },
+    "papermill": {
+     "duration": 0.033769,
+     "end_time": "2021-03-19T05:38:03.362348",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.328579",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "binary_encoder_pipe = Pipeline([\n",
+    "    ('imputer', SimpleImputer(strategy = 'constant', fill_value = 'NC', missing_values = '?')),\n",
+    "    ('binary', ce.BinaryEncoder())\n",
+    "])\n",
+    "\n",
+    "transformer = ColumnTransformer([\n",
+    "    ('one hot', OneHotEncoder(drop = 'first'), ['relationship', 'race', 'sex']),\n",
+    "    ('binary', binary_encoder_pipe, ['workclass', 'marital.status', 'occupation', 'native.country'])],\n",
+    "    remainder = 'passthrough')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022265,
+     "end_time": "2021-03-19T05:38:03.407584",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.385319",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Splitting Data*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.456571Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.455612Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.470867Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.471412Z"
+    },
+    "papermill": {
+     "duration": 0.041355,
+     "end_time": "2021-03-19T05:38:03.471590",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.430235",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<=50K    24720\n",
+       ">50K      7841\n",
+       "Name: income, dtype: int64"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult['income'].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023083,
+     "end_time": "2021-03-19T05:38:03.517599",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.494516",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "Income is the target data and **indicated with imbalance data**. I define **income with 1 if income is >50K and 0 if income is <50K**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.568392Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.567403Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.580593Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.581142Z"
+    },
+    "papermill": {
+     "duration": 0.04025,
+     "end_time": "2021-03-19T05:38:03.581329",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.541079",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "X = adult.drop(['fnlwgt', 'education', 'income'], axis = 1)\n",
+    "y = np.where(adult['income'] == '>50K', 1, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.632000Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.631007Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.637002Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.637530Z"
+    },
+    "papermill": {
+     "duration": 0.033104,
+     "end_time": "2021-03-19T05:38:03.637822",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.604718",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(32561, 12)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.689040Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.688033Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.726523Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.725847Z"
+    },
+    "papermill": {
+     "duration": 0.065514,
+     "end_time": "2021-03-19T05:38:03.726708",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.661194",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y,\n",
+    "                                                    test_size = 0.3, random_state = 1212)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023919,
+     "end_time": "2021-03-19T05:38:03.775037",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.751118",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "I use 0.3 as default score for test_size and X.shape for random_state so the data will be devided equally."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023793,
+     "end_time": "2021-03-19T05:38:03.822815",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.799022",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Define Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023731,
+     "end_time": "2021-03-19T05:38:03.871290",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.847559",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "I use 3 Boosting Algorithms Models:\n",
+    "* Ada Boost Classifier\n",
+    "* Gradient Boosting Classifier\n",
+    "* XGB Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.927028Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.926229Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.929154Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.929616Z"
+    },
+    "papermill": {
+     "duration": 0.034442,
+     "end_time": "2021-03-19T05:38:03.929828",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.895386",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "adaboost = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212)\n",
+    "pipe_ada = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('adaboost', adaboost)])\n",
+    "\n",
+    "gradboost = GradientBoostingClassifier(random_state = 1212)\n",
+    "pipe_grad = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('gradboost', gradboost)])\n",
+    "\n",
+    "XGBOOST = XGBClassifier(random_state = 1212)\n",
+    "pipe_XGB = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('XGBOOST', XGBOOST)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023691,
+     "end_time": "2021-03-19T05:38:03.977709",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.954018",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Cross Validation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023661,
+     "end_time": "2021-03-19T05:38:04.025361",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:04.001700",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Model Evaluation*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:04.081401Z",
+     "iopub.status.busy": "2021-03-19T05:38:04.080271Z",
+     "iopub.status.idle": "2021-03-19T05:38:44.672230Z",
+     "shell.execute_reply": "2021-03-19T05:38:44.672845Z"
+    },
+    "papermill": {
+     "duration": 40.623782,
+     "end_time": "2021-03-19T05:38:44.673057",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:04.049275",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def model_evaluation(model, metric):\n",
+    "    skfold = StratifiedKFold(n_splits = 5)\n",
+    "    model_cv = cross_val_score(model, X_train, y_train, cv = skfold, scoring = metric)\n",
+    "    return model_cv\n",
+    "\n",
+    "pipe_ada_cv = model_evaluation(pipe_ada, 'f1')\n",
+    "pipe_grad_cv = model_evaluation(pipe_grad, 'f1')\n",
+    "pipe_XGB_cv = model_evaluation(pipe_XGB, 'f1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.025351,
+     "end_time": "2021-03-19T05:38:44.725538",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:44.700187",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Fitting Data*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:44.789205Z",
+     "iopub.status.busy": "2021-03-19T05:38:44.788134Z",
+     "iopub.status.idle": "2021-03-19T05:38:53.398606Z",
+     "shell.execute_reply": "2021-03-19T05:38:53.398036Z"
+    },
+    "papermill": {
+     "duration": 8.647612,
+     "end_time": "2021-03-19T05:38:53.398853",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:44.751241",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "for model in [pipe_ada, pipe_grad, pipe_XGB]:\n",
+    "    model.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.025784,
+     "end_time": "2021-03-19T05:38:53.451009",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.425225",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Summary*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:53.527446Z",
+     "iopub.status.busy": "2021-03-19T05:38:53.526733Z",
+     "iopub.status.idle": "2021-03-19T05:38:53.815303Z",
+     "shell.execute_reply": "2021-03-19T05:38:53.815805Z"
+    },
+    "papermill": {
+     "duration": 0.33887,
+     "end_time": "2021-03-19T05:38:53.815995",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.477125",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "score_mean = [pipe_ada_cv.mean(), pipe_grad_cv.mean(), pipe_XGB_cv.mean()]\n",
+    "score_std = [pipe_ada_cv.std(), pipe_grad_cv.std(), pipe_XGB_cv.std()]\n",
+    "score_f1 = [f1_score(y_test, pipe_ada.predict(X_test)),\n",
+    "            f1_score(y_test, pipe_grad.predict(X_test)), \n",
+    "            f1_score(y_test, pipe_XGB.predict(X_test))]\n",
+    "method_name = ['Ada Boost Classifier', 'Gradient Boost Classifier ',\n",
+    "              'XGB Classifier']\n",
+    "summary = pd.DataFrame({'method': method_name, 'mean score': score_mean,\n",
+    "                        'std score': score_std, 'f1 score': score_f1})\n",
+    "summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.026318,
+     "end_time": "2021-03-19T05:38:53.869169",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.842851",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "From these scores, **XGB Classifier is the best one** with the highest f1 score and mean score, also the lowest std score. Let's cross-check with the important features, see if the model is correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:53.944904Z",
+     "iopub.status.busy": "2021-03-19T05:38:53.929491Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.176548Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.175387Z"
+    },
+    "papermill": {
+     "duration": 0.28086,
+     "end_time": "2021-03-19T05:38:54.176735",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.895875",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "plot_roc_curve(pipe_XGB, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.027942,
+     "end_time": "2021-03-19T05:38:54.233278",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.205336",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Importance Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.295503Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.294857Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.297765Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.297092Z"
+    },
+    "papermill": {
+     "duration": 0.036542,
+     "end_time": "2021-03-19T05:38:54.297927",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.261385",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "features = list(pipe_ada[0].transformers_[0][1].get_feature_names()) + pipe_ada[0].transformers_[1][1][1].get_feature_names() + ['age', 'education.num', 'capital.gain', 'capital.loss', 'hours.per.week']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.358245Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.357625Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.792959Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.792423Z"
+    },
+    "papermill": {
+     "duration": 0.466676,
+     "end_time": "2021-03-19T05:38:54.793113",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.326437",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_ada = pd.DataFrame(pipe_ada[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_ada.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For Ada Boost Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.859604Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.858939Z",
+     "iopub.status.idle": "2021-03-19T05:38:55.286891Z",
+     "shell.execute_reply": "2021-03-19T05:38:55.286335Z"
+    },
+    "papermill": {
+     "duration": 0.464119,
+     "end_time": "2021-03-19T05:38:55.287039",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.822920",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_grad = pd.DataFrame(pipe_grad[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_grad.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For Gradient Boost Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:55.356257Z",
+     "iopub.status.busy": "2021-03-19T05:38:55.355583Z",
+     "iopub.status.idle": "2021-03-19T05:38:55.939126Z",
+     "shell.execute_reply": "2021-03-19T05:38:55.938530Z"
+    },
+    "papermill": {
+     "duration": 0.62115,
+     "end_time": "2021-03-19T05:38:55.939279",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:55.318129",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_XGB = pd.DataFrame(pipe_XGB[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_XGB.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For XGB Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.031945,
+     "end_time": "2021-03-19T05:38:56.003841",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:55.971896",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "From Importance Features Table, the **XGB Classifier can boost almost all the features**. It's has a consistency with the cross validation result. Now, see if the HyperParameter Tuning process can boost until getting the maximum score."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.03221,
+     "end_time": "2021-03-19T05:38:56.068184",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:56.035974",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# HyperParameter Tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:56.141374Z",
+     "iopub.status.busy": "2021-03-19T05:38:56.140625Z",
+     "iopub.status.idle": "2021-03-19T06:01:37.865510Z",
+     "shell.execute_reply": "2021-03-19T06:01:37.864282Z"
+    },
+    "papermill": {
+     "duration": 1361.765454,
+     "end_time": "2021-03-19T06:01:37.865698",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:56.100244",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "XGBOOST = XGBClassifier(random_state = 1212)\n",
+    "estimator = Pipeline([('transformer', transformer), ('XGBOOST', XGBOOST)])\n",
+    "\n",
+    "hyperparam_space = {\n",
+    "    'XGBOOST__learning_rate': [0.1, 0.05, 0.01, 0.005],\n",
+    "    'XGBOOST__n_estimators': [50, 100, 150, 200],\n",
+    "    'XGBOOST__max_depth': [3, 5, 7, 9]\n",
+    "}\n",
+    "\n",
+    "random = RandomizedSearchCV(\n",
+    "                estimator,\n",
+    "                param_distributions = hyperparam_space,\n",
+    "                cv = StratifiedKFold(n_splits = 5),\n",
+    "                scoring = 'f1',\n",
+    "                n_iter = 10,\n",
+    "                n_jobs = -1)\n",
+    "\n",
+    "random.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:37.939505Z",
+     "iopub.status.busy": "2021-03-19T06:01:37.938761Z",
+     "iopub.status.idle": "2021-03-19T06:01:37.942876Z",
+     "shell.execute_reply": "2021-03-19T06:01:37.942253Z"
+    },
+    "papermill": {
+     "duration": 0.043411,
+     "end_time": "2021-03-19T06:01:37.943017",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:37.899606",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "best score 0.7017567140030995\n",
+      "best param {'XGBOOST__n_estimators': 200, 'XGBOOST__max_depth': 9, 'XGBOOST__learning_rate': 0.05}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('best score', random.best_score_)\n",
+    "print('best param', random.best_params_)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.034769,
+     "end_time": "2021-03-19T06:01:38.011326",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:37.976557",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "After HyperParameter Tuning, the best score is 0.6996, which getting lower. N estimator is 150, Max depth is 5, and Learning rate is 0.1. Let's compare the result."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.033061,
+     "end_time": "2021-03-19T06:01:38.078046",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:38.044985",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Before VS After Tuning Comparison"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:38.173068Z",
+     "iopub.status.busy": "2021-03-19T06:01:38.164508Z",
+     "iopub.status.idle": "2021-03-19T06:01:39.914461Z",
+     "shell.execute_reply": "2021-03-19T06:01:39.915204Z"
+    },
+    "papermill": {
+     "duration": 1.803827,
+     "end_time": "2021-03-19T06:01:39.915379",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:38.111552",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[06:01:38] WARNING: ../src/learner.cc:1061: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.90      0.94      0.92      7417\n",
+      "           1       0.77      0.66      0.71      2352\n",
+      "\n",
+      "    accuracy                           0.87      9769\n",
+      "   macro avg       0.83      0.80      0.82      9769\n",
+      "weighted avg       0.87      0.87      0.87      9769\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "estimator.fit(X_train, y_train)\n",
+    "y_pred_estimator = estimator.predict(X_test)\n",
+    "print(classification_report(y_test, y_pred_estimator))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:39.991027Z",
+     "iopub.status.busy": "2021-03-19T06:01:39.990364Z",
+     "iopub.status.idle": "2021-03-19T06:01:45.312598Z",
+     "shell.execute_reply": "2021-03-19T06:01:45.311942Z"
+    },
+    "papermill": {
+     "duration": 5.363188,
+     "end_time": "2021-03-19T06:01:45.312764",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:39.949576",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[06:01:40] WARNING: ../src/learner.cc:1061: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.89      0.94      0.92      7417\n",
+      "           1       0.78      0.64      0.70      2352\n",
+      "\n",
+      "    accuracy                           0.87      9769\n",
+      "   macro avg       0.84      0.79      0.81      9769\n",
+      "weighted avg       0.86      0.87      0.87      9769\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "random.best_estimator_.fit(X_train, y_train)\n",
+    "y_pred_random = random.best_estimator_.predict(X_test)\n",
+    "print(classification_report(y_test, y_pred_random))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:45.389702Z",
+     "iopub.status.busy": "2021-03-19T06:01:45.388729Z",
+     "iopub.status.idle": "2021-03-19T06:01:45.407492Z",
+     "shell.execute_reply": "2021-03-19T06:01:45.406952Z"
+    },
+    "papermill": {
+     "duration": 0.05942,
+     "end_time": "2021-03-19T06:01:45.407632",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:45.348212",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "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>method</th>\n",
+       "      <th>f1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>XGB Classifier Before Tuning</td>\n",
+       "      <td>0.713175</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>XGB Classifier After Tuning</td>\n",
+       "      <td>0.703169</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                         method  f1 score\n",
+       "0  XGB Classifier Before Tuning  0.713175\n",
+       "1   XGB Classifier After Tuning  0.703169"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "score_list = [f1_score(y_test, y_pred_estimator), f1_score(y_test, y_pred_random)]\n",
+    "method_name = ['XGB Classifier Before Tuning', 'XGB Classifier After Tuning']\n",
+    "best_summary = pd.DataFrame({\n",
+    "    'method': method_name,\n",
+    "    'f1 score': score_list\n",
+    "})\n",
+    "best_summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.035589,
+     "end_time": "2021-03-19T06:01:45.478797",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:45.443208",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "After all, HyperParameter Tuning doesn't work good in this data. So if I have to choose, I pick the **XGB Classifier score Before Tuning, which is 0.71**. I know the number isn't good enough either because the data is imbalance and I don't process any resampling on it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fairness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This DataFrame is created to stock differents models and fair metrics that we produce in this notebook\n",
+    "algo_metrics = pd.DataFrame(columns=['model', 'fair_metrics', 'prediction', 'probs'])\n",
+    "\n",
+    "def add_to_df_algo_metrics(algo_metrics, model, fair_metrics, preds, probs, name):\n",
+    "    return algo_metrics.append(pd.DataFrame(data=[[model, fair_metrics, preds, probs]], columns=['model', 'fair_metrics', 'prediction', 'probs'], index=[name]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fair_metrics(dataset, pred, pred_is_dataset=False):\n",
+    "    if pred_is_dataset:\n",
+    "        dataset_pred = pred\n",
+    "    else:\n",
+    "        dataset_pred = dataset.copy()\n",
+    "        dataset_pred.labels = pred\n",
+    "    \n",
+    "    cols = ['statistical_parity_difference', 'equal_opportunity_difference', 'average_abs_odds_difference',  'disparate_impact', 'theil_index']\n",
+    "    obj_fairness = [[0,0,0,1,0]]\n",
+    "    \n",
+    "    fair_metrics = pd.DataFrame(data=obj_fairness, index=['objective'], columns=cols)\n",
+    "    \n",
+    "    for attr in dataset_pred.protected_attribute_names:\n",
+    "        idx = dataset_pred.protected_attribute_names.index(attr)\n",
+    "        privileged_groups =  [{attr:dataset_pred.privileged_protected_attributes[idx][0]}] \n",
+    "        unprivileged_groups = [{attr:dataset_pred.unprivileged_protected_attributes[idx][0]}] \n",
+    "        \n",
+    "        classified_metric = ClassificationMetric(dataset, \n",
+    "                                                     dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        metric_pred = BinaryLabelDatasetMetric(dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        acc = classified_metric.accuracy()\n",
+    "\n",
+    "        row = pd.DataFrame([[metric_pred.mean_difference(),\n",
+    "                                classified_metric.equal_opportunity_difference(),\n",
+    "                                classified_metric.average_abs_odds_difference(),\n",
+    "                                metric_pred.disparate_impact(),\n",
+    "                                classified_metric.theil_index()]],\n",
+    "                           columns  = cols,\n",
+    "                           index = [attr]\n",
+    "                          )\n",
+    "        fair_metrics = fair_metrics.append(row)    \n",
+    "    \n",
+    "    fair_metrics = fair_metrics.replace([-np.inf, np.inf], 2)\n",
+    "        \n",
+    "    return fair_metrics\n",
+    "\n",
+    "def plot_fair_metrics(fair_metrics):\n",
+    "    fig, ax = plt.subplots(figsize=(20,4), ncols=5, nrows=1)\n",
+    "\n",
+    "    plt.subplots_adjust(\n",
+    "        left    =  0.125, \n",
+    "        bottom  =  0.1, \n",
+    "        right   =  0.9, \n",
+    "        top     =  0.9, \n",
+    "        wspace  =  .5, \n",
+    "        hspace  =  1.1\n",
+    "    )\n",
+    "\n",
+    "    y_title_margin = 1.2\n",
+    "\n",
+    "    plt.suptitle(\"Fairness metrics\", y = 1.09, fontsize=20)\n",
+    "    sns.set(style=\"dark\")\n",
+    "\n",
+    "    cols = fair_metrics.columns.values\n",
+    "    obj = fair_metrics.loc['objective']\n",
+    "    size_rect = [0.2,0.2,0.2,0.4,0.25]\n",
+    "    rect = [-0.1,-0.1,-0.1,0.8,0]\n",
+    "    bottom = [-1,-1,-1,0,0]\n",
+    "    top = [1,1,1,2,1]\n",
+    "    bound = [[-0.1,0.1],[-0.1,0.1],[-0.1,0.1],[0.8,1.2],[0,0.25]]\n",
+    "\n",
+    "    display(Markdown(\"### Check bias metrics :\"))\n",
+    "    display(Markdown(\"A model can be considered bias if just one of these five metrics show that this model is biased.\"))\n",
+    "    for attr in fair_metrics.index[1:len(fair_metrics)].values:\n",
+    "        display(Markdown(\"#### For the %s attribute :\"%attr))\n",
+    "        check = [bound[i][0] < fair_metrics.loc[attr][i] < bound[i][1] for i in range(0,5)]\n",
+    "        display(Markdown(\"With default thresholds, bias against unprivileged group detected in **%d** out of 5 metrics\"%(5 - sum(check))))\n",
+    "\n",
+    "    for i in range(0,5):\n",
+    "        plt.subplot(1, 5, i+1)\n",
+    "        ax = sns.barplot(x=fair_metrics.index[1:len(fair_metrics)], y=fair_metrics.iloc[1:len(fair_metrics)][cols[i]])\n",
+    "        \n",
+    "        for j in range(0,len(fair_metrics)-1):\n",
+    "            a, val = ax.patches[j], fair_metrics.iloc[j+1][cols[i]]\n",
+    "            marg = -0.2 if val < 0 else 0.1\n",
+    "            ax.text(a.get_x()+a.get_width()/5, a.get_y()+a.get_height()+marg, round(val, 3), fontsize=15,color='black')\n",
+    "\n",
+    "        plt.ylim(bottom[i], top[i])\n",
+    "        plt.setp(ax.patches, linewidth=0)\n",
+    "        ax.add_patch(patches.Rectangle((-5,rect[i]), 10, size_rect[i], alpha=0.3, facecolor=\"green\", linewidth=1, linestyle='solid'))\n",
+    "        plt.axhline(obj[i], color='black', alpha=0.3)\n",
+    "        plt.title(cols[i])\n",
+    "        ax.set_ylabel('')    \n",
+    "        ax.set_xlabel('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_fair_metrics_and_plot(data, model, plot=False, model_aif=False):\n",
+    "    pred = model.predict(data).labels if model_aif else model.predict(data.features)\n",
+    "    # fair_metrics function available in the metrics.py file\n",
+    "    fair = fair_metrics(data, pred)\n",
+    "\n",
+    "    if plot:\n",
+    "        # plot_fair_metrics function available in the visualisations.py file\n",
+    "        # The visualisation of this function is inspired by the dashboard on the demo of IBM aif360 \n",
+    "        plot_fair_metrics(fair)\n",
+    "        display(fair)\n",
+    "    \n",
+    "    return fair"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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>workclass</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>Black</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>4</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Machine-op-inspct</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Separated</td>\n",
+       "      <td>Prof-specialty</td>\n",
+       "      <td>Own-child</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age workclass  education.num marital.status         occupation  \\\n",
+       "0   90       NaN              9        Widowed                NaN   \n",
+       "1   82   Private              9        Widowed    Exec-managerial   \n",
+       "2   66       NaN             10        Widowed                NaN   \n",
+       "3   54   Private              4       Divorced  Machine-op-inspct   \n",
+       "4   41   Private             10      Separated     Prof-specialty   \n",
+       "\n",
+       "    relationship   race  sex  capital.gain  capital.loss  hours.per.week  \\\n",
+       "0  Not-in-family  White    0             0          4356              40   \n",
+       "1  Not-in-family  White    0             0          4356              18   \n",
+       "2      Unmarried  Black    0             0          4356              40   \n",
+       "3      Unmarried  White    0             0          3900              40   \n",
+       "4      Own-child  White    0             0          3900              40   \n",
+       "\n",
+       "  native.country  income  \n",
+       "0  United-States       0  \n",
+       "1  United-States       0  \n",
+       "2  United-States       0  \n",
+       "3  United-States       0  \n",
+       "4  United-States       0  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##train['Sex'] = train['Sex'].map( {'female': 1, 'male': 0} ).astype(int)\n",
+    "adult_df = adult.drop(['fnlwgt', 'education'], axis = 1)\n",
+    "adult_df[\"income\"]=adult_df[\"income\"].map({\"<=50K\":0,\">50K\":1})\n",
+    "adult_df[\"sex\"] = adult_df[\"sex\"].map({\"Male\":1,\"Female\":0})\n",
+    "adult_df[\"workclass\"] = adult_df[\"workclass\"].replace(\"?\",np.nan)\n",
+    "adult_df[\"occupation\"] = adult_df[\"occupation\"].replace(\"?\",np.nan)\n",
+    "adult_df[\"native.country\"] = adult_df[\"native.country\"].replace(\"?\",np.nan)\n",
+    "adult_df.head()\n",
+    "#features = [\"Pclass\", \"Sex\", \"SibSp\", \"Parch\", \"Survived\"]\n",
+    "#X = pd.get_dummies(train_data[features])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adult_df[\"workclass\"] = adult_df[\"workclass\"].fillna(adult_df[\"workclass\"].mode()[0])\n",
+    "adult_df[\"occupation\"] = adult_df[\"occupation\"].fillna(adult_df[\"occupation\"].mode()[0])\n",
+    "adult_df[\"native.country\"] = adult_df[\"native.country\"].fillna(adult_df[\"native.country\"].mode()[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "workclass\n",
+      "marital.status\n",
+      "occupation\n",
+      "relationship\n",
+      "race\n",
+      "native.country\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn import preprocessing\n",
+    "\n",
+    "categorical = ['workclass', 'marital.status', 'occupation', 'relationship','race','native.country',]\n",
+    "for feature in categorical:\n",
+    "        print(feature)\n",
+    "        le = preprocessing.LabelEncoder()\n",
+    "        adult_df[feature] = le.fit_transform(adult_df[feature])\n",
+    "        #X_test[feature] = le.transform(X_test[feature])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "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>workclass</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "      <td>6</td>\n",
+       "      <td>9</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "      <td>6</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>3</td>\n",
+       "      <td>10</td>\n",
+       "      <td>6</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>3</td>\n",
+       "      <td>10</td>\n",
+       "      <td>5</td>\n",
+       "      <td>9</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age  workclass  education.num  marital.status  occupation  relationship  \\\n",
+       "0   90          3              9               6           9             1   \n",
+       "1   82          3              9               6           3             1   \n",
+       "2   66          3             10               6           9             4   \n",
+       "3   54          3              4               0           6             4   \n",
+       "4   41          3             10               5           9             3   \n",
+       "\n",
+       "   race  sex  capital.gain  capital.loss  hours.per.week  native.country  \\\n",
+       "0     4    0             0          4356              40              38   \n",
+       "1     4    0             0          4356              18              38   \n",
+       "2     2    0             0          4356              40              38   \n",
+       "3     4    0             0          3900              40              38   \n",
+       "4     4    0             0          3900              40              38   \n",
+       "\n",
+       "   income  \n",
+       "0       0  \n",
+       "1       0  \n",
+       "2       0  \n",
+       "3       0  \n",
+       "4       0  "
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "privileged_groups = [{'sex': 1}]\n",
+    "unprivileged_groups = [{'sex': 0}]\n",
+    "dataset_orig = StandardDataset(adult_df,\n",
+    "                                  label_name='income',\n",
+    "                                  protected_attribute_names=['sex'],\n",
+    "                                  favorable_classes=[1],\n",
+    "                                  privileged_classes=[[1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "#### Original training dataset"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Difference in mean outcomes between unprivileged and privileged groups = -0.196276\n"
+     ]
+    }
+   ],
+   "source": [
+    "metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "                                             unprivileged_groups=unprivileged_groups,\n",
+    "                                             privileged_groups=privileged_groups)\n",
+    "display(Markdown(\"#### Original training dataset\"))\n",
+    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ipynbname\n",
+    "nb_fname = ipynbname.name()\n",
+    "nb_path = ipynbname.path()\n",
+    "\n",
+    "from sklearn.ensemble import AdaBoostClassifier\n",
+    "import pickle\n",
+    "\n",
+    "data_orig_train, data_orig_test = dataset_orig.split([0.7], shuffle=True)\n",
+    "X_train = data_orig_train.features\n",
+    "y_train = data_orig_train.labels.ravel()\n",
+    "\n",
+    "X_test = data_orig_test.features\n",
+    "y_test = data_orig_test.labels.ravel()\n",
+    "num_estimators = 100\n",
+    "\n",
+    "model = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212, n_estimators= 1)\n",
+    "\n",
+    "mdl = model.fit(X_train, y_train)\n",
+    "with open('../../Results/AdaBoost/' + nb_fname + '.pkl', 'wb') as f:\n",
+    "        pickle.dump(mdl, f)\n",
+    "\n",
+    "with open('../../Results/AdaBoost/' + nb_fname + '_Train' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_train, f) \n",
+    "    \n",
+    "with open('../../Results/AdaBoost/' + nb_fname + '_Test' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_test, f) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from csv import writer\n",
+    "from sklearn.metrics import accuracy_score, f1_score\n",
+    "\n",
+    "final_metrics = []\n",
+    "accuracy = []\n",
+    "f1= []\n",
+    "\n",
+    "for i in range(1,num_estimators+1):\n",
+    "    \n",
+    "    model = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212, n_estimators= i)\n",
+    "    \n",
+    "    mdl = model.fit(X_train, y_train)\n",
+    "    yy = mdl.predict(X_test)\n",
+    "    accuracy.append(accuracy_score(y_test, yy))\n",
+    "    f1.append(f1_score(y_test, yy))\n",
+    "    fair = get_fair_metrics_and_plot(data_orig_test, mdl)                           \n",
+    "    fair_list = fair.iloc[1].tolist()\n",
+    "    #fair_list.insert(0, i)\n",
+    "    final_metrics.append(fair_list)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "           0         1         2         3         4\n",
+      "0  -0.183168 -0.076254  0.087144  0.380655  0.131560\n",
+      "1  -0.173759 -0.102515  0.092808  0.343206  0.134372\n",
+      "2  -0.187010 -0.061932  0.081091  0.377050  0.126129\n",
+      "3  -0.188524 -0.076409  0.087742  0.346592  0.126292\n",
+      "4  -0.186375 -0.066125  0.081767  0.352659  0.125458\n",
+      "..       ...       ...       ...       ...       ...\n",
+      "95 -0.205228 -0.191345  0.148209  0.268040  0.132411\n",
+      "96 -0.205689 -0.189028  0.147491  0.268399  0.132296\n",
+      "97 -0.205074 -0.188520  0.146859  0.268187  0.132236\n",
+      "98 -0.205533 -0.194170  0.149477  0.264534  0.132262\n",
+      "99 -0.204459 -0.191345  0.147658  0.268777  0.132264\n",
+      "\n",
+      "[100 rows x 5 columns]\n"
+     ]
+    },
+    {
+     "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>classifier</th>\n",
+       "      <th>T0</th>\n",
+       "      <th>T1</th>\n",
+       "      <th>T2</th>\n",
+       "      <th>T3</th>\n",
+       "      <th>T4</th>\n",
+       "      <th>T5</th>\n",
+       "      <th>T6</th>\n",
+       "      <th>T7</th>\n",
+       "      <th>T8</th>\n",
+       "      <th>...</th>\n",
+       "      <th>T90</th>\n",
+       "      <th>T91</th>\n",
+       "      <th>T92</th>\n",
+       "      <th>T93</th>\n",
+       "      <th>T94</th>\n",
+       "      <th>T95</th>\n",
+       "      <th>T96</th>\n",
+       "      <th>T97</th>\n",
+       "      <th>T98</th>\n",
+       "      <th>T99</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>accuracy</th>\n",
+       "      <td>0.825468</td>\n",
+       "      <td>0.812263</td>\n",
+       "      <td>0.825366</td>\n",
+       "      <td>0.818098</td>\n",
+       "      <td>0.825366</td>\n",
+       "      <td>0.826492</td>\n",
+       "      <td>0.826901</td>\n",
+       "      <td>0.825878</td>\n",
+       "      <td>0.829563</td>\n",
+       "      <td>0.831201</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.825775</td>\n",
+       "      <td>0.826287</td>\n",
+       "      <td>0.826901</td>\n",
+       "      <td>0.826083</td>\n",
+       "      <td>0.824547</td>\n",
+       "      <td>0.824956</td>\n",
+       "      <td>0.824752</td>\n",
+       "      <td>0.825264</td>\n",
+       "      <td>0.825775</td>\n",
+       "      <td>0.825468</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>f1</th>\n",
+       "      <td>0.611529</td>\n",
+       "      <td>0.602686</td>\n",
+       "      <td>0.607094</td>\n",
+       "      <td>0.617603</td>\n",
+       "      <td>0.623233</td>\n",
+       "      <td>0.625745</td>\n",
+       "      <td>0.625636</td>\n",
+       "      <td>0.623089</td>\n",
+       "      <td>0.619255</td>\n",
+       "      <td>0.622568</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.611416</td>\n",
+       "      <td>0.612292</td>\n",
+       "      <td>0.613132</td>\n",
+       "      <td>0.611480</td>\n",
+       "      <td>0.610455</td>\n",
+       "      <td>0.610833</td>\n",
+       "      <td>0.610909</td>\n",
+       "      <td>0.611427</td>\n",
+       "      <td>0.611770</td>\n",
+       "      <td>0.611529</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistical_parity_difference</th>\n",
+       "      <td>-0.204459</td>\n",
+       "      <td>-0.183168</td>\n",
+       "      <td>-0.173759</td>\n",
+       "      <td>-0.187010</td>\n",
+       "      <td>-0.188524</td>\n",
+       "      <td>-0.186375</td>\n",
+       "      <td>-0.186373</td>\n",
+       "      <td>-0.184378</td>\n",
+       "      <td>-0.173918</td>\n",
+       "      <td>-0.174685</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.201235</td>\n",
+       "      <td>-0.201235</td>\n",
+       "      <td>-0.199853</td>\n",
+       "      <td>-0.200160</td>\n",
+       "      <td>-0.202466</td>\n",
+       "      <td>-0.205228</td>\n",
+       "      <td>-0.205689</td>\n",
+       "      <td>-0.205074</td>\n",
+       "      <td>-0.205533</td>\n",
+       "      <td>-0.204459</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>equal_opportunity_difference</th>\n",
+       "      <td>-0.191345</td>\n",
+       "      <td>-0.076254</td>\n",
+       "      <td>-0.102515</td>\n",
+       "      <td>-0.061932</td>\n",
+       "      <td>-0.076409</td>\n",
+       "      <td>-0.066125</td>\n",
+       "      <td>-0.064094</td>\n",
+       "      <td>-0.050543</td>\n",
+       "      <td>-0.064137</td>\n",
+       "      <td>-0.063850</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.189822</td>\n",
+       "      <td>-0.190330</td>\n",
+       "      <td>-0.190330</td>\n",
+       "      <td>-0.192139</td>\n",
+       "      <td>-0.181855</td>\n",
+       "      <td>-0.191345</td>\n",
+       "      <td>-0.189028</td>\n",
+       "      <td>-0.188520</td>\n",
+       "      <td>-0.194170</td>\n",
+       "      <td>-0.191345</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>average_abs_odds_difference</th>\n",
+       "      <td>0.147658</td>\n",
+       "      <td>0.087144</td>\n",
+       "      <td>0.092808</td>\n",
+       "      <td>0.081091</td>\n",
+       "      <td>0.087742</td>\n",
+       "      <td>0.081767</td>\n",
+       "      <td>0.080999</td>\n",
+       "      <td>0.074554</td>\n",
+       "      <td>0.075044</td>\n",
+       "      <td>0.074928</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.145107</td>\n",
+       "      <td>0.145203</td>\n",
+       "      <td>0.144259</td>\n",
+       "      <td>0.145433</td>\n",
+       "      <td>0.142604</td>\n",
+       "      <td>0.148209</td>\n",
+       "      <td>0.147491</td>\n",
+       "      <td>0.146859</td>\n",
+       "      <td>0.149477</td>\n",
+       "      <td>0.147658</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>disparate_impact</th>\n",
+       "      <td>-1.313875</td>\n",
+       "      <td>-0.965861</td>\n",
+       "      <td>-1.069424</td>\n",
+       "      <td>-0.975379</td>\n",
+       "      <td>-1.059607</td>\n",
+       "      <td>-1.042253</td>\n",
+       "      <td>-1.050134</td>\n",
+       "      <td>-1.037243</td>\n",
+       "      <td>-1.048319</td>\n",
+       "      <td>-1.057598</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-1.290512</td>\n",
+       "      <td>-1.293428</td>\n",
+       "      <td>-1.285519</td>\n",
+       "      <td>-1.286630</td>\n",
+       "      <td>-1.283391</td>\n",
+       "      <td>-1.316618</td>\n",
+       "      <td>-1.315281</td>\n",
+       "      <td>-1.316070</td>\n",
+       "      <td>-1.329787</td>\n",
+       "      <td>-1.313875</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>theil_index</th>\n",
+       "      <td>0.132264</td>\n",
+       "      <td>0.131560</td>\n",
+       "      <td>0.134372</td>\n",
+       "      <td>0.126129</td>\n",
+       "      <td>0.126292</td>\n",
+       "      <td>0.125458</td>\n",
+       "      <td>0.125693</td>\n",
+       "      <td>0.126586</td>\n",
+       "      <td>0.130037</td>\n",
+       "      <td>0.129040</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.132435</td>\n",
+       "      <td>0.132200</td>\n",
+       "      <td>0.132021</td>\n",
+       "      <td>0.132519</td>\n",
+       "      <td>0.132442</td>\n",
+       "      <td>0.132411</td>\n",
+       "      <td>0.132296</td>\n",
+       "      <td>0.132236</td>\n",
+       "      <td>0.132262</td>\n",
+       "      <td>0.132264</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>7 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               classifier        T0        T1        T2  \\\n",
+       "accuracy                         0.825468  0.812263  0.825366  0.818098   \n",
+       "f1                               0.611529  0.602686  0.607094  0.617603   \n",
+       "statistical_parity_difference   -0.204459 -0.183168 -0.173759 -0.187010   \n",
+       "equal_opportunity_difference    -0.191345 -0.076254 -0.102515 -0.061932   \n",
+       "average_abs_odds_difference      0.147658  0.087144  0.092808  0.081091   \n",
+       "disparate_impact                -1.313875 -0.965861 -1.069424 -0.975379   \n",
+       "theil_index                      0.132264  0.131560  0.134372  0.126129   \n",
+       "\n",
+       "                                     T3        T4        T5        T6  \\\n",
+       "accuracy                       0.825366  0.826492  0.826901  0.825878   \n",
+       "f1                             0.623233  0.625745  0.625636  0.623089   \n",
+       "statistical_parity_difference -0.188524 -0.186375 -0.186373 -0.184378   \n",
+       "equal_opportunity_difference  -0.076409 -0.066125 -0.064094 -0.050543   \n",
+       "average_abs_odds_difference    0.087742  0.081767  0.080999  0.074554   \n",
+       "disparate_impact              -1.059607 -1.042253 -1.050134 -1.037243   \n",
+       "theil_index                    0.126292  0.125458  0.125693  0.126586   \n",
+       "\n",
+       "                                     T7        T8  ...       T90       T91  \\\n",
+       "accuracy                       0.829563  0.831201  ...  0.825775  0.826287   \n",
+       "f1                             0.619255  0.622568  ...  0.611416  0.612292   \n",
+       "statistical_parity_difference -0.173918 -0.174685  ... -0.201235 -0.201235   \n",
+       "equal_opportunity_difference  -0.064137 -0.063850  ... -0.189822 -0.190330   \n",
+       "average_abs_odds_difference    0.075044  0.074928  ...  0.145107  0.145203   \n",
+       "disparate_impact              -1.048319 -1.057598  ... -1.290512 -1.293428   \n",
+       "theil_index                    0.130037  0.129040  ...  0.132435  0.132200   \n",
+       "\n",
+       "                                    T92       T93       T94       T95  \\\n",
+       "accuracy                       0.826901  0.826083  0.824547  0.824956   \n",
+       "f1                             0.613132  0.611480  0.610455  0.610833   \n",
+       "statistical_parity_difference -0.199853 -0.200160 -0.202466 -0.205228   \n",
+       "equal_opportunity_difference  -0.190330 -0.192139 -0.181855 -0.191345   \n",
+       "average_abs_odds_difference    0.144259  0.145433  0.142604  0.148209   \n",
+       "disparate_impact              -1.285519 -1.286630 -1.283391 -1.316618   \n",
+       "theil_index                    0.132021  0.132519  0.132442  0.132411   \n",
+       "\n",
+       "                                    T96       T97       T98       T99  \n",
+       "accuracy                       0.824752  0.825264  0.825775  0.825468  \n",
+       "f1                             0.610909  0.611427  0.611770  0.611529  \n",
+       "statistical_parity_difference -0.205689 -0.205074 -0.205533 -0.204459  \n",
+       "equal_opportunity_difference  -0.189028 -0.188520 -0.194170 -0.191345  \n",
+       "average_abs_odds_difference    0.147491  0.146859  0.149477  0.147658  \n",
+       "disparate_impact              -1.315281 -1.316070 -1.329787 -1.313875  \n",
+       "theil_index                    0.132296  0.132236  0.132262  0.132264  \n",
+       "\n",
+       "[7 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "final_result = pd.DataFrame(final_metrics)\n",
+    "print(final_result)\n",
+    "final_result[3] = np.log(final_result[3])\n",
+    "final_result = final_result.transpose()\n",
+    "acc_f1 = pd.DataFrame(accuracy)\n",
+    "acc_f1['f1'] = f1\n",
+    "acc_f1 = pd.DataFrame(acc_f1).transpose()\n",
+    "acc = acc_f1.rename(index={0: 'accuracy', 1: 'f1'})\n",
+    "final_result = final_result.rename(index={0: 'statistical_parity_difference', 1: 'equal_opportunity_difference', 2: 'average_abs_odds_difference', 3: 'disparate_impact', 4: 'theil_index'})\n",
+    "final_result = pd.concat([acc,final_result])\n",
+    "final_result.columns = ['T' + str(col) for col in final_result.columns]\n",
+    "final_result.insert(0, \"classifier\", final_result['T' + str(num_estimators - 1)])   ##Add final metrics add the beginning of the df\n",
+    "final_result.to_csv('../../Results/AdaBoost/' + nb_fname + '.csv')\n",
+    "final_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 1432.173477,
+   "end_time": "2021-03-19T06:01:46.424650",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2021-03-19T05:37:54.251173",
+   "version": "2.2.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

AdultNoteBook/Kernels/AdaBoost/1-adult-income.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56b26b047c35cd5c6fb4d43768b35b1f6ed4f7bffbdd7e03346c923e78e5ae4b
+size 17588574

AdultNoteBook/Kernels/AdaBoost/1-adult-income.py

@@ -0,0 +1,638 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# <p id="part0"></p>
+# 
+# <p style="font-family: Arials; line-height: 2; font-size: 24px; font-weight: bold; letter-spacing: 2px; text-align: center; color: #FF8C00">Adult Income 💸🤑💰 </p>
+# 
+# <img src="https://miro.medium.com/max/1000/1*08ltbgXFxujakJZSJswp1Q.png" width="100%" align="center" hspace="5%" vspace="5%"/>
+# 
+# <p style = "font-family: Inter, sans-serif; font-size: 14px; color: rgba(0,0,0,.7)"> An individual’s annual income results from various factors. Intuitively, it is influenced by the individual’s education level, age, gender, occupation, and etc.</p>
+# 
+# 
+# <p style="font-family: Arials; font-size: 20px; font-style: normal; font-weight: bold; letter-spacing: 3px; color: #808080; line-height:1.0">TABLE OF CONTENT</p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part1" style="color:#808080">0 PROLOGUE</a></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part2" style="color:#808080">1 IMPORTING LIBRARIES</a></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part3" style="color:#808080">2 DATA DESCRIPTION AND DATA CLEANING</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3">
+# <a href="#part4" style="color:#808080">2.1 Import Data</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3">
+# <a href="#part5" style="color:#808080">2.2 Data types</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3">
+# <a href="#part6" style="color:#808080">2.3 Missing values</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"> 
+# <a href="#part7" style="color:#808080">2.4 Duplicates</a></p>
+# 
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part8" style="color:#808080">3 ANALYSIS</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"> 
+# <a href="#part9" style="color:#808080">3.1 Uni-Vriate Analysis:</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"> 
+# <a href="#part10" style="color:#808080">3.2 Bi-Vriate Analysis:</a></p>
+# 
+# <p style="text-indent: 1vw; font-family: Arials; font-size: 14px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"> 
+# <a href="#part11" style="color:#808080">3.3 Multi-Vriate Analysis:</a></p>
+# 
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part12" style="color:#808080">4 FINAL CONCLUSIONS</a></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 2px; color: #808080; line-height:1.3"><a href="#part13" style="color:#808080">5 MODELLING</a></p>
+
+# <p id="part1"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: bold; font-weight: bold; letter-spacing: 3px; color: #FF8C00">0 PROLOGUE</p>
+# <hr style="height: 0.5px; border: 0; background-color: #808080">
+# 
+# 
+# 
+# <p style="font-family: Arials, sans-serif; font-size: 14px; color: rgba(0,0,0,.7)"><strong>FEATURES:</strong></p>
+# 
+# <ol style="font-family: Arials, sans-serif; font-size: 14px; line-height:1.5; color: rgba(0,0,0,.7)">
+# <li><strong>AGE</strong> -continuous. </li>
+# <p></p>    
+# <li><strong> workclass</strong> -Private, Self-emp-not-inc, Self-emp-inc, Federal-gov, Local-gov, State-gov, Without-pay, Never-worked.</li>
+# <p></p>
+# <li><strong>fnlwgt</strong> -continuous.</li>
+# <p></p>    
+# <li><strong>education</strong> - Bachelors, Some-college, 11th, HS-grad, Prof-school, Assoc-acdm, Assoc-voc, 9th, 7th-8th, 12th, Masters, 1st-4th, 10th, Doctorate, 5th-6th, Preschool.</li>   
+# <p></p>    
+# <li><strong>education-num</strong> - continuous.</li>   
+# <p></p>    
+# <li><strong>marital-status</strong> -Married-civ-spouse, Divorced, Never-married, Separated, Widowed, Married-spouse-absent, Married-AF-spouse.</li>    
+# <p></p>    
+# <li><strong>occupation</strong> -Tech-support, Craft-repair, Other-service, Sales, Exec-managerial, Prof-specialty, Handlers-cleaners, Machine-op-inspct, Adm-clerical, Farming-fishing, Transport-moving, Priv-house-serv, Protective-serv, Armed-Forces.</li>      
+# <p></p>     
+# <li><strong>relationship</strong> -Wife, Own-child, Husband, Not-in-family, Other-relative, Unmarried.</li>    
+# <p></p> 
+# <li><strong>race</strong> -White, Asian-Pac-Islander, Amer-Indian-Eskimo, Other, Black.</li>    
+# <p></p> 
+# <li><strong>sex</strong> -Female, Male.</li>    
+# <p></p>
+# <li><strong>capital-gain</strong> -continuous.</li>    
+# <p></p> 
+# <li><strong>capital-loss</strong> -continuous.</li>    
+# <p></p>
+# <li><strong>hours-per-week</strong> -continuous.</li>    
+# <p></p>
+# <li><strong>native-country</strong> -United-States, Cambodia, England, Puerto-Rico, Canada, Germany, Outlying-US(Guam-USVI-etc), India, Japan, Greece, South, China, Cuba, Iran, Honduras, Philippines, Italy, Poland, Jamaica, Vietnam, Mexico, Portugal, Ireland, France, Dominican-Republic, Laos, Ecuador, Taiwan, Haiti, Columbia, Hungary, Guatemala, Nicaragua, Scotland, Thailand, Yugoslavia, El-Salvador, Trinadad&Tobago, Peru, Hong, Holand-Netherlands.</li>    
+# <p></p>
+# <li><strong>class</strong> - >50K, <=50K</li>    
+# <p></p>
+#    
+# </ol>
+# 
+# 
+# 
+# 
+
+# <p style="font-family: Arials; line-height: 1.5; font-size: 16px; font-weight: bold; letter-spacing: 2px; text-align: center; color: #FF8C00">If you liked this notebook, please upvote.</p>
+# <p style="text-align: center">😊😊😊</p>
+
+# <p id="part2"></p>
+# 
+# # <span style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 3px; color: #FF8C00">1 IMPORTING LIBRARIES</span>
+# <hr style="height: 0.5px; border: 0; background-color: #808080">
+# 
+# <p style="font-family: Arials, sans-serif; font-size: 14px; line-height:1.0; color: rgba(0,0,0,.7)"><strong>LIBRARIES:</strong></p>
+# 
+# <ol style="font-family: Arials, sans-serif; font-size: 14px; line-height:1.5; color: rgba(0,0,0,.7)">
+# <li>Library <strong>pandas</strong> will be required to work with data in tabular representation.</li>
+# <p></p>
+# <li>Library <strong>numpy</strong> will be required to round the data in the correlation matrix.</li>
+# <p></p>
+# <li>Library <strong>missingno</strong> will be required to visualize missing values in the data.</li>
+# <p></p>   
+# <li>Library <strong>matplotlib, seaborn, plotly</strong> required for data visualization.</li>
+# <p></p>
+# </ol>
+
+# In[1]:
+
+
+## for eda and visuls:
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import plotly.express as px
+import missingno
+import matplotlib.pyplot as plt
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+
+
+
+# <p id="part3"></p>
+# 
+# # <span style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: bold; letter-spacing: 3px; color: #FF8C00">2 DATA DESCRIPTION AND DATA CLEANING</span>
+# <hr style="height: 0.5px; border: 0; background-color: #808080">
+# 
+# <p style="font-family: Arials, sans-serif; font-size: 14px; color: rgba(0,0,0,.7)">In this block, cleaning part will be carried out, data types, missing values, duplicates.</p>
+
+# <p id="part4"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">2.1 Import Data</p>
+
+# In[2]:
+
+
+# Reading Data:
+df=pd.read_csv("/kaggle/input/adult-census-income/adult.csv")
+df.head()  #Loading the First Five Rows:
+
+
+# In[3]:
+
+
+# Let's Look The Dimensions Of The Data:
+print(f'The Data-Set Contain {df.shape[0]} Rows and {df.shape[1]} Columns')
+
+
+# <p id="part5"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">2.2 Data Types</p>
+
+# In[4]:
+
+
+#Check Data Types
+df.dtypes
+
+
+# <p id="part6"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">2.3 Missing values</p>
+
+# <p style = "font-family: Inter, sans-serif; font-size: 14px; color: rgba(0,0,0,.7)"> Let's calculate the percentage of blanks and filled values for all columns.</p>
+
+# In[5]:
+
+
+# loop through the columns and check the missing values
+for col in df.columns:
+    pct_missing = df[col].isnull().sum()
+    print(f'{col} - {pct_missing :.1%}')
+
+
+# In[6]:
+
+
+# Build a matrix of missing values
+missingno.matrix(df, fontsize = 16)
+plt.show()
+
+
+# <div style="background: #DCDCDC"><p style="font-family: Arials, sans-serif; font-size: 16px; color: #000000"><strong>CONCLUSION:</strong> The data has no missing values, so no further transformations are required.</p></div>
+
+# <p id="part7"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">2.4 Duplicates</p>
+
+# In[7]:
+
+
+#Check The Duplicates In the Data-Set:
+df.duplicated().sum()
+
+
+# <p style = "font-family: Inter, sans-serif; font-size: 14px; color: rgba(0,0,0,.7)">There are 24 Duplicate Value Present in the Data-set.</p>
+
+# In[8]:
+
+
+# We will drop the Duplicate value:
+df=df.drop_duplicates(keep="first")
+
+
+# ### In some columns there is ? present or null values let's handle that also:
+
+# In[9]:
+
+
+df["workclass"]=df["workclass"].replace("?",np.nan)
+df["occupation"]=df["occupation"].replace("?",np.nan)
+df["native.country"]=df["native.country"].replace("?",np.nan)
+
+
+# In[10]:
+
+
+df.isna().sum()
+
+
+# In[11]:
+
+
+df["workclass"]=df["workclass"].fillna(df["workclass"].mode()[0])
+df["occupation"]=df["occupation"].fillna(df["occupation"].mode()[0])
+df["native.country"]=df["native.country"].fillna(df["native.country"].mode()[0])
+
+
+# <div style="background: #DCDCDC"><p style="font-family: Arials, sans-serif; font-size: 16px; color: #000000"><strong>CONCLUSION:</strong>Now our Data is Clean We can do Further Analysis.</p></div>
+
+# <p id="part8"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">3. Analysis:</p>
+
+# <p id="part9"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">3.1 Uni-variate Analysis:</p>
+
+# In[12]:
+
+
+fig =  plt.figure(figsize = (15,6))
+fig.patch.set_facecolor('#f5f6f6')
+
+
+                                                   
+gs = fig.add_gridspec(2,3)
+gs.update(wspace=0.2,hspace= 0.2)
+
+ax0 = fig.add_subplot(gs[0,0])
+ax1 = fig.add_subplot(gs[0,1])
+ax2 = fig.add_subplot(gs[0,2])
+ax3 = fig.add_subplot(gs[1,0])
+ax4 = fig.add_subplot(gs[1,1])
+ax5 = fig.add_subplot(gs[1,2])
+
+axes=[ax0,ax1,ax2,ax3,ax4,ax5]
+for ax in axes:
+    ax.set_facecolor('#f5f6f6')
+    ax.tick_params(axis='x',
+                   labelsize = 12, which = 'major',
+                   direction = 'out',pad = 2,
+                   length = 1.5)
+    ax.tick_params(axis='y', colors= 'black')
+    ax.axes.get_yaxis().set_visible(False)
+    
+    for loc in ['left', 'right', 'top', 'bottom']:
+        ax.spines[loc].set_visible(False)
+
+
+        
+cols = df.select_dtypes(exclude = 'object').columns
+
+sns.kdeplot(x = df[cols[0]],color="green",fill=True,ax = ax0)
+sns.kdeplot(x = df[cols[1]],color="red",fill=True,ax = ax1)
+sns.kdeplot(x = df[cols[2]],color="blue",fill=True,ax = ax2)
+sns.kdeplot(x = df[cols[3]],color="black",fill=True,ax = ax3)
+sns.kdeplot(x = df[cols[4]],color="pink",fill=True,ax = ax4)
+sns.kdeplot(x = df[cols[5]],color="green",fill=True,ax = ax5)
+
+fig.text(0.2,0.98,"Univariate Analysis on Numerical Columns:",**{'font':'serif', 'size':18,'weight':'bold'}, alpha = 1)
+fig.text(0.1,0.90,"Most of the adults are range of 20-45 and on average an adult spend around 40hrs per week on work\n Also as we can see there is so much otliers present in the numerical columns:",**{'font':'serif', 'size':12,'weight':'bold'}, alpha = 1)
+
+
+# In[13]:
+
+
+df.select_dtypes(include="object").columns
+
+
+# In[14]:
+
+
+income=df["income"].reset_index()
+px.pie(values=income["index"],names=income["income"], color_discrete_sequence=px.colors.sequential.RdBu,
+      title='Income of the Adults')
+
+
+# In[15]:
+
+
+sex=df["sex"].reset_index()
+px.pie(values=sex["index"],names=sex["sex"],title='%AGE OF MALE AND FEMALE', hole=.3)
+
+
+# In[16]:
+
+
+race=df["race"].reset_index()
+px.pie(values=race["index"],names=race["race"])
+
+
+# In[17]:
+
+
+relationship=df["relationship"].reset_index()
+px.pie(values=relationship["index"],names=relationship["relationship"])
+
+
+# In[18]:
+
+
+occupation=df["occupation"].reset_index()
+px.pie(values=occupation["index"],names=occupation["occupation"])
+
+
+# In[19]:
+
+
+marital_status=df["marital.status"].reset_index()
+px.pie(values=marital_status["index"],names=marital_status["marital.status"])
+
+
+# In[20]:
+
+
+education=df["education"].reset_index()
+px.pie(values=education["index"],names=education["education"])
+
+
+# In[21]:
+
+
+
+fig=plt.figure(figsize=(10,6))
+ax=sns.countplot(df["workclass"])
+plt.title("COUNT OF WORK CLASS")
+
+for loc in ['left', 'right', 'top', 'bottom']:
+    ax.spines[loc].set_visible(False)
+    
+
+fig.show()
+
+#workcls=df["workclass"].reset_index()
+#px.pie(values=workcls["index"],names=workcls["workclass"])
+
+
+# <p id="part10"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">3.2 Bi-Variate Analysis:</p>
+
+# In[22]:
+
+
+df.head(1)
+
+
+# In[23]:
+
+
+fig=plt.figure(figsize=(10,6))
+ax=sns.kdeplot(x=df["age"],hue=df["income"],fill=True)
+ax.set_facecolor('#f5f6f6')
+for loc in ['left', 'right', 'top', 'bottom']:
+    ax.spines[loc].set_visible(False)
+ 
+fig.text(0.4,1,"Distribution of income with age:",**{'font':'serif', 'size':18,'weight':'bold'}, alpha = 1)
+fig.text(0.1,0.90,"First of all most of the adults have income less than 50k \n But With increasing in age Income is also increasing :",**{'font':'serif', 'size':12,}, alpha = 1)
+
+
+fig.show()
+
+
+# In[24]:
+
+
+fig=plt.figure(figsize=(10,6))
+ax=sns.kdeplot(x=df["education.num"],hue=df["income"],fill=True,)
+ax.set_facecolor('#f5f6f6')
+for loc in ['left', 'right', 'top', 'bottom']:
+    ax.spines[loc].set_visible(False)
+ 
+fig.text(0.2,1,"Distribution of Number of years of Education with Income:",**{'font':'serif', 'size':18,'weight':'bold'}, alpha = 1)
+fig.text(0.1,0.90,"With increasing in years of education Income is also increasing :",**{'font':'serif', 'size':12,'weight':'bold'}, alpha = 1)
+
+
+fig.show()
+
+
+# <p id="part11"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: normal; font-weight: normal; letter-spacing: 3px; color: #FF8C00; line-height:1.0">3.3 Multi-Variate Analysis:</p>
+
+# <p id="part13"></p>
+# 
+# <p style="font-family: Arials; font-size: 16px; font-style: bold; font-weight: bold; letter-spacing: 3px; color: #FF8C00; line-height:1.0">5. Modelling:</p>
+# 
+# 
+
+# <p style="font-family: Arials; font-size: 16px; font-style: bold; font-weight: bold; letter-spacing: 3px; color: #FF8C00; line-height:1.0">5.0 Make data ready for Modelling:</p>
+
+# In[25]:
+
+
+df.income.unique()
+
+
+# In[26]:
+
+
+df["income"]=df["income"].map({"<=50K":0,">50K":1})
+
+
+# In[27]:
+
+
+X = df.drop(['income'], axis=1)
+y = df['income']
+
+
+# In[28]:
+
+
+from sklearn.model_selection import train_test_split
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 42)
+
+
+# In[29]:
+
+
+from sklearn import preprocessing
+
+categorical = ['workclass','education', 'marital.status', 'occupation', 'relationship','race', 'sex','native.country',]
+for feature in categorical:
+        le = preprocessing.LabelEncoder()
+        X_train[feature] = le.fit_transform(X_train[feature])
+        X_test[feature] = le.transform(X_test[feature])
+
+
+# In[30]:
+
+
+
+from sklearn.preprocessing import StandardScaler
+
+scaler = StandardScaler()
+
+X_train = pd.DataFrame(scaler.fit_transform(X_train), columns = X.columns)
+
+X_test = pd.DataFrame(scaler.transform(X_test), columns = X.columns)
+
+
+# ## Random forest
+
+# In[31]:
+
+
+from sklearn.ensemble import RandomForestClassifier
+random_forest = RandomForestClassifier(n_estimators=100)
+random_forest.fit(X_train, y_train)
+y_pred = random_forest.predict(X_test)
+
+from sklearn import metrics
+print(metrics.classification_report(y_test,y_pred))
+
+
+# ## knn
+
+# from sklearn.neighbors import KNeighborsClassifier
+# neig = np.arange(1, 25)
+# train_accuracy = []
+# test_accuracy = []
+# # Loop over different values of k
+# for i, k in enumerate(neig):
+#     # k from 1 to 25(exclude)
+#     knn = KNeighborsClassifier(n_neighbors=k)
+#     # Fit with knn
+#     knn.fit(X_train,y_train)
+#     #train accuracy
+#     train_accuracy.append(knn.score(X_train, y_train))
+#     # test accuracy
+#     test_accuracy.append(knn.score(X_test, y_test))
+# 
+# # Plot
+# plt.figure(figsize=[13,8])
+# plt.plot(neig, test_accuracy, label = 'Testing Accuracy')
+# plt.plot(neig, train_accuracy, label = 'Training Accuracy')
+# plt.legend()
+# plt.title('-value VS Accuracy')
+# plt.xlabel('Number of Neighbors')
+# plt.ylabel('Accuracy')
+# plt.xticks(neig)
+# plt.savefig('graph.png')
+# plt.show()
+# print("Best accuracy is {} with K = {}".format(np.max(test_accuracy),1+test_accuracy.index(np.max(test_accuracy))))
+
+# In[32]:
+
+
+
+from sklearn.linear_model import LogisticRegression
+model=LogisticRegression()
+model.fit(X_train,y_train)
+
+y_test_pred=model.predict(X_test)
+from sklearn import metrics
+print(metrics.classification_report(y_test,y_pred))
+
+
+# In[33]:
+
+
+from sklearn.metrics import accuracy_score
+
+
+# In[34]:
+
+
+test_score = accuracy_score(y_test, model.predict(X_test)) * 100
+train_score = accuracy_score(y_train, model.predict(X_train)) * 100
+
+results_df = pd.DataFrame(data=[["Logistic Regression", train_score, test_score]], 
+                          columns=['Model', 'Training Accuracy %', 'Testing Accuracy %'])
+results_df
+
+
+# In[35]:
+
+
+from sklearn.tree import DecisionTreeClassifier
+model=DecisionTreeClassifier()
+model.fit(X_train,y_train)
+dt=model.predict(X_test)
+from sklearn import metrics
+print(metrics.classification_report(y_test,y_pred))
+
+
+# In[36]:
+
+
+from sklearn.svm import SVC
+model=SVC(kernel="rbf")
+model.fit(X_train,y_train)
+sv=model.predict(X_test)
+from sklearn import metrics
+print(metrics.classification_report(y_test,y_pred))
+
+
+# In[37]:
+
+
+from sklearn.ensemble import AdaBoostClassifier
+
+model=AdaBoostClassifier(learning_rate= 0.15,n_estimators= 25)
+model.fit(X_train,y_train)
+ab=model.predict(X_test)
+from sklearn import metrics
+print(metrics.classification_report(y_test,y_pred))
+
+
+# ## hyper para meter tuning:
+
+# In[38]:
+
+
+from sklearn.model_selection import GridSearchCV
+
+
+# In[39]:
+
+
+clf = DecisionTreeClassifier()
+# Hyperparameter Optimization
+parameters = {'max_features': ['log2', 'sqrt','auto'], 
+              'criterion': ['entropy', 'gini'],
+              'max_depth': [2, 3, 5, 10, 50], 
+              'min_samples_split': [2, 3, 50, 100],
+              'min_samples_leaf': [1, 5, 8, 10]
+             }
+
+# Run the grid search
+grid_obj = GridSearchCV(clf, parameters)
+grid_obj = grid_obj.fit(X_train, y_train)
+
+# Set the clf to the best combination of parameters
+clf = grid_obj.best_estimator_
+
+# Train the model using the training sets 
+clf.fit(X_train, y_train)
+
+
+# In[40]:
+
+
+y_pred = clf.predict(X_test)
+
+
+# In[41]:
+
+
+# Calculating the accuracy
+acc_dt = round( metrics.accuracy_score(y_test, y_pred) * 100, 2 )
+print( 'Accuracy of Decision Tree model : ', acc_dt )
+
+
+# <p style="font-family: Arials; line-height: 1.5; font-size: 16px; font-weight: bold; letter-spacing: 2px; text-align: center; color: #FF8C00">Thank you for reading this work!
+# Any feedback on this work would be very grateful.
+# If you liked this notebook, Upvote.</p>
+#     <p style="text-align: center">😊😊😊</p>
+
+# In[ ]:
+
+
+
+

AdultNoteBook/Kernels/AdaBoost/2-boosting-algorithms-model-for-adult-census-income.ipynb

@@ -0,0 +1,2199 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:00.573511Z",
+     "iopub.status.busy": "2021-03-19T05:38:00.572716Z",
+     "iopub.status.idle": "2021-03-19T05:38:02.804511Z",
+     "shell.execute_reply": "2021-03-19T05:38:02.803821Z"
+    },
+    "papermill": {
+     "duration": 2.263268,
+     "end_time": "2021-03-19T05:38:02.804744",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:00.541476",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.preprocessing import OneHotEncoder\n",
+    "import category_encoders as ce\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.compose import ColumnTransformer\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, StratifiedKFold, cross_val_score\n",
+    "\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier\n",
+    "from xgboost.sklearn import XGBClassifier\n",
+    "from sklearn.metrics import classification_report, f1_score, plot_roc_curve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aif360.datasets import StandardDataset\n",
+    "from aif360.metrics import BinaryLabelDatasetMetric, ClassificationMetric\n",
+    "import matplotlib.patches as patches\n",
+    "from aif360.algorithms.preprocessing import Reweighing\n",
+    "#from packages import *\n",
+    "#from ml_fairness import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "\n",
+    "\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:02.853355Z",
+     "iopub.status.busy": "2021-03-19T05:38:02.852585Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.027399Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.026828Z"
+    },
+    "papermill": {
+     "duration": 0.200945,
+     "end_time": "2021-03-19T05:38:03.027547",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:02.826602",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "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>workclass</th>\n",
+       "      <th>fnlwgt</th>\n",
+       "      <th>education</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>5898</th>\n",
+       "      <td>35</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>28160</td>\n",
+       "      <td>Bachelors</td>\n",
+       "      <td>13</td>\n",
+       "      <td>Married-spouse-absent</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      age workclass  fnlwgt  education  education.num         marital.status  \\\n",
+       "5898   35   Private   28160  Bachelors             13  Married-spouse-absent   \n",
+       "\n",
+       "           occupation relationship   race     sex  capital.gain  capital.loss  \\\n",
+       "5898  Exec-managerial    Unmarried  White  Female             0             0   \n",
+       "\n",
+       "      hours.per.week native.country income  \n",
+       "5898              40  United-States  <=50K  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult = pd.read_csv('../../Data/adult.csv')\n",
+    "adult.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.108677Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.108008Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.125920Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.125335Z"
+    },
+    "papermill": {
+     "duration": 0.076114,
+     "end_time": "2021-03-19T05:38:03.126077",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.049963",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 32561 entries, 0 to 32560\n",
+      "Data columns (total 15 columns):\n",
+      " #   Column          Non-Null Count  Dtype \n",
+      "---  ------          --------------  ----- \n",
+      " 0   age             32561 non-null  int64 \n",
+      " 1   workclass       32561 non-null  object\n",
+      " 2   fnlwgt          32561 non-null  int64 \n",
+      " 3   education       32561 non-null  object\n",
+      " 4   education.num   32561 non-null  int64 \n",
+      " 5   marital.status  32561 non-null  object\n",
+      " 6   occupation      32561 non-null  object\n",
+      " 7   relationship    32561 non-null  object\n",
+      " 8   race            32561 non-null  object\n",
+      " 9   sex             32561 non-null  object\n",
+      " 10  capital.gain    32561 non-null  int64 \n",
+      " 11  capital.loss    32561 non-null  int64 \n",
+      " 12  hours.per.week  32561 non-null  int64 \n",
+      " 13  native.country  32561 non-null  object\n",
+      " 14  income          32561 non-null  object\n",
+      "dtypes: int64(6), object(9)\n",
+      "memory usage: 3.7+ MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "adult.info()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022213,
+     "end_time": "2021-03-19T05:38:03.171196",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.148983",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*In this info detail, indicate that there is no missing value at all. But if you see the whole data carefully, you will find **missing value with '?'**.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023501,
+     "end_time": "2021-03-19T05:38:03.217098",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.193597",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# PreProcessing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022005,
+     "end_time": "2021-03-19T05:38:03.261561",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.239556",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Preprocessing scheme:*\n",
+    "* Encode all columns\n",
+    "* Drop education because it's already encoded on education.num\n",
+    "* Drop fnlwgt because it's unique"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022184,
+     "end_time": "2021-03-19T05:38:03.306152",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.283968",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Handling Missing Value In Pipeline*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.356440Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.355434Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.361557Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.362164Z"
+    },
+    "papermill": {
+     "duration": 0.033769,
+     "end_time": "2021-03-19T05:38:03.362348",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.328579",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "binary_encoder_pipe = Pipeline([\n",
+    "    ('imputer', SimpleImputer(strategy = 'constant', fill_value = 'NC', missing_values = '?')),\n",
+    "    ('binary', ce.BinaryEncoder())\n",
+    "])\n",
+    "\n",
+    "transformer = ColumnTransformer([\n",
+    "    ('one hot', OneHotEncoder(drop = 'first'), ['relationship', 'race', 'sex']),\n",
+    "    ('binary', binary_encoder_pipe, ['workclass', 'marital.status', 'occupation', 'native.country'])],\n",
+    "    remainder = 'passthrough')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.022265,
+     "end_time": "2021-03-19T05:38:03.407584",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.385319",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Splitting Data*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.456571Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.455612Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.470867Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.471412Z"
+    },
+    "papermill": {
+     "duration": 0.041355,
+     "end_time": "2021-03-19T05:38:03.471590",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.430235",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<=50K    24720\n",
+       ">50K      7841\n",
+       "Name: income, dtype: int64"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult['income'].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023083,
+     "end_time": "2021-03-19T05:38:03.517599",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.494516",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "Income is the target data and **indicated with imbalance data**. I define **income with 1 if income is >50K and 0 if income is <50K**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.568392Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.567403Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.580593Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.581142Z"
+    },
+    "papermill": {
+     "duration": 0.04025,
+     "end_time": "2021-03-19T05:38:03.581329",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.541079",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "X = adult.drop(['fnlwgt', 'education', 'income'], axis = 1)\n",
+    "y = np.where(adult['income'] == '>50K', 1, 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.632000Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.631007Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.637002Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.637530Z"
+    },
+    "papermill": {
+     "duration": 0.033104,
+     "end_time": "2021-03-19T05:38:03.637822",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.604718",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(32561, 12)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.689040Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.688033Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.726523Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.725847Z"
+    },
+    "papermill": {
+     "duration": 0.065514,
+     "end_time": "2021-03-19T05:38:03.726708",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.661194",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y,\n",
+    "                                                    test_size = 0.3, random_state = 1212)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023919,
+     "end_time": "2021-03-19T05:38:03.775037",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.751118",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "I use 0.3 as default score for test_size and X.shape for random_state so the data will be devided equally."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023793,
+     "end_time": "2021-03-19T05:38:03.822815",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.799022",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Define Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023731,
+     "end_time": "2021-03-19T05:38:03.871290",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.847559",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "I use 3 Boosting Algorithms Models:\n",
+    "* Ada Boost Classifier\n",
+    "* Gradient Boosting Classifier\n",
+    "* XGB Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:03.927028Z",
+     "iopub.status.busy": "2021-03-19T05:38:03.926229Z",
+     "iopub.status.idle": "2021-03-19T05:38:03.929154Z",
+     "shell.execute_reply": "2021-03-19T05:38:03.929616Z"
+    },
+    "papermill": {
+     "duration": 0.034442,
+     "end_time": "2021-03-19T05:38:03.929828",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.895386",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "adaboost = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212)\n",
+    "pipe_ada = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('adaboost', adaboost)])\n",
+    "\n",
+    "gradboost = GradientBoostingClassifier(random_state = 1212)\n",
+    "pipe_grad = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('gradboost', gradboost)])\n",
+    "\n",
+    "XGBOOST = XGBClassifier(random_state = 1212)\n",
+    "pipe_XGB = Pipeline([\n",
+    "    ('transformer', transformer),\n",
+    "    ('XGBOOST', XGBOOST)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023691,
+     "end_time": "2021-03-19T05:38:03.977709",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:03.954018",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Cross Validation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.023661,
+     "end_time": "2021-03-19T05:38:04.025361",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:04.001700",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Model Evaluation*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:04.081401Z",
+     "iopub.status.busy": "2021-03-19T05:38:04.080271Z",
+     "iopub.status.idle": "2021-03-19T05:38:44.672230Z",
+     "shell.execute_reply": "2021-03-19T05:38:44.672845Z"
+    },
+    "papermill": {
+     "duration": 40.623782,
+     "end_time": "2021-03-19T05:38:44.673057",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:04.049275",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def model_evaluation(model, metric):\n",
+    "    skfold = StratifiedKFold(n_splits = 5)\n",
+    "    model_cv = cross_val_score(model, X_train, y_train, cv = skfold, scoring = metric)\n",
+    "    return model_cv\n",
+    "\n",
+    "pipe_ada_cv = model_evaluation(pipe_ada, 'f1')\n",
+    "pipe_grad_cv = model_evaluation(pipe_grad, 'f1')\n",
+    "pipe_XGB_cv = model_evaluation(pipe_XGB, 'f1')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.025351,
+     "end_time": "2021-03-19T05:38:44.725538",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:44.700187",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Fitting Data*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:44.789205Z",
+     "iopub.status.busy": "2021-03-19T05:38:44.788134Z",
+     "iopub.status.idle": "2021-03-19T05:38:53.398606Z",
+     "shell.execute_reply": "2021-03-19T05:38:53.398036Z"
+    },
+    "papermill": {
+     "duration": 8.647612,
+     "end_time": "2021-03-19T05:38:53.398853",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:44.751241",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "for model in [pipe_ada, pipe_grad, pipe_XGB]:\n",
+    "    model.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.025784,
+     "end_time": "2021-03-19T05:38:53.451009",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.425225",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "*Summary*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:53.527446Z",
+     "iopub.status.busy": "2021-03-19T05:38:53.526733Z",
+     "iopub.status.idle": "2021-03-19T05:38:53.815303Z",
+     "shell.execute_reply": "2021-03-19T05:38:53.815805Z"
+    },
+    "papermill": {
+     "duration": 0.33887,
+     "end_time": "2021-03-19T05:38:53.815995",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.477125",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "score_mean = [pipe_ada_cv.mean(), pipe_grad_cv.mean(), pipe_XGB_cv.mean()]\n",
+    "score_std = [pipe_ada_cv.std(), pipe_grad_cv.std(), pipe_XGB_cv.std()]\n",
+    "score_f1 = [f1_score(y_test, pipe_ada.predict(X_test)),\n",
+    "            f1_score(y_test, pipe_grad.predict(X_test)), \n",
+    "            f1_score(y_test, pipe_XGB.predict(X_test))]\n",
+    "method_name = ['Ada Boost Classifier', 'Gradient Boost Classifier ',\n",
+    "              'XGB Classifier']\n",
+    "summary = pd.DataFrame({'method': method_name, 'mean score': score_mean,\n",
+    "                        'std score': score_std, 'f1 score': score_f1})\n",
+    "summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.026318,
+     "end_time": "2021-03-19T05:38:53.869169",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.842851",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "From these scores, **XGB Classifier is the best one** with the highest f1 score and mean score, also the lowest std score. Let's cross-check with the important features, see if the model is correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:53.944904Z",
+     "iopub.status.busy": "2021-03-19T05:38:53.929491Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.176548Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.175387Z"
+    },
+    "papermill": {
+     "duration": 0.28086,
+     "end_time": "2021-03-19T05:38:54.176735",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:53.895875",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "plot_roc_curve(pipe_XGB, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.027942,
+     "end_time": "2021-03-19T05:38:54.233278",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.205336",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Importance Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.295503Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.294857Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.297765Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.297092Z"
+    },
+    "papermill": {
+     "duration": 0.036542,
+     "end_time": "2021-03-19T05:38:54.297927",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.261385",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "features = list(pipe_ada[0].transformers_[0][1].get_feature_names()) + pipe_ada[0].transformers_[1][1][1].get_feature_names() + ['age', 'education.num', 'capital.gain', 'capital.loss', 'hours.per.week']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.358245Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.357625Z",
+     "iopub.status.idle": "2021-03-19T05:38:54.792959Z",
+     "shell.execute_reply": "2021-03-19T05:38:54.792423Z"
+    },
+    "papermill": {
+     "duration": 0.466676,
+     "end_time": "2021-03-19T05:38:54.793113",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.326437",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_ada = pd.DataFrame(pipe_ada[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_ada.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For Ada Boost Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:54.859604Z",
+     "iopub.status.busy": "2021-03-19T05:38:54.858939Z",
+     "iopub.status.idle": "2021-03-19T05:38:55.286891Z",
+     "shell.execute_reply": "2021-03-19T05:38:55.286335Z"
+    },
+    "papermill": {
+     "duration": 0.464119,
+     "end_time": "2021-03-19T05:38:55.287039",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:54.822920",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_grad = pd.DataFrame(pipe_grad[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_grad.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For Gradient Boost Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:55.356257Z",
+     "iopub.status.busy": "2021-03-19T05:38:55.355583Z",
+     "iopub.status.idle": "2021-03-19T05:38:55.939126Z",
+     "shell.execute_reply": "2021-03-19T05:38:55.938530Z"
+    },
+    "papermill": {
+     "duration": 0.62115,
+     "end_time": "2021-03-19T05:38:55.939279",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:55.318129",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imptab_XGB = pd.DataFrame(pipe_XGB[1].feature_importances_, columns = ['imp'], index = features)\n",
+    "imptab_XGB.sort_values('imp').plot(kind = 'barh', figsize = (15,8))\n",
+    "plt.title('Importance Table For XGB Classifier Model')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.031945,
+     "end_time": "2021-03-19T05:38:56.003841",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:55.971896",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "From Importance Features Table, the **XGB Classifier can boost almost all the features**. It's has a consistency with the cross validation result. Now, see if the HyperParameter Tuning process can boost until getting the maximum score."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.03221,
+     "end_time": "2021-03-19T05:38:56.068184",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:56.035974",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# HyperParameter Tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T05:38:56.141374Z",
+     "iopub.status.busy": "2021-03-19T05:38:56.140625Z",
+     "iopub.status.idle": "2021-03-19T06:01:37.865510Z",
+     "shell.execute_reply": "2021-03-19T06:01:37.864282Z"
+    },
+    "papermill": {
+     "duration": 1361.765454,
+     "end_time": "2021-03-19T06:01:37.865698",
+     "exception": false,
+     "start_time": "2021-03-19T05:38:56.100244",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "XGBOOST = XGBClassifier(random_state = 1212)\n",
+    "estimator = Pipeline([('transformer', transformer), ('XGBOOST', XGBOOST)])\n",
+    "\n",
+    "hyperparam_space = {\n",
+    "    'XGBOOST__learning_rate': [0.1, 0.05, 0.01, 0.005],\n",
+    "    'XGBOOST__n_estimators': [50, 100, 150, 200],\n",
+    "    'XGBOOST__max_depth': [3, 5, 7, 9]\n",
+    "}\n",
+    "\n",
+    "random = RandomizedSearchCV(\n",
+    "                estimator,\n",
+    "                param_distributions = hyperparam_space,\n",
+    "                cv = StratifiedKFold(n_splits = 5),\n",
+    "                scoring = 'f1',\n",
+    "                n_iter = 10,\n",
+    "                n_jobs = -1)\n",
+    "\n",
+    "random.fit(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:37.939505Z",
+     "iopub.status.busy": "2021-03-19T06:01:37.938761Z",
+     "iopub.status.idle": "2021-03-19T06:01:37.942876Z",
+     "shell.execute_reply": "2021-03-19T06:01:37.942253Z"
+    },
+    "papermill": {
+     "duration": 0.043411,
+     "end_time": "2021-03-19T06:01:37.943017",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:37.899606",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "best score 0.7017567140030995\n",
+      "best param {'XGBOOST__n_estimators': 200, 'XGBOOST__max_depth': 9, 'XGBOOST__learning_rate': 0.05}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('best score', random.best_score_)\n",
+    "print('best param', random.best_params_)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.034769,
+     "end_time": "2021-03-19T06:01:38.011326",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:37.976557",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "After HyperParameter Tuning, the best score is 0.6996, which getting lower. N estimator is 150, Max depth is 5, and Learning rate is 0.1. Let's compare the result."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.033061,
+     "end_time": "2021-03-19T06:01:38.078046",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:38.044985",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Before VS After Tuning Comparison"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:38.173068Z",
+     "iopub.status.busy": "2021-03-19T06:01:38.164508Z",
+     "iopub.status.idle": "2021-03-19T06:01:39.914461Z",
+     "shell.execute_reply": "2021-03-19T06:01:39.915204Z"
+    },
+    "papermill": {
+     "duration": 1.803827,
+     "end_time": "2021-03-19T06:01:39.915379",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:38.111552",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[06:01:38] WARNING: ../src/learner.cc:1061: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.90      0.94      0.92      7417\n",
+      "           1       0.77      0.66      0.71      2352\n",
+      "\n",
+      "    accuracy                           0.87      9769\n",
+      "   macro avg       0.83      0.80      0.82      9769\n",
+      "weighted avg       0.87      0.87      0.87      9769\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "estimator.fit(X_train, y_train)\n",
+    "y_pred_estimator = estimator.predict(X_test)\n",
+    "print(classification_report(y_test, y_pred_estimator))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:39.991027Z",
+     "iopub.status.busy": "2021-03-19T06:01:39.990364Z",
+     "iopub.status.idle": "2021-03-19T06:01:45.312598Z",
+     "shell.execute_reply": "2021-03-19T06:01:45.311942Z"
+    },
+    "papermill": {
+     "duration": 5.363188,
+     "end_time": "2021-03-19T06:01:45.312764",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:39.949576",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[06:01:40] WARNING: ../src/learner.cc:1061: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.89      0.94      0.92      7417\n",
+      "           1       0.78      0.64      0.70      2352\n",
+      "\n",
+      "    accuracy                           0.87      9769\n",
+      "   macro avg       0.84      0.79      0.81      9769\n",
+      "weighted avg       0.86      0.87      0.87      9769\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "random.best_estimator_.fit(X_train, y_train)\n",
+    "y_pred_random = random.best_estimator_.predict(X_test)\n",
+    "print(classification_report(y_test, y_pred_random))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-03-19T06:01:45.389702Z",
+     "iopub.status.busy": "2021-03-19T06:01:45.388729Z",
+     "iopub.status.idle": "2021-03-19T06:01:45.407492Z",
+     "shell.execute_reply": "2021-03-19T06:01:45.406952Z"
+    },
+    "papermill": {
+     "duration": 0.05942,
+     "end_time": "2021-03-19T06:01:45.407632",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:45.348212",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "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>method</th>\n",
+       "      <th>f1 score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>XGB Classifier Before Tuning</td>\n",
+       "      <td>0.713175</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>XGB Classifier After Tuning</td>\n",
+       "      <td>0.703169</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                         method  f1 score\n",
+       "0  XGB Classifier Before Tuning  0.713175\n",
+       "1   XGB Classifier After Tuning  0.703169"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "score_list = [f1_score(y_test, y_pred_estimator), f1_score(y_test, y_pred_random)]\n",
+    "method_name = ['XGB Classifier Before Tuning', 'XGB Classifier After Tuning']\n",
+    "best_summary = pd.DataFrame({\n",
+    "    'method': method_name,\n",
+    "    'f1 score': score_list\n",
+    "})\n",
+    "best_summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "papermill": {
+     "duration": 0.035589,
+     "end_time": "2021-03-19T06:01:45.478797",
+     "exception": false,
+     "start_time": "2021-03-19T06:01:45.443208",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "After all, HyperParameter Tuning doesn't work good in this data. So if I have to choose, I pick the **XGB Classifier score Before Tuning, which is 0.71**. I know the number isn't good enough either because the data is imbalance and I don't process any resampling on it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fairness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This DataFrame is created to stock differents models and fair metrics that we produce in this notebook\n",
+    "algo_metrics = pd.DataFrame(columns=['model', 'fair_metrics', 'prediction', 'probs'])\n",
+    "\n",
+    "def add_to_df_algo_metrics(algo_metrics, model, fair_metrics, preds, probs, name):\n",
+    "    return algo_metrics.append(pd.DataFrame(data=[[model, fair_metrics, preds, probs]], columns=['model', 'fair_metrics', 'prediction', 'probs'], index=[name]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fair_metrics(dataset, pred, pred_is_dataset=False):\n",
+    "    if pred_is_dataset:\n",
+    "        dataset_pred = pred\n",
+    "    else:\n",
+    "        dataset_pred = dataset.copy()\n",
+    "        dataset_pred.labels = pred\n",
+    "    \n",
+    "    cols = ['statistical_parity_difference', 'equal_opportunity_difference', 'average_abs_odds_difference',  'disparate_impact', 'theil_index']\n",
+    "    obj_fairness = [[0,0,0,1,0]]\n",
+    "    \n",
+    "    fair_metrics = pd.DataFrame(data=obj_fairness, index=['objective'], columns=cols)\n",
+    "    \n",
+    "    for attr in dataset_pred.protected_attribute_names:\n",
+    "        idx = dataset_pred.protected_attribute_names.index(attr)\n",
+    "        privileged_groups =  [{attr:dataset_pred.privileged_protected_attributes[idx][0]}] \n",
+    "        unprivileged_groups = [{attr:dataset_pred.unprivileged_protected_attributes[idx][0]}] \n",
+    "        \n",
+    "        classified_metric = ClassificationMetric(dataset, \n",
+    "                                                     dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        metric_pred = BinaryLabelDatasetMetric(dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        acc = classified_metric.accuracy()\n",
+    "\n",
+    "        row = pd.DataFrame([[metric_pred.mean_difference(),\n",
+    "                                classified_metric.equal_opportunity_difference(),\n",
+    "                                classified_metric.average_abs_odds_difference(),\n",
+    "                                metric_pred.disparate_impact(),\n",
+    "                                classified_metric.theil_index()]],\n",
+    "                           columns  = cols,\n",
+    "                           index = [attr]\n",
+    "                          )\n",
+    "        fair_metrics = fair_metrics.append(row)    \n",
+    "    \n",
+    "    fair_metrics = fair_metrics.replace([-np.inf, np.inf], 2)\n",
+    "        \n",
+    "    return fair_metrics\n",
+    "\n",
+    "def plot_fair_metrics(fair_metrics):\n",
+    "    fig, ax = plt.subplots(figsize=(20,4), ncols=5, nrows=1)\n",
+    "\n",
+    "    plt.subplots_adjust(\n",
+    "        left    =  0.125, \n",
+    "        bottom  =  0.1, \n",
+    "        right   =  0.9, \n",
+    "        top     =  0.9, \n",
+    "        wspace  =  .5, \n",
+    "        hspace  =  1.1\n",
+    "    )\n",
+    "\n",
+    "    y_title_margin = 1.2\n",
+    "\n",
+    "    plt.suptitle(\"Fairness metrics\", y = 1.09, fontsize=20)\n",
+    "    sns.set(style=\"dark\")\n",
+    "\n",
+    "    cols = fair_metrics.columns.values\n",
+    "    obj = fair_metrics.loc['objective']\n",
+    "    size_rect = [0.2,0.2,0.2,0.4,0.25]\n",
+    "    rect = [-0.1,-0.1,-0.1,0.8,0]\n",
+    "    bottom = [-1,-1,-1,0,0]\n",
+    "    top = [1,1,1,2,1]\n",
+    "    bound = [[-0.1,0.1],[-0.1,0.1],[-0.1,0.1],[0.8,1.2],[0,0.25]]\n",
+    "\n",
+    "    display(Markdown(\"### Check bias metrics :\"))\n",
+    "    display(Markdown(\"A model can be considered bias if just one of these five metrics show that this model is biased.\"))\n",
+    "    for attr in fair_metrics.index[1:len(fair_metrics)].values:\n",
+    "        display(Markdown(\"#### For the %s attribute :\"%attr))\n",
+    "        check = [bound[i][0] < fair_metrics.loc[attr][i] < bound[i][1] for i in range(0,5)]\n",
+    "        display(Markdown(\"With default thresholds, bias against unprivileged group detected in **%d** out of 5 metrics\"%(5 - sum(check))))\n",
+    "\n",
+    "    for i in range(0,5):\n",
+    "        plt.subplot(1, 5, i+1)\n",
+    "        ax = sns.barplot(x=fair_metrics.index[1:len(fair_metrics)], y=fair_metrics.iloc[1:len(fair_metrics)][cols[i]])\n",
+    "        \n",
+    "        for j in range(0,len(fair_metrics)-1):\n",
+    "            a, val = ax.patches[j], fair_metrics.iloc[j+1][cols[i]]\n",
+    "            marg = -0.2 if val < 0 else 0.1\n",
+    "            ax.text(a.get_x()+a.get_width()/5, a.get_y()+a.get_height()+marg, round(val, 3), fontsize=15,color='black')\n",
+    "\n",
+    "        plt.ylim(bottom[i], top[i])\n",
+    "        plt.setp(ax.patches, linewidth=0)\n",
+    "        ax.add_patch(patches.Rectangle((-5,rect[i]), 10, size_rect[i], alpha=0.3, facecolor=\"green\", linewidth=1, linestyle='solid'))\n",
+    "        plt.axhline(obj[i], color='black', alpha=0.3)\n",
+    "        plt.title(cols[i])\n",
+    "        ax.set_ylabel('')    \n",
+    "        ax.set_xlabel('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_fair_metrics_and_plot(data, model, plot=False, model_aif=False):\n",
+    "    pred = model.predict(data).labels if model_aif else model.predict(data.features)\n",
+    "    # fair_metrics function available in the metrics.py file\n",
+    "    fair = fair_metrics(data, pred)\n",
+    "\n",
+    "    if plot:\n",
+    "        # plot_fair_metrics function available in the visualisations.py file\n",
+    "        # The visualisation of this function is inspired by the dashboard on the demo of IBM aif360 \n",
+    "        plot_fair_metrics(fair)\n",
+    "        display(fair)\n",
+    "    \n",
+    "    return fair"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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>workclass</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>Black</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>4</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Machine-op-inspct</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Separated</td>\n",
+       "      <td>Prof-specialty</td>\n",
+       "      <td>Own-child</td>\n",
+       "      <td>White</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age workclass  education.num marital.status         occupation  \\\n",
+       "0   90       NaN              9        Widowed                NaN   \n",
+       "1   82   Private              9        Widowed    Exec-managerial   \n",
+       "2   66       NaN             10        Widowed                NaN   \n",
+       "3   54   Private              4       Divorced  Machine-op-inspct   \n",
+       "4   41   Private             10      Separated     Prof-specialty   \n",
+       "\n",
+       "    relationship   race  sex  capital.gain  capital.loss  hours.per.week  \\\n",
+       "0  Not-in-family  White    0             0          4356              40   \n",
+       "1  Not-in-family  White    0             0          4356              18   \n",
+       "2      Unmarried  Black    0             0          4356              40   \n",
+       "3      Unmarried  White    0             0          3900              40   \n",
+       "4      Own-child  White    0             0          3900              40   \n",
+       "\n",
+       "  native.country  income  \n",
+       "0  United-States       0  \n",
+       "1  United-States       0  \n",
+       "2  United-States       0  \n",
+       "3  United-States       0  \n",
+       "4  United-States       0  "
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##train['Sex'] = train['Sex'].map( {'female': 1, 'male': 0} ).astype(int)\n",
+    "adult_df = adult.drop(['fnlwgt', 'education'], axis = 1)\n",
+    "adult_df[\"income\"]=adult_df[\"income\"].map({\"<=50K\":0,\">50K\":1})\n",
+    "adult_df[\"sex\"] = adult_df[\"sex\"].map({\"Male\":1,\"Female\":0})\n",
+    "adult_df[\"workclass\"] = adult_df[\"workclass\"].replace(\"?\",np.nan)\n",
+    "adult_df[\"occupation\"] = adult_df[\"occupation\"].replace(\"?\",np.nan)\n",
+    "adult_df[\"native.country\"] = adult_df[\"native.country\"].replace(\"?\",np.nan)\n",
+    "adult_df.head()\n",
+    "#features = [\"Pclass\", \"Sex\", \"SibSp\", \"Parch\", \"Survived\"]\n",
+    "#X = pd.get_dummies(train_data[features])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adult_df[\"workclass\"] = adult_df[\"workclass\"].fillna(adult_df[\"workclass\"].mode()[0])\n",
+    "adult_df[\"occupation\"] = adult_df[\"occupation\"].fillna(adult_df[\"occupation\"].mode()[0])\n",
+    "adult_df[\"native.country\"] = adult_df[\"native.country\"].fillna(adult_df[\"native.country\"].mode()[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "workclass\n",
+      "marital.status\n",
+      "occupation\n",
+      "relationship\n",
+      "race\n",
+      "native.country\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn import preprocessing\n",
+    "\n",
+    "categorical = ['workclass', 'marital.status', 'occupation', 'relationship','race','native.country',]\n",
+    "for feature in categorical:\n",
+    "        print(feature)\n",
+    "        le = preprocessing.LabelEncoder()\n",
+    "        adult_df[feature] = le.fit_transform(adult_df[feature])\n",
+    "        #X_test[feature] = le.transform(X_test[feature])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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>workclass</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "      <td>6</td>\n",
+       "      <td>9</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "      <td>6</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>3</td>\n",
+       "      <td>10</td>\n",
+       "      <td>6</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>3</td>\n",
+       "      <td>10</td>\n",
+       "      <td>5</td>\n",
+       "      <td>9</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age  workclass  education.num  marital.status  occupation  relationship  \\\n",
+       "0   90          3              9               6           9             1   \n",
+       "1   82          3              9               6           3             1   \n",
+       "2   66          3             10               6           9             4   \n",
+       "3   54          3              4               0           6             4   \n",
+       "4   41          3             10               5           9             3   \n",
+       "\n",
+       "   race  sex  capital.gain  capital.loss  hours.per.week  native.country  \\\n",
+       "0     4    0             0          4356              40              38   \n",
+       "1     4    0             0          4356              18              38   \n",
+       "2     2    0             0          4356              40              38   \n",
+       "3     4    0             0          3900              40              38   \n",
+       "4     4    0             0          3900              40              38   \n",
+       "\n",
+       "   income  \n",
+       "0       0  \n",
+       "1       0  \n",
+       "2       0  \n",
+       "3       0  \n",
+       "4       0  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adult_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.21598015058404135, 0.0)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from scipy.stats import pearsonr\n",
+    "\n",
+    "pearsonr(adult_df['income'], adult_df['sex'])\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "privileged_groups = [{'sex': 1}]\n",
+    "unprivileged_groups = [{'sex': 0}]\n",
+    "dataset_orig = StandardDataset(adult_df,\n",
+    "                                  label_name='income',\n",
+    "                                  protected_attribute_names=['sex'],\n",
+    "                                  favorable_classes=[1],\n",
+    "                                  privileged_classes=[[1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "#### Original training dataset"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Difference in mean outcomes between unprivileged and privileged groups = -0.196276\n"
+     ]
+    }
+   ],
+   "source": [
+    "metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "                                             unprivileged_groups=unprivileged_groups,\n",
+    "                                             privileged_groups=privileged_groups)\n",
+    "display(Markdown(\"#### Original training dataset\"))\n",
+    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_orig_train = pd.read_pickle('../../Results/AdaBoost/2-boosting-algorithms-model-for-adult-census-income_Train.pkl')\n",
+    "data_orig_test = pd.read_pickle('../../Results/AdaBoost/2-boosting-algorithms-model-for-adult-census-income_Test.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ipynbname\n",
+    "nb_fname = ipynbname.name()\n",
+    "nb_path = ipynbname.path()\n",
+    "\n",
+    "from sklearn.ensemble import AdaBoostClassifier\n",
+    "import pickle\n",
+    "\n",
+    "#data_orig_train, data_orig_test = dataset_orig.split([0.7], shuffle=True)\n",
+    "X_train = data_orig_train.features\n",
+    "y_train = data_orig_train.labels.ravel()\n",
+    "\n",
+    "X_test = data_orig_test.features\n",
+    "y_test = data_orig_test.labels.ravel()\n",
+    "num_estimators = 100\n",
+    "\n",
+    "model = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212, n_estimators= 1)\n",
+    "\n",
+    "mdl = model.fit(X_train, y_train)\n",
+    "#with open('../../Results/AdaBoost/' + nb_fname + '.pkl', 'wb') as f:\n",
+    "#        pickle.dump(mdl, f)\n",
+    "\n",
+    "#with open('../../Results/AdaBoost/' + nb_fname + '_Train' + '.pkl', 'wb') as f:\n",
+    "#    pickle.dump(data_orig_train, f) \n",
+    "    \n",
+    "#with open('../../Results/AdaBoost/' + nb_fname + '_Test' + '.pkl', 'wb') as f:\n",
+    "#    pickle.dump(data_orig_test, f) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from csv import writer\n",
+    "from sklearn.metrics import accuracy_score, f1_score\n",
+    "\n",
+    "final_metrics = []\n",
+    "accuracy = []\n",
+    "f1= []\n",
+    "\n",
+    "for i in range(1,num_estimators+1):\n",
+    "    \n",
+    "    model = AdaBoostClassifier(DecisionTreeClassifier(criterion='entropy', splitter = 'random', max_depth = 1), random_state = 1212, n_estimators= i)\n",
+    "    \n",
+    "    mdl = model.fit(X_train, y_train)\n",
+    "    yy = mdl.predict(X_test)\n",
+    "    accuracy.append(accuracy_score(y_test, yy))\n",
+    "    f1.append(f1_score(y_test, yy))\n",
+    "    fair = get_fair_metrics_and_plot(data_orig_test, mdl)                           \n",
+    "    fair_list = fair.iloc[1].tolist()\n",
+    "    #fair_list.insert(0, i)\n",
+    "    final_metrics.append(fair_list)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "           0         1         2         3         4\n",
+      "0   0.000000  0.000000  0.000000       NaN  0.271671\n",
+      "1   0.000000  0.000000  0.000000       NaN  0.271671\n",
+      "2  -0.435397 -0.718274  0.515449  0.000000  0.140487\n",
+      "3  -0.021355 -0.012690  0.018903  0.000000  0.274012\n",
+      "4  -0.456752 -0.730964  0.534352  0.000000  0.139671\n",
+      "..       ...       ...       ...       ...       ...\n",
+      "95 -0.182016 -0.143454  0.111036  0.269581  0.126545\n",
+      "96 -0.182169 -0.145264  0.112051  0.268516  0.126926\n",
+      "97 -0.183398 -0.147294  0.113555  0.268094  0.126696\n",
+      "98 -0.183859 -0.147294  0.113837  0.266706  0.126696\n",
+      "99 -0.184166 -0.145485  0.113153  0.267274  0.126415\n",
+      "\n",
+      "[100 rows x 5 columns]\n"
+     ]
+    },
+    {
+     "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>classifier</th>\n",
+       "      <th>T0</th>\n",
+       "      <th>T1</th>\n",
+       "      <th>T2</th>\n",
+       "      <th>T3</th>\n",
+       "      <th>T4</th>\n",
+       "      <th>T5</th>\n",
+       "      <th>T6</th>\n",
+       "      <th>T7</th>\n",
+       "      <th>T8</th>\n",
+       "      <th>...</th>\n",
+       "      <th>T90</th>\n",
+       "      <th>T91</th>\n",
+       "      <th>T92</th>\n",
+       "      <th>T93</th>\n",
+       "      <th>T94</th>\n",
+       "      <th>T95</th>\n",
+       "      <th>T96</th>\n",
+       "      <th>T97</th>\n",
+       "      <th>T98</th>\n",
+       "      <th>T99</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>accuracy</th>\n",
+       "      <td>0.845941</td>\n",
+       "      <td>0.762105</td>\n",
+       "      <td>0.762105</td>\n",
+       "      <td>0.761695</td>\n",
+       "      <td>0.752994</td>\n",
+       "      <td>0.752585</td>\n",
+       "      <td>0.808169</td>\n",
+       "      <td>0.809499</td>\n",
+       "      <td>0.814208</td>\n",
+       "      <td>0.812673</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.846351</td>\n",
+       "      <td>0.845839</td>\n",
+       "      <td>0.845737</td>\n",
+       "      <td>0.845225</td>\n",
+       "      <td>0.845737</td>\n",
+       "      <td>0.846555</td>\n",
+       "      <td>0.846146</td>\n",
+       "      <td>0.845839</td>\n",
+       "      <td>0.845839</td>\n",
+       "      <td>0.845941</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>f1</th>\n",
+       "      <td>0.639866</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.548662</td>\n",
+       "      <td>0.020300</td>\n",
+       "      <td>0.543704</td>\n",
+       "      <td>0.443917</td>\n",
+       "      <td>0.449897</td>\n",
+       "      <td>0.503148</td>\n",
+       "      <td>0.482173</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.641509</td>\n",
+       "      <td>0.640057</td>\n",
+       "      <td>0.639560</td>\n",
+       "      <td>0.639485</td>\n",
+       "      <td>0.639215</td>\n",
+       "      <td>0.640096</td>\n",
+       "      <td>0.638962</td>\n",
+       "      <td>0.639195</td>\n",
+       "      <td>0.639195</td>\n",
+       "      <td>0.639866</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistical_parity_difference</th>\n",
+       "      <td>-0.184166</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-0.435397</td>\n",
+       "      <td>-0.021355</td>\n",
+       "      <td>-0.456752</td>\n",
+       "      <td>-0.160701</td>\n",
+       "      <td>-0.161317</td>\n",
+       "      <td>-0.202337</td>\n",
+       "      <td>-0.173927</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.184475</td>\n",
+       "      <td>-0.184474</td>\n",
+       "      <td>-0.184934</td>\n",
+       "      <td>-0.185090</td>\n",
+       "      <td>-0.183399</td>\n",
+       "      <td>-0.182016</td>\n",
+       "      <td>-0.182169</td>\n",
+       "      <td>-0.183398</td>\n",
+       "      <td>-0.183859</td>\n",
+       "      <td>-0.184166</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>equal_opportunity_difference</th>\n",
+       "      <td>-0.145485</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-0.718274</td>\n",
+       "      <td>-0.012690</td>\n",
+       "      <td>-0.730964</td>\n",
+       "      <td>-0.379695</td>\n",
+       "      <td>-0.376297</td>\n",
+       "      <td>-0.453168</td>\n",
+       "      <td>-0.365838</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.145198</td>\n",
+       "      <td>-0.146500</td>\n",
+       "      <td>-0.152149</td>\n",
+       "      <td>-0.147515</td>\n",
+       "      <td>-0.144469</td>\n",
+       "      <td>-0.143454</td>\n",
+       "      <td>-0.145264</td>\n",
+       "      <td>-0.147294</td>\n",
+       "      <td>-0.147294</td>\n",
+       "      <td>-0.145485</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>average_abs_odds_difference</th>\n",
+       "      <td>0.113153</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.515449</td>\n",
+       "      <td>0.018903</td>\n",
+       "      <td>0.534352</td>\n",
+       "      <td>0.222674</td>\n",
+       "      <td>0.220975</td>\n",
+       "      <td>0.271748</td>\n",
+       "      <td>0.220662</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.112947</td>\n",
+       "      <td>0.113709</td>\n",
+       "      <td>0.116423</td>\n",
+       "      <td>0.114533</td>\n",
+       "      <td>0.112363</td>\n",
+       "      <td>0.111036</td>\n",
+       "      <td>0.112051</td>\n",
+       "      <td>0.113555</td>\n",
+       "      <td>0.113837</td>\n",
+       "      <td>0.113153</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>disparate_impact</th>\n",
+       "      <td>-1.319479</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-inf</td>\n",
+       "      <td>-inf</td>\n",
+       "      <td>-inf</td>\n",
+       "      <td>-inf</td>\n",
+       "      <td>-5.172173</td>\n",
+       "      <td>-5.111415</td>\n",
+       "      <td>-3.127099</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-1.314049</td>\n",
+       "      <td>-1.317365</td>\n",
+       "      <td>-1.325888</td>\n",
+       "      <td>-1.313182</td>\n",
+       "      <td>-1.313088</td>\n",
+       "      <td>-1.310885</td>\n",
+       "      <td>-1.314845</td>\n",
+       "      <td>-1.316418</td>\n",
+       "      <td>-1.321608</td>\n",
+       "      <td>-1.319479</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>theil_index</th>\n",
+       "      <td>0.126415</td>\n",
+       "      <td>0.271671</td>\n",
+       "      <td>0.271671</td>\n",
+       "      <td>0.140487</td>\n",
+       "      <td>0.274012</td>\n",
+       "      <td>0.139671</td>\n",
+       "      <td>0.188861</td>\n",
+       "      <td>0.187256</td>\n",
+       "      <td>0.172201</td>\n",
+       "      <td>0.178419</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.125786</td>\n",
+       "      <td>0.126283</td>\n",
+       "      <td>0.126481</td>\n",
+       "      <td>0.126316</td>\n",
+       "      <td>0.126646</td>\n",
+       "      <td>0.126545</td>\n",
+       "      <td>0.126926</td>\n",
+       "      <td>0.126696</td>\n",
+       "      <td>0.126696</td>\n",
+       "      <td>0.126415</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>7 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               classifier        T0        T1        T2  \\\n",
+       "accuracy                         0.845941  0.762105  0.762105  0.761695   \n",
+       "f1                               0.639866  0.000000  0.000000  0.548662   \n",
+       "statistical_parity_difference   -0.184166  0.000000  0.000000 -0.435397   \n",
+       "equal_opportunity_difference    -0.145485  0.000000  0.000000 -0.718274   \n",
+       "average_abs_odds_difference      0.113153  0.000000  0.000000  0.515449   \n",
+       "disparate_impact                -1.319479       NaN       NaN      -inf   \n",
+       "theil_index                      0.126415  0.271671  0.271671  0.140487   \n",
+       "\n",
+       "                                     T3        T4        T5        T6  \\\n",
+       "accuracy                       0.752994  0.752585  0.808169  0.809499   \n",
+       "f1                             0.020300  0.543704  0.443917  0.449897   \n",
+       "statistical_parity_difference -0.021355 -0.456752 -0.160701 -0.161317   \n",
+       "equal_opportunity_difference  -0.012690 -0.730964 -0.379695 -0.376297   \n",
+       "average_abs_odds_difference    0.018903  0.534352  0.222674  0.220975   \n",
+       "disparate_impact                   -inf      -inf      -inf -5.172173   \n",
+       "theil_index                    0.274012  0.139671  0.188861  0.187256   \n",
+       "\n",
+       "                                     T7        T8  ...       T90       T91  \\\n",
+       "accuracy                       0.814208  0.812673  ...  0.846351  0.845839   \n",
+       "f1                             0.503148  0.482173  ...  0.641509  0.640057   \n",
+       "statistical_parity_difference -0.202337 -0.173927  ... -0.184475 -0.184474   \n",
+       "equal_opportunity_difference  -0.453168 -0.365838  ... -0.145198 -0.146500   \n",
+       "average_abs_odds_difference    0.271748  0.220662  ...  0.112947  0.113709   \n",
+       "disparate_impact              -5.111415 -3.127099  ... -1.314049 -1.317365   \n",
+       "theil_index                    0.172201  0.178419  ...  0.125786  0.126283   \n",
+       "\n",
+       "                                    T92       T93       T94       T95  \\\n",
+       "accuracy                       0.845737  0.845225  0.845737  0.846555   \n",
+       "f1                             0.639560  0.639485  0.639215  0.640096   \n",
+       "statistical_parity_difference -0.184934 -0.185090 -0.183399 -0.182016   \n",
+       "equal_opportunity_difference  -0.152149 -0.147515 -0.144469 -0.143454   \n",
+       "average_abs_odds_difference    0.116423  0.114533  0.112363  0.111036   \n",
+       "disparate_impact              -1.325888 -1.313182 -1.313088 -1.310885   \n",
+       "theil_index                    0.126481  0.126316  0.126646  0.126545   \n",
+       "\n",
+       "                                    T96       T97       T98       T99  \n",
+       "accuracy                       0.846146  0.845839  0.845839  0.845941  \n",
+       "f1                             0.638962  0.639195  0.639195  0.639866  \n",
+       "statistical_parity_difference -0.182169 -0.183398 -0.183859 -0.184166  \n",
+       "equal_opportunity_difference  -0.145264 -0.147294 -0.147294 -0.145485  \n",
+       "average_abs_odds_difference    0.112051  0.113555  0.113837  0.113153  \n",
+       "disparate_impact              -1.314845 -1.316418 -1.321608 -1.319479  \n",
+       "theil_index                    0.126926  0.126696  0.126696  0.126415  \n",
+       "\n",
+       "[7 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "final_result = pd.DataFrame(final_metrics)\n",
+    "print(final_result)\n",
+    "final_result[3] = np.log(final_result[3])\n",
+    "final_result = final_result.transpose()\n",
+    "acc_f1 = pd.DataFrame(accuracy)\n",
+    "acc_f1['f1'] = f1\n",
+    "acc_f1 = pd.DataFrame(acc_f1).transpose()\n",
+    "acc = acc_f1.rename(index={0: 'accuracy', 1: 'f1'})\n",
+    "final_result = final_result.rename(index={0: 'statistical_parity_difference', 1: 'equal_opportunity_difference', 2: 'average_abs_odds_difference', 3: 'disparate_impact', 4: 'theil_index'})\n",
+    "final_result = pd.concat([acc,final_result])\n",
+    "final_result.columns = ['T' + str(col) for col in final_result.columns]\n",
+    "final_result.insert(0, \"classifier\", final_result['T' + str(num_estimators - 1)])   ##Add final metrics add the beginning of the df\n",
+    "#final_result.to_csv('../../Results/AdaBoost/' + nb_fname + '.csv')\n",
+    "final_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 1432.173477,
+   "end_time": "2021-03-19T06:01:46.424650",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2021-03-19T05:37:54.251173",
+   "version": "2.2.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

AdultNoteBook/Kernels/AdaBoost/2-boosting-algorithms-model-for-adult-census-income.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder
+import category_encoders as ce
+from sklearn.impute import SimpleImputer
+from sklearn.compose import ColumnTransformer
+
+from sklearn.model_selection import train_test_split, RandomizedSearchCV, StratifiedKFold, cross_val_score
+
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
+from xgboost.sklearn import XGBClassifier
+from sklearn.metrics import classification_report, f1_score, plot_roc_curve
+
+
+# In[2]:
+
+
+adult = pd.read_csv('../input/adult-census-income/adult.csv')
+adult.sample()
+
+
+# In[3]:
+
+
+adult.info()
+
+
+# *In this info detail, indicate that there is no missing value at all. But if you see the whole data carefully, you will find **missing value with '?'**.*
+
+# # PreProcessing
+
+# *Preprocessing scheme:*
+# * Encode all columns
+# * Drop education because it's already encoded on education.num
+# * Drop fnlwgt because it's unique
+
+# *Handling Missing Value In Pipeline*
+
+# In[4]:
+
+
+binary_encoder_pipe = Pipeline([
+    ('imputer', SimpleImputer(strategy = 'constant', fill_value = 'NC', missing_values = '?')),
+    ('binary', ce.BinaryEncoder())
+])
+
+transformer = ColumnTransformer([
+    ('one hot', OneHotEncoder(drop = 'first'), ['relationship', 'race', 'sex']),
+    ('binary', binary_encoder_pipe, ['workclass', 'marital.status', 'occupation', 'native.country'])],
+    remainder = 'passthrough')
+
+
+# *Splitting Data*
+
+# In[5]:
+
+
+adult['income'].value_counts()
+
+
+# Income is the target data and **indicated with imbalance data**. I define **income with 1 if income is >50K and 0 if income is <50K**.
+
+# In[6]:
+
+
+X = adult.drop(['fnlwgt', 'education', 'income'], axis = 1)
+y = np.where(adult['income'] == '>50K', 1, 0)
+
+
+# In[7]:
+
+
+X.shape
+
+
+# In[8]:
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y,
+                                                    test_size = 0.3, random_state = 1212)
+
+
+# I use 0.3 as default score for test_size and X.shape for random_state so the data will be devided equally.
+
+# # Define Model
+
+# I use 3 Boosting Algorithms Models:
+# * Ada Boost Classifier
+# * Gradient Boosting Classifier
+# * XGB Classifier
+
+# In[9]:
+
+
+adaboost = AdaBoostClassifier(DecisionTreeClassifier(), random_state = 1212)
+pipe_ada = Pipeline([
+    ('transformer', transformer),
+    ('adaboost', adaboost)])
+
+gradboost = GradientBoostingClassifier(random_state = 1212)
+pipe_grad = Pipeline([
+    ('transformer', transformer),
+    ('gradboost', gradboost)])
+
+XGBOOST = XGBClassifier(random_state = 1212)
+pipe_XGB = Pipeline([
+    ('transformer', transformer),
+    ('XGBOOST', XGBOOST)])
+
+
+# # Cross Validation
+
+# *Model Evaluation*
+
+# In[10]:
+
+
+def model_evaluation(model, metric):
+    skfold = StratifiedKFold(n_splits = 5)
+    model_cv = cross_val_score(model, X_train, y_train, cv = skfold, scoring = metric)
+    return model_cv
+
+pipe_ada_cv = model_evaluation(pipe_ada, 'f1')
+pipe_grad_cv = model_evaluation(pipe_grad, 'f1')
+pipe_XGB_cv = model_evaluation(pipe_XGB, 'f1')
+
+
+# *Fitting Data*
+
+# In[11]:
+
+
+for model in [pipe_ada, pipe_grad, pipe_XGB]:
+    model.fit(X_train, y_train)
+
+
+# *Summary*
+
+# In[12]:
+
+
+score_mean = [pipe_ada_cv.mean(), pipe_grad_cv.mean(), pipe_XGB_cv.mean()]
+score_std = [pipe_ada_cv.std(), pipe_grad_cv.std(), pipe_XGB_cv.std()]
+score_f1 = [f1_score(y_test, pipe_ada.predict(X_test)),
+            f1_score(y_test, pipe_grad.predict(X_test)), 
+            f1_score(y_test, pipe_XGB.predict(X_test))]
+method_name = ['Ada Boost Classifier', 'Gradient Boost Classifier ',
+              'XGB Classifier']
+summary = pd.DataFrame({'method': method_name, 'mean score': score_mean,
+                        'std score': score_std, 'f1 score': score_f1})
+summary
+
+
+# From these scores, **XGB Classifier is the best one** with the highest f1 score and mean score, also the lowest std score. Let's cross-check with the important features, see if the model is correct.
+
+# In[13]:
+
+
+plot_roc_curve(pipe_XGB, X_test, y_test)
+
+
+# # Importance Features
+
+# In[14]:
+
+
+features = list(pipe_ada[0].transformers_[0][1].get_feature_names()) + pipe_ada[0].transformers_[1][1][1].get_feature_names() + ['age', 'education.num', 'capital.gain', 'capital.loss', 'hours.per.week']
+
+
+# In[15]:
+
+
+imptab_ada = pd.DataFrame(pipe_ada[1].feature_importances_, columns = ['imp'], index = features)
+imptab_ada.sort_values('imp').plot(kind = 'barh', figsize = (15,8))
+plt.title('Importance Table For Ada Boost Classifier Model')
+plt.show()
+
+
+# In[16]:
+
+
+imptab_grad = pd.DataFrame(pipe_grad[1].feature_importances_, columns = ['imp'], index = features)
+imptab_grad.sort_values('imp').plot(kind = 'barh', figsize = (15,8))
+plt.title('Importance Table For Gradient Boost Classifier Model')
+plt.show()
+
+
+# In[17]:
+
+
+imptab_XGB = pd.DataFrame(pipe_XGB[1].feature_importances_, columns = ['imp'], index = features)
+imptab_XGB.sort_values('imp').plot(kind = 'barh', figsize = (15,8))
+plt.title('Importance Table For XGB Classifier Model')
+plt.show()
+
+
+# From Importance Features Table, the **XGB Classifier can boost almost all the features**. It's has a consistency with the cross validation result. Now, see if the HyperParameter Tuning process can boost until getting the maximum score.
+
+# # HyperParameter Tuning
+
+# In[18]:
+
+
+XGBOOST = XGBClassifier(random_state = 1212)
+estimator = Pipeline([('transformer', transformer), ('XGBOOST', XGBOOST)])
+
+hyperparam_space = {
+    'XGBOOST__learning_rate': [0.1, 0.05, 0.01, 0.005],
+    'XGBOOST__n_estimators': [50, 100, 150, 200],
+    'XGBOOST__max_depth': [3, 5, 7, 9]
+}
+
+random = RandomizedSearchCV(
+                estimator,
+                param_distributions = hyperparam_space,
+                cv = StratifiedKFold(n_splits = 5),
+                scoring = 'f1',
+                n_iter = 10,
+                n_jobs = -1)
+
+random.fit(X_train, y_train)
+
+
+# In[19]:
+
+
+print('best score', random.best_score_)
+print('best param', random.best_params_)
+
+
+# After HyperParameter Tuning, the best score is 0.6996, which getting lower. N estimator is 150, Max depth is 5, and Learning rate is 0.1. Let's compare the result.
+
+# # Before VS After Tuning Comparison
+
+# In[20]:
+
+
+estimator.fit(X_train, y_train)
+y_pred_estimator = estimator.predict(X_test)
+print(classification_report(y_test, y_pred_estimator))
+
+
+# In[21]:
+
+
+random.best_estimator_.fit(X_train, y_train)
+y_pred_random = random.best_estimator_.predict(X_test)
+print(classification_report(y_test, y_pred_random))
+
+
+# In[22]:
+
+
+score_list = [f1_score(y_test, y_pred_estimator), f1_score(y_test, y_pred_random)]
+method_name = ['XGB Classifier Before Tuning', 'XGB Classifier After Tuning']
+best_summary = pd.DataFrame({
+    'method': method_name,
+    'f1 score': score_list
+})
+best_summary
+
+
+# After all, HyperParameter Tuning doesn't work good in this data. So if I have to choose, I pick the **XGB Classifier score Before Tuning, which is 0.71**. I know the number isn't good enough either because the data is imbalance and I don't process any resampling on it.

AdultNoteBook/Kernels/AdaBoost/4-deep-analysis-and-90-accuracy.py

@@ -0,0 +1,994 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[2]:
+
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px 
+import seaborn as sns
+import warnings
+warnings.filterwarnings('ignore')
+
+
+# In[3]:
+
+
+df=pd.read_csv('../input/adult-census-income/adult.csv')
+
+
+# # EDA
+
+# In[4]:
+
+
+df.head()
+
+
+# In[5]:
+
+
+df.shape
+
+
+# Dataset has 32561 rows and 15 columns.
+
+# In[6]:
+
+
+df.nunique()
+
+
+# Label column has only two categories, hence it is a problem of classification. There are no constant columns nor there are any identifier column.
+
+# In[7]:
+
+
+df.isnull().sum()
+
+
+# There are no null values in the dataset
+
+# In[8]:
+
+
+df.dtypes
+
+
+# There are 8 object type feautures rest of the features are of integer type.
+
+# In[9]:
+
+
+df.skew()
+
+
+# There is skewness present in the data which needs to be removed.
+
+# In[10]:
+
+
+df['income'].value_counts()
+
+
+# Dataset is imbalanced.
+
+# In[11]:
+
+
+df.describe()
+
+
+# All the columns are not present as they are of object type. Count of each column is 32561 showing there are no null values. Mean is very much greater than the median in capital gain and capital loss stating that there is high skewness present and data is skewed to the right side. Also there is high variance in Capital gain and Capital loss column. Min, Max, and interquartile ranges have variable difference, that means there are outliers present in the data.
+
+# ### Univariate Analysis
+
+# In[12]:
+
+
+plt.figure(figsize=(15,8))
+plt.subplot(1,2,1)
+df['income'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.subplot(1,2,2)
+sns.countplot(x='income',data=df)
+plt.ylabel('No. of People')
+df['income'].value_counts()
+
+
+# Dataset if highly imbalanced. There is less than 25% of >50K income category while more than 75% of <=50K income.
+
+# In[13]:
+
+
+#Separating categorical and continuous variables
+cat=[feature for feature in df.columns if df[feature].nunique()<45]
+cont=[feature for feature in df.columns if df[feature].nunique()>45]
+
+
+# In[14]:
+
+
+plt.figure(figsize=(15,15))
+plt.subplot(2,1,1)
+df['workclass'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(2,1,2)
+sns.countplot(x='workclass',data=df)
+plt.ylabel('No. of Individuals')
+df['workclass'].value_counts()
+
+
+# There are 9 workclass in total including Never worked and one unknown category(?).Most individuals work in private sector and there are very few who have never worked or work without pay. There are 3 categories of govt job provided state, federal and local among which no. of people working in the local govt is highest.
+
+# In[15]:
+
+
+plt.figure(figsize=(15,15))
+plt.subplot(2,1,1)
+df['education'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(2,1,2)
+sns.countplot(x='education',data=df)
+plt.xticks(rotation=45)
+plt.ylabel('No. of Individuals')
+df['education'].value_counts()
+
+
+# Most of the people are high school graduate. There are few who have done masters and doctorate. The no. of people who went through just the preschool or 1st to 4th is the least.
+
+# In[16]:
+
+
+plt.figure(figsize=(15,15))
+plt.subplot(2,1,1)
+df['education.num'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(2,1,2)
+sns.countplot(x='education.num',data=df)
+plt.ylabel('No. of Individuals')
+df['education.num'].value_counts()
+
+
+# Majority of individuals lie in the 9th 10th category of education no. which is a liitle higher than the median education number. People with least and highest educations are very few.
+
+# In[17]:
+
+
+plt.figure(figsize=(15,15))
+plt.subplot(2,1,1)
+df['marital.status'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(2,1,2)
+sns.countplot(x='marital.status',data=df)
+plt.ylabel('No. of Individuals')
+df['marital.status'].value_counts()
+
+
+# Majority of people are married to a civialian spouse or Never married. Least people are married to armed forces. From the above maritial status data we can see that there are less young people in the workforce as compared to young ones.
+
+# In[18]:
+
+
+plt.figure(figsize=(20,15))
+plt.subplot(2,1,1)
+df['occupation'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(2,1,2)
+sns.countplot(x='occupation',data=df)
+plt.xticks(rotation=45)
+plt.ylabel('No. of Individuals')
+df['occupation'].value_counts()
+
+
+# We can observe over here that prof-speciality has the highest number for people than any other occupation. followed by craft repair persons. Minimum occupation category is the armed forces with only 9 people in it. There is an unknown category of occupation too.
+
+# In[19]:
+
+
+plt.figure(figsize=(20,8))
+plt.subplot(1,2,1)
+df['relationship'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.ylabel('')
+plt.subplot(1,2,2)
+sns.countplot(x='relationship',data=df)
+plt.ylabel('No. of Individuals')
+df['relationship'].value_counts()
+
+
+# There are much more husband working than their wives. There are 25% individuals working who fall in not in family category.
+
+# In[20]:
+
+
+plt.figure(figsize=(20,8))
+plt.subplot(1,2,1)
+df['race'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.subplot(1,2,2)
+sns.countplot(x='race',data=df)
+plt.xticks(rotation=45)
+plt.ylabel('No. of Individuals')
+df['race'].value_counts()
+
+
+# SInce this is from european countries, most of the individuals working here are white. There is also an other category where minory races are present.
+
+# In[21]:
+
+
+plt.figure(figsize=(15,7))
+plt.subplot(1,2,1)
+df['sex'].value_counts().plot.pie(autopct='%1.1f%%')
+plt.subplot(1,2,2)
+sns.countplot(x='sex',data=df)
+plt.ylabel('No. of Individuals')
+df['sex'].value_counts()
+
+
+# There is more than double the number of men working than the no. of women.
+
+# In[22]:
+
+
+plt.figure(figsize=(15,8))
+sns.countplot(x='native.country',data=df)
+plt.xticks(rotation=90)
+plt.ylabel('No. of Individuals')
+df['native.country'].value_counts()
+
+
+# Majority of the people working belong from U.S. whereas there are people who come to U.S. from their own countries but there no. is very low. Second highest no. of people belong from Mexico as it is a neighboring country.
+
+# In[23]:
+
+
+plt.figure(figsize=(8,6))
+sns.histplot(df['age'],kde=True,color='r')
+plt.ylabel('No. of Individuals')
+print('Minimum',df['age'].min())
+print('Maximum',df['age'].max())
+
+
+# Minimum age of a working individual is 17 and highest is 90 which is way far retirement, but majority of the people working are in the age 25 to 45. Data is skewed to the right side.
+
+# In[24]:
+
+
+plt.figure(figsize=(8,6))
+sns.histplot(df['fnlwgt'],kde=True,color='k')
+plt.ylabel('No. of Individuals')
+print('Minimum',df['fnlwgt'].min())
+print('Maximum',df['fnlwgt'].max())
+
+
+# It is assigned by combination of features and has the peak wt as 0.2*1e6. Data does not follow normal distribution and data is rigt skewed.
+
+# In[25]:
+
+
+plt.figure(figsize=(15,12))
+sns.distplot(df['capital.gain'],color='m', kde_kws={"color": "k"})
+print('Minimum',df['capital.gain'].min())
+print('Maximum',df['capital.gain'].max())
+
+
+# Minimum capital gain is 0 while the range goes on to 99999 but most of the people are with the gain of 1000. Data is highly skewed with a very long tail due to presence of large outliers. Outliers here are very few people belonging to elite class who have very large capital gains.
+
+# In[26]:
+
+
+plt.figure(figsize=(15,12))
+sns.distplot(df['capital.loss'],color='g', kde_kws={"color": "k"})
+print('Minimum',df['capital.loss'].min())
+print('Maximum',df['capital.loss'].max())
+
+
+# Minimum capital loss is 0 while the range goes on above 4000 but most of the people are with the loss of 1000. There is also a slight peak seen near 2000. Data is highly skewed with a long tail to the right side.
+
+# In[27]:
+
+
+plt.figure(figsize=(15,12))
+sns.distplot(df['hours.per.week'],color='b', kde_kws={"color": "k"})
+print('Minimum',df['hours.per.week'].min())
+print('Maximum',df['hours.per.week'].max())
+
+
+# Most of the people work 40 hours a day where there is a high chance that they belong to private sector. There are people working as low ass 1 hour a week and as high as 99 hours a week which undoubtfully might belong from the armed forces. Data shows less skewness compared to the other features in the dataframe.
+
+# In[28]:
+
+
+for i in cont:
+    sns.boxplot(df[i])
+    plt.figure()
+
+
+# There are outliers in all the features, while capital gain and capital loss have very vast no. of outliers.
+
+# ### Bivariate Analysis
+
+# In[29]:
+
+
+plt.figure(figsize=(8,6))
+sns.stripplot(x='income',y='workclass',data=df)
+
+
+# There are individuals belonging from every workclass who earn >50k except for never worked and without pay, and even there no. is low in the <=50k category.
+
+# In[30]:
+
+
+plt.figure(figsize=(8,6))
+sns.stripplot(x='income',y='education',data=df)
+
+
+# There is no individual who has done preschool and earns >50k salary while there are few who earn 50k even after going through 1st-4th and 5th-6th in the education criteria. It is also to be noticed that there are doctorates and prof who earn <=50k even with such high education. 
+
+# In[31]:
+
+
+plt.figure(figsize=(8,6))
+sns.stripplot(x='income',y='education.num',data=df)
+
+
+# It is clearly seen that as the education no. increases chances of earning >50K salary also increases
+
+# In[32]:
+
+
+plt.figure(figsize=(8,6))
+sns.stripplot(x='income',y='marital.status',data=df)
+
+
+# There are less no. of individual who are married armed forces spouse, thats why the no. is less in both the categories while people with married spouse absent are less in >50k category income comparatively.
+
+# In[33]:
+
+
+plt.figure(figsize=(8,6))
+sns.stripplot(x='income',y='occupation',data=df)
+
+
+# There are very few people with income greater than armed forces and private house service while all the other categories of people are distributed evenly in both the income categories.
+
+# In[34]:
+
+
+plt.figure(figsize=(8,15))
+sns.stripplot(x='income',y='native.country',data=df)
+
+
+# The grapghs shows people belonging to diff countries have less chances of earning >50k which is wrong, this is because no. of individuals belonging from other countries other than U.S are very low nut it is to be noticed that there are more people in the category <=50k than >50k.
+
+# In[35]:
+
+
+plt.figure(figsize=(6,8))
+sns.boxenplot(x='income',y='age',data=df,palette="Dark2")
+
+
+# People with higher mean age earn >50k while there are individuals earning <=50k even wat very high age.
+
+# In[36]:
+
+
+plt.figure(figsize=(6,8))
+sns.boxenplot(x='income',y='fnlwgt',data=df,palette="Dark2_r")
+
+
+# People are equally divided with respect to fnlwgt in the income category while it is seen that as the fnlwt is high indiduals fall into <=50k income category.
+
+# In[37]:
+
+
+plt.figure(figsize=(6,8))
+sns.boxenplot(x='income',y='capital.gain',data=df,palette="crest")
+
+
+# As the capital gain increases more people fall into >50k salary while mean of both categories remain cloase to zero capital.gain
+
+# In[38]:
+
+
+plt.figure(figsize=(6,8))
+sns.boxenplot(x='income',y='capital.loss',data=df,palette="ocean")
+
+
+# There is more density in the >50k income category with increase in capital loss while mean of both categories remain cloase to zero capital.gain
+
+# In[39]:
+
+
+plt.figure(figsize=(6,8))
+sns.boxenplot(x='income',y='hours.per.week',data=df,palette="rocket")
+
+
+# People earning >50K income work mean hours per week greater than tose earning <50K while people from both the categories work from min to max hours per week.
+
+# In[40]:
+
+
+#age vs Categorical features
+fig,ax=plt.subplots(5,2,figsize=(15,55))
+r=0
+c=0
+for i,n in enumerate(cat):
+    if i%2==0 and i>0:
+        r+=1
+        c=0
+    graph=sns.stripplot(x=n,y='age',data=df,ax=ax[r,c])
+    if n=='native.country' or n=='occupation' or n=='education':
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 90)
+    else:
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 45)
+    if n!='education.num':
+        graph.set(xlabel=None)
+    c+=1
+
+
+# Individuals working in the government secctor have atmost age 70 to 80 with few outliers which must be the retirement age for them. There are no individuals who do not work after age of 30. There are no individuals of age >70 belonging to the pre school education category while Doctorates and proffessors appear from late 20's as they have to study for more years to get to that level of education. Same is the case with education num, as the education number increases age also is increased. There are no people after the age of 50 in the married to armed forces category with just a few outliers. Widowed category has seen increase as the age age seem to increase, there are very few widows at an early age. There are less people with high age from other races than the white race. There are more no. of working men at higher age than women. There are very few people belonging from other countries with high age.
+
+# In[41]:
+
+
+#Hours per week vs categorical Feature
+fig,ax=plt.subplots(5,2,figsize=(15,55))
+r=0
+c=0
+for i,n in enumerate(cat):
+    if i%2==0 and i>0:
+        r+=1
+        c=0
+    graph=sns.violinplot(x=n,y='hours.per.week',data=df,ax=ax[r,c])
+    if n=='native.country' or n=='occupation' or n=='education':
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 90)
+    else:
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 45)
+    if n!='education.num':
+        graph.set(xlabel=None)
+    c+=1
+
+
+# Govt employees do not work more than 80 hours a week that also with rare cases. It is seen that people with less education worl more no. hours of the week which is quite logical. No armed force person works more than 60 hours a week while farmers and transport movers has working hours mean higher than other occupation. More no, of individuals who have relationship as own child have high density for working only 20 hous a week. Female works for less no. of hours as compared to men.
+
+# In[42]:
+
+
+#Capital gain vs categorical Feature
+fig,ax=plt.subplots(5,2,figsize=(15,55))
+r=0
+c=0
+for i,n in enumerate(cat):
+    if i%2==0 and i>0:
+        r+=1
+        c=0
+    graph=sns.boxplot(x=n,y='capital.gain',data=df,ax=ax[r,c])
+    if n=='native.country' or n=='occupation' or n=='education':
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 90)
+    else:
+        graph.set_xticklabels(graph.get_xticklabels(),rotation = 45)
+    if n!='education.num':
+        graph.set(xlabel=None)
+    c+=1
+
+
+# Highest capital gains are seen in individuals belonging to private or self employed workclass. There are more no. of prof-school  than any other education category with highest capital gains. There are individuals even with preschool knowledge have capital gain more than 40000. As the education level increases capital gain also increases. People from the armed forces have the least capital gain while most prominent capitals gains are found in people who are in the sales occupation. Whites have more capital gains than any other race. Men also seem to have high capital gains as compared to females. There are many people from <=50k income category who have captital gains more than 10000.
+
+# ### Multivariate Analysis
+
+# In[43]:
+
+
+data=df.groupby(['age','income']).apply(lambda x:x['hours.per.week'].count()).reset_index(name='Hours')
+px.line(data,x='age',y='Hours',color='income',title='age of individuals by Hours of work in the income category  ')
+
+
+# People earning <=50k tend to work for high no. of hours at a young age and the no. of hours decreases as the age increases but still they work for more no. of hours even at a later age as compared to people earning >50K
+
+# In[44]:
+
+
+plt.figure(figsize=(6,8))
+sns.barplot(x='income',y='age',hue='sex',data=df)
+plt.ylabel('Average age')
+
+
+# As the age increases  people are paid more but males are paid more than females.
+
+# In[45]:
+
+
+sns.factorplot(x='workclass',y='education.num',hue='income',data=df)
+plt.xticks(rotation=90)
+
+
+# Some people belonging to a particular workclass might have less education and some workclass might require more education level, but no matter whatever workclass, people in the same workclass, if they have higher education level they earn more. It is also to be noticed that there is no person from without pay and never worked workclass category who earn more than 50k which is logical.
+
+# In[46]:
+
+
+sns.factorplot(x='sex',y='education.num',hue='income',data=df)
+plt.xticks(rotation=90)
+
+
+# Females with higher education level earn equal to men having less education level than them irrespective of any income category they fall.
+
+# In[47]:
+
+
+sns.factorplot(x='race',y='education.num',hue='income',data=df)
+plt.xticks(rotation=90)
+
+
+# Asian pacific race have comparatively more education than the fellows who earn same as much as they do, belonging to other races. Indians and some other races earn >50k with lowest education level.
+
+# In[48]:
+
+
+sns.factorplot(x='occupation',y='education.num',hue='income',data=df)
+plt.xticks(rotation=90)
+
+
+# People with highest education level belong to armed forces, but people with even education level quite low, who belong to handlers cleaners, transport moving  occupation earn as much as they do. Same is the case with prof speciality. occupation of private house service who earn >50k and <50k have the highest education level difference while prof speciality have the minimum difference.
+
+# In[49]:
+
+
+plt.figure(figsize=(8,8))
+sns.scatterplot(x='age',y='hours.per.week',hue='income',data=df)
+
+
+# From the scatterplot between age, hours.per.week and income, we observe that a person needs to be >30 to be earning more than 50K, else needs to work at least 60 hours.per.week to earn >50K.
+
+# In[50]:
+
+
+plt.figure(figsize=(10,10))
+sns.heatmap(df.corr(),annot=True)
+
+
+# There are only few features in the above heat map as most of them are of object type. From here we can see that the independent features don not have much correlation with each other i.e. no multicollinearity.
+
+# # Feature Engineering
+
+# ###### Encoding
+
+# In[51]:
+
+
+from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
+l=LabelEncoder()
+o=OrdinalEncoder()
+
+
+# In[52]:
+
+
+#We use ordinal encoder to Encode Independent features
+for i in df.columns:
+    if df[i].dtypes=='O' and i!='income':
+        df[i]=o.fit_transform(df[i].values.reshape(-1,1))
+
+
+# In[53]:
+
+
+#We use label encoder to encode label 
+df['income']=l.fit_transform(df['income'])
+
+
+# ##### Removing Outliers
+
+# In[54]:
+
+
+from scipy.stats import zscore
+
+
+# In[55]:
+
+
+#Method to find optimum threshold
+def threshold():
+    for i in np.arange(3,5,0.2):
+        data=df.copy()
+        data=data[(z<i).all(axis=1)]
+        loss=(df.shape[0]-data.shape[0])/df.shape[0]*100
+        print('With threshold {} data loss is {}%'.format(np.round(i,1),np.round(loss,2))) 
+
+
+# In[56]:
+
+
+z=np.abs(zscore(df))
+threshold()
+
+
+# From above we choose threhold as 4.2 as data is precious and we cannot afford to lose more than 8% of data.
+
+# In[57]:
+
+
+df=df[(z<4.2).all(axis=1)]
+
+
+# ###### Removing Skewness
+
+# In[58]:
+
+
+#using Power transformer to remove skewness
+from sklearn.preprocessing import PowerTransformer
+pt=PowerTransformer()
+
+
+# In[59]:
+
+
+for i in cont:
+    if np.abs(df[i].skew())>0.5:
+        df[i]=pt.fit_transform(df[i].values.reshape(-1,1))
+
+
+# In[60]:
+
+
+for i in cont:
+    sns.distplot(df[i])
+    plt.figure()
+
+
+# A lot of skewness has been resuced but we cannot remove skewness more than this.
+
+# In[61]:
+
+
+#Separating dependent and independent features.
+x=df.copy()
+x.drop('income',axis=1,inplace=True)
+y=df['income']
+
+
+# ##### Handling Imbalanced Data
+
+# In[62]:
+
+
+#Oversampling using Smote
+from imblearn.over_sampling import SMOTE
+over=SMOTE()
+
+
+# In[63]:
+
+
+x,y=over.fit_resample(x,y)
+
+
+# In[64]:
+
+
+plt.figure(figsize=(15,5))
+plt.subplot(1,2,1)
+y.value_counts().plot.pie(autopct='%1.1f%%')
+plt.subplot(1,2,2)
+sns.countplot(y)
+y.value_counts()
+
+
+# Data is balanced now, both the category of income have 50% data each.
+
+# ##### Scaling the data
+
+# In[65]:
+
+
+#Scaling the data using min max scaler
+from sklearn.preprocessing import MinMaxScaler
+scaler=MinMaxScaler()
+
+
+# In[66]:
+
+
+xd=scaler.fit_transform(x)
+x=pd.DataFrame(xd,columns=x.columns)
+
+
+# # Modelling Phase
+
+# In[67]:
+
+
+#We import Classification Models
+from sklearn.naive_bayes import  GaussianNB
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.ensemble import GradientBoostingClassifier
+from xgboost import XGBClassifier
+
+
+# In[68]:
+
+
+from sklearn.model_selection import train_test_split, cross_val_score
+
+
+# In[69]:
+
+
+from sklearn.metrics import accuracy_score,confusion_matrix,classification_report,roc_auc_score,roc_curve
+
+
+# In[70]:
+
+
+#Function to find the best random state
+def randomstate(x,y):
+    maxx=0
+    model=LogisticRegression()
+    for i in range(1,201):
+        xtrain,xtest,ytrain,ytest=train_test_split(x,y,test_size=0.25,random_state=i)
+        model.fit(xtrain,ytrain)
+        p=model.predict(xtest)
+        accu=accuracy_score(p,ytest)
+        if accu>maxx:
+            maxx=accu
+            j=i
+    return j
+
+
+# In[71]:
+
+
+#To evakuate performances of all the models
+def performance(p,ytest,m,xtest,s):
+    print('------------------------------------',m,'------------------------------------')
+    print('Accuracy',np.round(accuracy_score(p,ytest),4))
+    print('----------------------------------------------------------')
+    print('Mean of Cross Validation Score',np.round(s.mean(),4))
+    print('----------------------------------------------------------')
+    print('AUC_ROC Score',np.round(roc_auc_score(ytest,m.predict_proba(xtest)[:,1]),4))
+    print('----------------------------------------------------------')
+    print('Confusion Matrix')
+    print(confusion_matrix(p,ytest))
+    print('----------------------------------------------------------')
+    print('Classification Report')
+    print(classification_report(p,ytest))
+
+
+# In[72]:
+
+
+#Creating a list of models which will be created one by one
+models=[GaussianNB(),KNeighborsClassifier(),LogisticRegression(),DecisionTreeClassifier(),
+        RandomForestClassifier(),AdaBoostClassifier(),GradientBoostingClassifier(),XGBClassifier(verbosity=0)]
+
+
+# In[73]:
+
+
+#Creates and trains model from the models list
+def createmodel(x,y):
+    xtrain,xtest,ytrain,ytest=train_test_split(x,y,test_size=0.25,random_state=randomstate(x,y))
+    for i in models:
+        model=i
+        model.fit(xtrain,ytrain)
+        p=model.predict(xtest)
+        score=cross_val_score(model,x,y,cv=10)
+        performance(p,ytest,model,xtest,score) 
+
+
+# In[74]:
+
+
+createmodel(x,y)
+
+
+# Random Forest, Gradient Boost, Xtreme Gradient Boost give us the best performance, so we further try hyperparameter tuning on them
+
+# # Hyperparameter Tuning
+
+# In[75]:
+
+
+from sklearn.model_selection import GridSearchCV
+
+
+# In[76]:
+
+
+xtrain,xtest,ytrain,ytest=train_test_split(x,y,test_size=0.25,random_state=randomstate(x,y))
+
+
+# ##### Random Forest
+
+# In[77]:
+
+
+params={'n_estimators':[100,300,500],
+            'criterion':['gini','entropty'],
+            'max_depth':[None,1,2,3,4,5,6,7,8,9,10],
+           'max_features':['int','float','auto','log2']}
+
+
+# In[78]:
+
+
+g=GridSearchCV(RandomForestClassifier(),params,cv=10)
+
+
+# In[79]:
+
+
+g.fit(xtrain,ytrain)
+
+
+# In[80]:
+
+
+print(g.best_params_)
+print(g.best_estimator_)
+print(g.best_score_)
+
+
+# In[81]:
+
+
+m=RandomForestClassifier(max_features='log2', n_estimators=500)
+m.fit(xtrain,ytrain)
+p=m.predict(xtest)
+score=cross_val_score(m,x,y,cv=10)
+performance(p,ytest,m,xtest,score)
+
+
+# ##### Gradient Boost
+
+# In[82]:
+
+
+from sklearn.model_selection import RandomizedSearchCV
+
+
+# In[83]:
+
+
+params={'n_estimators':[100,300,500],
+      'learning_rate':[0.001,0.01,0.10,],
+      'subsample':[0.5,1],
+      'max_depth':[1,2,3,4,5,6,7,8,9,10,None]}
+
+
+# In[84]:
+
+
+g=RandomizedSearchCV(GradientBoostingClassifier(),params,cv=10)
+
+
+# In[85]:
+
+
+g.fit(xtrain,ytrain)
+
+
+# In[86]:
+
+
+print(g.best_params_)
+print(g.best_estimator_)
+print(g.best_score_)
+
+
+# In[87]:
+
+
+m=GradientBoostingClassifier(max_depth=8, subsample=0.5)
+m.fit(xtrain,ytrain)
+p=m.predict(xtest)
+score=cross_val_score(m,x,y,cv=10)
+performance(p,ytest,m,xtest,score)
+
+
+# ##### Xtreme Gradient Boost
+
+# In[88]:
+
+
+params={
+ "learning_rate"    : [0.01,0.05, 0.10, 0.15, ] ,
+ "max_depth"        : [ 3, 4, 5, 6, 8, 10, 12, 15],
+ "min_child_weight" : [ 1, 3, 5, 7 ],
+ "gamma"            : [ 0.0, 0.1, 0.2 , 0.3, 0.4 ],
+ "colsample_bytree" : [ 0.3, 0.4, 0.5 , 0.7 ]
+    }
+
+
+# In[89]:
+
+
+g=RandomizedSearchCV(XGBClassifier(),params,cv=10)
+
+
+# In[90]:
+
+
+g.fit(xtrain,ytrain)
+
+
+# In[91]:
+
+
+print(g.best_params_)
+print(g.best_estimator_)
+print(g.best_score_)
+
+
+# In[92]:
+
+
+m=XGBClassifier(colsample_bytree=0.3, gamma= 0.1, learning_rate= 0.15, max_depth= 10, min_child_weight= 5)
+m.fit(xtrain,ytrain)
+p=m.predict(xtest)
+score=cross_val_score(m,x,y,cv=10)
+performance(p,ytest,m,xtest,score)
+
+
+# We choose random forest as our final model because it gives the highest cross validation score as well as difference between its accuracy score and cross validation score is minimum.
+
+# # Finalizing the model
+
+# In[93]:
+
+
+model=RandomForestClassifier(max_features='log2', n_estimators=500)
+model.fit(xtrain,ytrain)
+p=model.predict(xtest)
+score=cross_val_score(model,x,y,cv=10)
+
+
+# # Evaluation Metrics
+
+# In[94]:
+
+
+performance(p,ytest,model,xtest,score)
+
+
+# In[95]:
+
+
+fpred=pd.Series(model.predict_proba(xtest)[:,1])
+fpr,tpr,threshold=roc_curve(ytest,fpred)
+
+
+# In[96]:
+
+
+plt.plot(fpr,tpr,color='k',label='ROC')
+plt.plot([0,1],[0,1],color='b',linestyle='--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('ROC-AUC curve')
+plt.legend()
+
+
+# # Saving the model
+
+# In[97]:
+
+
+import joblib
+joblib.dump(model,'census_income.obj')
+
+
+# In[ ]:
+
+
+
+

AdultNoteBook/Kernels/AdaBoost/5-income-classification-using-meta-learning.py

@@ -0,0 +1,632 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Adult Census Income Classification using Meta Learning
+
+# In[1]:
+
+
+#importing the required libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+plt.style.use('ggplot')
+
+from imblearn.over_sampling import RandomOverSampler
+from sklearn.model_selection import train_test_split
+
+from numpy import mean, std
+
+
+# In[2]:
+
+
+#reading the dataset and converting it to dataframe
+df = pd.read_csv("../input/adult-census-income/adult.csv")
+
+
+# In[3]:
+
+
+#Viewing the top 5 rows of our dataset
+df.head()
+
+
+# ## Exploratory Data Analysis
+
+# **Income - Target column**
+
+# In[4]:
+
+
+sns.countplot(df.income)
+
+
+# *As we can see, there is a **class imbalance**. The ">50K" class is comparatively very less. So, we will do **Random Over-Sampling** during preprocessing.*
+# 
+
+# **Age**
+
+# In[5]:
+
+
+sns.distplot(df[df.income=='<=50K'].age, color='g')
+sns.distplot(df[df.income=='>50K'].age, color='r')
+
+
+# *We can observe a rough margin **around 30**. We will divide age into 2 parts ie. under 30 and over 30. We need to check if its useful for our model during testing.*
+
+# **Workclass**
+
+# In[6]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.workclass, hue=df.income, palette='tab10')
+
+
+# *Majority of the data falls under **Private**. So, we will convert this into Private and not-Private.*
+
+# **fnlwgt**
+
+# In[7]:
+
+
+sns.distplot(df[df.income=='<=50K'].fnlwgt, color='r')
+sns.distplot(df[df.income=='>50K'].fnlwgt, color='g')
+
+
+# *This is a very **ambiguous** attribute. Will check during testing.*
+
+# **Education**
+
+# In[8]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.education, hue=df.income, palette='muted')
+
+
+# **education.num**
+
+# In[9]:
+
+
+sns.countplot(df["education.num"], hue=df.income)
+
+
+# **marital.status**
+
+# In[10]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df['marital.status'], hue=df.income)
+
+
+# *We observe that the majority of ">50K" class is **Married-civ-spouse**. So we ll make it 1 and others 0*
+
+# **occupation**
+
+# In[11]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.occupation, hue=df.income, palette='rocket')
+
+
+# **relationship**
+
+# In[12]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.relationship, hue=df.income, palette='muted')
+
+
+# **race**
+
+# In[13]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.race, hue=df.income, palette='Set2')
+
+
+# **sex**
+
+# In[14]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.sex, hue=df.income)
+
+
+# **capital.gain**
+
+# In[15]:
+
+
+df['capital.gain'].value_counts()
+
+
+# **capital.loss**
+
+# In[16]:
+
+
+df['capital.loss'].value_counts()
+
+
+# **hours.per.week**
+
+# In[17]:
+
+
+sns.distplot(df[df.income=='<=50K']['hours.per.week'], color='b')
+sns.distplot(df[df.income=='>50K']['hours.per.week'], color='r')
+
+
+# **native.country**
+
+# In[18]:
+
+
+df['native.country'].value_counts()
+
+
+# ## Preprocessing
+
+# ### Finding and Handling Missing Data
+# 
+# *Observing the dataset, I found that the null values are marked as "?", So, we will now convert them to numpy.nan(null values).*
+
+# In[19]:
+
+
+df[df.select_dtypes("object") =="?"] = np.nan
+nans = df.isnull().sum()
+if len(nans[nans>0]):
+    print("Missing values detected.\n")
+    print(nans[nans>0])
+else:
+    print("No missing values. You are good to go.")
+
+
+# In[20]:
+
+
+#majority of the values are "Private". Lets fill the missing values as "Private".
+df.workclass.fillna("Private", inplace=True)
+
+df.occupation.fillna(method='bfill', inplace=True)
+
+#majority of the values are "United-States". Lets fill the missing values as "United-States".
+df['native.country'].fillna("United-States", inplace=True)
+
+print("Handled missing values successfully.")
+
+
+# In[21]:
+
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.utils import column_or_1d
+
+class MyLabelEncoder(LabelEncoder):
+
+    def fit(self, y, arr=[]):
+        y = column_or_1d(y, warn=True)
+        if arr == []:
+            arr=y
+        self.classes_ = pd.Series(arr).unique()
+        return self
+
+le = MyLabelEncoder()
+
+
+# ### Feature Engineering and Encoding the columns
+
+# In[22]:
+
+
+# age_enc = pd.cut(df.age, bins=(0,25,45,65,100), labels=(0,1,2,3))
+df['age_enc'] = df.age.apply(lambda x: 1 if x > 30 else 0)
+
+def prep_workclass(x):
+    if x == 'Never-worked' or x == 'Without-pay':
+        return 0
+    elif x == 'Private':
+        return 1
+    elif x == 'State-gov' or x == 'Local-gov' or x == 'Federal-gov':
+        return 2
+    elif x == 'Self-emp-not-inc':
+        return 3
+    else:
+        return 4
+
+df['workclass_enc'] = df.workclass.apply(prep_workclass)
+
+df['fnlwgt_enc'] = df.fnlwgt.apply(lambda x: 0 if x>200000 else 1)
+
+le.fit(df.education, arr=['Preschool', '1st-4th', '5th-6th', '7th-8th', '9th','10th', '11th', '12th', 
+                                             'HS-grad', 'Prof-school', 'Assoc-acdm', 'Assoc-voc', 'Some-college', 'Bachelors', 'Masters', 'Doctorate'])
+df['education_enc'] = le.transform(df.education)
+
+
+df['education.num_enc'] = df['education.num'].apply(lambda x: 1 if x>=9 else 0)
+
+df['marital.status_enc'] = df['marital.status'].apply(lambda x: 1 if x=='Married-civ-spouse' or x == 'Married-AF-spouse' else 0)
+
+def prep_occupation(x):
+    if x in ['Prof-specialty', 'Exec-managerial', 'Tech-support', 'Protective-serv']:
+        return 2
+    elif x in ['Sales', 'Craft-repair']:
+        return 1
+    else:
+        return 0
+
+df['occupation_enc'] = df.occupation.apply(prep_occupation)
+
+df['relationship_enc'] = df.relationship.apply(lambda x: 1 if x in ['Husband', 'Wife'] else 0)
+
+df['race_enc'] = df.race.apply(lambda x: 1 if x=='White' else 0)
+
+df['sex_enc'] = df.sex.apply(lambda x: 1 if x=='Male' else 0)
+
+df['capital.gain_enc'] = pd.cut(df["capital.gain"], 
+                                bins=[-1,0,df[df["capital.gain"]>0]["capital.gain"].median(), df["capital.gain"].max()], labels=(0,1,2)).astype('int64')
+
+df['capital.loss_enc'] = pd.cut(df["capital.loss"], 
+                                bins=[-1,0,df[df["capital.loss"]>0]["capital.loss"].median(), df["capital.loss"].max()], labels=(0,1,2)).astype('int64')
+
+# hpw_enc = pd.cut(df['hours.per.week'], bins= (0,30,40,53,168), labels=(0,1,2,3))
+df['hours.per.week_enc'] = pd.qcut(df['hours.per.week'], q=5, labels=(0,1,2,3), duplicates='drop').astype('int64')
+
+df['native.country_enc'] = df['native.country'].apply(lambda x: 1 if x=='United-States' else 0)
+
+df['income_enc'] = df.income.apply(lambda x: 1 if x==">50K" else 0)
+
+print("Encoding complete.")
+
+
+# In[23]:
+
+
+df.select_dtypes("object").info()
+
+
+# In[24]:
+
+
+#dropping encoded columns - education, sex, income
+df.drop(['education', 'sex', 'income'], 1, inplace=True)
+
+
+# ### Label Encoding without Feature Engineering
+
+# In[25]:
+
+
+for feature in df.select_dtypes("object").columns:
+    df[feature]=le.fit_transform(df[feature])
+
+
+# ### Feature Selection
+
+# In[26]:
+
+
+df.info()
+
+
+# In[27]:
+
+
+#Visualizing the pearson correlation with the target class
+pcorr = df.drop('income_enc',1).corrwith(df.income_enc)
+plt.figure(figsize=(10,6))
+plt.title("Pearson Correlation of Features with Income")
+plt.xlabel("Features")
+plt.ylabel("Correlation Coeff")
+plt.xticks(rotation=90)
+plt.bar(pcorr.index, list(map(abs,pcorr.values)))
+
+
+# From the pearson correlation plot, we can see that correlation of few columns are very **low** with the target column, so, we ll drop them.
+
+# In[28]:
+
+
+df.drop(['workclass', 'fnlwgt','occupation', 'race', 'native.country', 'fnlwgt_enc', 'race_enc', 'native.country_enc'], 1, inplace=True)
+
+
+# In[29]:
+
+
+sns.heatmap(df.corr().apply(abs))
+
+
+# **Dropping redundant features**
+
+# We can see that **education_enc, education.num_enc and education.num** as well as **relationship_enc and marital.status_enc** have **high correlation**. So, we will only keep one of them based on their correlation with income_enc.
+# 
+# We also have some redundant feautres as we have engineered features from them(age, capital.gain, etc.).
+
+# In[30]:
+
+
+df.drop(['age', 'education.num_enc', 'education_enc', 'marital.status_enc', 'capital.gain', 'capital.loss', 'hours.per.week'], 1, inplace = True)
+
+
+# In[31]:
+
+
+df.info()
+
+
+# In[32]:
+
+
+X = df.drop('income_enc', 1)
+y = df.income_enc
+
+
+# ### Train Test Split (3:1)
+
+# In[33]:
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
+
+
+# In[34]:
+
+
+print("No. of rows in training data:",X_train.shape[0])
+print("No. of rows in testing data:",X_test.shape[0])
+
+
+# ### Random Over Sampling
+
+# *We can see the class imbalance in our target. This results in models that have poor predictive performance, specifically for the minority class. So, we need to random over sampling*
+
+# In[35]:
+
+
+oversample = RandomOverSampler(sampling_strategy=0.5) #50% oversampling
+X_over, y_over = oversample.fit_resample(X_train, y_train)
+
+
+# In[36]:
+
+
+y_over.value_counts()
+
+
+# ## Model Preparation
+
+# In[37]:
+
+
+#Model Imports
+from sklearn.model_selection import StratifiedKFold, cross_val_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import make_pipeline
+from sklearn.metrics import classification_report, confusion_matrix
+
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import AdaBoostClassifier, ExtraTreesClassifier, GradientBoostingClassifier, RandomForestClassifier, StackingClassifier
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+
+
+# In[38]:
+
+
+seed= 42
+
+
+# In[39]:
+
+
+models = {
+    'LR':LogisticRegression(random_state=seed),
+    'SVC':SVC(random_state=seed),
+    'AB':AdaBoostClassifier(random_state=seed),
+    'ET':ExtraTreesClassifier(random_state=seed),
+    'GB':GradientBoostingClassifier(random_state=seed),
+    'RF':RandomForestClassifier(random_state=seed),
+    'XGB':XGBClassifier(random_state=seed),
+    'LGBM':LGBMClassifier(random_state=seed)
+    }
+
+
+# In[40]:
+
+
+# evaluate a give model using cross-validation
+def evaluate_models(model, xtrain, ytrain):
+    cv = StratifiedKFold(shuffle=True, random_state=seed)
+    scores = cross_val_score(model, xtrain, ytrain, scoring='accuracy', cv=cv, error_score='raise')
+    return scores
+
+def plot_scores(xval,yval,show_value=False):
+    plt.ylim(ymax = max(yval)+0.5, ymin = min(yval)-0.5)
+    plt.xticks(rotation=45)
+    s = sns.barplot(xval,yval)
+    if show_value:
+        for x,y in zip(range(len(yval)),yval):
+            s.text(x,y+0.1,round(y,2),ha="center")
+
+
+# In[41]:
+
+
+# evaluate the models and store results for 100% oversampled minority class
+results, names = list(), list()
+for name, model in models.items():
+    scores = evaluate_models(model, X_train, y_train) 
+    results.append(scores) 
+    names.append(name) 
+    print('*%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
+
+
+# In[42]:
+
+
+plt.boxplot(results, labels=names, showmeans=True)
+plt.show() 
+
+
+# In[43]:
+
+
+param_grids = {
+    'LR':{'C':[0.001,0.01,0.1,1,10]},
+    'SVC':{'gamma':[0.01,0.02,0.05,0.08,0.1], 'C':range(1,8)},
+    
+    'AB':{'learning_rate': [0.05, 0.1, 0.2], 'n_estimators': [100, 200, 500]},
+    
+    'ET':{'max_depth':[5,8,10,12], 'min_samples_split': [5,9,12],
+          'n_estimators': [100,200,500,800]},
+    
+    'GB':{'learning_rate': [0.05, 0.1, 0.2], 'max_depth':[3,5,9],
+          'min_samples_split': [5,7,9], 'n_estimators': [100,200,500],
+          'subsample':[0.5,0.7,0.9]},
+    
+    'RF':{'max_depth':[3,5,9,15], 'n_estimators': [100, 200, 500, 1000],
+          'learning_rate': [0.05, 0.1, 0.2], 'min_samples_split': [5,9,12]},
+    
+    'XGB':{'max_depth':[3,5,7,9], 'n_estimators': [100, 200, 500],
+           'learning_rate': [0.05, 0.1, 0.2], 'subsample':[0.5,0.7,0.9]},
+    
+    'LGBM':{'n_estimators': [100,200,500],'learning_rate': [0.05, 0.1, 0.2],
+            'subsample':[0.5,0.7,0.9],'num_leaves': [25,31,50]}
+}
+
+
+# In[44]:
+
+
+# !pip install sklearn-deap
+# from evolutionary_search import EvolutionaryAlgorithmSearchCV
+
+
+# In[45]:
+
+
+# evaluate the models and store results
+# best_params = []
+# names= []
+# for name, param_grid, model in zip(param_grids.keys(), param_grids.values(), models.values()):
+#     eascv = EvolutionaryAlgorithmSearchCV(model, param_grid, verbose=3, cv=3)
+#     eascv.fit(X_train,y_train)
+#     names.append(name)
+#     best_params.append(eascv.best_params_)
+#     print(name)
+#     print("best score:",eascv.best_score_)
+#     print("best params:",eascv.best_params_)
+
+
+# In[46]:
+
+
+best_params=[
+    {'C': 10},
+    {'gamma': 0.1, 'C': 2},
+    {'learning_rate': 0.1, 'n_estimators': 500},
+    {'max_depth': 12, 'min_samples_split': 9, 'n_estimators': 100},
+    {'learning_rate': 0.05, 'max_depth': 3, 'min_samples_split': 9, 'n_estimators': 200, 'subsample': 0.9},
+    {'max_depth': 9, 'n_estimators': 200, 'min_samples_split': 5},
+    {'max_depth': 3, 'n_estimators': 200, 'learning_rate': 0.1, 'subsample': 0.9},
+    {'n_estimators': 100, 'learning_rate': 0.05, 'subsample': 0.9, 'num_leaves': 25}
+            ]
+
+
+# In[47]:
+
+
+models = [
+    ('LR',LogisticRegression(random_state=seed)),
+    ('SVC',SVC(random_state=seed)),
+    ('AB',AdaBoostClassifier(random_state=seed)),
+    ('ET',ExtraTreesClassifier(random_state=seed)),
+    ('GB',GradientBoostingClassifier(random_state=seed)),
+    ('RF',RandomForestClassifier(random_state=seed)),
+    ('XGB',XGBClassifier(random_state=seed)),
+    ('LGBM',LGBMClassifier(random_state=seed))
+]
+
+
+# In[48]:
+
+
+for model, param in zip(models, best_params):
+    model[1].set_params(**param)
+
+
+# In[49]:
+
+
+models.append(('MLModel',StackingClassifier(estimators = models[:-1])))
+
+
+# In[50]:
+
+
+scores=[]
+preds=[]
+for model in models:
+    model[1].fit(X_train,y_train)
+    print(model[0],"trained.")
+    scores.append(model[1].score(X_test,y_test))
+    preds.append(model[1].predict(X_test))
+print("Results are ready.")
+
+
+# ## Using Classification Based on Assocation
+
+# In[51]:
+
+
+get_ipython().system('pip install pyarc==1.0.23')
+get_ipython().system('pip install pyfim')
+from pyarc import CBA, TransactionDB
+
+
+# In[52]:
+
+
+txns_train = TransactionDB.from_DataFrame(X_train.join(y_train))
+txns_test = TransactionDB.from_DataFrame(X_test.join(y_test))
+
+
+cba = CBA(support=0.15, confidence=0.5, algorithm="m1")
+cba.fit(txns_train)
+
+
+# In[53]:
+
+
+cba_score = cba.rule_model_accuracy(txns_test) 
+scores.append(cba_score)
+models.append(["CBA"])
+
+
+# In[54]:
+
+
+model_names= [i[0] for i in models]
+scores = list(map(lambda x: x*100, scores))
+
+
+# In[55]:
+
+
+plot_scores(model_names, scores, True)
+

AdultNoteBook/Kernels/AdaBoost/6-income-prediction-eda-to-visuals-0-98-auc.py

@@ -0,0 +1,682 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# ## Importing Important libraries
+
+# In[1]:
+
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import warnings
+warnings.filterwarnings('ignore')
+
+
+# #### Loading the data onto notebook.
+
+# In[2]:
+
+
+data = pd.read_csv("../input/adult-census-income/adult.csv")
+data
+
+
+# ![](https://kiarofoods.com/wp-content/uploads/2019/10/line_break.png)
+# # Exploratory Data Analysis:
+# **Problem Type Identification:** We have the target variable available with us. So, it a supervised machine learning problem. First we try to find out the type of supervised machine learning that we have in this case study by lookin at the target variable
+
+# In[3]:
+
+
+print(f"Target: 'Income'\nUnique Values in Income: {data.income.unique()}\nNumber of unique values: {data.income.nunique()}")
+
+
+# In the problem, we have 'Income' as the Target variable. we see that we have only two values which are to be predicted, either the income is greater than 50K, which is Yes, or the income is less than or equal to 50K, which is No. We will label encode the target variable.
+
+# In[4]:
+
+
+data['income'] = data['income'].str.replace('<=50K', '0')
+data['income'] = data['income'].str.replace('>50K', '1')
+data['income'] = data['income'].astype(np.int64)
+
+
+# In[5]:
+
+
+data.income.dtypes
+
+
+# We can see that, we have encoded the values of the target variable, and converted it into int data-type. This problem is a classification problem with 'Income' as the target variable. Making a copy of the dataset to work ahead
+
+# In[6]:
+
+
+ds = data.copy()
+print(f"Unique values in 'education': {ds.education.nunique()}\nUnique values in 'Education_num': {ds['education.num'].nunique()}")
+
+
+# We see that for the feature 'Education', we already have the encoded values in feature 'Education_num'. 'Education' will be removed from the dataset.
+
+# In[7]:
+
+
+ds.drop(['education'], axis = 1, inplace = True)
+
+
+# Checking to see that is there any Null values present in the data that we have. Handling the null values will be the first thing that we need to do. Then, we have a look at the data-types of the other features and the value counts and unique values in those features.
+
+# In[8]:
+
+
+plt.title("Null values in the data", fontsize = 12)
+sns.heatmap(ds.isnull(), cmap = 'inferno')
+plt.show()
+
+
+# From the heatmap, we see that the dataset consists of no null values. But for some features, we have '?' as the values present. **'?' will be considered as null values.** We move ahead with the feature engineering part. Checking the datatypes of the columns
+
+# In[9]:
+
+
+print("Datatype of every feature: ")
+ds.dtypes
+
+
+# In[10]:
+
+
+print("Number of unique values in every feature: ")
+ds.nunique()
+
+
+# *'Workclass', 'Marital_status', 'Occupation', 'Relationship', 'Race', 'Sex', 'Native_country' are the categorical variables in the data*. Proper encoding or conversion of these variables is necessary for the feature engineering. We will look at these attributes and convert them one by one.
+# 
+# **'Workclass':** Starting off with the work class, we look the number of unique values and value counts for those values
+
+# In[11]:
+
+
+ds.workclass.value_counts()
+
+
+# In work class, *majority of the people are private employees*. The *minority of people are either working without-pay or they have never-worked*. We can combine the values of these two values as one. first we remove the blank space from the column is present in any values.
+
+# In[12]:
+
+
+ds['workclass'] = ds['workclass'].str.replace('Never-worked', 'Without-pay')
+
+
+# Now, we have 8 unique values in this feature. But, we see that **there are some values where we have '?' in the column. This values can be replaced with NaN values.**
+
+# In[13]:
+
+
+ds['workclass'] = ds['workclass'].replace('?', np.NaN)
+
+
+# In[14]:
+
+
+plt.figure(figsize = (10,6))
+plt.title("Income of people according to their workclass", fontsize = 16)
+sns.countplot(y = ds['workclass'], hue = ds['income'])
+plt.show()
+
+
+# We see that the **majority of people who have income more than 50K a year are from private sector**. Same goes for the people with income less than 50K. But *for the Self Employed sector, the number of people whose income > 50K are more than the number of people whose income < 50K.* Now, moving ahead with replacing the null values and encoding the feature. **We will replace the NaN values in the 'Workclass' feature by the mode of the column, grouping it by the 'Occupation' feature.** We now have 7 unique values in Workclass feature. We can encode these values using the frequency encoding technique.
+
+# In[15]:
+
+
+from scipy.stats import mode
+workclass_mode = ds.pivot_table(values='workclass', columns='occupation',aggfunc=(lambda x:mode(x).mode[0]))
+workclass_mode
+
+
+# In[16]:
+
+
+loc1 = ds['workclass'].isnull()
+ds.loc[loc1, 'workclass'] = ds.loc[loc1,'occupation'].apply(lambda x: workclass_mode[x])
+
+
+# In[17]:
+
+
+workclass_enc = (ds.groupby('workclass').size()) / len(ds)
+print(workclass_enc)
+
+ds['workclass_enc'] = ds['workclass'].apply(lambda x : workclass_enc[x])
+ds['workclass_enc'].head(3)
+
+
+# In[18]:
+
+
+ds.drop(['workclass'], axis = 1, inplace = True)
+
+
+# **'Occupation':** Similar to 'Workclass', we will look at the unique values and value counts in the 'Occupation' feature.
+
+# In[19]:
+
+
+ds.occupation.value_counts()
+
+
+# **We will drop the rows where the occupation is NaN.**
+
+# In[20]:
+
+
+ds['occupation'] = ds['occupation'].replace('?', np.NaN)
+ds = ds.loc[ds['occupation'].isnull() == False]
+ds
+
+
+# As we cannn see that after removing the null values from 'occupation', we are left with 30718 observations.
+
+# In[21]:
+
+
+plt.style.use('ggplot')
+plt.figure(figsize = (10,6))
+plt.title("Income of people according to their occupation", fontsize = 16)
+sns.countplot(y = ds['occupation'], hue = ds['income'])
+plt.show()
+
+
+# Majority of people whose income is greater than 50K are either executive managers or they belong to any professional speciality. Now, encoding the occupation by frequency of the values in the column.
+
+# In[22]:
+
+
+occupation_enc = (ds.groupby('occupation').size()) / len(ds)
+print(occupation_enc)
+
+ds['occupation_enc'] = ds['occupation'].apply(lambda x : occupation_enc[x])
+ds['occupation_enc'].head(3)
+
+
+# In[23]:
+
+
+ds.drop(['occupation'], axis = 1, inplace = True)
+
+
+# **'Native_country':** We are checking for the salary on people in USA and outside USA, so , **we will convert all the values where country is not USA to 'non-usa'.** This way, we can encode the values by one-hot encoding without increasing the curse of dimensionality.
+
+# In[24]:
+
+
+ds['native.country'].loc[ds['native.country'] == 'United-States'] = 'usa'
+ds['native.country'].loc[ds['native.country'] != 'usa'] = 'non_usa'
+ds['native.country'].value_counts()
+
+
+# In[25]:
+
+
+plt.style.use('default')
+
+
+# In[26]:
+
+
+plt.style.use('seaborn-pastel')
+
+
+# In[27]:
+
+
+plt.figure(figsize = (8,3))
+plt.title("Income of people according to their native country", fontsize = 16)
+sns.countplot(y = ds['native.country'], hue = ds['income'])
+plt.show()
+
+
+# **Majority of people with higher income belong to the USA**. We also have more number of people from USA then any other country combined in this dataset. Encoding this feature using one hot encoding.
+
+# In[28]:
+
+
+ds['country_enc'] = ds['native.country'].map({'usa' : 1, 'non_usa' : 0})
+ds.drop(['native.country'], axis = 1, inplace = True)
+
+
+# **'Sex':** Similarly, encoding the sex using one hot encoding.
+
+# In[29]:
+
+
+plt.title("Income of people by their sex", fontsize = 16)
+sns.countplot(x = ds['sex'], hue = ds['income'])
+plt.show()
+
+
+# We can see that male have more salary than female. Also in the dataset, the number of men are more than women. Encoding this feature with one hot encoding.
+
+# In[30]:
+
+
+ds['sex_enc'] = ds['sex'].map({'Male' : 1, 'Female' : 0})
+ds.drop(['sex'], axis = 1, inplace = True)
+
+
+# **'Marital_status':** Looking at the iincome of people according to their marital status.
+
+# In[31]:
+
+
+plt.style.use('default')
+
+
+# In[32]:
+
+
+plt.style.use('seaborn-talk')
+
+
+# In[33]:
+
+
+plt.title("Income of people by Marital Status", fontsize = 16)
+sns.countplot(y = ds['marital.status'], hue = ds['income'])
+plt.show()
+
+
+# **Married people have a higher income as compared to others.** Encoding the feature
+
+# In[34]:
+
+
+marital_status_enc = (ds.groupby('marital.status').size()) / len(ds)
+print(marital_status_enc)
+
+ds['marital_status_enc'] = ds['marital.status'].apply(lambda x : marital_status_enc[x])
+ds['marital_status_enc'].head(3)
+
+
+# In[35]:
+
+
+ds.drop(['marital.status'], axis = 1, inplace = True)
+
+
+# Similarly, **for 'Race' and 'Relationship'**
+
+# In[36]:
+
+
+plt.style.use('bmh')
+
+
+# In[37]:
+
+
+plt.figure(figsize = (12,4))
+
+plt.subplot(1, 2, 1)
+sns.countplot(y = ds['race'], hue = ds['income'])
+plt.title("Income respective to Race", fontsize = 12)
+
+plt.subplot(1, 2, 2)
+sns.countplot(y = ds['relationship'], hue = ds['income'])
+plt.title("Income respective to Relationship", fontsize = 12)
+
+plt.tight_layout(pad = 4)
+plt.show()
+
+
+# **White people have a higher salary as compared to other races**. Similarly, **husband in the family have a higher salary as compared to other relationship in the family.** Encoding both these columns
+
+# In[38]:
+
+
+race_enc = (ds.groupby('race').size()) / len(ds)
+print(race_enc,'\n')
+ds['race_enc'] = ds['race'].apply(lambda x : race_enc[x])
+
+relationship_enc = (ds.groupby('relationship').size()) / len(ds)
+print(relationship_enc)
+ds['relationship_enc'] = ds['relationship'].apply(lambda x : relationship_enc[x])
+
+
+# In[39]:
+
+
+ds.drop(['race', 'relationship'], axis = 1, inplace = True)
+new_ds = ds.drop(['income'], axis = 1)
+new_ds['income'] = ds['income']
+new_ds
+
+
+# ## Outliers:
+# We check if any outliers are present in the continous attributes of the dataset. We check it both by visualisations and the zscore for the continous columns.
+
+# In[40]:
+
+
+plt.style.use('default')
+
+
+# In[41]:
+
+
+plt.style.use('ggplot')
+
+
+# In[42]:
+
+
+clist = ['fnlwgt','age','capital.gain','capital.loss','hours.per.week']
+plt.figure(figsize = (12,6))
+for i in range(0, len(clist)):
+    plt.subplot(2,3, i+1)
+    sns.boxplot(ds[clist[i]], color = 'skyblue')
+print("BoxPlots of the features:")
+plt.show()
+
+
+# **Outliers are present in the continous columns of the feature**. We will check the z-score of the features and and clip them from the data.
+
+# In[43]:
+
+
+from scipy.stats import zscore
+zabs = np.abs(zscore(new_ds.loc[:,'fnlwgt':'hours.per.week']))
+print(np.shape(np.where(zabs >= 3)))
+new_ds = new_ds[(zabs < 3).all(axis = 1)]
+new_ds
+
+
+# WE have a total of 2566 outliers in the data. After removing the outliers, we have 28213 observations left.
+# ## Correlation:
+# Checking the correlation between the features and target variable to see which of them columns are more related to target.
+
+# In[44]:
+
+
+plt.figure(figsize = (14, 8))
+plt.title("Correlation between target and features:")
+sns.heatmap(new_ds.corr(), annot = True)
+plt.show()
+
+
+# 'Capital_gain', 'Education_num', 'Marital_status_enc', 'Relationship_enc' are most correlated to the Income of the observations.
+# ## Scaling:
+# As we see that the values of attributes in the dataset vary largely, so it is important to scale the data. Using the Min-Max scaler in order to bring normalisation in the data.
+
+# In[45]:
+
+
+from sklearn.preprocessing import MinMaxScaler
+scale = MinMaxScaler()
+new_ds.loc[:,'age':'hours.per.week'] = scale.fit_transform(new_ds.loc[:,'age':'hours.per.week'])
+new_ds
+
+
+# AS we can see from the above table that the data is now more normalised and can be used by the models for learning.
+# ![](https://kiarofoods.com/wp-content/uploads/2019/10/line_break.png)
+# # Data Imbalance:
+# If the data is imbalanced, it can cause the overfitting and bias in the odel prediction. So it is important to check and cure the data imbalance if present. We check the target variable to see if it is balanced or not.
+
+# In[46]:
+
+
+plt.figure(figsize = (8, 4))
+plt.title("Values distribution in target class: Income")
+sns.countplot(data = new_ds, x = 'income')
+plt.show()
+
+
+# As we can see that data is imbalanced. In order **to remove the data imbalance, we use the SMOTETomek class to create synthetic values using KNN algorithm.**
+
+# In[47]:
+
+
+from imblearn.combine import SMOTETomek
+x = new_ds.loc[:,"age":"relationship_enc"]
+y = new_ds.loc[:,"income"]
+smk = SMOTETomek()
+x_new, y_new = smk.fit_resample(x, y)
+
+
+# In[48]:
+
+
+plt.figure(figsize = (8, 4))
+plt.title("Values in target class after using SMOTETomek")
+sns.countplot(x = y_new)
+plt.show()
+
+
+# As we can see that we now have a balanced dataset, so we can model ahead with the model building part.
+# ![](https://kiarofoods.com/wp-content/uploads/2019/10/line_break.png)
+# # Model Building:
+# Starting with the spliting of the training and testing data. For that, we check to see what is the best random state.
+
+# In[49]:
+
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+from sklearn.model_selection import train_test_split
+
+max_accuracy = 0
+best_rs = 0
+for i in range(1, 150):
+    x_train, x_test, y_train, y_test = train_test_split(x_new, y_new, test_size = 0.30, random_state = i)
+    lg = LogisticRegression()
+    lg.fit(x_train, y_train)
+    pred = lg.predict(x_test)
+    acc = accuracy_score(y_test, pred)
+    if acc > max_accuracy: # after each iteration, acc is replace by the best possible accuracy
+        max_accuracy = acc
+        best_rs = i
+print(f"Best Random State is {best_rs}, {max_accuracy*100}")
+
+
+# Best possible random state is 67, so using it to split the data
+
+# In[50]:
+
+
+x_train, x_test, y_train, y_test = train_test_split(x_new, y_new, test_size = 0.30, random_state = 67)
+
+
+# In[51]:
+
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+
+
+# ## Model Fitting:
+# Fitting 7 different models to check which model gives the best accuracy.
+
+# In[52]:
+
+
+# For Logistic Regression
+lg = LogisticRegression()
+lg.fit(x_train, y_train)
+pred_lg = lg.predict(x_test)
+print("Accuracy Score of Logistic Regression model is", accuracy_score(y_test, pred_lg)*100)
+
+# For Decision Tree Classifier
+dtc = DecisionTreeClassifier()
+dtc.fit(x_train, y_train)
+pred_dtc = dtc.predict(x_test)
+print("Accuracy Score of Decision Tree Classifier model is", accuracy_score(y_test, pred_dtc)*100)
+
+# For K-Nearest Neighbour Classifier
+knc = KNeighborsClassifier(n_neighbors = 5)
+knc.fit(x_train, y_train)
+pred_knc = knc.predict(x_test)
+print("Accuracy Score of K-Nearest Neighbour Classifier model is", accuracy_score(y_test, pred_knc)*100)
+
+# For Support Vector Classifier
+svc = SVC(kernel = 'rbf')
+svc.fit(x_train, y_train)
+pred_svc = svc.predict(x_test)
+print("Accuracy Score of Support Vector Classifier model is", accuracy_score(y_test, pred_svc)*100)
+
+# For Random Forest Classifier
+rfc = RandomForestClassifier()
+rfc.fit(x_train, y_train)
+pred_rfc = rfc.predict(x_test)
+print("Accuracy Score of Random Forest model is", accuracy_score(y_test, pred_rfc)*100)
+
+# For MultinomialNB
+nb = MultinomialNB() # making the Multinomial Naive Bayes class
+nb.fit(x_train, y_train) # fitting the model
+pred_nb = nb.predict(x_test) # predicting the values
+print("Accuracy Score of MultinomialNB model is", accuracy_score(y_test, pred_nb)*100)
+
+# For ADA Boost Classifier
+ada= AdaBoostClassifier()
+ada.fit(x_train, y_train) # fitting the model
+pred_ada = ada.predict(x_test) # predicting the values
+print("Accuracy Score of ADA Boost model is", accuracy_score(y_test, pred_ada)*100)
+
+
+# Best accuracy score is given by Random Forest Classifier model. In order to avoid the bias and overfitting or underfitting, we cross validate the models and check the mean accuracy score of them.
+# ## Cross Validation:
+# Cross validating the m,odels to see if they are underfitting or overfitting and to prevent bias. We will compare the mean accuracy scores of the model.
+
+# In[53]:
+
+
+from sklearn.model_selection import cross_val_score
+
+lg_scores = cross_val_score(lg, x_new, y_new, cv = 10) # cross validating the model
+print(lg_scores) # accuracy scores of each cross validation cycle
+print(f"Mean of accuracy scores is for Logistic Regression is {lg_scores.mean()*100}\n")
+
+dtc_scores = cross_val_score(dtc, x_new, y_new, cv = 10)
+print(dtc_scores)
+print(f"Mean of accuracy scores is for Decision Tree Classifier is {dtc_scores.mean()*100}\n")
+
+knc_scores = cross_val_score(knc, x_new, y_new, cv = 10)
+print(knc_scores)
+print(f"Mean of accuracy scores is for KNN Classifier is {knc_scores.mean()*100}\n")
+
+svc_scores = cross_val_score(svc, x_new, y_new, cv = 10)
+print(svc_scores)
+print(f"Mean of accuracy scores is for SVC Classifier is {svc_scores.mean()*100}\n")
+
+rfc_scores = cross_val_score(rfc, x_new, y_new, cv = 10)
+print(rfc_scores)
+print(f"Mean of accuracy scores is for Random Forest Classifier is {rfc_scores.mean()*100}\n")
+
+nb_scores = cross_val_score(nb, x_new, y_new, cv = 10)
+print(nb_scores)
+print(f"Mean of accuracy scores is for MultinomialNB is {nb_scores.mean()*100}\n")
+
+ada_scores = cross_val_score(ada, x_new, y_new, cv = 10)
+print(ada_scores)
+print(f"Mean of accuracy scores is for ADA Boost Classifier is {ada_scores.mean()*100}\n")
+
+
+# In[54]:
+
+
+# Checking for difference between accuracy and mean accuracies.
+lis3 = ['Logistic Regression','Decision Tree Classifier','KNeighbors Classifier','SVC', 'Random Forest Classifier', 
+        'MultinomialNB', 'ADA Boost Classifier']
+
+lis1 = [accuracy_score(y_test, pred_lg)*100, accuracy_score(y_test, pred_dtc)*100, accuracy_score(y_test, pred_knc)*100, 
+        accuracy_score(y_test, pred_svc)*100, accuracy_score(y_test, pred_rfc)*100, accuracy_score(y_test, pred_nb)*100,
+        accuracy_score(y_test, pred_ada)*100]
+
+lis2 = [lg_scores.mean()*100, dtc_scores.mean()*100, knc_scores.mean()*100, svc_scores.mean()*100, rfc_scores.mean()*100, 
+        nb_scores.mean()*100, ada_scores.mean()*100]
+
+for i in range(0, 7):
+    dif = (lis1[i]) - (lis2[i])
+    print(lis3[i], dif)
+
+
+# **Random forest classifier is the best model with highest cross validation mean score and accuracy score**. We will use it for the model building.
+# ## Hyperparameter Tuning:
+# Tuning the parameters of the Random Forest in order to obtain the best possible parameters for model building.
+
+# In[55]:
+
+
+from sklearn.model_selection import GridSearchCV
+rfc = RandomForestClassifier()
+param = dict()
+param['criterion'] = ['gini', 'entropy']
+param['n_estimators'] = [1, 2, 4, 8, 10, 16, 32, 64, 100, 200]
+param['min_samples_split'] = [1,2,5,8,10,15,20,25,50,55,60,80,100]
+
+
+gs = GridSearchCV(estimator = rfc, param_grid = param, scoring='f1', cv = 5, n_jobs = 3)
+gs.fit(x_train, y_train)
+print(gs.best_score_)
+print(gs.best_params_)
+
+
+# After the hyperparameter tuning, **the best parameters for Random Forest Classifier are 'crietrion' = 'entropy', 'min_samples_split' = 2, 'n_estimators' = 100**. We build the model using these parameters.
+
+# In[56]:
+
+
+rfc = RandomForestClassifier(criterion = 'entropy', min_samples_split = 2, n_estimators = 100)
+rfc.fit(x_train, y_train)
+print(rfc.score(x_train, y_train))
+pred_rfc = rfc.predict(x_test)
+
+
+# ![](https://kiarofoods.com/wp-content/uploads/2019/10/line_break.png)
+# # Model Evaluation:
+# We have build the model after the cross validation and hyper parameter tuning. It is now time to evaluate the model using the classification report, confusion matrix and ROC curve.
+
+# In[57]:
+
+
+from sklearn.metrics import plot_roc_curve
+from sklearn.metrics import confusion_matrix, classification_report
+
+print("Accuracy Score of RFC model is", accuracy_score(y_test, pred_rfc)*100)
+print("Confusion matrix for RFC Model is")
+print(confusion_matrix(y_test, pred_rfc))
+print("Classification Report of the RFC Model is")
+print(classification_report(y_test, pred_rfc))
+
+plot_roc_curve(rfc, x_test, y_test) # arg. are model name, feature testing data, label testing data.
+plt.title("Recevier's Operating Characteristic")
+plt.xlabel("False Positive Rate")
+plt.ylabel("True Positive Rate")
+plt.show()
+
+
+# After the model evaluation , we get the **precision and recall for both the target variable as 0.92 and 0.91**. The **f1- score of the model is 0.92**. The ROC curve gave us **the AUC score which is 0.98**. Model evaluation gives the results that ***the prediction is very accurate.***
+# ![](https://miro.medium.com/max/2400/1*IH10jlQEJ7GW1_oq8s7WPw.png)
+# # Serialisation:
+# Now we save the Random Forest Classifier Model as an object using joblib.
+
+# In[58]:
+
+
+import joblib
+joblib.dump(rfc, 'Census Income Prediction.obj') # saving the model as an object
+
+
+# In[ ]:
+
+
+
+

AdultNoteBook/Kernels/AdaBoost/7-adult-census-income-eda-and-prediction-87-35.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Adult Census Income EDA and Prediction
+# 
+# In this kernel I work with the UCI Adult Census Income dataset. The prediction task is to determine whether a person makes over $50K a year. I start with an exhaustive EDA, and I then train various models to solve the prediction task.
+
+# In[1]:
+
+
+import numpy as np
+import pandas as pd 
+import matplotlib.pyplot as plt 
+import seaborn as sns
+get_ipython().run_line_magic('matplotlib', 'inline')
+
+
+import os
+print(os.listdir("../input"))
+
+data = pd.read_csv("../input/adult.csv")
+
+
+# ## Exploratory Data Analysis
+
+# In[2]:
+
+
+print(len(data))
+data.head(10)
+
+
+# In[3]:
+
+
+data.isnull().sum()
+
+
+# Good.
+
+# In[4]:
+
+
+data.dtypes
+
+
+# In[5]:
+
+
+sns.countplot(data['income'])
+plt.show()
+
+
+# ### Distribution of features
+
+# In[6]:
+
+
+# Sex distribution
+sns.countplot(data['sex'])
+plt.show()
+
+
+# In[7]:
+
+
+# Age distribution
+ages = data['age'].hist(bins=max(data['age'])-min(data['age']))
+mean_val = np.mean(data['age'])
+plt.axvline(mean_val, linestyle='dashed', linewidth=2, color='yellow', label='mean age')
+plt.xlabel('age')
+plt.ylabel('count')
+plt.legend()
+plt.show()
+
+
+# In[8]:
+
+
+data['hours.per.week'].hist()
+plt.xlabel('hours per week')
+plt.ylabel('count')
+plt.show()
+
+
+# In[9]:
+
+
+fig, axs = plt.subplots(ncols=2, nrows=4, figsize=(20, 20))
+plt.subplots_adjust(hspace=0.68)
+fig.delaxes(axs[3][1])
+
+
+# Workclass
+wc_plot = sns.countplot(data['workclass'], ax=axs[0][0])
+wc_plot.set_xticklabels(wc_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Native country
+nc_plot = sns.countplot(data['native.country'], ax=axs[0][1])
+nc_plot.set_xticklabels(nc_plot.get_xticklabels(), rotation=72, ha="right")
+
+# Education
+order=['Preschool', '1st-4th', '5th-6th', '7th-8th', '9th', '10th', '11th', '12th', 'HS-grad',
+       'Some-college', 'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Masters', 'Prof-school', 'Doctorate']
+ed_plot = sns.countplot(data['education'], order=order, ax=axs[1][0])
+ed_plot.set_xticklabels(ed_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Marital status
+ms_plot = sns.countplot(data['marital.status'], ax=axs[1][1])
+ms_plot.set_xticklabels(ms_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Relationship
+rel_plot = sns.countplot(data['relationship'], ax=axs[2][0])
+rel_plot.set_xticklabels(rel_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Race
+race_plot = sns.countplot(data['race'], ax=axs[2][1])
+race_plot.set_xticklabels(race_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Occupation
+occ_plot = sns.countplot(data['occupation'], ax=axs[3][0])
+occ_plot.set_xticklabels(occ_plot.get_xticklabels(), rotation=40, ha="right")
+
+plt.show()
+
+
+# 
+# ### How do features relate to one another?
+
+# In[10]:
+
+
+plt.figure(figsize=(24, 6))
+ro = sns.countplot(data['occupation'], hue=data['sex'])
+ro.set_xticklabels(ro.get_xticklabels(), rotation=30, ha="right")
+plt.show()
+
+
+# In[11]:
+
+
+plt.figure(figsize=(20, 6))
+ro = sns.countplot(data['education'], hue=data['sex'], order=order)
+ro.set_xticklabels(ro.get_xticklabels(), rotation=40, ha="right")
+#ro.set_yscale('log')
+plt.show()
+
+
+# In[12]:
+
+
+data['income'] = data['income'].map({'<=50K': 0, '>50K': 1}) 
+
+
+# ### How do features relate to income?
+
+# In[13]:
+
+
+fig, axs = plt.subplots(ncols=2, nrows=4, figsize=(24, 28))
+#fig.delaxes(axs[3][1])
+plt.subplots_adjust(hspace=0.4)
+
+# education and income
+sns.catplot(x="education", y="income", data=data, kind="bar", height = 6, palette = "muted", order=order, ax=axs[0][0])
+axs[0][0].set_xticklabels(axs[0][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[0][0].set_ylabel(">50K probability")
+
+sns.catplot(x="workclass", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[0][1])
+axs[0][1].set_xticklabels(axs[0][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[0][1].set_ylabel(">50K probability")
+
+
+sns.catplot(x="relationship", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[1][0])
+axs[1][0].set_xticklabels(axs[1][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[1][0].set_ylabel(">50K probability")
+
+sns.catplot(x="marital.status", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[1][1])
+axs[1][1].set_xticklabels(axs[1][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[1][1].set_ylabel(">50K probability")
+
+sns.catplot(x="race", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[2][0])
+axs[2][0].set_xticklabels(axs[2][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[2][0].set_ylabel(">50K probability")
+
+sns.catplot(x="native.country", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[2][1])
+axs[2][1].set_xticklabels(axs[2][1].axes.get_xticklabels(), rotation=55, ha="right")
+axs[2][1].set_ylabel(">50K probability")
+
+sns.catplot(x="sex", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[3][0])
+axs[3][0].set_xticklabels(axs[3][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[3][0].set_ylabel(">50K probability")
+
+sns.catplot(x="occupation", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[3][1])
+axs[3][1].set_xticklabels(axs[3][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[3][1].set_ylabel(">50K probability")
+
+#ed_income.set_ylabels(">50K probability")
+
+for i in range(2,10):
+        plt.close(i)
+
+plt.show()
+
+
+# #### Another way of visualizing this
+
+# In[14]:
+
+
+plt.figure(figsize=(20, 6))
+sns.countplot(data['marital.status'], hue=data['income'])
+plt.show()
+
+
+# ## Data Preparation
+# 
+# Now the data needs to be prepared for prediction.
+
+# In[15]:
+
+
+data['sex'] = data['sex'].map({'Male': 1, 'Female': 0}) 
+
+
+# In[16]:
+
+
+data['race'] = data['race'].map({'White': 1, 'Asian-Pac-Islander': 1, 'Black':0, 'Amer-Indian-Eskimo':0, 'Other':0}) 
+data['relationship'] = data['relationship'].map({'Not-in-family':0, 'Unmarried':0, 'Own-child':0, 'Other-relative':0, 'Husband':1, 'Wife':1})
+data['marital.status'] = data['marital.status'].map({'Widowed':0, 'Divorced':0, 'Separated':0, 'Never-married':0, 'Married-civ-spouse':1, 'Married-AF-spouse':1, 'Married-spouse-absent':0})
+
+
+# In[17]:
+
+
+g = sns.heatmap(data[['relationship', 'marital.status']].corr(),annot=True, fmt = ".2f", cmap = "coolwarm")
+plt.show()
+
+
+# relationship and marital.status contain the same information now, so one of them can be removed
+
+# In[18]:
+
+
+data.drop(['marital.status'], axis=1,inplace=True)
+
+
+# LabelEncoder can be used to transform the rest of the categorical features.
+
+# In[19]:
+
+
+# data.drop(['workclass', 'education', 'occupation', 'native.country'], axis=1,inplace=True)
+
+data.drop(['education'], axis=1,inplace=True)
+
+labels = ['workclass', 'occupation', 'native.country']
+
+from sklearn.preprocessing import LabelEncoder
+le = LabelEncoder()
+for l in labels:
+    data[l]=le.fit_transform(data[l])
+
+
+# In[20]:
+
+
+data.head(10)
+
+
+# The dataset is ready.
+
+# ## Prediction
+
+# #### Importing the relevant libraries
+
+# In[21]:
+
+
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, VotingClassifier, BaggingClassifier, ExtraTreesClassifier
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.model_selection import GridSearchCV, cross_val_score, cross_val_predict, StratifiedKFold, learning_curve, train_test_split, KFold
+# from sklearn.metrics import classification_report
+from sklearn.metrics import confusion_matrix, accuracy_score
+from sklearn.svm import SVC
+
+
+# #### Preparing data for training and testing with k-fold Cross-Validation
+
+# In[22]:
+
+
+seed = 42
+
+from sklearn.preprocessing import StandardScaler
+
+X = StandardScaler().fit_transform(data.loc[:, data.columns != 'income'])
+Y = data['income']
+
+# X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
+
+kf = KFold(n_splits=10, shuffle=True, random_state=seed)
+
+
+# In[23]:
+
+
+a = len(data.loc[data.income==0])/len(data)
+print(a)
+
+
+# One would get a 76% accuracy by just always predicting <=50k. Our model has to do better than that or it's not learning anything.
+
+# ### Starting with some simple models
+
+# In[24]:
+
+
+
+fig, axs = plt.subplots(ncols=2, nrows=2, figsize=(24, 14))
+
+
+classifiers = [
+    LogisticRegression(solver='newton-cg'),
+    KNeighborsClassifier(n_neighbors=17), # Some trial and error I don't show went into this hyperpa
+    LinearDiscriminantAnalysis(),
+    GaussianNB()
+]
+
+
+for i, c in enumerate(classifiers):
+    
+    x_axs = i%2
+    y_axs = int(i/2)
+    # print(c)
+    print(type(c).__name__)
+    pred = cross_val_predict(c, X, Y, cv=kf)
+    print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+
+    sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g', ax=axs[y_axs][x_axs])
+    axs[y_axs][x_axs].set_xlabel('Predicted')
+    axs[y_axs][x_axs].set_ylabel('Real')
+    axs[y_axs][x_axs].set_title(type(c).__name__)
+
+plt.show()
+
+
+# Logistic regression performs best with 84.25% accuracy. 
+# 
+
+# ### More complex models
+
+# In[25]:
+
+
+import warnings
+warnings.filterwarnings(action='ignore')
+fig, axs = plt.subplots(ncols=2, nrows=3, figsize=(24, 21))
+
+classifiers = [
+    DecisionTreeClassifier(),
+    BaggingClassifier(),
+    RandomForestClassifier(),
+    ExtraTreesClassifier(),
+    GradientBoostingClassifier(),
+    AdaBoostClassifier()
+]
+
+
+for i, c in enumerate(classifiers):
+    
+    x_axs = i%2
+    y_axs = int(i/2)
+    
+    # print(c)
+    print(type(c).__name__)
+    pred = cross_val_predict(c, X, Y, cv=kf)
+    print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+    
+    sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g', ax=axs[y_axs][x_axs])
+    axs[y_axs][x_axs].set_xlabel('Predicted')
+    axs[y_axs][x_axs].set_ylabel('Real')
+    axs[y_axs][x_axs].set_title(type(c).__name__)
+
+plt.show()
+
+
+# Gradient Boosting with no hyperparameter tuning gets to 86.58% accuracy. Not bad. Let's see if we can do better.
+
+# ### Model Tuning
+
+# GridSearchCV allows to try out a lot of hyperparameters at once.
+
+# In[26]:
+
+
+'''
+# This takes about 2 hours to run
+params = {'max_depth': [5, 6, 7], 
+         'n_estimators': [100, 150, 200],
+          'learning_rate': [0.1, 0.07, 0.05],
+          'max_features': ['sqrt', 'log2', 3, 4, 5]
+         }
+'''
+
+
+params = {'max_depth': [6], 
+         'n_estimators': [200],
+          'learning_rate': [0.07, 0.06],
+          'max_features': [3,4]
+         }
+
+classifier = GradientBoostingClassifier()
+
+grid = GridSearchCV(classifier, param_grid=params, cv=kf)
+search_result = grid.fit(X, Y)
+
+
+# In[27]:
+
+
+# GridSearch results
+means = search_result.cv_results_['mean_test_score']
+params = search_result.cv_results_['params']
+for m, p in zip(means, params):
+    print(f"{m} with: {p}")
+
+
+# In[28]:
+
+
+p = np.argmax(means)
+best_param = params[p]
+
+final_model = GradientBoostingClassifier(**best_param)
+
+print(final_model)
+pred = cross_val_predict(final_model, X, Y, cv=kf)
+print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+
+sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g')
+plt.show()
+
+
+# Final prediction accuracy: 87.35%

AdultNoteBook/Kernels/ExtraTrees/1-income-prediction-84-369-accuracy.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# #Income Prediction Problem
+# In this Notebook, I am working through the Income Prediction problem associated with the Adult Income Census dataset. The goal is to accurately predict whether or not someone is making more or less than $50,000 a year. While working through this problem, I am following a framework I use to attack all my machine learning problems. It includes the following steps:
+# 
+# 1. Load Libraries
+# 2. Load Data
+# 3. Analyze Data
+# 4. Feature Engineering
+# 5. Modeling
+# 6. Algorithm Tuning
+# 7. Finalizing the Model
+# 
+# I hope you enjoy this notebook and find it useful. Please keep in mind this is my first Notebook on here so don't judge it too harshly!
+
+# ##1. Load Libaraies
+
+# First, we need to load all of our libraries we will use for this project.
+
+# In[1]:
+
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+get_ipython().run_line_magic('matplotlib', 'inline')
+
+from collections import Counter
+
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, VotingClassifier
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neural_network import MLPClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold, learning_curve, train_test_split, KFold
+from sklearn.metrics import classification_report
+from sklearn.metrics import confusion_matrix
+from sklearn.metrics import accuracy_score
+
+sns.set(style='white', context='notebook', palette='deep')
+
+
+# ##2. Load Data
+
+# Next, we load our data.
+
+# In[2]:
+
+
+dataset = pd.read_csv("../input/adult.csv")
+
+# Check for Null Data
+dataset.isnull().sum()
+
+
+# In[3]:
+
+
+# Replace All Null Data in NaN
+dataset = dataset.fillna(np.nan)
+
+
+# In[4]:
+
+
+# Get data types
+dataset.dtypes
+
+
+# In[5]:
+
+
+# Peek at data
+dataset.head(4)
+
+
+# In[6]:
+
+
+
+# Reformat Column We Are Predicting
+dataset['income']=dataset['income'].map({'<=50K': 0, '>50K': 1, '<=50K.': 0, '>50K.': 1})
+dataset.head(4)
+
+
+# ##3. Analyze Data
+
+# In[7]:
+
+
+# Identify Numeric features
+numeric_features = ['age','fnlwgt','education.num','capital.gain','capital.loss','hours.per.week','income']
+
+# Identify Categorical features
+cat_features = ['workclass','education','marital.status', 'occupation', 'relationship', 'race', 'sex', 'native']
+
+
+# ###3.1. Numeric Data Analysis
+
+# In[8]:
+
+
+# Count of >50K & <=50K
+sns.countplot(dataset['income'],label="Count")
+sns.plt.show()
+
+
+# In[9]:
+
+
+# Correlation matrix between numerical values
+g = sns.heatmap(dataset[numeric_features].corr(),annot=True, fmt = ".2f", cmap = "coolwarm")
+sns.plt.show()
+
+
+# In[10]:
+
+
+# Explore Education Num vs Income
+g = sns.factorplot(x="education.num",y="income",data=dataset,kind="bar",size = 6,palette = "muted")
+g.despine(left=True)
+g = g.set_ylabels(">50K probability")
+
+
+# In[11]:
+
+
+# Explore Hours Per Week vs Income
+g  = sns.factorplot(x="hours.per.week",y="income",data=dataset,kind="bar",size = 6,palette = "muted")
+g.despine(left=True)
+g = g.set_ylabels(">50K probability")
+
+
+# In[12]:
+
+
+# Explore Age vs Income
+g = sns.FacetGrid(dataset, col='income')
+g = g.map(sns.distplot, "age")
+sns.plt.show()
+
+
+# ###3.2. Categorical Data Analysis
+
+# In[13]:
+
+
+# Fill Missing Category Entries
+dataset["workclass"] = dataset["workclass"].fillna("X")
+dataset["occupation"] = dataset["occupation"].fillna("X")
+dataset["native.country"] = dataset["native.country"].fillna("United-States")
+
+# Confirm All Missing Data is Handled
+dataset.isnull().sum()
+
+
+# In[14]:
+
+
+# Explore Native Nation vs Income
+g = sns.barplot(x="native.country",y="income",data=dataset)
+g = g.set_ylabel("Income >50K Probability")
+sns.plt.show()
+
+
+# In[15]:
+
+
+# Explore Sex vs Income
+g = sns.barplot(x="sex",y="income",data=dataset)
+g = g.set_ylabel("Income >50K Probability")
+sns.plt.show()
+
+
+# In[16]:
+
+
+# Explore Relationship vs Income
+g = sns.factorplot(x="relationship",y="income",data=dataset,kind="bar", size = 6 ,
+palette = "muted")
+g.despine(left=True)
+g = g.set_ylabels("Income >50K Probability")
+sns.plt.show()
+
+
+# In[17]:
+
+
+# Explore Marital Status vs Income
+g = sns.factorplot(x="marital.status",y="income",data=dataset,kind="bar", size = 6 ,
+palette = "muted")
+g.despine(left=True)
+g = g.set_ylabels("Income >50K Probability")
+sns.plt.show()
+
+
+# In[18]:
+
+
+# Explore Workclass vs Income
+g = sns.factorplot(x="workclass",y="income",data=dataset,kind="bar", size = 6 ,
+palette = "muted")
+g.despine(left=True)
+g = g.set_ylabels("Income >50K Probability")
+sns.plt.show()
+
+
+# ##4. Feature Engineering
+
+# In[19]:
+
+
+####################################################
+############### FEATURE ENGINEERING ################
+####################################################
+# Convert Sex value to 0 and 1
+dataset["sex"] = dataset["sex"].map({"Male": 0, "Female":1})
+
+# Create Married Column - Binary Yes(1) or No(0)
+dataset["marital.status"] = dataset["marital.status"].replace(['Never-married','Divorced','Separated','Widowed'], 'Single')
+dataset["marital.status"] = dataset["marital.status"].replace(['Married-civ-spouse','Married-spouse-absent','Married-AF-spouse'], 'Married')
+dataset["marital.status"] = dataset["marital.status"].map({"Married":1, "Single":0})
+dataset["marital.status"] = dataset["marital.status"].astype(int)
+
+# Drop the data you don't want to use
+dataset.drop(labels=["workclass","education","occupation","relationship","race","native.country"], axis = 1, inplace = True)
+print('Dataset with Dropped Labels')
+print(dataset.head())
+
+
+# ##5. Modeling
+
+# In[20]:
+
+
+###################################################
+##################### MODELING #####################
+####################################################
+# Split-out Validation Dataset and Create Test Variables
+array = dataset.values
+X = array[:,0:8]
+Y = array[:,8]
+print('Split Data: X')
+print(X)
+print('Split Data: Y')
+print(Y)
+validation_size = 0.20
+seed = 7
+num_folds = 10
+scoring = 'accuracy'
+X_train, X_validation, Y_train, Y_validation = train_test_split(X,Y,
+    test_size=validation_size,random_state=seed)
+
+# Params for Random Forest
+num_trees = 100
+max_features = 3
+
+#Spot Check 5 Algorithms (LR, LDA, KNN, CART, GNB, SVM)
+models = []
+models.append(('LR', LogisticRegression()))
+models.append(('LDA', LinearDiscriminantAnalysis()))
+models.append(('KNN', KNeighborsClassifier()))
+models.append(('CART', DecisionTreeClassifier()))
+models.append(('NB', GaussianNB()))
+models.append(('RF', RandomForestClassifier(n_estimators=num_trees, max_features=max_features)))
+#models.append(('SVM', SVC()))
+# evalutate each model in turn
+results = []
+names = []
+for name, model in models:
+    kfold = KFold(n_splits=10, random_state=seed)
+    cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')
+    results.append(cv_results)
+    names.append(name)
+    msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
+    print(msg)
+
+
+# In[21]:
+
+
+fig = plt.figure()
+fig.suptitle('Algorith Comparison')
+ax = fig.add_subplot(111)
+plt.boxplot(results)
+ax.set_xticklabels(names)
+plt.show()
+
+
+# ##6. Algorithm Tuning
+
+# In[22]:
+
+
+####################################################
+################ ALGORITHM TUNING ##################
+####################################################
+'''
+Commented Out to Reduce Script Time - Took 20 Minutes to run.
+best n_estimator = 250
+best max_feature = 5
+# Tune Random Forest
+n_estimators = np.array([50,100,150,200,250])
+max_features = np.array([1,2,3,4,5])
+param_grid = dict(n_estimators=n_estimators,max_features=max_features)
+model = RandomForestClassifier()
+kfold = KFold(n_splits=num_folds, random_state=seed)
+grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=scoring, cv=kfold)
+grid_result = grid.fit(X_train, Y_train)
+print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
+means = grid_result.cv_results_['mean_test_score']
+stds = grid_result.cv_results_['std_test_score']
+params = grid_result.cv_results_['params']
+for mean, stdev, param in zip(means, stds, params):
+    print("%f (%f) with: %r" % (mean, stdev, param))
+'''
+
+
+# ##7. Finalize Model
+
+# In[23]:
+
+
+####################################################
+################# FINALIZE MODEL ###################
+####################################################
+# 5. Finalize Model
+# a) Predictions on validation dataset - KNN
+random_forest = RandomForestClassifier(n_estimators=250,max_features=5)
+random_forest.fit(X_train, Y_train)
+predictions = random_forest.predict(X_validation)
+print("Accuracy: %s%%" % (100*accuracy_score(Y_validation, predictions)))
+print(confusion_matrix(Y_validation, predictions))
+print(classification_report(Y_validation, predictions))
+

AdultNoteBook/Kernels/ExtraTrees/10-accurate-predictions-with-20-test-data.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+import numpy as np
+get_ipython().run_line_magic('matplotlib', 'inline')
+
+
+# In[2]:
+
+
+data = pd.DataFrame.from_csv("../input/adult.csv", header=0, index_col=None)
+
+
+# In[3]:
+
+
+data.head(5)
+
+
+# In[4]:
+
+
+data["income"].value_counts()
+
+
+# In[5]:
+
+
+data.isnull().values.any()
+
+
+# In[6]:
+
+
+data = data.replace("?", np.nan)
+
+
+# In[7]:
+
+
+data.isnull().sum()
+
+
+# In[8]:
+
+
+null_data = data[pd.isnull(data).any(1)]
+null_data["income"].value_counts()
+
+
+# In[9]:
+
+
+data.dropna(inplace=True)
+
+
+# In[10]:
+
+
+bins = (-1, 0, 5, 12, 18, 25, 35, 60, 120)
+group_names = ['Unknown', 'Baby', 'Child', 'Teenager', 'Student', 'Young Adult', 'Adult', 'Senior']
+categories = pd.cut(data["age"], bins, labels=group_names)
+data["age"] = categories
+
+
+# In[11]:
+
+
+sns.countplot(y='native.country',data=data)
+
+
+# In[12]:
+
+
+sns.countplot(y='education', hue='income', data=data)
+
+
+# In[13]:
+
+
+sns.countplot(y='occupation', hue='income', data=data)
+
+
+# In[14]:
+
+
+# education = education.num
+data.drop(["education", "fnlwgt"], axis=1, inplace=True)
+
+
+# In[15]:
+
+
+from sklearn import preprocessing
+
+
+# In[16]:
+
+
+for f in data:
+    if f in ["age", "workclass", "marital.status", "occupation", "relationship", "race", "sex", "native.country", "income"]:
+        le = preprocessing.LabelEncoder()
+        le = le.fit(data[f])
+        data[f] = le.transform(data[f])
+data.head(5)
+
+
+# In[17]:
+
+
+y = data["income"]
+X = data.drop(["income"], axis=1)
+
+
+# In[18]:
+
+
+from sklearn.ensemble import ExtraTreesClassifier
+
+
+# In[19]:
+
+
+forest = ExtraTreesClassifier(n_estimators=100,random_state=0)
+
+forest.fit(X, y)
+
+importances = forest.feature_importances_
+std = np.std([tree.feature_importances_ for tree in forest.estimators_],axis=0)
+indices = np.argsort(importances)[::-1]
+
+plt.figure()
+plt.title("Feature importances")
+plt.bar(range(X.shape[1]), importances[indices], color="r", yerr=std[indices], align="center")
+plt.xticks(range(X.shape[1]), indices)
+plt.xlim([-1, X.shape[1]])
+plt.show()
+
+
+# In[20]:
+
+
+X = data.drop(["race", "native.country", "sex", "capital.loss", "workclass", "age"], axis=1)
+
+
+# In[21]:
+
+
+from sklearn.model_selection import train_test_split
+
+
+# In[22]:
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
+
+
+# In[23]:
+
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score
+
+
+# In[24]:
+
+
+forest = RandomForestClassifier(10)
+forest.fit(X_train, y_train)
+
+
+# In[25]:
+
+
+predictions = forest.predict_proba(X_test)
+predictions = [np.argmax(p) for p in predictions]
+
+
+# In[26]:
+
+
+precision = accuracy_score(predictions, y_test) * 100
+
+
+# In[27]:
+
+
+print("Precision: {0}%".format(precision))
+

AdultNoteBook/Kernels/ExtraTrees/12-compare-all-the-classification-models.py

@@ -0,0 +1,1690 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # 1. Introduction
+# A census is the procedure of systematically acquiring and recording information about the members of a given population.
+# The census is a special, wide-range activity, which takes place once a decade in the entire country. The purpose is to gather information about the general population, in order to present a full and reliable picture of the population in the country - its housing conditions and demographic, social and economic characteristics. The information collected includes data on age, gender, country of origin, marital status, housing conditions, marriage, education, employment, etc.
+
+# ## 1.1  Data description
+# This data was extracted from the 1994 Census bureau database by Ronny Kohavi and Barry Becker (Data Mining and Visualization, Silicon Graphics).  The prediction task is to determine whether a person makes over $50K a year.
+
+# ## 1.2 Features Description
+# **1. Categorical Attributes**
+#  * **workclass**:  Private, Self-emp-not-inc, Self-emp-inc, Federal-gov, Local-gov, State-gov, Without-pay, Never-worked.
+#   -  Individual work category  
+#  * **education**: Bachelors, Some-college, 11th, HS-grad, Prof-school, Assoc-acdm, Assoc-voc, 9th, 7th-8th, 12th, Masters, 1st-4th, 10th, Doctorate, 5th-6th, Preschool.
+#   -  Individual's highest education degree  
+#  * **marital-status**: Married-civ-spouse, Divorced, Never-married, Separated, Widowed, Married-spouse-absent, Married-AF-spouse.
+#   -  Individual marital status  
+#  * **occupation**:  Tech-support, Craft-repair, Other-service, Sales, Exec-managerial, Prof-specialty, Handlers-cleaners, Machine-op-inspct, Adm-clerical, Farming-fishing, Transport-moving, Priv-house-serv, Protective-serv, Armed-Forces.
+#   -  Individual's occupation  
+#  * **relationship**:  Wife, Own-child, Husband, Not-in-family, Other-relative, Unmarried.
+#   -  Individual's relation in a family   
+#  * **race**:  White, Asian-Pac-Islander, Amer-Indian-Eskimo, Other, Black.
+#   -  Race of Individual   
+#  * **sex**:  Female, Male.
+#  * **native-country**:  United-States, Cambodia, England, Puerto-Rico, Canada, Germany, Outlying-US(Guam-USVI-etc), India, Japan, Greece, South, China, Cuba, Iran, Honduras, Philippines, Italy, Poland, Jamaica, Vietnam, Mexico, Portugal, Ireland, France, Dominican-Republic, Laos, Ecuador, Taiwan, Haiti, Columbia, Hungary, Guatemala, Nicaragua, Scotland, Thailand, Yugoslavia, El-Salvador, Trinadad&Tobago, Peru, Hong, Holand-Netherlands.
+#   -  Individual's native country   
+#   
+# **2. Continuous Attributes**
+#  * **age**: continuous.
+#   -  Age of an individual  
+#  * **fnlwgt**: final weight, continuous. 
+#  * The weights on the CPS files are controlled to independent estimates of the civilian noninstitutional population of the US.  These are prepared monthly for us by Population Division here at the Census Bureau.
+#  * **capital-gain**: continuous.
+#  * **capital-loss**: continuous.
+#  * **hours-per-week**: continuous.
+#   -  Individual's working hour per week   
+
+# ## 1.3 Objective of this project
+# The goal of this machine learning project is to predict whether a person makes over 50K a year or not given their demographic variation. This is a classification problem.
+
+# # 2. Import packages
+
+# In[ ]:
+
+
+import numpy as np 
+import pandas as pd 
+import seaborn as sns
+import warnings
+warnings.filterwarnings("ignore")
+import plotly.offline as py
+import plotly.graph_objs as go
+import plotly.tools as tls
+import matplotlib.pyplot as plt
+get_ipython().run_line_magic('matplotlib', 'inline')
+
+
+# In[ ]:
+
+
+from sklearn.model_selection import train_test_split,cross_val_score,GridSearchCV
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.ensemble import RandomForestClassifier,AdaBoostClassifier,BaggingClassifier,ExtraTreesClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import ExtraTreesClassifier
+from sklearn.metrics import accuracy_score,confusion_matrix,roc_auc_score
+from sklearn import metrics
+from datetime import datetime
+from sklearn.feature_selection import RFE
+from sklearn.model_selection import StratifiedKFold
+
+
+# ## Load Data
+
+# In[ ]:
+
+
+data = pd.read_csv("../input/adult-census-income/adult.csv")
+data.head()
+
+
+# In[ ]:
+
+
+data.shape
+
+
+# # 3. Data Cleaning
+
+# Fixing the common nan values
+# 
+#     Nan values were as ? in data. Hence we fix this with most frequent element(mode) in the entire dataset. It generalizes well, as we will see with the accuracy of our classifiers
+
+# In[ ]:
+
+
+attrib, counts = np.unique(data['workclass'], return_counts = True)
+most_freq_attrib = attrib[np.argmax(counts, axis = 0)]
+data['workclass'][data['workclass'] == '?'] = most_freq_attrib 
+
+attrib, counts = np.unique(data['occupation'], return_counts = True)
+most_freq_attrib = attrib[np.argmax(counts, axis = 0)]
+data['occupation'][data['occupation'] == '?'] = most_freq_attrib 
+
+attrib, counts = np.unique(data['native.country'], return_counts = True)
+most_freq_attrib = attrib[np.argmax(counts, axis = 0)]
+data['native.country'][data['native.country'] == '?'] = most_freq_attrib 
+
+
+# Lets look the data it again :
+
+# In[ ]:
+
+
+# for later use
+data_num = data.copy()
+data1 = data.copy()
+data.head(10)
+
+
+# # 4. Feature Engineering
+
+# Education
+# 
+#     9th, 10th, 11th, 12th comes under HighSchool Grad but it has mentioned separately
+#     Create Elementary object for 1st-4th, 5th-6th, 7th-8th
+# 
+# Marital Status
+# 
+#     
+#     Married-civ-spouse,Married-spouse-absent,Married-AF-spouse comes under category Married
+#     Divorced, separated again comes under category separated.
+# 
+# Workclass
+# 
+#     Self-emp-not-inc, Self-emp-inc comes under category self employed
+#     Local-gov,State-gov,Federal-gov comes under category goverment emloyees
+# 
+
+# In[ ]:
+
+
+hs_grad = ['HS-grad','11th','10th','9th','12th']
+elementary = ['1st-4th','5th-6th','7th-8th']
+
+# replace elements in list.
+data1['education'].replace(to_replace = hs_grad,value = 'HS-grad',inplace = True)
+data1['education'].replace(to_replace = elementary,value = 'elementary_school',inplace = True)
+
+data1['education'].value_counts()
+
+
+# In[ ]:
+
+
+married= ['Married-spouse-absent','Married-civ-spouse','Married-AF-spouse']
+separated = ['Separated','Divorced']
+
+#replace elements in list.
+data1['marital.status'].replace(to_replace = married ,value = 'Married',inplace = True)
+data1['marital.status'].replace(to_replace = separated,value = 'Separated',inplace = True)
+
+data1['marital.status'].value_counts()
+
+
+# In[ ]:
+
+
+self_employed = ['Self-emp-not-inc','Self-emp-inc']
+govt_employees = ['Local-gov','State-gov','Federal-gov']
+
+#replace elements in list.
+data1['workclass'].replace(to_replace = self_employed ,value = 'Self_employed',inplace = True)
+data1['workclass'].replace(to_replace = govt_employees,value = 'Govt_employees',inplace = True)
+
+data1['workclass'].value_counts()
+
+
+# ### Deleting the unuseful features and observations
+
+# In[ ]:
+
+
+del_cols = ['education.num']
+data1.drop(labels = del_cols,axis = 1,inplace = True)
+
+
+# ### Updating the columns
+
+# In[ ]:
+
+
+num_col_new = ['age','capital.gain', 'capital.loss',
+       'hours.per.week','fnlwgt']
+cat_col_new = ['workclass', 'education', 'marital.status', 'occupation','relationship',
+               'race', 'sex', 'income']
+
+
+# # 5. Pipeline
+
+# In[ ]:
+
+
+from sklearn.pipeline import Pipeline
+from sklearn.base import TransformerMixin
+from sklearn.preprocessing import MinMaxScaler,StandardScaler
+
+scaler = MinMaxScaler()
+pd.DataFrame(scaler.fit_transform(data1[num_col_new]),columns = num_col_new).head(5)
+
+
+# In[ ]:
+
+
+class DataFrameSelector(TransformerMixin):
+    def __init__(self,attribute_names):
+        self.attribute_names = attribute_names
+                
+    def fit(self,X,y = None):
+        return self
+    
+    def transform(self,X):
+        return X[self.attribute_names]
+    
+    
+class num_trans(TransformerMixin):
+    def __init__(self):
+        pass
+    
+    def fit(self,X,y=None):
+        return self
+    
+    def transform(self,X):
+        df = pd.DataFrame(X)
+        df.columns = num_col_new 
+        return df
+        
+    
+    
+pipeline = Pipeline([('selector',DataFrameSelector(num_col_new)),  
+                     ('scaler',MinMaxScaler()),
+                    ('transform',num_trans())])
+
+
+# In[ ]:
+
+
+num_df = pipeline.fit_transform(data1)
+num_df.shape
+
+
+# In[ ]:
+
+
+# columns which I don't need after creating dummy variables dataframe
+cols = ['workclass_Govt_employess','education_Some-college',
+        'marital-status_Never-married','occupation_Other-service',
+        'race_Black','sex_Male','income_>50K']
+
+
+# In[ ]:
+
+
+class dummies(TransformerMixin):
+    def __init__(self,cols):
+        self.cols = cols
+    
+    def fit(self,X,y = None):
+        return self
+    
+    def transform(self,X):
+        df = pd.get_dummies(X)
+        df_new = df[df.columns.difference(cols)] 
+#difference returns the original columns, with the columns passed as argument removed.
+        return df_new
+
+pipeline_cat=Pipeline([('selector',DataFrameSelector(cat_col_new)),
+                      ('dummies',dummies(cols))])
+cat_df = pipeline_cat.fit_transform(data1)
+cat_df.shape
+
+
+# In[ ]:
+
+
+cat_df['id'] = pd.Series(range(cat_df.shape[0]))
+num_df['id'] = pd.Series(range(num_df.shape[0]))
+
+
+# In[ ]:
+
+
+final_df = pd.merge(cat_df,num_df,how = 'inner', on = 'id')
+print(f"Number of observations in final dataset: {final_df.shape}")
+
+
+# ## 5.2 Split the dataset¶
+
+# In[ ]:
+
+
+y = final_df['income_<=50K']
+final_df.drop(labels = ['id','income_<=50K','fnlwgt'],axis = 1,inplace = True)
+X = final_df
+
+
+# ## 5.3 Take a look to Income class distribution
+
+# In[ ]:
+
+
+sns.countplot(x="income", data= data)
+plt.show()
+data["income"].value_counts()
+
+
+# ### Implementating model on imbalanced data
+
+# In[ ]:
+
+
+X_train1,X_test1,y_train1,y_test1 = train_test_split(X,y,test_size =0.15,random_state = 42)
+#fitting the model
+lr=LogisticRegression()
+lr.fit(X_train1,y_train1)
+# predict 
+y_pred4=lr.predict(X_test1)
+print("Accuracy:",metrics.accuracy_score(y_test1, y_pred4))
+print("Precision:",metrics.precision_score(y_test1, y_pred4))
+print("Recall:",metrics.recall_score(y_test1, y_pred4))
+print("F1 score:",metrics.f1_score(y_test1, y_pred4))
+print("AUC :",metrics.roc_auc_score(y_test1, y_pred4))
+
+
+# ## 5.4 Resampling
+# 
+# The main idea of sampling classes is to either increasing the samples of the minority class or decreasing the samples of the majority class. This is done in order to obtain a fair balance in the number of instances for both the classes.
+# 
+# There can be two main types of sampling:
+# 
+#     You can add copies of instances from the minority class which is called over-sampling (or more formally sampling with replacement), or
+#     You can delete instances from the majority class, which is called under-sampling.
+# 
+# 
+# A widely adopted technique for dealing with highly unbalanced datasets is called resampling. It consists of removing samples from the majority class (under-sampling) and / or adding more examples from the minority class (over-sampling).
+# 
+# Despite the advantage of balancing classes, these techniques also have their weaknesses (there is no free lunch). The simplest implementation of over-sampling is to duplicate random records from the minority class, which can cause overfitting. In under-sampling, the simplest technique involves removing random records from the majority class, which can cause loss of information.
+# 
+# **Under-sampling**
+# 
+# Advantages of this approach:
+# 
+#     It can help improve the runtime of the model and solve the memory problems by reducing the number of training data samples when the training data set is enormous.
+# ![resampling.png](attachment:resampling.png)
+
+# In[ ]:
+
+
+from imblearn.under_sampling import RandomUnderSampler
+
+rus = RandomUnderSampler()
+X_rus, y_rus = rus.fit_sample(X, y)
+
+
+# In[ ]:
+
+
+X_rus = pd.DataFrame(X_rus)
+X_rus.columns = ['education_Assoc-acdm', 'education_Assoc-voc', 'education_Bachelors',
+       'education_Doctorate', 'education_HS-grad', 'education_Masters',
+       'education_Preschool', 'education_Prof-school',
+       'education_elementary_school', 'gender_Female',
+       'marital-status_Married', 'marital-status_Separated',
+       'marital-status_Widowed', 'occupation_Adm-clerical',
+       'occupation_Armed-Forces', 'occupation_Craft-repair',
+       'occupation_Exec-managerial', 'occupation_Farming-fishing',
+       'occupation_Handlers-cleaners', 'occupation_Machine-op-inspct',
+       'occupation_Priv-house-serv', 'occupation_Prof-specialty',
+       'occupation_Protective-serv', 'occupation_Sales',
+       'occupation_Tech-support', 'occupation_Transport-moving',
+       'race_Amer-Indian-Eskimo', 'race_Asian-Pac-Islander', 'race_Other',
+       'race_White', 'relationship_Husband', 'relationship_Not-in-family',
+       'relationship_Other-relative', 'relationship_Own-child',
+       'relationship_Unmarried', 'relationship_Wife',
+       'workclass_Govt_employees', 'workclass_Never-worked',
+       'workclass_Private', 'workclass_Self_employed', 'workclass_Without-pay',
+       'age', 'capital-gain', 'capital-loss', 'hours-per-week']
+y_rus = pd.DataFrame(y_rus)
+y_rus.columns = ["income"]
+
+
+# In[ ]:
+
+
+sns.countplot(x=y_rus["income"])
+plt.show()
+
+
+# In[ ]:
+
+
+X_train,X_test,y_train,y_test = train_test_split(X_rus,y_rus,test_size =0.15,random_state = 42)
+
+
+# ## 5.5 Baseline models
+
+# In[ ]:
+
+
+# Spot-Check Algorithms
+def GetBasedModel():
+    basedModels = []
+    basedModels.append(('LR'   , LogisticRegression()))
+    basedModels.append(('LDA'  , LinearDiscriminantAnalysis()))
+    basedModels.append(('KNN'  , KNeighborsClassifier()))
+    basedModels.append(('CART' , DecisionTreeClassifier()))
+    basedModels.append(('NB'   , GaussianNB()))
+    basedModels.append(('AB'   , AdaBoostClassifier()))
+    basedModels.append(('GBM'  , GradientBoostingClassifier()))
+    basedModels.append(('RF'   , RandomForestClassifier()))
+    basedModels.append(('ET'   , ExtraTreesClassifier()))
+
+    
+    return basedModels
+
+
+# In[ ]:
+
+
+def BasedLine2(X_train, y_train,models):
+    # Test options and evaluation metric
+    num_folds = 3
+    scoring = 'accuracy'
+
+    results = []
+    names = []
+    for name, model in models:
+        kfold = StratifiedKFold(n_splits=num_folds, random_state=10)
+        cv_results = cross_val_score(model, X_train, y_train, cv=kfold, scoring=scoring)
+        results.append(cv_results)
+        names.append(name)
+        msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
+        print(msg)
+        
+    return names,results
+
+
+# In[ ]:
+
+
+models = GetBasedModel()
+names,results = BasedLine2(X_train, y_train,models)
+
+
+# ## 5.6 Models Scores
+
+# In[ ]:
+
+
+def ScoreDataFrame(names,results):
+    def floatingDecimals(f_val, dec=3):
+        prc = "{:."+str(dec)+"f}" 
+    
+        return float(prc.format(f_val))
+
+    scores = []
+    for r in results:
+        scores.append(floatingDecimals(r.mean(),4))
+
+    scoreDataFrame = pd.DataFrame({'Model':names, 'Score': scores})
+    return scoreDataFrame
+basedLineScore = ScoreDataFrame(names,results)
+basedLineScore.sort_values(by='Score', ascending=False)
+
+
+# # 6. Tuning Machine Learning Models
+
+# ## 6.1 Logistic Regression
+
+# **Logistic Regression is used when the dependent variable(target) is categorical.**
+# 
+# **Model**
+# 
+# Output = 0 or 1
+# 
+# Hypothesis => Z = WX + B
+# 
+# hΘ(x) = sigmoid (Z)
+# 
+# **Sigmoid Function**
+# ![logistic.png](attachment:logistic.png)
+# 
+# If ‘Z’ goes to infinity, Y(predicted) will become 1 and if ‘Z’ goes to negative infinity, Y(predicted) will become 0.
+# 
+# **Cost Function**
+# ![sfd.png](attachment:sfd.png)
+
+# ## Hyperparameter Tuning 
+# A hyperparameter is a parameter whose value is set before the learning process begins.
+# Tuning Strategies
+# 
+# We will explore two different methods for optimizing hyperparameters:
+# 
+#     Grid Search
+#     Random Search
+
+# ### Grid Search vs Random search
+# 
+# **Grid search** is a traditional way to perform hyperparameter optimization. It works by searching exhaustively through a specified subset of hyperparameters.
+# 
+# **Random search** differs from grid search mainly in that it searches the specified subset of hyperparameters randomly instead of exhaustively. The major benefit being decreased processing time.
+# 
+# * There is a tradeoff to decreased processing time, however. We aren’t guaranteed to find the optimal combination of hyperparameters.
+# 
+# ![HPO1.png](attachment:HPO1.png)
+
+# ### Grid Search
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "from sklearn.model_selection import GridSearchCV\nlr = LogisticRegression(class_weight='balanced',random_state=42)\nparam_grid = { \n    'C': [0.1,0.2,0.3,0.4],\n    'penalty': ['l1', 'l2'],\n    'class_weight':[{0: 1, 1: 1},{ 0:0.67, 1:0.33 },{ 0:0.75, 1:0.25 },{ 0:0.8, 1:0.2 }]}\nCV_rfc = GridSearchCV(estimator=lr, param_grid=param_grid, cv= 5)\nCV_rfc.fit(X_train, y_train)\nprint(CV_rfc.best_params_)")
+
+
+# **C : Inverse of regularization strength**
+# 
+# we use paramter C as our regularization parameter. Parameter C = 1/λ.
+# 
+# Lambda (λ) controls the trade-off between allowing the model to increase it's complexity as much as it wants with trying to keep it simple. For example, if λ is very low or 0, the model will have enough power to increase it's complexity (overfit) by assigning big values to the weights for each parameter. If, in the other hand, we increase the value of λ, the model will tend to underfit, as the model will become too simple.
+# 
+# * Parameter C will work the other way around. For small values of C, we increase the regularization strength which will create simple models which underfit the data. For big values of C, we low the power of regularization which imples the model is allowed to increase it's complexity, and therefore, overfit the data.
+# 
+# **L2 Regularization or Ridge Regularization**
+# 
+# * Ridge regression adds “squared magnitude” of coefficient as penalty term to the loss function. Here the highlighted part represents L2 regularization element.
+# ![ewr.png](attachment:ewr.png)
+# 
+# **L1 Regularization or Lasso**
+# 
+# * Lasso Regression (Least Absolute Shrinkage and Selection Operator) adds “absolute value of magnitude” of coefficient as penalty term to the loss function.
+# ![tre.png](attachment:tre.png)
+# 
+# The key difference between these techniques is that Lasso shrinks the less important feature’s coefficient to zero thus, removing some feature altogether. So, this works well for feature selection in case we have a huge number of features.
+# 
+# **Class weight**
+# 
+# * If we have highly imbalanced classes and have no addressed it during preprocessing, we have the option of using the class_weight parameter to weight the classes to make certain we have a balanced mix of each class. Class weights will be given by n_samples / (n_classes * np.bincount(y))
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "#fitting the model\nlr1=LogisticRegression(C=0.4, random_state=4 ,penalty='l1', class_weight={0:1,1:1})\nlr1.fit(X_train,y_train)\n# predict \ny_pred1=lr1.predict(X_test)")
+
+
+# ### Evaluation of logistic regression(Grid Search)
+# **Confusion Matrix**
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred1)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+
+# In[ ]:
+
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred1))
+print("Precision:",metrics.precision_score(y_test, y_pred1))
+print("Recall:",metrics.recall_score(y_test, y_pred1))
+print("F1 score:",metrics.f1_score(y_test, y_pred1))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred1))
+
+
+# **Precision:**
+# Precision is about being precise, i.e., how accurate your model is. In other words, you can say, when a model makes a prediction, how often it is correct.
+# Precision can be thought of as a measure of a classifier's exactness.
+# ![ret.png](attachment:ret.png)
+# 
+# **Recall:**
+# Out of all the positive classes, how much we predicted correctly. It should be high as possible.
+# Recall can be thought of as a measure of a classifier's completeness.
+# ![ytu.png](attachment:ytu.png)
+# 
+# **F1 score**
+# It is difficult to compare two models with low precision and high recall or vice versa. So to make them comparable, we use F-Score.
+# 
+# F-score helps to measure Recall and Precision at the same time. It uses Harmonic Mean in place of Arithmetic Mean by punishing the extreme values more.
+# ![uyt.png](attachment:uyt.png)
+
+# ### ROC Curve
+
+# An ROC curve (receiver operating characteristic curve) is a graph showing the performance of a classification model at all classification thresholds. This curve plots two parameters:
+# 
+#     True Positive Rate
+#     False Positive Rate
+# ![gfh.png](attachment:gfh.png)
+
+# In[ ]:
+
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred1)
+auc = metrics.roc_auc_score(y_test, y_pred1)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# ### Random search
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "from sklearn.model_selection import RandomizedSearchCV\nlr = LogisticRegression(class_weight='balanced',random_state=42)\nparam_grid = { \n    'C': [0.1,0.2,0.3,0.4],\n    'penalty': ['l1', 'l2'],\n    'class_weight':[{0: 1, 1: 1},{ 0:0.67, 1:0.33 },{ 0:0.75, 1:0.25 },{ 0:0.8, 1:0.2 }]}\nCV_rfc = RandomizedSearchCV(estimator=lr, param_distributions=param_grid, cv= 5,random_state=1)\nCV_rfc.fit(X_train, y_train)\nprint(CV_rfc.best_params_)")
+
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "#fitting the model\nlr2=LogisticRegression(C=0.3, random_state=4 ,penalty='l2', class_weight={0:1,1:1})\nlr2.fit(X_train,y_train)\n# predict \ny_pred2=lr2.predict(X_test)")
+
+
+# ### Evaluation of logistic regression(Random Search)
+
+# #### Confusion Matrix
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred2)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+
+# In[ ]:
+
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred2))
+print("Precision:",metrics.precision_score(y_test, y_pred2))
+print("Recall:",metrics.recall_score(y_test, y_pred2))
+print("F1 score:",metrics.f1_score(y_test, y_pred2))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred2))
+
+
+# In[ ]:
+
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred2)
+auc = metrics.roc_auc_score(y_test, y_pred2)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# ## Recursive Feature Elimination
+
+# * The Recursive Feature Elimination (or RFE) works by recursively removing attributes and building a model on those attributes that remain. 
+# * It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute.
+# * As the name suggests, this method eliminates worst performing features on a particular model one after the other until the best subset of features are known.
+# ![vnb.png](attachment:vnb.png)
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', 'from sklearn.feature_selection import RFE\n\n# feature extraction\nlr = LogisticRegression()\nrfe = RFE(lr, 15)\nlr3 = rfe.fit(X_train, y_train)\n\nprint("Num Features: ", lr3.n_features_)\nprint("Selected Features: ",  lr3.support_)\nprint("Feature Ranking: ", lr3.ranking_)')
+
+
+# **Features sorted by their rank:**
+
+# In[ ]:
+
+
+feature = list(X_train.columns.values) 
+print(sorted(zip(map(lambda x: round(x, 4), lr3.ranking_), feature)))
+
+
+# In[ ]:
+
+
+
+X_train_f = X_train[['age','capital-gain','capital-loss','education_Bachelors','education_Doctorate','education_Masters',
+                     'education_Preschool','education_Prof-school','education_elementary_school',
+                     'hours-per-week','occupation_Priv-house-serv','relationship_Not-in-family','relationship_Other-relative'
+                     ,'relationship_Own-child','relationship_Unmarried']]
+
+X_test_f = X_test[['age','capital-gain','capital-loss','education_Bachelors','education_Doctorate','education_Masters',
+                     'education_Preschool','education_Prof-school','education_elementary_school',
+                     'hours-per-week','occupation_Priv-house-serv','relationship_Not-in-family','relationship_Other-relative'
+                     ,'relationship_Own-child','relationship_Unmarried']]
+
+lr4=LogisticRegression(C=0.4, random_state=4 ,penalty='l2', class_weight={0:1,1:1})
+get_ipython().run_line_magic('time', 'lr4.fit(X_train_f,y_train)')
+
+
+# In[ ]:
+
+
+# predict 
+y_pred4=lr4.predict(X_test_f)
+cf_matrix = confusion_matrix(y_test, y_pred4)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred4))
+print("Precision:",metrics.precision_score(y_test, y_pred4))
+print("Recall:",metrics.recall_score(y_test, y_pred4))
+print("F1 score:",metrics.f1_score(y_test, y_pred4))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred4))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred4)
+auc = metrics.roc_auc_score(y_test, y_pred4)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# ## PCA analysis
+# Principal Component Analysis (or PCA) uses linear algebra to transform the dataset into a compressed form.
+# 
+# Generally this is called a data reduction technique. A property of PCA is that you can choose the number of dimensions or principal component in the transformed result.
+# 
+# In this case we will use it to analyse the feature importanace
+
+# In[ ]:
+
+
+from sklearn.preprocessing import StandardScaler
+X_std = StandardScaler().fit_transform(X_train)
+
+
+from sklearn.decomposition import PCA as sklearnPCA
+
+sklearn_pca = sklearnPCA(n_components=39)
+Y_sklearn = sklearn_pca.fit_transform(X_std)
+
+cum_sum = sklearn_pca.explained_variance_ratio_.cumsum()
+
+sklearn_pca.explained_variance_ratio_[:10].sum()
+
+cum_sum = cum_sum*100
+
+fig, ax = plt.subplots(figsize=(8,8))
+plt.bar(range(39), cum_sum, label='Cumulative _Sum_of_Explained _Varaince', color = 'b',alpha=0.5)
+
+
+# In[ ]:
+
+
+#Cumulative explained variance
+from sklearn.decomposition import PCA
+pca = PCA(39)
+pca_full = pca.fit(X)
+
+plt.plot(np.cumsum(pca_full.explained_variance_ratio_))
+plt.xlabel('# of components')
+plt.ylabel('Cumulative explained variance')
+
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', '# 26 Principal Components seems good \npca = PCA(n_components=26)\nX_transformed = pca.fit_transform(X_train)\n\nX_train_pca, X_test_pca, y_train_pca, y_test_pca = train_test_split( \n    X_transformed, y_train, test_size=0.2, random_state=13)\n\nlr5=LogisticRegression(C=0.4, random_state=4 ,penalty=\'l1\', class_weight={0:1,1:1})\nlr5.fit(X_train_pca, y_train_pca)\n\n# predict \ny_pred =lr5.predict(X_test_pca)\n\ncf_matrix = confusion_matrix(y_test_pca, y_pred)\nsns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt=\'g\')\nplt.tight_layout()\nplt.title(\'Confusion matrix\', y=1.1)\nplt.ylabel(\'Actual label\')\nplt.xlabel(\'Predicted label\')\nplt.show()\n\nprint("Accuracy:",metrics.accuracy_score(y_test_pca, y_pred))\nprint("Precision:",metrics.precision_score(y_test_pca, y_pred))\nprint("Recall:",metrics.recall_score(y_test_pca, y_pred))\nprint("F1 score:",metrics.f1_score(y_test_pca, y_pred))\nprint("AUC :",metrics.roc_auc_score(y_test_pca, y_pred))\n\nfpr, tpr, _ = metrics.roc_curve(y_test_pca,  y_pred)\nauc = metrics.roc_auc_score(y_test_pca, y_pred)\nplt.plot(fpr,tpr,label="data 1, auc="+str(auc))\nplt.legend(loc=4)\nplt.plot([0, 1], [0, 1],\'r--\')\nplt.xlabel(\'False Positive Rate\')\nplt.ylabel(\'True Positive Rate\')\nplt.title(\'Receiver operating characteristic\')\nplt.show()')
+
+
+# # Feature Importance
+
+# In[ ]:
+
+
+data1 = pd.DataFrame(X,y)
+
+clf = ExtraTreesClassifier(n_estimators=250,
+                              random_state=2)
+
+clf.fit(X_train, y_train)
+
+
+# Plot feature importance
+feature_importance = clf.feature_importances_
+# make importances relative to max importance
+feature_importance = 100.0 * (feature_importance / feature_importance.max())
+sorted_idx = np.argsort(feature_importance)
+pos = np.arange(sorted_idx.shape[0]) + .5
+plt.figure(figsize=(10,10))
+plt.barh(pos, feature_importance[sorted_idx], align='center')
+plt.yticks(pos, data1.columns[sorted_idx])
+plt.xlabel('Relative Importance')
+plt.title('Variable Importance')
+plt.show()
+
+
+# In[ ]:
+
+
+X_train_ef = X_train[['race_Asian-Pac-Islander','education_Assoc-voc', 'workclass_Govt_employees','occupation_Craft-repair',
+       'education_Doctorate','workclass_Self_employed', 'occupation_Adm-clerical','occupation_Sales', 'education_Prof-school',
+       'workclass_Private','race_White', 'occupation_Prof-specialty', 'relationship_Unmarried','marital-status_Separated', 'education_elementary_school',
+       'education_Masters', 'relationship_Wife', 'education_Bachelors','capital-loss', 'occupation_Exec-managerial', 'gender_Female',
+       'relationship_Not-in-family', 'education_HS-grad','relationship_Own-child', 'capital-gain', 'relationship_Husband',
+       'marital-status_Married', 'hours-per-week', 'age']]
+                      
+X_test_ef = X_test[['race_Asian-Pac-Islander','education_Assoc-voc', 'workclass_Govt_employees',
+       'occupation_Craft-repair', 'education_Doctorate','workclass_Self_employed', 'occupation_Adm-clerical',
+       'occupation_Sales', 'education_Prof-school', 'workclass_Private','race_White', 'occupation_Prof-specialty', 'relationship_Unmarried',
+       'marital-status_Separated', 'education_elementary_school','education_Masters', 'relationship_Wife', 'education_Bachelors',
+       'capital-loss', 'occupation_Exec-managerial', 'gender_Female','relationship_Not-in-family', 'education_HS-grad',
+       'relationship_Own-child', 'capital-gain', 'relationship_Husband','marital-status_Married', 'hours-per-week', 'age']]
+
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', 'lr5=LogisticRegression(C=0.4, random_state=4 ,penalty=\'l1\', class_weight={0:1,1:1})\nlr5.fit(X_train_ef, y_train)\n\n# predict \ny_pred =lr5.predict(X_test_ef)\n\ncf_matrix = confusion_matrix(y_test, y_pred)\nsns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt=\'g\')\nplt.tight_layout()\nplt.title(\'Confusion matrix\', y=1.1)\nplt.ylabel(\'Actual label\')\nplt.xlabel(\'Predicted label\')\nplt.show()\n\nprint("Accuracy:",metrics.accuracy_score(y_test, y_pred))\nprint("Precision:",metrics.precision_score(y_test, y_pred))\nprint("Recall:",metrics.recall_score(y_test, y_pred))\nprint("F1 score:",metrics.f1_score(y_test, y_pred))\nprint("AUC :",metrics.roc_auc_score(y_test, y_pred))\n\nfpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)\nauc = metrics.roc_auc_score(y_test, y_pred)\nplt.plot(fpr,tpr,label="data 1, auc="+str(auc))\nplt.legend(loc=4)\nplt.plot([0, 1], [0, 1],\'r--\')\nplt.xlabel(\'False Positive Rate\')\nplt.ylabel(\'True Positive Rate\')\nplt.title(\'Receiver operating characteristic\')\nplt.show()')
+
+
+# ### Grid Search
+
+# In[ ]:
+
+
+class GridSearch(object):
+    
+    def __init__(self,X_train,y_train,model,hyperparameters):
+        
+        self.X_train = X_train
+        self.y_train = y_train
+        self.model = model
+        self.hyperparameters = hyperparameters
+        
+    def GridSearch(self):
+        # Create randomized search 10-fold cross validation and 100 iterations
+        cv = 10
+        clf = GridSearchCV(self.model,
+                                 self.hyperparameters,
+                                 cv=cv,
+                                 verbose=0,
+                                 n_jobs=-1
+                                 )
+        # Fit randomized search
+        best_model = clf.fit(self.X_train, self.y_train)
+        message = (best_model.best_score_, best_model.best_params_)
+        print("Best: %f using %s" % (message))
+
+        return best_model,best_model.best_params_
+    
+    def Best_Model_Predict(self,X_test):
+        
+        best_model,_ = self.GridSearch()
+        pred = best_model.predict(X_test)
+        return pred
+
+
+# ### Random Search
+
+# In[ ]:
+
+
+from scipy.stats import uniform
+
+class RandomSearch(object):
+    
+    def __init__(self,X_train,y_train,model,hyperparameters):
+        
+        self.X_train = X_train
+        self.y_train = y_train
+        self.model = model
+        self.hyperparameters = hyperparameters
+        
+    def RandomSearch(self):
+        # Create randomized search 10-fold cross validation and 100 iterations
+        cv = 10
+        clf = RandomizedSearchCV(self.model,
+                                 self.hyperparameters,
+                                 random_state=1,
+                                 n_iter=100,
+                                 cv=cv,
+                                 verbose=0,
+                                 n_jobs=-1
+                                 )
+        # Fit randomized search
+        best_model = clf.fit(self.X_train, self.y_train)
+        message = (best_model.best_score_, best_model.best_params_)
+        print("Best: %f using %s" % (message))
+
+        return best_model,best_model.best_params_
+    
+    def Best_Model_Predict(self,X_test):
+        
+        best_model,_ = self.RandomSearch()
+        pred = best_model.predict(X_test)
+        return pred
+
+
+# # 6.2 KNN
+
+# **kNN is non-parametric, instance based, lazy algorithm and used in the supervised setting.**
+# 
+# * Non-parametric :
+#       
+#       It means that algorithm has no pre assumptions about the functional form of the model, to avoid mismodeling .
+# 
+# * Instance based :
+#       
+#       It means that our algorithm does not explicitly learn a model.
+#       Instead, it memorize the training instances which are subsequently used as “knowledge” for the prediction.
+# 
+# * Lazy algorithm :
+# 
+#       It means that it does not use the training data for the Generalization i.e. these algorithm has no explicit training phase or it is minimal. Training is very fast.
+#       
+# **kNN Algorithm for Classification**
+# 
+# Training element {xi, yi} , Testing point(x)
+# 
+#     Compute the Distance D(x,xi) to every training element xi.
+#     Select k closest instance xi1,xi2,…….., xik and their labels yi1, yi2 …, yik.
+#     Output the class y* which is most frequent in yi1,yi2 ……yik.
+#     
+# 
+# 
+# **Significant of “k”**
+# 
+#     Value of k has strong effect on kNN performance.
+#     k act as controller to decide the shape of decision boundary.
+#     Large value of k has following properties:
+# 
+#  1. Smoother decision boundary
+#  2. It provide more voters for prediction, it implies less affect from outliers.
+#  3. As a result has Lower Variance and High Bias.
+#  
+#  ![gh.jpeg](attachment:gh.jpeg)
+#  
+# **How to Select k**
+# 
+#     The simplest solution is Cross Validation.
+#     Best method is to try many k values and use Cross-Validation to see which k value is giving the best result.
+# 
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "k_range = list(range(2,15))\nd_metric = ['euclidean','minkowski']\n\nparam_grid = dict(n_neighbors = k_range, metric =d_metric)\n\nknn = KNeighborsClassifier()\n\nKNN_GridSearch = GridSearch(X_train_f, y_train, knn ,param_grid)\ny_pred = KNN_GridSearch.Best_Model_Predict(X_test_f)")
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+print("Precision:",metrics.precision_score(y_test, y_pred))
+print("Recall:",metrics.recall_score(y_test, y_pred))
+print("F1 score:",metrics.f1_score(y_test, y_pred))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)
+auc = metrics.roc_auc_score(y_test, y_pred)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# # 6.3 SVM (Support Vector Machine)
+
+# **What is a Support Vector Machine**
+# A Support Vector Machine is a supervised machine learning algorithm which can be used for both classification and regression problems. It follows a technique called the kernel trick to transform the data and based on these transformations, it finds an optimal boundary between the possible outputs.
+# 
+# **How does it work?**
+# The main idea is to identify the optimal separating hyperplane which maximizes the margin of the training data. 
+# 
+# The goal of SVMs is to find the optimal hyperplane because it not only classifies the existing dataset but also helps predict the class of the unseen data. And the optimal hyperplane is the one which has the biggest margin.
+# 
+# ![Margin.png](attachment:Margin.png)
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "param_grid = [{'gamma': [ 0.1, 1, 10],'C': [ 0.10, 10, 100]}]\n\nsvm = SVC()\n\nsvm_GridSearch = GridSearch(X_train_f, y_train, svm,param_grid )\ny_pred = svm_GridSearch.Best_Model_Predict(X_test_f)")
+
+
+# **Kernel**
+# 
+# kernel parameters selects the type of hyperplane used to separate the data. Using ‘linear’ will use a linear hyperplane (a line in the case of 2D data). ‘rbf’ and ‘poly’ uses a non linear hyper-plane.
+# 
+# **gamma**
+# 
+# gamma is a parameter for non linear hyperplanes. The higher the gamma value it tries to exactly fit the training data set.  Increasing gamma leads to overfitting as the classifier tries to perfectly fit the training data.
+# 
+# **C**
+# 
+# C is the penalty parameter of the error term. It controls the trade off between smooth decision boundary and classifying the training points correctly.
+# A smaller C value leads to a wider street but more margin violations
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+print("Precision:",metrics.precision_score(y_test, y_pred))
+print("Recall:",metrics.recall_score(y_test, y_pred))
+print("F1 score:",metrics.f1_score(y_test, y_pred))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)
+auc = metrics.roc_auc_score(y_test, y_pred)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# # 6.4 LDA
+# 
+# * Linear Discriminant Analysis (LDA) is most commonly used as dimensionality reduction technique in the pre-processing step for pattern-classification and machine learning applications. 
+# 
+# * The goal is to project a dataset onto a lower-dimensional space with good class-separability in order avoid overfitting (“curse of dimensionality”) and also reduce computational costs.
+# 
+# In general, dimensionality reduction does not only help reducing computational costs for a given classification task, but it can also be helpful to avoid overfitting by minimizing the error in parameter estimation (“curse of dimensionality”).
+# 
+# ![sdfg.jpg](attachment:sdfg.jpg)
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "param_grid = [{'n_components': [1,2,3,4]}]\n\nlda = LinearDiscriminantAnalysis()\n\nlda_GridSearch = GridSearch(X_train, y_train, lda , param_grid )\ny_pred = lda_GridSearch.Best_Model_Predict(X_test)")
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+print("Precision:",metrics.precision_score(y_test, y_pred))
+print("Recall:",metrics.recall_score(y_test, y_pred))
+print("F1 score:",metrics.f1_score(y_test, y_pred))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)
+auc = metrics.roc_auc_score(y_test, y_pred)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# # 6.5 Decision Tree
+
+# **Introduction to Decision Trees**
+# 
+# * A decision tree is a decision support tool that uses a tree-like graph or model of decisions and their possible consequences, including chance event outcomes, resource costs, and utility. It is one way to display an algorithm that only contains conditional control statements.
+# 
+# **How does Decision Tree works ?**
+# 
+# * Decision tree is a type of supervised learning algorithm (having a pre-defined target variable) that is mostly used in classification problems. It works for both categorical and continuous input and output variables. In this technique, we split the population or sample into two or more homogeneous sets (or sub-populations) based on most significant splitter / differentiator in input variables.
+# 
+# ![asdwq.png](attachment:asdwq.png)
+# 
+# The core algorithm for building decision trees called ID3 by J. R. Quinlan which employs a top-down, greedy search through the space of possible branches with no backtracking. ID3 uses Entropy and Information Gain to construct a decision tree. 
+# 
+# **The popular attribute selection measures:**
+# 
+#     Information gain
+#     Gini index
+# 
+# 
+# **Advantages of CART**
+# 
+#     Simple to understand, interpret, visualize.
+#     Decision trees implicitly perform variable screening or feature selection.
+#     Can handle both numerical and categorical data. Can also handle multi-output problems.
+#     Decision trees require relatively little effort from users for data preparation.
+#     Nonlinear relationships between parameters do not affect tree performance.
+#     
+# **Disadvantages of CART**
+# 
+#     Decision-tree learners can create over-complex trees that do not generalize the data well.This is called overfitting.
+#     Decision trees can be unstable because small variations in the data might result in a completely different tree being generated. This is called variance, which needs to be lowered by methods like bagging and boosting.
+
+# ### Implemention of Decision Tree
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', 'from scipy.stats import randint\nmax_depth_value = [4, 5,6,7,8,9,10,11,12,13]\nmax_features_value =  randint(1, 7)\nmin_samples_leaf_value = randint(1, 4)\ncriterion_value = ["gini", "entropy"]\n\nparam_grid = dict(max_depth = max_depth_value,\n                  max_features = max_features_value,\n                  min_samples_leaf = min_samples_leaf_value,\n                  criterion = criterion_value)\n\nCART = DecisionTreeClassifier(random_state=1)\n\nCART_RandSearch = RandomSearch(X_train_f, y_train, CART, param_grid)\nPrediction_CART = CART_RandSearch.Best_Model_Predict(X_test_f)')
+
+
+# ####  How does a tree decide where to split?
+# 
+# Decision tree splits the nodes on all available variables and then selects the split which results in most homogeneous sub-nodes.
+# 
+# Let’s look at the two most commonly used algorithms in decision tree:
+# 
+# #### Gini:
+# 
+# Gini  says, if we select two items from a population at random then they must be of same class and probability for this is 1 if population is pure.
+# Steps to Calculate Gini for a split
+# 
+#     Calculate Gini for sub-nodes, using formula sum of square of probability for success and failure (p^2+q^2).
+#     Calculate Gini for split using weighted Gini score of each node of that split
+# 
+# Example: – Referring to example used above, where we want to segregate the students based on target variable ( playing cricket or not ). 
+# 
+# ![dt.PNG](attachment:dt.PNG)
+# Split on Gender:
+# 
+#     Calculate, Gini for sub-node Female = (0.2)*(0.2)+(0.8)*(0.8)=0.68
+#     Gini for sub-node Male = (0.65)*(0.65)+(0.35)*(0.35)=0.55
+#     Calculate weighted Gini for Split Gender = (10/30)*0.68+(20/30)*0.55 = 0.59
+# 
+# Similar for Split on Class:
+# 
+#     Gini for sub-node Class IX = (0.43)*(0.43)+(0.57)*(0.57)=0.51
+#     Gini for sub-node Class X = (0.56)*(0.56)+(0.44)*(0.44)=0.51
+#     Calculate weighted Gini for Split Class = (14/30)*0.51+(16/30)*0.51 = 0.51
+# 
+# Above, you can see that Gini score for Split on Gender is higher than Split on Class, hence, the node split will take place on Gender.
+# 
+# #### Information Gain:
+# 
+# Information gain can be understood as decrease in “uncertainty” of the result.
+#  
+# Information theory is a measure to define this degree of disorganization in a system known as Entropy. If the sample is completely homogeneous, then the entropy is zero and if the sample is an equally divided (50% – 50%), it has entropy of one.
+# 
+# Entropy can be calculated using formula:-
+# ![et.PNG](attachment:et.PNG)
+# 
+# Here p and q is probability of success and failure respectively in that node. Entropy is also used with categorical target variable. It chooses the split which has lowest entropy compared to parent node and other splits. The lesser the entropy, the better it is.
+# 
+# Steps to calculate entropy for a split:
+# 
+#     Calculate entropy of parent node
+#     Calculate entropy of each individual node of split and calculate weighted average of all sub-nodes available in split.
+# 
+# Example: Let’s use this method to identify best split for student example.
+# 
+#     Entropy for parent node = -(15/30) log2 (15/30) – (15/30) log2 (15/30) = 1. Here 1 shows that it is a impure node.
+#     Entropy for Female node = -(2/10) log2 (2/10) – (8/10) log2 (8/10) = 0.72 and for male node,  -(13/20) log2 (13/20) – (7/20) log2 (7/20) = 0.93
+#     Entropy for split Gender = Weighted entropy of sub-nodes = (10/30)*0.72 + (20/30)*0.93 = 0.86
+#     Entropy for Class IX node, -(6/14) log2 (6/14) – (8/14) log2 (8/14) = 0.99 and for Class X node,  -(9/16) log2 (9/16) – (7/16) log2 (7/16) = 0.99.
+#     Entropy for split Class =  (14/30)*0.99 + (16/30)*0.99 = 0.99
+# 
+# Above, you can see that entropy for Split on Gender is the lowest among all, so the tree will split on Gender. We can derive information gain from entropy as 1- Entropy.
+
+# ## Visualize Decision Tree
+
+# In[ ]:
+
+
+# Visualize Decision Tree
+from sklearn import tree
+from sklearn.tree import export_graphviz
+from IPython.display import Image 
+
+feature_names = [i for i in X_train_f.columns]
+
+y_train_str = y_train.astype('str')
+y_train_str[y_train_str == 1] = "1"
+y_train_str[y_train_str == 0] ="0"
+y_train_str = y_train_str.values
+
+model_1 = tree.DecisionTreeClassifier(criterion='gini', max_depth= 13, max_features= 2, min_samples_leaf= 2) 
+model_1.fit(X_train_f, y_train)
+
+from sklearn.externals.six import StringIO
+# Let's give dot_data some space so it will not feel nervous any more
+dot_data = StringIO()
+tree.export_graphviz(model_1, out_file=dot_data,filled=True)
+import pydotplus
+
+graph = pydotplus.graphviz.graph_from_dot_data(dot_data.getvalue())
+# make sure you have graphviz installed and set in path
+Image(graph.create_png())
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, Prediction_CART)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, Prediction_CART))
+print("Precision:",metrics.precision_score(y_test, Prediction_CART))
+print("Recall:",metrics.recall_score(y_test, Prediction_CART))
+print("F1 score:",metrics.f1_score(y_test, Prediction_CART))
+print("AUC :",metrics.roc_auc_score(y_test, Prediction_CART))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  Prediction_CART)
+auc = metrics.roc_auc_score(y_test, Prediction_CART)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# # 6.6 Ensemble methods
+# 
+# **What is an ensemble method?**
+# 
+# Ensemble is a Machine Learning concept in which the idea is to train multiple models using the same learning algorithm. The ensembles take part in a bigger group of methods, called multiclassifiers, where a set of hundreds or thousands of learners with a common objective are fused together to solve the problem.
+# When we try to predict the target variable using any machine learning technique, the main causes of difference in actual and predicted values are noise, variance, and bias. Ensemble helps to reduce these factors (except noise, which is irreducible error).
+# 
+# **Techniques to perform ensemble decision trees:**
+# 
+# **1. Bagging**
+# 
+# Bagging is used when the goal is to reduce the variance of a decision tree classifier. Here the objective is to create several subsets of data from training sample chosen randomly with replacement. Each collection of subset data is used to train their decision trees. As a result, we get an ensemble of different models. Average of all the predictions from different trees are used which is more robust than a single decision tree classifier.
+# 
+# Bagging Steps:
+# 
+#     Suppose there are N observations and M features in training data set. A sample from training data set is taken randomly with replacement.
+#     A subset of M features are selected randomly and whichever feature gives the best split is used to split the node iteratively.
+#     The tree is grown to the largest.
+#     Above steps are repeated n times and prediction is given based on the aggregation of predictions from n number of trees.
+# 
+# Advantages:
+# 
+#     Reduces over-fitting of the model.
+#     Handles higher dimensionality data very well.
+#     Maintains accuracy for missing data.
+# 
+# Disadvantages:
+# 
+#     Since final prediction is based on the mean predictions from subset trees, it won’t give precise values for the classification and regression model.
+#     
+#  ![dfg.png](attachment:dfg.png)
+# 
+# 
+# **2. Boosting**
+# 
+# Boosting is used to create a collection of predictors. In this technique, learners are learned sequentially with early learners fitting simple models to the data and then analysing data for errors. Consecutive trees (random sample) are fit and at every step, the goal is to improve the accuracy from the prior tree. When an input is misclassified by a hypothesis, its weight is increased so that next hypothesis is more likely to classify it correctly. This process converts weak learners into better performing model.
+# 
+# Boosting Steps:
+# 
+#     Draw a random subset of training samples d1 without replacement from the training set D to train a weak learner C1
+#     Draw second random training subset d2 without replacement from the training set and add 50 percent of the samples that were previously falsely classified/misclassified to train a weak learner C2
+#     Find the training samples d3 in the training set D on which C1 and C2 disagree to train a third weak learner C3
+#     Combine all the weak learners via majority voting.
+# 
+# Advantages:
+# 
+#     Supports different loss function (we have used ‘binary:logistic’ for this example).
+#     Works well with interactions.
+# 
+# Disadvantages:
+# 
+#     Prone to over-fitting.
+#     Requires careful tuning of different hyper-parameters.
+# 
+# *     Bagging to decrease the model’s variance;
+# *     Boosting to decreasing the model’s bias, and;
+# *     Stacking to increasing the predictive force of the classifier.
+# 
+# ![boosting.png](attachment:boosting.png)
+
+# ## 6.6.1 Bagging
+
+# # 6.6.1.1 Random Forest
+# 
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "param_grid = [\n{'n_estimators': [10, 25,30], 'max_features': ['auto', 'sqrt', 'log2', None], \n 'max_depth': [10, 20, None], 'bootstrap': [True, False]}\n]\n\nrf = RandomForestClassifier()\n\nrf_GridSearch = GridSearch(X_train, y_train, rf ,param_grid )\ny_pred = rf_GridSearch.Best_Model_Predict(X_test)")
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+print("Precision:",metrics.precision_score(y_test, y_pred))
+print("Recall:",metrics.recall_score(y_test, y_pred))
+print("F1 score:",metrics.f1_score(y_test, y_pred))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)
+auc = metrics.roc_auc_score(y_test, y_pred)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# **Set of hyperparameters:**
+# 
+# *     n_estimators = number of trees in the foreset
+# *     max_features = max number of features considered for splitting a node
+# *     max_depth = max number of levels in each decision tree
+# *     bootstrap = method for sampling data points (with or without replacement)
+# 
+# 
+# **max_features:** 
+# 
+# These are the maximum number of features Random Forest is allowed to try in individual tree. 
+# 
+# 1)Auto : This will simply take all the features which make sense in every tree.Here we simply do not put any restrictions on the individual tree.
+# 
+# 2)sqrt : This option will take square root of the total number of features in individual run. For instance, if the total number of variables are 100, we can only take 10 of them in individual tree.
+# 
+# 3)log2:It is another option which takes log to the base 2 of the features input.
+# 
+# Increasing max_features generally improves the performance of the model as at each node now we have a higher number of options to be considered.But, for sure, you decrease the speed of algorithm by increasing the max_features. Hence, you need to strike the right balance and choose the optimal max_features.
+# 
+# **n_estimators :** 
+# 
+# This is the number of trees you want to build before taking the maximum voting or averages of predictions. Higher number of trees give you better performance but makes your code slower. You should choose as high value as your processor can handle because this makes your predictions stronger and more stable.
+# 
+# **min_sample_leaf:** 
+# 
+# Leaf is the end node of a decision tree. A smaller leaf makes the model more prone to capturing noise in train data. Hence it is important to try different values to get good estimate.
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "param_grid = [\n{'n_estimators': [10, 25,30], 'max_features': ['auto', 'sqrt', 'log2', None], \n 'max_depth': [10, 20, None], 'bootstrap': [True, False]}\n]\n\nrf = RandomForestClassifier()\n\nrf_GridSearch = GridSearch(X_train_ef, y_train, rf ,param_grid )\ny_pred = rf_GridSearch.Best_Model_Predict(X_test_ef)")
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+print("Precision:",metrics.precision_score(y_test, y_pred))
+print("Recall:",metrics.recall_score(y_test, y_pred))
+print("F1 score:",metrics.f1_score(y_test, y_pred))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred))
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred)
+auc = metrics.roc_auc_score(y_test, y_pred)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# ## 6.6.2 Boosting
+
+# # 6.6.2.1 GradientBoosting
+# 
+# A special case of boosting where errors are minimized by gradient descent algorithm e.g. the strategy consulting firms leverage by using case interviews to weed out less qualified candidates.
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', 'learning_rate_ = [.01,.05,.1,.5,1]\nn_estimators_ = [50,100,150,200,250,300]\n\nparam_grid = dict(learning_rate=learning_rate_, n_estimators=n_estimators_)\n\nGB = GradientBoostingClassifier()\n\nGB_GridSearch = RandomSearch(X_train, y_train, GB, param_grid)')
+
+
+# In[ ]:
+
+
+Prediction_GB = GB_GridSearch.Best_Model_Predict(X_test)
+
+
+# In[ ]:
+
+
+from xgboost import XGBClassifier
+%%time
+learning_rate_ = [.01,.05,.1,.5,1]
+n_estimators_ = [50,100,150,200,250,300]
+
+param_grid = dict(learning_rate=learning_rate_, n_estimators=n_estimators_,n_jobs=-1)
+
+GB =  XGBClassifier()
+
+GB_GridSearch = RandomSearch(X_train, y_train, GB, param_grid)
+Prediction_GB = GB_GridSearch.Best_Model_Predict(X_test)
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, Prediction_GB)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, Prediction_GB))
+print("Precision:",metrics.precision_score(y_test, Prediction_GB))
+print("Recall:",metrics.recall_score(y_test, Prediction_GB))
+print("F1 score:",metrics.f1_score(y_test, Prediction_GB))
+print("AUC :",metrics.roc_auc_score(y_test, Prediction_GB))
+
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  Prediction_GB)
+auc = metrics.roc_auc_score(y_test, Prediction_GB)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+#.712
+
+
+# # 7. Neural Network
+# 
+# ![nn_diagram_1.png](attachment:nn_diagram_1.png)
+# 
+# **The Sequential model is a linear stack of layers.**
+# 
+# **Specifying the input shape**
+# 
+#     The model needs to know what input shape it should expect. For this reason, the first layer in a Sequential model (and only the first, because following layers can do automatic shape inference) needs to receive information about its input shape.
+#     
+# **Compilation**
+# 
+# Before training a model, we need to configure the learning process, which is done via the compile method. It receives three arguments:
+# 
+#     An optimizer. 
+#     This could be the string identifier of an existing optimizer (such as rmsprop , adam or adagrad).
+#     
+#     A loss function. 
+#     This is the objective that the model will try to minimize. It can be the string identifier of an existing loss function (such as categorical_crossentropy or mse), or it can be an objective function. 
+#     
+#     A list of metrics.
+#     For any classification problem you will want to set this to metrics=['accuracy']. A metric could be the string identifier of an existing metric or a custom metric function.
+# 
+# **Training**
+# 
+#     Keras models are trained on Numpy arrays of input data and labels. For training a model,we will use the fit function.
+
+# In[ ]:
+
+
+get_ipython().run_cell_magic('time', '', "import keras\nfrom keras.models import Sequential\nfrom keras.layers import Dense\n\nmodel = Sequential()\n\n# Adding the input layer and the first hidden layer\nmodel.add(Dense(output_dim = 16, activation = 'relu', input_dim = 45))\n# Adding the second hidden layer\nmodel.add(Dense(output_dim = 8,  activation = 'relu'))\n\n# Adding the output layer\nmodel.add(Dense(output_dim = 1, activation = 'sigmoid'))\n\nmodel.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\n\nmodel.fit(X_train, y_train, batch_size = 10, nb_epoch = 100)\n\ny_pred1 = model.predict(X_test)\ny_pred1 = (y_pred1 > 0.5)\n")
+
+
+# In[ ]:
+
+
+cf_matrix = confusion_matrix(y_test, y_pred1)
+sns.heatmap(pd.DataFrame(cf_matrix), annot=True, cmap="YlGnBu" ,fmt='g')
+plt.tight_layout()
+plt.title('Confusion matrix', y=1.1)
+plt.ylabel('Actual label')
+plt.xlabel('Predicted label')
+plt.show()
+
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred1))
+print("Precision:",metrics.precision_score(y_test, y_pred1))
+print("Recall:",metrics.recall_score(y_test, y_pred1))
+print("F1 score:",metrics.f1_score(y_test, y_pred1))
+print("AUC :",metrics.roc_auc_score(y_test, y_pred1))
+
+
+fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred1)
+auc = metrics.roc_auc_score(y_test, y_pred1)
+plt.plot(fpr,tpr,label="data 1, auc="+str(auc))
+plt.legend(loc=4)
+plt.plot([0, 1], [0, 1],'r--')
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('Receiver operating characteristic')
+plt.show()
+
+
+# In[ ]:
+
+
+
+m = { 
+"GradientBoosting" : {
+    "Accuracy": 0.8280,
+    "Precision": 0.84150,
+    "Recall": 0.8063,
+    "F1 score": 0.82352,
+    "AUC" : 0.82795,
+    "RunTime(sec)" : 481
+    },
+"Random Forest" : {
+    "Accuracy": 0.82064,
+    "Precision": 0.86139,
+    "Recall": 0.76217,
+    "F1 score": 0.80875,
+    "AUC" : 0.8203,
+    "RunTime(sec)" : 59.4
+    },
+"LDA" : {
+    "Accuracy": 0.8001,
+    "Precision": 0.8307,
+    "Recall": 0.7512,
+    "F1 score": 0.7890,
+    "AUC" : 0.7998,
+    "RunTime(sec)" : 1.2
+    },
+"Decision Tree" : {
+    "Accuracy": 0.7992,
+    "Precision": 0.8607,
+    "Recall": 0.7117,
+    "F1 score": 0.7791,
+    "AUC" : 0.7988,
+    "RunTime(sec)" : 2.1
+    },
+"SVM" : {
+    "Accuracy": 0.8066,
+    "Precision": 0.8592,
+    "Recall": 0.7312,
+    "F1 score": 0.7900,
+    "AUC" : 0.8063,
+    "RunTime(sec)" : 500.4
+    },
+"KNN" : {
+    "Accuracy": 0.7924,
+    "Precision": 0.8212,
+    "Recall": 0.74498,
+    "F1 score": 0.7812,
+    "AUC" : 0.7921,
+    "RunTime(sec)" : 144.1
+    },
+"LR(ET)" : {
+    "Accuracy": 0.8069,
+    "Precision": 0.8156,
+    "Recall": 0.7908,
+    "F1 score": 0.8030,
+    "AUC" : 0.80687,
+    "RunTime(sec)" : .688
+    },
+"LR(PCA)" : {
+    "Accuracy": 0.7866,
+    "Precision": 0.8162,
+    "Recall": 0.7492,
+    "F1 score": 0.7813,
+    "AUC" : 0.7872,
+    "RunTime(sec)" : .433
+    },
+"LR(REF)" : {
+    "Accuracy": 0.7984,
+    "Precision": 0.8409,
+    "Recall": 0.7335,
+    "F1 score":0.7835,
+    "AUC" : 0.7980,
+    "RunTime(sec)" : 1.7
+    },
+"LR(GridSearch)" : {
+    "Accuracy": 0.81636,
+    "Precision": 0.8270,
+    "Recall": 0.7977,
+    "F1 score": 0.8121,
+    "AUC" : 0.8162,
+    "RunTime(sec)" : 23.8
+    },
+"LR(RandomSearch)":{
+    "Accuracy": 0.8120,
+    "Precision": 0.8302,
+    "Recall": 0.7822,
+    "F1 score": 0.8055,
+    "AUC" : 0.8119,
+    "RunTime(sec)" : 4.9
+    },
+"Neural Network" : {
+    "Accuracy": 0.8157,
+    "Precision": 0.8466,
+    "Recall": 0.76905,
+    "F1 score": 0.7707,
+    "AUC" : 0.8155,
+    "RunTime(sec)" : 120
+    },
+}
+df = pd.DataFrame(m)
+df.T
+
+
+# # Summary
+# 
+# I have choosen two performance criterion for models:
+# 1. Model Accuracy
+# 2. Run time
+# 
+# #### 1. Model Accuracy
+# 
+# **GradientBoosting** outperform all the models if we take accuracy under consideration.It has 82.7% accuracy. But it takes nearly 481 sec (8 min) to pick the hyperparameters, train the model and predict the output.
+# 
+# There is another way to reduce the runtime by a factor of 8 without losing much accuracy if we use Random Forest for modelling.
+# **Random Forest** has accuracy 82% but it has nearly 1 min runtime.
+# 
+# #### 2. Run time
+# 
+# In case if our focus is on runtime then **Logistic Regression** has runtime 4.9 sec with accuracy 81.1%.
+# 
+# But if we want lowest runtime, we have to diminishing the accuracy. In that case **LDA** is the best choice with nearly 80% accuracy and 1.2 sec of runtime.
+
+# **The results obtained above can be used as a standard point of reference for other comparative studies done in the field of predicting values from census data. This comparative study can further be used as a basis for improving the present classifiers and techniques resulting in making better technologies for accurately predicting income level of an individual.**
+
+# In[ ]:
+
+
+
+
+
+# In[ ]:
+
+
+
+

AdultNoteBook/Kernels/ExtraTrees/3-income-classification-using-meta-learning.py

@@ -0,0 +1,632 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Adult Census Income Classification using Meta Learning
+
+# In[1]:
+
+
+#importing the required libraries
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+plt.style.use('ggplot')
+
+from imblearn.over_sampling import RandomOverSampler
+from sklearn.model_selection import train_test_split
+
+from numpy import mean, std
+
+
+# In[2]:
+
+
+#reading the dataset and converting it to dataframe
+df = pd.read_csv("../input/adult-census-income/adult.csv")
+
+
+# In[3]:
+
+
+#Viewing the top 5 rows of our dataset
+df.head()
+
+
+# ## Exploratory Data Analysis
+
+# **Income - Target column**
+
+# In[4]:
+
+
+sns.countplot(df.income)
+
+
+# *As we can see, there is a **class imbalance**. The ">50K" class is comparatively very less. So, we will do **Random Over-Sampling** during preprocessing.*
+# 
+
+# **Age**
+
+# In[5]:
+
+
+sns.distplot(df[df.income=='<=50K'].age, color='g')
+sns.distplot(df[df.income=='>50K'].age, color='r')
+
+
+# *We can observe a rough margin **around 30**. We will divide age into 2 parts ie. under 30 and over 30. We need to check if its useful for our model during testing.*
+
+# **Workclass**
+
+# In[6]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.workclass, hue=df.income, palette='tab10')
+
+
+# *Majority of the data falls under **Private**. So, we will convert this into Private and not-Private.*
+
+# **fnlwgt**
+
+# In[7]:
+
+
+sns.distplot(df[df.income=='<=50K'].fnlwgt, color='r')
+sns.distplot(df[df.income=='>50K'].fnlwgt, color='g')
+
+
+# *This is a very **ambiguous** attribute. Will check during testing.*
+
+# **Education**
+
+# In[8]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.education, hue=df.income, palette='muted')
+
+
+# **education.num**
+
+# In[9]:
+
+
+sns.countplot(df["education.num"], hue=df.income)
+
+
+# **marital.status**
+
+# In[10]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df['marital.status'], hue=df.income)
+
+
+# *We observe that the majority of ">50K" class is **Married-civ-spouse**. So we ll make it 1 and others 0*
+
+# **occupation**
+
+# In[11]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.occupation, hue=df.income, palette='rocket')
+
+
+# **relationship**
+
+# In[12]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.relationship, hue=df.income, palette='muted')
+
+
+# **race**
+
+# In[13]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.race, hue=df.income, palette='Set2')
+
+
+# **sex**
+
+# In[14]:
+
+
+plt.xticks(rotation=90)
+sns.countplot(df.sex, hue=df.income)
+
+
+# **capital.gain**
+
+# In[15]:
+
+
+df['capital.gain'].value_counts()
+
+
+# **capital.loss**
+
+# In[16]:
+
+
+df['capital.loss'].value_counts()
+
+
+# **hours.per.week**
+
+# In[17]:
+
+
+sns.distplot(df[df.income=='<=50K']['hours.per.week'], color='b')
+sns.distplot(df[df.income=='>50K']['hours.per.week'], color='r')
+
+
+# **native.country**
+
+# In[18]:
+
+
+df['native.country'].value_counts()
+
+
+# ## Preprocessing
+
+# ### Finding and Handling Missing Data
+# 
+# *Observing the dataset, I found that the null values are marked as "?", So, we will now convert them to numpy.nan(null values).*
+
+# In[19]:
+
+
+df[df.select_dtypes("object") =="?"] = np.nan
+nans = df.isnull().sum()
+if len(nans[nans>0]):
+    print("Missing values detected.\n")
+    print(nans[nans>0])
+else:
+    print("No missing values. You are good to go.")
+
+
+# In[20]:
+
+
+#majority of the values are "Private". Lets fill the missing values as "Private".
+df.workclass.fillna("Private", inplace=True)
+
+df.occupation.fillna(method='bfill', inplace=True)
+
+#majority of the values are "United-States". Lets fill the missing values as "United-States".
+df['native.country'].fillna("United-States", inplace=True)
+
+print("Handled missing values successfully.")
+
+
+# In[21]:
+
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.utils import column_or_1d
+
+class MyLabelEncoder(LabelEncoder):
+
+    def fit(self, y, arr=[]):
+        y = column_or_1d(y, warn=True)
+        if arr == []:
+            arr=y
+        self.classes_ = pd.Series(arr).unique()
+        return self
+
+le = MyLabelEncoder()
+
+
+# ### Feature Engineering and Encoding the columns
+
+# In[22]:
+
+
+# age_enc = pd.cut(df.age, bins=(0,25,45,65,100), labels=(0,1,2,3))
+df['age_enc'] = df.age.apply(lambda x: 1 if x > 30 else 0)
+
+def prep_workclass(x):
+    if x == 'Never-worked' or x == 'Without-pay':
+        return 0
+    elif x == 'Private':
+        return 1
+    elif x == 'State-gov' or x == 'Local-gov' or x == 'Federal-gov':
+        return 2
+    elif x == 'Self-emp-not-inc':
+        return 3
+    else:
+        return 4
+
+df['workclass_enc'] = df.workclass.apply(prep_workclass)
+
+df['fnlwgt_enc'] = df.fnlwgt.apply(lambda x: 0 if x>200000 else 1)
+
+le.fit(df.education, arr=['Preschool', '1st-4th', '5th-6th', '7th-8th', '9th','10th', '11th', '12th', 
+                                             'HS-grad', 'Prof-school', 'Assoc-acdm', 'Assoc-voc', 'Some-college', 'Bachelors', 'Masters', 'Doctorate'])
+df['education_enc'] = le.transform(df.education)
+
+
+df['education.num_enc'] = df['education.num'].apply(lambda x: 1 if x>=9 else 0)
+
+df['marital.status_enc'] = df['marital.status'].apply(lambda x: 1 if x=='Married-civ-spouse' or x == 'Married-AF-spouse' else 0)
+
+def prep_occupation(x):
+    if x in ['Prof-specialty', 'Exec-managerial', 'Tech-support', 'Protective-serv']:
+        return 2
+    elif x in ['Sales', 'Craft-repair']:
+        return 1
+    else:
+        return 0
+
+df['occupation_enc'] = df.occupation.apply(prep_occupation)
+
+df['relationship_enc'] = df.relationship.apply(lambda x: 1 if x in ['Husband', 'Wife'] else 0)
+
+df['race_enc'] = df.race.apply(lambda x: 1 if x=='White' else 0)
+
+df['sex_enc'] = df.sex.apply(lambda x: 1 if x=='Male' else 0)
+
+df['capital.gain_enc'] = pd.cut(df["capital.gain"], 
+                                bins=[-1,0,df[df["capital.gain"]>0]["capital.gain"].median(), df["capital.gain"].max()], labels=(0,1,2)).astype('int64')
+
+df['capital.loss_enc'] = pd.cut(df["capital.loss"], 
+                                bins=[-1,0,df[df["capital.loss"]>0]["capital.loss"].median(), df["capital.loss"].max()], labels=(0,1,2)).astype('int64')
+
+# hpw_enc = pd.cut(df['hours.per.week'], bins= (0,30,40,53,168), labels=(0,1,2,3))
+df['hours.per.week_enc'] = pd.qcut(df['hours.per.week'], q=5, labels=(0,1,2,3), duplicates='drop').astype('int64')
+
+df['native.country_enc'] = df['native.country'].apply(lambda x: 1 if x=='United-States' else 0)
+
+df['income_enc'] = df.income.apply(lambda x: 1 if x==">50K" else 0)
+
+print("Encoding complete.")
+
+
+# In[23]:
+
+
+df.select_dtypes("object").info()
+
+
+# In[24]:
+
+
+#dropping encoded columns - education, sex, income
+df.drop(['education', 'sex', 'income'], 1, inplace=True)
+
+
+# ### Label Encoding without Feature Engineering
+
+# In[25]:
+
+
+for feature in df.select_dtypes("object").columns:
+    df[feature]=le.fit_transform(df[feature])
+
+
+# ### Feature Selection
+
+# In[26]:
+
+
+df.info()
+
+
+# In[27]:
+
+
+#Visualizing the pearson correlation with the target class
+pcorr = df.drop('income_enc',1).corrwith(df.income_enc)
+plt.figure(figsize=(10,6))
+plt.title("Pearson Correlation of Features with Income")
+plt.xlabel("Features")
+plt.ylabel("Correlation Coeff")
+plt.xticks(rotation=90)
+plt.bar(pcorr.index, list(map(abs,pcorr.values)))
+
+
+# From the pearson correlation plot, we can see that correlation of few columns are very **low** with the target column, so, we ll drop them.
+
+# In[28]:
+
+
+df.drop(['workclass', 'fnlwgt','occupation', 'race', 'native.country', 'fnlwgt_enc', 'race_enc', 'native.country_enc'], 1, inplace=True)
+
+
+# In[29]:
+
+
+sns.heatmap(df.corr().apply(abs))
+
+
+# **Dropping redundant features**
+
+# We can see that **education_enc, education.num_enc and education.num** as well as **relationship_enc and marital.status_enc** have **high correlation**. So, we will only keep one of them based on their correlation with income_enc.
+# 
+# We also have some redundant feautres as we have engineered features from them(age, capital.gain, etc.).
+
+# In[30]:
+
+
+df.drop(['age', 'education.num_enc', 'education_enc', 'marital.status_enc', 'capital.gain', 'capital.loss', 'hours.per.week'], 1, inplace = True)
+
+
+# In[31]:
+
+
+df.info()
+
+
+# In[32]:
+
+
+X = df.drop('income_enc', 1)
+y = df.income_enc
+
+
+# ### Train Test Split (3:1)
+
+# In[33]:
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
+
+
+# In[34]:
+
+
+print("No. of rows in training data:",X_train.shape[0])
+print("No. of rows in testing data:",X_test.shape[0])
+
+
+# ### Random Over Sampling
+
+# *We can see the class imbalance in our target. This results in models that have poor predictive performance, specifically for the minority class. So, we need to random over sampling*
+
+# In[35]:
+
+
+oversample = RandomOverSampler(sampling_strategy=0.5) #50% oversampling
+X_over, y_over = oversample.fit_resample(X_train, y_train)
+
+
+# In[36]:
+
+
+y_over.value_counts()
+
+
+# ## Model Preparation
+
+# In[37]:
+
+
+#Model Imports
+from sklearn.model_selection import StratifiedKFold, cross_val_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import make_pipeline
+from sklearn.metrics import classification_report, confusion_matrix
+
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import AdaBoostClassifier, ExtraTreesClassifier, GradientBoostingClassifier, RandomForestClassifier, StackingClassifier
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+
+
+# In[38]:
+
+
+seed= 42
+
+
+# In[39]:
+
+
+models = {
+    'LR':LogisticRegression(random_state=seed),
+    'SVC':SVC(random_state=seed),
+    'AB':AdaBoostClassifier(random_state=seed),
+    'ET':ExtraTreesClassifier(random_state=seed),
+    'GB':GradientBoostingClassifier(random_state=seed),
+    'RF':RandomForestClassifier(random_state=seed),
+    'XGB':XGBClassifier(random_state=seed),
+    'LGBM':LGBMClassifier(random_state=seed)
+    }
+
+
+# In[40]:
+
+
+# evaluate a give model using cross-validation
+def evaluate_models(model, xtrain, ytrain):
+    cv = StratifiedKFold(shuffle=True, random_state=seed)
+    scores = cross_val_score(model, xtrain, ytrain, scoring='accuracy', cv=cv, error_score='raise')
+    return scores
+
+def plot_scores(xval,yval,show_value=False):
+    plt.ylim(ymax = max(yval)+0.5, ymin = min(yval)-0.5)
+    plt.xticks(rotation=45)
+    s = sns.barplot(xval,yval)
+    if show_value:
+        for x,y in zip(range(len(yval)),yval):
+            s.text(x,y+0.1,round(y,2),ha="center")
+
+
+# In[41]:
+
+
+# evaluate the models and store results for 100% oversampled minority class
+results, names = list(), list()
+for name, model in models.items():
+    scores = evaluate_models(model, X_train, y_train) 
+    results.append(scores) 
+    names.append(name) 
+    print('*%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
+
+
+# In[42]:
+
+
+plt.boxplot(results, labels=names, showmeans=True)
+plt.show() 
+
+
+# In[43]:
+
+
+param_grids = {
+    'LR':{'C':[0.001,0.01,0.1,1,10]},
+    'SVC':{'gamma':[0.01,0.02,0.05,0.08,0.1], 'C':range(1,8)},
+    
+    'AB':{'learning_rate': [0.05, 0.1, 0.2], 'n_estimators': [100, 200, 500]},
+    
+    'ET':{'max_depth':[5,8,10,12], 'min_samples_split': [5,9,12],
+          'n_estimators': [100,200,500,800]},
+    
+    'GB':{'learning_rate': [0.05, 0.1, 0.2], 'max_depth':[3,5,9],
+          'min_samples_split': [5,7,9], 'n_estimators': [100,200,500],
+          'subsample':[0.5,0.7,0.9]},
+    
+    'RF':{'max_depth':[3,5,9,15], 'n_estimators': [100, 200, 500, 1000],
+          'learning_rate': [0.05, 0.1, 0.2], 'min_samples_split': [5,9,12]},
+    
+    'XGB':{'max_depth':[3,5,7,9], 'n_estimators': [100, 200, 500],
+           'learning_rate': [0.05, 0.1, 0.2], 'subsample':[0.5,0.7,0.9]},
+    
+    'LGBM':{'n_estimators': [100,200,500],'learning_rate': [0.05, 0.1, 0.2],
+            'subsample':[0.5,0.7,0.9],'num_leaves': [25,31,50]}
+}
+
+
+# In[44]:
+
+
+# !pip install sklearn-deap
+# from evolutionary_search import EvolutionaryAlgorithmSearchCV
+
+
+# In[45]:
+
+
+# evaluate the models and store results
+# best_params = []
+# names= []
+# for name, param_grid, model in zip(param_grids.keys(), param_grids.values(), models.values()):
+#     eascv = EvolutionaryAlgorithmSearchCV(model, param_grid, verbose=3, cv=3)
+#     eascv.fit(X_train,y_train)
+#     names.append(name)
+#     best_params.append(eascv.best_params_)
+#     print(name)
+#     print("best score:",eascv.best_score_)
+#     print("best params:",eascv.best_params_)
+
+
+# In[46]:
+
+
+best_params=[
+    {'C': 10},
+    {'gamma': 0.1, 'C': 2},
+    {'learning_rate': 0.1, 'n_estimators': 500},
+    {'max_depth': 12, 'min_samples_split': 9, 'n_estimators': 100},
+    {'learning_rate': 0.05, 'max_depth': 3, 'min_samples_split': 9, 'n_estimators': 200, 'subsample': 0.9},
+    {'max_depth': 9, 'n_estimators': 200, 'min_samples_split': 5},
+    {'max_depth': 3, 'n_estimators': 200, 'learning_rate': 0.1, 'subsample': 0.9},
+    {'n_estimators': 100, 'learning_rate': 0.05, 'subsample': 0.9, 'num_leaves': 25}
+            ]
+
+
+# In[47]:
+
+
+models = [
+    ('LR',LogisticRegression(random_state=seed)),
+    ('SVC',SVC(random_state=seed)),
+    ('AB',AdaBoostClassifier(random_state=seed)),
+    ('ET',ExtraTreesClassifier(random_state=seed)),
+    ('GB',GradientBoostingClassifier(random_state=seed)),
+    ('RF',RandomForestClassifier(random_state=seed)),
+    ('XGB',XGBClassifier(random_state=seed)),
+    ('LGBM',LGBMClassifier(random_state=seed))
+]
+
+
+# In[48]:
+
+
+for model, param in zip(models, best_params):
+    model[1].set_params(**param)
+
+
+# In[49]:
+
+
+models.append(('MLModel',StackingClassifier(estimators = models[:-1])))
+
+
+# In[50]:
+
+
+scores=[]
+preds=[]
+for model in models:
+    model[1].fit(X_train,y_train)
+    print(model[0],"trained.")
+    scores.append(model[1].score(X_test,y_test))
+    preds.append(model[1].predict(X_test))
+print("Results are ready.")
+
+
+# ## Using Classification Based on Assocation
+
+# In[51]:
+
+
+get_ipython().system('pip install pyarc==1.0.23')
+get_ipython().system('pip install pyfim')
+from pyarc import CBA, TransactionDB
+
+
+# In[52]:
+
+
+txns_train = TransactionDB.from_DataFrame(X_train.join(y_train))
+txns_test = TransactionDB.from_DataFrame(X_test.join(y_test))
+
+
+cba = CBA(support=0.15, confidence=0.5, algorithm="m1")
+cba.fit(txns_train)
+
+
+# In[53]:
+
+
+cba_score = cba.rule_model_accuracy(txns_test) 
+scores.append(cba_score)
+models.append(["CBA"])
+
+
+# In[54]:
+
+
+model_names= [i[0] for i in models]
+scores = list(map(lambda x: x*100, scores))
+
+
+# In[55]:
+
+
+plot_scores(model_names, scores, True)
+

AdultNoteBook/Kernels/ExtraTrees/4-a-simple-knn-application.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # KNN 
+
+# # 1. Libraries
+
+# In[1]:
+
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from sklearn import preprocessing
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.model_selection import train_test_split
+from sklearn import metrics
+
+from sklearn.ensemble import ExtraTreesClassifier
+
+
+# # 2. Dataset
+
+# In[2]:
+
+
+dataset = pd.read_csv('../input/adult.csv')
+display(dataset.head(5))
+
+
+# In[3]:
+
+
+dataset.describe()
+
+
+# In[4]:
+
+
+display(dataset.info())
+
+
+# ## 2.1 Analising columns values
+# No line seems to have Nan or empty values. However futher investigation is needed once it's already possible to see '?' values in different columns. 
+
+# In[5]:
+
+
+print("Work class categories \n")
+print(dataset['workclass'].unique())
+
+
+# In[6]:
+
+
+print("Education categories")
+education_dataset = dataset[['education','education.num']]
+education_dataset = education_dataset.drop_duplicates()
+
+data = {'education': education_dataset['education'], 'education.num': education_dataset['education.num']}
+
+education_dataset = pd.DataFrame(data=data)
+education_dataset['education'].astype('category')
+education_dataset.index = education_dataset['education.num']
+print(education_dataset[['education']].sort_values('education.num'))
+
+
+# The columns 'education' and 'education.num' represent the same information. 'education.num' is the respective label for an education level. 
+
+# In[7]:
+
+
+print('marital status')
+print(dataset['marital.status'].unique())
+print(' \n occupation')
+print(dataset['occupation'].unique())
+print(' \n relationship')
+print(dataset['relationship'].unique())
+print(' \n race')
+print(dataset['race'].unique())
+print(' \n native.country')
+print(dataset['native.country'].unique())
+
+
+# ## 2.2 Dataset cleaning
+# 
+# As mentioned before, in many columns are present the '?' value for a missing information. So it will be removed every observation that contains a missing value. Also, it will be removed the columns 'capital.gain' and 'capital.loss', which doesn't seem so clear its meaning, and 'fnlwgt' which represents some final avaliation about the observation, thus the fitting process will get an equal result.
+
+# In[8]:
+
+
+#Replacing ? for a nan value to drop every line with it
+dataset = dataset.replace({'?': np.nan})
+dataset = dataset.dropna()
+dataset = dataset.drop(['fnlwgt', 'capital.gain','capital.loss'], axis=1)
+
+
+# # 3. EDA
+
+# In[9]:
+
+
+ax = dataset['sex'].value_counts().plot(kind="bar")
+ax.set_ylabel("Quantity")
+plt.title("Sex quantities")
+plt.show()
+
+ax = dataset['age'].hist()
+ax.set_xlabel("Age")
+ax.set_ylabel("Quantity")
+plt.title("Age quantities")
+plt.show()
+
+ax = dataset['education.num'].hist()
+ax.set_xlabel("Education label")
+ax.set_ylabel("Quantity")
+plt.title("Education level quantities")
+plt.show()
+
+ax = dataset['race'].value_counts().plot(kind="bar")
+ax.set_ylabel("Quantity")
+plt.title("Race quantities")
+plt.show()
+
+dataset['native.country'].value_counts().plot(kind="bar")
+ax.set_ylabel("Quantity")
+plt.title("Countries quantities")
+plt.show()
+
+dataset['income'].value_counts().plot(kind="bar")
+ax.set_ylabel("Quantity")
+plt.title("Income quantities")
+plt.show()
+
+
+# # 4. Fitting a model
+
+# In[10]:
+
+
+#Preparing the features and target
+features = dataset.drop("income", axis=1)
+target = dataset.income
+
+#encoding the category features
+features_to_encode = features[['workclass', 'education', 'marital.status',
+       'occupation', 'relationship', 'race', 'sex',
+       'native.country']]
+
+features_encoded = features_to_encode.apply(preprocessing.LabelEncoder().fit_transform)
+target = preprocessing.LabelEncoder().fit_transform(target)
+features[['workclass', 'education', 'marital.status',
+       'occupation', 'relationship', 'race', 'sex',
+       'native.country']] = features_encoded
+
+print(features.shape, target.shape)
+
+display(features.head(5))
+
+
+# In[11]:
+
+
+#Dividing train and test data
+X_train, X_test, y_train, y_test = train_test_split(features,target, test_size=0.3)
+
+
+# In[12]:
+
+
+#Analising the % importance level in each feature
+forest = ExtraTreesClassifier(n_estimators=250,random_state=0)
+forest.fit(features, target)
+importances = forest.feature_importances_
+feature_importances = pd.DataFrame(importances*100,index = X_train.columns,columns=['importance']).sort_values('importance', ascending=False)
+display(feature_importances)
+
+
+# In[13]:
+
+
+#Analisng the accuracy by increasing the number of K
+scores = []
+for i in range(1,30):
+    knn = KNeighborsClassifier(n_neighbors=i)
+    knn.fit(X_train, y_train)
+    y_pred = knn.predict(X_test)
+    scores.append(metrics.accuracy_score(y_test, y_pred))
+
+sns.lineplot(range(1,30), scores)
+plt.xlabel('Value of K for KNN')
+plt.ylabel('Testing Accuracy')
+plt.title("Respective accuracy when increased the number of K")
+plt.grid(True)
+plt.show()
+
+
+# In[14]:
+
+
+print("The best K value in this dataset is {0} - Accuracy = {1}".format(scores.index(max(scores)), max(scores)))
+

AdultNoteBook/Kernels/ExtraTrees/5-adult-census-income-eda-and-prediction-87-35.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Adult Census Income EDA and Prediction
+# 
+# In this kernel I work with the UCI Adult Census Income dataset. The prediction task is to determine whether a person makes over $50K a year. I start with an exhaustive EDA, and I then train various models to solve the prediction task.
+
+# In[1]:
+
+
+import numpy as np
+import pandas as pd 
+import matplotlib.pyplot as plt 
+import seaborn as sns
+get_ipython().run_line_magic('matplotlib', 'inline')
+
+
+import os
+print(os.listdir("../input"))
+
+data = pd.read_csv("../input/adult.csv")
+
+
+# ## Exploratory Data Analysis
+
+# In[2]:
+
+
+print(len(data))
+data.head(10)
+
+
+# In[3]:
+
+
+data.isnull().sum()
+
+
+# Good.
+
+# In[4]:
+
+
+data.dtypes
+
+
+# In[5]:
+
+
+sns.countplot(data['income'])
+plt.show()
+
+
+# ### Distribution of features
+
+# In[6]:
+
+
+# Sex distribution
+sns.countplot(data['sex'])
+plt.show()
+
+
+# In[7]:
+
+
+# Age distribution
+ages = data['age'].hist(bins=max(data['age'])-min(data['age']))
+mean_val = np.mean(data['age'])
+plt.axvline(mean_val, linestyle='dashed', linewidth=2, color='yellow', label='mean age')
+plt.xlabel('age')
+plt.ylabel('count')
+plt.legend()
+plt.show()
+
+
+# In[8]:
+
+
+data['hours.per.week'].hist()
+plt.xlabel('hours per week')
+plt.ylabel('count')
+plt.show()
+
+
+# In[9]:
+
+
+fig, axs = plt.subplots(ncols=2, nrows=4, figsize=(20, 20))
+plt.subplots_adjust(hspace=0.68)
+fig.delaxes(axs[3][1])
+
+
+# Workclass
+wc_plot = sns.countplot(data['workclass'], ax=axs[0][0])
+wc_plot.set_xticklabels(wc_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Native country
+nc_plot = sns.countplot(data['native.country'], ax=axs[0][1])
+nc_plot.set_xticklabels(nc_plot.get_xticklabels(), rotation=72, ha="right")
+
+# Education
+order=['Preschool', '1st-4th', '5th-6th', '7th-8th', '9th', '10th', '11th', '12th', 'HS-grad',
+       'Some-college', 'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Masters', 'Prof-school', 'Doctorate']
+ed_plot = sns.countplot(data['education'], order=order, ax=axs[1][0])
+ed_plot.set_xticklabels(ed_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Marital status
+ms_plot = sns.countplot(data['marital.status'], ax=axs[1][1])
+ms_plot.set_xticklabels(ms_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Relationship
+rel_plot = sns.countplot(data['relationship'], ax=axs[2][0])
+rel_plot.set_xticklabels(rel_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Race
+race_plot = sns.countplot(data['race'], ax=axs[2][1])
+race_plot.set_xticklabels(race_plot.get_xticklabels(), rotation=40, ha="right")
+
+# Occupation
+occ_plot = sns.countplot(data['occupation'], ax=axs[3][0])
+occ_plot.set_xticklabels(occ_plot.get_xticklabels(), rotation=40, ha="right")
+
+plt.show()
+
+
+# 
+# ### How do features relate to one another?
+
+# In[10]:
+
+
+plt.figure(figsize=(24, 6))
+ro = sns.countplot(data['occupation'], hue=data['sex'])
+ro.set_xticklabels(ro.get_xticklabels(), rotation=30, ha="right")
+plt.show()
+
+
+# In[11]:
+
+
+plt.figure(figsize=(20, 6))
+ro = sns.countplot(data['education'], hue=data['sex'], order=order)
+ro.set_xticklabels(ro.get_xticklabels(), rotation=40, ha="right")
+#ro.set_yscale('log')
+plt.show()
+
+
+# In[12]:
+
+
+data['income'] = data['income'].map({'<=50K': 0, '>50K': 1}) 
+
+
+# ### How do features relate to income?
+
+# In[13]:
+
+
+fig, axs = plt.subplots(ncols=2, nrows=4, figsize=(24, 28))
+#fig.delaxes(axs[3][1])
+plt.subplots_adjust(hspace=0.4)
+
+# education and income
+sns.catplot(x="education", y="income", data=data, kind="bar", height = 6, palette = "muted", order=order, ax=axs[0][0])
+axs[0][0].set_xticklabels(axs[0][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[0][0].set_ylabel(">50K probability")
+
+sns.catplot(x="workclass", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[0][1])
+axs[0][1].set_xticklabels(axs[0][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[0][1].set_ylabel(">50K probability")
+
+
+sns.catplot(x="relationship", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[1][0])
+axs[1][0].set_xticklabels(axs[1][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[1][0].set_ylabel(">50K probability")
+
+sns.catplot(x="marital.status", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[1][1])
+axs[1][1].set_xticklabels(axs[1][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[1][1].set_ylabel(">50K probability")
+
+sns.catplot(x="race", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[2][0])
+axs[2][0].set_xticklabels(axs[2][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[2][0].set_ylabel(">50K probability")
+
+sns.catplot(x="native.country", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[2][1])
+axs[2][1].set_xticklabels(axs[2][1].axes.get_xticklabels(), rotation=55, ha="right")
+axs[2][1].set_ylabel(">50K probability")
+
+sns.catplot(x="sex", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[3][0])
+axs[3][0].set_xticklabels(axs[3][0].axes.get_xticklabels(), rotation=40, ha="right")
+axs[3][0].set_ylabel(">50K probability")
+
+sns.catplot(x="occupation", y="income", data=data, kind="bar", height = 6, palette = "muted", ax=axs[3][1])
+axs[3][1].set_xticklabels(axs[3][1].axes.get_xticklabels(), rotation=40, ha="right")
+axs[3][1].set_ylabel(">50K probability")
+
+#ed_income.set_ylabels(">50K probability")
+
+for i in range(2,10):
+        plt.close(i)
+
+plt.show()
+
+
+# #### Another way of visualizing this
+
+# In[14]:
+
+
+plt.figure(figsize=(20, 6))
+sns.countplot(data['marital.status'], hue=data['income'])
+plt.show()
+
+
+# ## Data Preparation
+# 
+# Now the data needs to be prepared for prediction.
+
+# In[15]:
+
+
+data['sex'] = data['sex'].map({'Male': 1, 'Female': 0}) 
+
+
+# In[16]:
+
+
+data['race'] = data['race'].map({'White': 1, 'Asian-Pac-Islander': 1, 'Black':0, 'Amer-Indian-Eskimo':0, 'Other':0}) 
+data['relationship'] = data['relationship'].map({'Not-in-family':0, 'Unmarried':0, 'Own-child':0, 'Other-relative':0, 'Husband':1, 'Wife':1})
+data['marital.status'] = data['marital.status'].map({'Widowed':0, 'Divorced':0, 'Separated':0, 'Never-married':0, 'Married-civ-spouse':1, 'Married-AF-spouse':1, 'Married-spouse-absent':0})
+
+
+# In[17]:
+
+
+g = sns.heatmap(data[['relationship', 'marital.status']].corr(),annot=True, fmt = ".2f", cmap = "coolwarm")
+plt.show()
+
+
+# relationship and marital.status contain the same information now, so one of them can be removed
+
+# In[18]:
+
+
+data.drop(['marital.status'], axis=1,inplace=True)
+
+
+# LabelEncoder can be used to transform the rest of the categorical features.
+
+# In[19]:
+
+
+# data.drop(['workclass', 'education', 'occupation', 'native.country'], axis=1,inplace=True)
+
+data.drop(['education'], axis=1,inplace=True)
+
+labels = ['workclass', 'occupation', 'native.country']
+
+from sklearn.preprocessing import LabelEncoder
+le = LabelEncoder()
+for l in labels:
+    data[l]=le.fit_transform(data[l])
+
+
+# In[20]:
+
+
+data.head(10)
+
+
+# The dataset is ready.
+
+# ## Prediction
+
+# #### Importing the relevant libraries
+
+# In[21]:
+
+
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, VotingClassifier, BaggingClassifier, ExtraTreesClassifier
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.model_selection import GridSearchCV, cross_val_score, cross_val_predict, StratifiedKFold, learning_curve, train_test_split, KFold
+# from sklearn.metrics import classification_report
+from sklearn.metrics import confusion_matrix, accuracy_score
+from sklearn.svm import SVC
+
+
+# #### Preparing data for training and testing with k-fold Cross-Validation
+
+# In[22]:
+
+
+seed = 42
+
+from sklearn.preprocessing import StandardScaler
+
+X = StandardScaler().fit_transform(data.loc[:, data.columns != 'income'])
+Y = data['income']
+
+# X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
+
+kf = KFold(n_splits=10, shuffle=True, random_state=seed)
+
+
+# In[23]:
+
+
+a = len(data.loc[data.income==0])/len(data)
+print(a)
+
+
+# One would get a 76% accuracy by just always predicting <=50k. Our model has to do better than that or it's not learning anything.
+
+# ### Starting with some simple models
+
+# In[24]:
+
+
+
+fig, axs = plt.subplots(ncols=2, nrows=2, figsize=(24, 14))
+
+
+classifiers = [
+    LogisticRegression(solver='newton-cg'),
+    KNeighborsClassifier(n_neighbors=17), # Some trial and error I don't show went into this hyperpa
+    LinearDiscriminantAnalysis(),
+    GaussianNB()
+]
+
+
+for i, c in enumerate(classifiers):
+    
+    x_axs = i%2
+    y_axs = int(i/2)
+    # print(c)
+    print(type(c).__name__)
+    pred = cross_val_predict(c, X, Y, cv=kf)
+    print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+
+    sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g', ax=axs[y_axs][x_axs])
+    axs[y_axs][x_axs].set_xlabel('Predicted')
+    axs[y_axs][x_axs].set_ylabel('Real')
+    axs[y_axs][x_axs].set_title(type(c).__name__)
+
+plt.show()
+
+
+# Logistic regression performs best with 84.25% accuracy. 
+# 
+
+# ### More complex models
+
+# In[25]:
+
+
+import warnings
+warnings.filterwarnings(action='ignore')
+fig, axs = plt.subplots(ncols=2, nrows=3, figsize=(24, 21))
+
+classifiers = [
+    DecisionTreeClassifier(),
+    BaggingClassifier(),
+    RandomForestClassifier(),
+    ExtraTreesClassifier(),
+    GradientBoostingClassifier(),
+    AdaBoostClassifier()
+]
+
+
+for i, c in enumerate(classifiers):
+    
+    x_axs = i%2
+    y_axs = int(i/2)
+    
+    # print(c)
+    print(type(c).__name__)
+    pred = cross_val_predict(c, X, Y, cv=kf)
+    print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+    
+    sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g', ax=axs[y_axs][x_axs])
+    axs[y_axs][x_axs].set_xlabel('Predicted')
+    axs[y_axs][x_axs].set_ylabel('Real')
+    axs[y_axs][x_axs].set_title(type(c).__name__)
+
+plt.show()
+
+
+# Gradient Boosting with no hyperparameter tuning gets to 86.58% accuracy. Not bad. Let's see if we can do better.
+
+# ### Model Tuning
+
+# GridSearchCV allows to try out a lot of hyperparameters at once.
+
+# In[26]:
+
+
+'''
+# This takes about 2 hours to run
+params = {'max_depth': [5, 6, 7], 
+         'n_estimators': [100, 150, 200],
+          'learning_rate': [0.1, 0.07, 0.05],
+          'max_features': ['sqrt', 'log2', 3, 4, 5]
+         }
+'''
+
+
+params = {'max_depth': [6], 
+         'n_estimators': [200],
+          'learning_rate': [0.07, 0.06],
+          'max_features': [3,4]
+         }
+
+classifier = GradientBoostingClassifier()
+
+grid = GridSearchCV(classifier, param_grid=params, cv=kf)
+search_result = grid.fit(X, Y)
+
+
+# In[27]:
+
+
+# GridSearch results
+means = search_result.cv_results_['mean_test_score']
+params = search_result.cv_results_['params']
+for m, p in zip(means, params):
+    print(f"{m} with: {p}")
+
+
+# In[28]:
+
+
+p = np.argmax(means)
+best_param = params[p]
+
+final_model = GradientBoostingClassifier(**best_param)
+
+print(final_model)
+pred = cross_val_predict(final_model, X, Y, cv=kf)
+print("Accuracy score:", round(accuracy_score(Y, pred), 4), '\n')
+
+sns.heatmap(confusion_matrix(Y, pred), annot=True, fmt='g')
+plt.show()
+
+
+# Final prediction accuracy: 87.35%

AdultNoteBook/Kernels/GBC/.ipynb_checkpoints/0-income-prediction-84-369-accuracy-checkpoint.ipynb

@@ -0,0 +1,1164 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "26ca1808-47be-4291-bae6-aee31907dfd0",
+    "_execution_state": "idle",
+    "_uuid": "8b5645b4fc767f691c88c0beeb918337c49b6433"
+   },
+   "source": [
+    "#Income Prediction Problem\n",
+    "In this Notebook, I am working through the Income Prediction problem associated with the Adult Income Census dataset. The goal is to accurately predict whether or not someone is making more or less than $50,000 a year. While working through this problem, I am following a framework I use to attack all my machine learning problems. It includes the following steps:\n",
+    "\n",
+    "1. Load Libraries\n",
+    "2. Load Data\n",
+    "3. Analyze Data\n",
+    "4. Feature Engineering\n",
+    "5. Modeling\n",
+    "6. Algorithm Tuning\n",
+    "7. Finalizing the Model\n",
+    "\n",
+    "I hope you enjoy this notebook and find it useful. Please keep in mind this is my first Notebook on here so don't judge it too harshly!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "2249cd4d-d941-4015-8103-9dcdec8bc587",
+    "_execution_state": "idle",
+    "_uuid": "b36102e03c9ec96cd20c1f6d40a1f8591d45c0c6"
+   },
+   "source": [
+    "##1. Load Libaraies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "bfca2f2a-d078-4f0a-ad8a-3d3571a08f76",
+    "_execution_state": "idle",
+    "_uuid": "e5e4b5ee88062058ceff62de7993eac563c1582b"
+   },
+   "source": [
+    "First, we need to load all of our libraries we will use for this project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "_cell_guid": "9201e3be-d4ec-4e38-9e7b-eb7bf54d7c25",
+    "_execution_state": "idle",
+    "_uuid": "de4cbbff6d2b51eb47a5a4719da64cd27804989d"
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "%matplotlib inline\n",
+    "\n",
+    "from collections import Counter\n",
+    "\n",
+    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, VotingClassifier\n",
+    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.neural_network import MLPClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold, learning_curve, train_test_split, KFold\n",
+    "from sklearn.metrics import classification_report\n",
+    "from sklearn.metrics import confusion_matrix\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "\n",
+    "sns.set(style='white', context='notebook', palette='deep')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aif360.datasets import StandardDataset\n",
+    "from aif360.metrics import BinaryLabelDatasetMetric, ClassificationMetric\n",
+    "import matplotlib.patches as patches\n",
+    "from aif360.algorithms.preprocessing import Reweighing\n",
+    "#from packages import *\n",
+    "#from ml_fairness import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "\n",
+    "\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "bf1d51ca-c701-44dd-a305-dbbfd4bb0cec",
+    "_execution_state": "idle",
+    "_uuid": "161e57d369bf62b7ad27912cc4ae0116ac5de0b6"
+   },
+   "source": [
+    "##2. Load Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "960b99a1-4408-4c1a-b86b-788c17e3b18b",
+    "_execution_state": "idle",
+    "_uuid": "0ecc4df26f5b56f9bfc4ed1841a73c8aafa00837"
+   },
+   "source": [
+    "Next, we load our data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "_cell_guid": "946806b5-f230-4216-b42e-a8358e51b605",
+    "_execution_state": "idle",
+    "_uuid": "c4141c604b71fa95c187aa09fe7bed39106fcb1d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "age               0\n",
+       "workclass         0\n",
+       "fnlwgt            0\n",
+       "education         0\n",
+       "education.num     0\n",
+       "marital.status    0\n",
+       "occupation        0\n",
+       "relationship      0\n",
+       "race              0\n",
+       "sex               0\n",
+       "capital.gain      0\n",
+       "capital.loss      0\n",
+       "hours.per.week    0\n",
+       "native.country    0\n",
+       "income            0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = pd.read_csv(\"../../Data/adult.csv\")\n",
+    "\n",
+    "# Check for Null Data\n",
+    "dataset.isnull().sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "_cell_guid": "25324eeb-2942-45fe-afae-0532421929cb",
+    "_execution_state": "idle",
+    "_uuid": "771a425b9b2a13c2266d851158fbc9e53211e118"
+   },
+   "outputs": [],
+   "source": [
+    "# Replace All Null Data in NaN\n",
+    "dataset = dataset.fillna(np.nan)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "_cell_guid": "86a2ec1f-d7e8-4f29-a949-68240fe69d87",
+    "_execution_state": "idle",
+    "_uuid": "68a3687580bd65fb09a100d49cecfe1774df79dc"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "age                int64\n",
+       "workclass         object\n",
+       "fnlwgt             int64\n",
+       "education         object\n",
+       "education.num      int64\n",
+       "marital.status    object\n",
+       "occupation        object\n",
+       "relationship      object\n",
+       "race              object\n",
+       "sex               object\n",
+       "capital.gain       int64\n",
+       "capital.loss       int64\n",
+       "hours.per.week     int64\n",
+       "native.country    object\n",
+       "income            object\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get data types\n",
+    "dataset.dtypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "_cell_guid": "1cbf148a-b814-40a3-9154-70c4511bdcd2",
+    "_execution_state": "idle",
+    "_uuid": "5fd35d640fdd346662ac08f7ab16ab996dfeb864"
+   },
+   "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>workclass</th>\n",
+       "      <th>fnlwgt</th>\n",
+       "      <th>education</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>?</td>\n",
+       "      <td>77053</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>?</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>132870</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>?</td>\n",
+       "      <td>186061</td>\n",
+       "      <td>Some-college</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>?</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>Black</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>140359</td>\n",
+       "      <td>7th-8th</td>\n",
+       "      <td>4</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Machine-op-inspct</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age workclass  fnlwgt     education  education.num marital.status  \\\n",
+       "0   90         ?   77053       HS-grad              9        Widowed   \n",
+       "1   82   Private  132870       HS-grad              9        Widowed   \n",
+       "2   66         ?  186061  Some-college             10        Widowed   \n",
+       "3   54   Private  140359       7th-8th              4       Divorced   \n",
+       "\n",
+       "          occupation   relationship   race     sex  capital.gain  \\\n",
+       "0                  ?  Not-in-family  White  Female             0   \n",
+       "1    Exec-managerial  Not-in-family  White  Female             0   \n",
+       "2                  ?      Unmarried  Black  Female             0   \n",
+       "3  Machine-op-inspct      Unmarried  White  Female             0   \n",
+       "\n",
+       "   capital.loss  hours.per.week native.country income  \n",
+       "0          4356              40  United-States  <=50K  \n",
+       "1          4356              18  United-States  <=50K  \n",
+       "2          4356              40  United-States  <=50K  \n",
+       "3          3900              40  United-States  <=50K  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Peek at data\n",
+    "dataset.head(4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "_cell_guid": "c183daab-b3b2-4cab-91a0-05f0b7a98dce",
+    "_execution_state": "idle",
+    "_uuid": "0b0c1b473300ee13c423318626c371835d032e12"
+   },
+   "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>workclass</th>\n",
+       "      <th>fnlwgt</th>\n",
+       "      <th>education</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>?</td>\n",
+       "      <td>77053</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>?</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>132870</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>?</td>\n",
+       "      <td>186061</td>\n",
+       "      <td>Some-college</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>?</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>Black</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>140359</td>\n",
+       "      <td>7th-8th</td>\n",
+       "      <td>4</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Machine-op-inspct</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age workclass  fnlwgt     education  education.num marital.status  \\\n",
+       "0   90         ?   77053       HS-grad              9        Widowed   \n",
+       "1   82   Private  132870       HS-grad              9        Widowed   \n",
+       "2   66         ?  186061  Some-college             10        Widowed   \n",
+       "3   54   Private  140359       7th-8th              4       Divorced   \n",
+       "\n",
+       "          occupation   relationship   race     sex  capital.gain  \\\n",
+       "0                  ?  Not-in-family  White  Female             0   \n",
+       "1    Exec-managerial  Not-in-family  White  Female             0   \n",
+       "2                  ?      Unmarried  Black  Female             0   \n",
+       "3  Machine-op-inspct      Unmarried  White  Female             0   \n",
+       "\n",
+       "   capital.loss  hours.per.week native.country  income  \n",
+       "0          4356              40  United-States       0  \n",
+       "1          4356              18  United-States       0  \n",
+       "2          4356              40  United-States       0  \n",
+       "3          3900              40  United-States       0  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "# Reformat Column We Are Predicting\n",
+    "dataset['income']=dataset['income'].map({'<=50K': 0, '>50K': 1, '<=50K.': 0, '>50K.': 1})\n",
+    "dataset.head(4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "7ad8dd1d-470b-4e1e-b7b5-44769b775131",
+    "_execution_state": "idle",
+    "_uuid": "6cb8261a58c38c0492512efdbd1621d910965d52"
+   },
+   "source": [
+    "##3. Analyze Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "_cell_guid": "1c4744ab-7e9a-4993-ae0e-3c725912c638",
+    "_execution_state": "idle",
+    "_uuid": "31c7a7019b800cdea2eae4d2904b3ad428219da2"
+   },
+   "outputs": [],
+   "source": [
+    "# Identify Numeric features\n",
+    "numeric_features = ['age','fnlwgt','education.num','capital.gain','capital.loss','hours.per.week','income']\n",
+    "\n",
+    "# Identify Categorical features\n",
+    "cat_features = ['workclass','education','marital.status', 'occupation', 'relationship', 'race', 'sex', 'native']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "0ade92f2-fcb2-487d-a581-34a89f85e3c5",
+    "_execution_state": "idle",
+    "_uuid": "1d0cdf67c8b35f2389931629a5f105823a42c804"
+   },
+   "source": [
+    "###3.1. Numeric Data Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "_cell_guid": "7004fe8d-fefd-4ade-805a-1dddf9c88928",
+    "_execution_state": "idle",
+    "_uuid": "bd1dbe810e1435bf36a9e262a115382c6c2761f4"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n"
+     ]
+    },
+    {
+     "ename": "AttributeError",
+     "evalue": "module 'seaborn' has no attribute 'plt'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-9-b46d4f116953>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Count of >50K & <=50K\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0msns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcountplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'income'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"Count\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m: module 'seaborn' has no attribute 'plt'"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Count of >50K & <=50K\n",
+    "sns.countplot(dataset['income'],label=\"Count\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "dc5bcab4-92fc-461c-9d7c-1a9580d23846",
+    "_execution_state": "idle",
+    "_uuid": "c92ee829ae5ca6724f3778a45f4e2a3df5f88c2a"
+   },
+   "outputs": [],
+   "source": [
+    "# Correlation matrix between numerical values\n",
+    "g = sns.heatmap(dataset[numeric_features].corr(),annot=True, fmt = \".2f\", cmap = \"coolwarm\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "57867c79-49b3-4e90-a196-aa9a297040a3",
+    "_execution_state": "idle",
+    "_uuid": "56537a5cce38758ab1e8514cbb7e12da27339984"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Education Num vs Income\n",
+    "g = sns.factorplot(x=\"education.num\",y=\"income\",data=dataset,kind=\"bar\",size = 6,palette = \"muted\")\n",
+    "g.despine(left=True)\n",
+    "g = g.set_ylabels(\">50K probability\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "40c1d5aa-7f1c-4cdd-94c6-fd074d404162",
+    "_execution_state": "idle",
+    "_uuid": "7d13c85496761accb5791803b816e6152d5b4fc8"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Hours Per Week vs Income\n",
+    "g  = sns.factorplot(x=\"hours.per.week\",y=\"income\",data=dataset,kind=\"bar\",size = 6,palette = \"muted\")\n",
+    "g.despine(left=True)\n",
+    "g = g.set_ylabels(\">50K probability\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "c719cef4-5d7f-4218-b5d5-f6ec2941a51e",
+    "_execution_state": "idle",
+    "_uuid": "2fa3fe2ff1f5dc96f2502767ce87263d86eb077b"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Age vs Income\n",
+    "g = sns.FacetGrid(dataset, col='income')\n",
+    "g = g.map(sns.distplot, \"age\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "cb5fb656-d724-4448-97b5-931560fcf9f2",
+    "_execution_state": "idle",
+    "_uuid": "076ad21bd294eb420d70df41407144cf12903e67"
+   },
+   "source": [
+    "###3.2. Categorical Data Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "_cell_guid": "dbccf607-7eb6-4e8b-8c00-2e91a2477ffe",
+    "_execution_state": "idle",
+    "_uuid": "0367e18fa3ea49392b03696aa5e75443c98ea471"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "age               0\n",
+       "workclass         0\n",
+       "fnlwgt            0\n",
+       "education         0\n",
+       "education.num     0\n",
+       "marital.status    0\n",
+       "occupation        0\n",
+       "relationship      0\n",
+       "race              0\n",
+       "sex               0\n",
+       "capital.gain      0\n",
+       "capital.loss      0\n",
+       "hours.per.week    0\n",
+       "native.country    0\n",
+       "income            0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Fill Missing Category Entries\n",
+    "dataset[\"workclass\"] = dataset[\"workclass\"].fillna(\"X\")\n",
+    "dataset[\"occupation\"] = dataset[\"occupation\"].fillna(\"X\")\n",
+    "dataset[\"native.country\"] = dataset[\"native.country\"].fillna(\"United-States\")\n",
+    "\n",
+    "# Confirm All Missing Data is Handled\n",
+    "dataset.isnull().sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "_cell_guid": "5c6b1b5c-886d-44b1-ac09-1d410cda49d1",
+    "_execution_state": "idle",
+    "_uuid": "557e3c876124213d21e797095c23f6e0b9a5c5ab"
+   },
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "module 'seaborn' has no attribute 'plt'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-11-0138039b851b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbarplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"native.country\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"income\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_ylabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Income >50K Probability\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0msns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m: module 'seaborn' has no attribute 'plt'"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Explore Native Nation vs Income\n",
+    "g = sns.barplot(x=\"native.country\",y=\"income\",data=dataset)\n",
+    "g = g.set_ylabel(\"Income >50K Probability\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "30b367e2-afec-49fa-b52a-0371f1d6c0bc",
+    "_execution_state": "idle",
+    "_uuid": "36779048741bd7d8c4be010aab17761657dcc952"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Sex vs Income\n",
+    "g = sns.barplot(x=\"sex\",y=\"income\",data=dataset)\n",
+    "g = g.set_ylabel(\"Income >50K Probability\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "70d38dd5-6ea6-4f6b-a5ea-2cd8d7c5e3b4",
+    "_execution_state": "idle",
+    "_uuid": "2b3ef28f7ccd536387bb5dc29f30a63df5c1f8a8"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Relationship vs Income\n",
+    "g = sns.factorplot(x=\"relationship\",y=\"income\",data=dataset,kind=\"bar\", size = 6 ,\n",
+    "palette = \"muted\")\n",
+    "g.despine(left=True)\n",
+    "g = g.set_ylabels(\"Income >50K Probability\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "c35908c8-7587-4dd6-826a-044a61a1fddd",
+    "_execution_state": "idle",
+    "_uuid": "8b0379c50391da248a88b6062e290200af00e65b"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Marital Status vs Income\n",
+    "g = sns.factorplot(x=\"marital.status\",y=\"income\",data=dataset,kind=\"bar\", size = 6 ,\n",
+    "palette = \"muted\")\n",
+    "g.despine(left=True)\n",
+    "g = g.set_ylabels(\"Income >50K Probability\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "6dcfbb5a-dff6-4d90-9ed5-9c217810a7ea",
+    "_execution_state": "idle",
+    "_uuid": "5199bc6918c701af26e84802b068fc858f9d0617"
+   },
+   "outputs": [],
+   "source": [
+    "# Explore Workclass vs Income\n",
+    "g = sns.factorplot(x=\"workclass\",y=\"income\",data=dataset,kind=\"bar\", size = 6 ,\n",
+    "palette = \"muted\")\n",
+    "g.despine(left=True)\n",
+    "g = g.set_ylabels(\"Income >50K Probability\")\n",
+    "sns.plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "f370f948-2810-48a9-b54f-b4c9c8ff851d",
+    "_execution_state": "idle",
+    "_uuid": "be23c9e7f4907134e69ca32b3e50de52e7f0a111"
+   },
+   "source": [
+    "##4. Feature Engineering"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "_cell_guid": "1f2a9e2f-273b-495b-a615-4e9b8dd33c69",
+    "_execution_state": "idle",
+    "_uuid": "33f5e2439162592c594918029c6ececc4d6fa817"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset with Dropped Labels\n",
+      "   age  fnlwgt  education.num  marital.status  sex  capital.gain  \\\n",
+      "0   90   77053              9               0    0             0   \n",
+      "1   82  132870              9               0    0             0   \n",
+      "2   66  186061             10               0    0             0   \n",
+      "3   54  140359              4               0    0             0   \n",
+      "4   41  264663             10               0    0             0   \n",
+      "\n",
+      "   capital.loss  hours.per.week  income  \n",
+      "0          4356              40       0  \n",
+      "1          4356              18       0  \n",
+      "2          4356              40       0  \n",
+      "3          3900              40       0  \n",
+      "4          3900              40       0  \n"
+     ]
+    }
+   ],
+   "source": [
+    "####################################################\n",
+    "############### FEATURE ENGINEERING ################\n",
+    "####################################################\n",
+    "# Convert Sex value to 0 and 1\n",
+    "dataset[\"sex\"] = dataset[\"sex\"].map({\"Male\": 1, \"Female\":0})\n",
+    "\n",
+    "# Create Married Column - Binary Yes(1) or No(0)\n",
+    "dataset[\"marital.status\"] = dataset[\"marital.status\"].replace(['Never-married','Divorced','Separated','Widowed'], 'Single')\n",
+    "dataset[\"marital.status\"] = dataset[\"marital.status\"].replace(['Married-civ-spouse','Married-spouse-absent','Married-AF-spouse'], 'Married')\n",
+    "dataset[\"marital.status\"] = dataset[\"marital.status\"].map({\"Married\":1, \"Single\":0})\n",
+    "dataset[\"marital.status\"] = dataset[\"marital.status\"].astype(int)\n",
+    "\n",
+    "# Drop the data you don't want to use\n",
+    "dataset.drop(labels=[\"workclass\",\"education\",\"occupation\",\"relationship\",\"race\",\"native.country\"], axis = 1, inplace = True)\n",
+    "print('Dataset with Dropped Labels')\n",
+    "print(dataset.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "46f46b2b-9ecc-4010-88c2-ae7872f80d8f",
+    "_execution_state": "idle",
+    "_uuid": "ab574da3a5eed4439cd48fe5dd6e681f01778d6e"
+   },
+   "source": [
+    "##5. Modeling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "2168869f-7cc2-4156-94a2-f1d27faaea17",
+    "_execution_state": "idle",
+    "_uuid": "a8b064a5427aa5e314094466a394d623bf7f020c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Split Data: X\n",
+      "[[    90  77053      9 ...      0   4356     40]\n",
+      " [    82 132870      9 ...      0   4356     18]\n",
+      " [    66 186061     10 ...      0   4356     40]\n",
+      " ...\n",
+      " [    40 154374      9 ...      0      0     40]\n",
+      " [    58 151910      9 ...      0      0     40]\n",
+      " [    22 201490      9 ...      0      0     20]]\n",
+      "Split Data: Y\n",
+      "[0 0 0 ... 1 0 0]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR: 0.796836 (0.003727)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LDA: 0.829507 (0.004318)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "KNN: 0.774455 (0.005765)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CART: 0.808009 (0.006767)\n",
+      "NB: 0.794303 (0.003642)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
+      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n"
+     ]
+    }
+   ],
+   "source": [
+    "###################################################\n",
+    "##################### MODELING #####################\n",
+    "####################################################\n",
+    "# Split-out Validation Dataset and Create Test Variables\n",
+    "array = dataset.values\n",
+    "X = array[:,0:8]\n",
+    "Y = array[:,8]\n",
+    "print('Split Data: X')\n",
+    "print(X)\n",
+    "print('Split Data: Y')\n",
+    "print(Y)\n",
+    "validation_size = 0.20\n",
+    "seed = 7\n",
+    "num_folds = 10\n",
+    "scoring = 'accuracy'\n",
+    "X_train, X_validation, Y_train, Y_validation = train_test_split(X,Y,\n",
+    "    test_size=validation_size,random_state=seed)\n",
+    "\n",
+    "# Params for Random Forest\n",
+    "num_trees = 100\n",
+    "max_features = 3\n",
+    "\n",
+    "#Spot Check 5 Algorithms (LR, LDA, KNN, CART, GNB, SVM)\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(('RF', RandomForestClassifier(n_estimators=num_trees, max_features=max_features)))\n",
+    "#models.append(('SVM', SVC()))\n",
+    "# evalutate each model in turn\n",
+    "results = []\n",
+    "names = []\n",
+    "for name, model in models:\n",
+    "    kfold = KFold(n_splits=10, random_state=seed)\n",
+    "    cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring='accuracy')\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": "code",
+   "execution_count": 22,
+   "metadata": {
+    "_cell_guid": "28db75e2-b091-4199-a358-e83b26e29836",
+    "_execution_state": "idle",
+    "_uuid": "8be8d86aeb3f97e762f7184db80c2fa4f5fcb5ed"
+   },
+   "outputs": [],
+   "source": [
+    "fig = plt.figure()\n",
+    "fig.suptitle('Algorith Comparison')\n",
+    "ax = fig.add_subplot(111)\n",
+    "plt.boxplot(results)\n",
+    "ax.set_xticklabels(names)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "bc5073e0-41df-4105-8215-ad8cb89241f8",
+    "_execution_state": "idle",
+    "_uuid": "a016da59293800e79278556bae8a0aa550e46184"
+   },
+   "source": [
+    "##6. Algorithm Tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "ce7f4775-1714-482c-a6de-ceeae6fac0d2",
+    "_execution_state": "idle",
+    "_uuid": "6d3b6b7ac9a070d9c9513d56d40aa3e2a75ce997"
+   },
+   "outputs": [],
+   "source": [
+    "####################################################\n",
+    "################ ALGORITHM TUNING ##################\n",
+    "####################################################\n",
+    "'''\n",
+    "Commented Out to Reduce Script Time - Took 20 Minutes to run.\n",
+    "best n_estimator = 250\n",
+    "best max_feature = 5\n",
+    "# Tune Random Forest\n",
+    "n_estimators = np.array([50,100,150,200,250])\n",
+    "max_features = np.array([1,2,3,4,5])\n",
+    "param_grid = dict(n_estimators=n_estimators,max_features=max_features)\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(X_train, Y_train)\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",
+    "for mean, stdev, param in zip(means, stds, params):\n",
+    "    print(\"%f (%f) with: %r\" % (mean, stdev, param))\n",
+    "'''"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "52cb2e35-1e66-4e7c-bc74-4e7e149d6a60",
+    "_execution_state": "idle",
+    "_uuid": "7491499e7b6de7b0b50cd671a4db9262062d0679"
+   },
+   "source": [
+    "##7. Finalize Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "_cell_guid": "a1c36e3d-3aaa-4952-854a-1d9093387928",
+    "_execution_state": "idle",
+    "_uuid": "6a62aa15b02a8d0de1166725e8122344418785ed"
+   },
+   "outputs": [],
+   "source": [
+    "####################################################\n",
+    "################# FINALIZE MODEL ###################\n",
+    "####################################################\n",
+    "# 5. Finalize Model\n",
+    "# a) Predictions on validation dataset - KNN\n",
+    "random_forest = RandomForestClassifier(n_estimators=250,max_features=5)\n",
+    "random_forest.fit(X_train, Y_train)\n",
+    "predictions = random_forest.predict(X_validation)\n",
+    "print(\"Accuracy: %s%%\" % (100*accuracy_score(Y_validation, predictions)))\n",
+    "print(confusion_matrix(Y_validation, predictions))\n",
+    "print(classification_report(Y_validation, predictions))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

AdultNoteBook/Kernels/GBC/.ipynb_checkpoints/1-multiple-ml-techniques-and-analysis-of-dataset-checkpoint.ipynb

@@ -0,0 +1,1476 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "f31622ec-28ad-6203-7af8-ac8fc6ef9d57"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "_cell_guid": "9e275424-f0c4-c4e0-e8fa-ed4a0bf44a3b"
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn import metrics\n",
+    "from sklearn import datasets\n",
+    "from sklearn.feature_selection import RFE\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.ensemble import ExtraTreesClassifier\n",
+    "from sklearn.ensemble import GradientBoostingClassifier\n",
+    "from sklearn import tree\n",
+    "#from sklearn.cross_validation import KFold, cross_val_score\n",
+    "#from sklearn.cross_validation import train_test_split\n",
+    "%matplotlib inline\n",
+    "\n",
+    "path = '../../Data/adult.csv'\n",
+    "data = pd.read_csv(path)\n",
+    "\n",
+    "# remove rows where occupation is unknown\n",
+    "data = data[data.occupation != '?']\n",
+    "raw_data = data[data.occupation != '?']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aif360.datasets import StandardDataset\n",
+    "from aif360.metrics import BinaryLabelDatasetMetric, ClassificationMetric\n",
+    "import matplotlib.patches as patches\n",
+    "from aif360.algorithms.preprocessing import Reweighing\n",
+    "#from packages import *\n",
+    "#from ml_fairness import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "\n",
+    "\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "_cell_guid": "9b69562b-3aa3-7097-d454-4d956c7a1815"
+   },
+   "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>workclass</th>\n",
+       "      <th>fnlwgt</th>\n",
+       "      <th>education</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>...</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>hours.per.week</th>\n",
+       "      <th>native.country</th>\n",
+       "      <th>income</th>\n",
+       "      <th>workclass_num</th>\n",
+       "      <th>over50K</th>\n",
+       "      <th>marital_num</th>\n",
+       "      <th>race_num</th>\n",
+       "      <th>sex_num</th>\n",
+       "      <th>rel_num</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>132870</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Widowed</td>\n",
+       "      <td>Exec-managerial</td>\n",
+       "      <td>Not-in-family</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>...</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>18</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>140359</td>\n",
+       "      <td>7th-8th</td>\n",
+       "      <td>4</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Machine-op-inspct</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>264663</td>\n",
+       "      <td>Some-college</td>\n",
+       "      <td>10</td>\n",
+       "      <td>Separated</td>\n",
+       "      <td>Prof-specialty</td>\n",
+       "      <td>Own-child</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>34</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>216864</td>\n",
+       "      <td>HS-grad</td>\n",
+       "      <td>9</td>\n",
+       "      <td>Divorced</td>\n",
+       "      <td>Other-service</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3770</td>\n",
+       "      <td>45</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>38</td>\n",
+       "      <td>Private</td>\n",
+       "      <td>150601</td>\n",
+       "      <td>10th</td>\n",
+       "      <td>6</td>\n",
+       "      <td>Separated</td>\n",
+       "      <td>Adm-clerical</td>\n",
+       "      <td>Unmarried</td>\n",
+       "      <td>White</td>\n",
+       "      <td>Male</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3770</td>\n",
+       "      <td>40</td>\n",
+       "      <td>United-States</td>\n",
+       "      <td>&lt;=50K</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 21 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   age workclass  fnlwgt     education  education.num marital.status  \\\n",
+       "1   82   Private  132870       HS-grad              9        Widowed   \n",
+       "3   54   Private  140359       7th-8th              4       Divorced   \n",
+       "4   41   Private  264663  Some-college             10      Separated   \n",
+       "5   34   Private  216864       HS-grad              9       Divorced   \n",
+       "6   38   Private  150601          10th              6      Separated   \n",
+       "\n",
+       "          occupation   relationship   race     sex  ...  capital.loss  \\\n",
+       "1    Exec-managerial  Not-in-family  White  Female  ...          4356   \n",
+       "3  Machine-op-inspct      Unmarried  White  Female  ...          3900   \n",
+       "4     Prof-specialty      Own-child  White  Female  ...          3900   \n",
+       "5      Other-service      Unmarried  White  Female  ...          3770   \n",
+       "6       Adm-clerical      Unmarried  White    Male  ...          3770   \n",
+       "\n",
+       "   hours.per.week  native.country income workclass_num  over50K  marital_num  \\\n",
+       "1              18   United-States  <=50K             0        0            0   \n",
+       "3              40   United-States  <=50K             0        0            1   \n",
+       "4              40   United-States  <=50K             0        0            2   \n",
+       "5              45   United-States  <=50K             0        0            1   \n",
+       "6              40   United-States  <=50K             0        0            2   \n",
+       "\n",
+       "   race_num  sex_num  rel_num  \n",
+       "1         0        0        0  \n",
+       "3         0        0        0  \n",
+       "4         0        0        0  \n",
+       "5         0        0        0  \n",
+       "6         0        1        0  \n",
+       "\n",
+       "[5 rows x 21 columns]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# create numerical columns representing the categorical data\n",
+    "data['workclass_num'] = data.workclass.map({'Private':0, 'State-gov':1, 'Federal-gov':2, 'Self-emp-not-inc':3, 'Self-emp-inc':4, 'Local-gov':5, 'Without-pay':6})\n",
+    "data['over50K'] = np.where(data.income == '<=50K', 0, 1)\n",
+    "data['marital_num'] = data['marital.status'].map({'Widowed':0, 'Divorced':1, 'Separated':2, 'Never-married':3, 'Married-civ-spouse':4, 'Married-AF-spouse':4, 'Married-spouse-absent':5})\n",
+    "data['race_num'] = data.race.map({'White':0, 'Black':1, 'Asian-Pac-Islander':2, 'Amer-Indian-Eskimo':3, 'Other':4})\n",
+    "data['sex_num'] = np.where(data.sex == 'Female', 0, 1)\n",
+    "data['rel_num'] = data.relationship.map({'Not-in-family':0, 'Unmarried':0, 'Own-child':0, 'Other-relative':0, 'Husband':1, 'Wife':1})\n",
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "2792e5d4-f5b1-1da4-9820-fbffd1b75db6"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "_cell_guid": "5f790189-c824-2ab8-0db2-7c4fa2b5be83"
+   },
+   "outputs": [],
+   "source": [
+    "X = data[['workclass_num', 'education.num', 'marital_num', 'race_num', 'sex_num', 'rel_num', 'capital.gain', 'capital.loss']]\n",
+    "y = data.over50K"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "7f56d42f-b270-7f2d-d4ca-8ae76b868f8e"
+   },
+   "outputs": [],
+   "source": [
+    "# create a base classifier used to evaluate a subset of attributes\n",
+    "logreg = LogisticRegression()\n",
+    "\n",
+    "# create the RFE model and select 3 attributes\n",
+    "rfe = RFE(logreg, 3)\n",
+    "rfe = rfe.fit(X, y)\n",
+    "\n",
+    "# summarize the selection of the attributes\n",
+    "print(rfe.support_)\n",
+    "print(rfe.ranking_)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "1a6c8ea4-9f59-6625-5845-acd310fccd68"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "cb700d68-917e-59ac-b8a1-e07452dd1f3b"
+   },
+   "outputs": [],
+   "source": [
+    "# fit an Extra Tree model to the data\n",
+    "extree = ExtraTreesClassifier()\n",
+    "extree.fit(X, y)\n",
+    "\n",
+    "# display the relative importance of each attribute\n",
+    "relval = extree.feature_importances_\n",
+    "\n",
+    "# horizontal bar plot of feature importance\n",
+    "pos = np.arange(8) + 0.5\n",
+    "plt.barh(pos, relval, align='center')\n",
+    "plt.title(\"Feature Importance\")\n",
+    "plt.xlabel(\"Model Accuracy\")\n",
+    "plt.ylabel(\"Features\")\n",
+    "plt.yticks(pos, ('Working Class', 'Education', 'Marital Status', 'Race', 'Sex', 'Relationship Status', 'Capital Gain', 'Capital Loss'))\n",
+    "plt.grid(True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "e8153e4f-c2b2-4edf-70e8-17cdd44ae67d"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "a3ac453b-33b0-b1de-e354-aa5e04bb579e"
+   },
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=13)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "9610a106-d3cf-16c4-62f3-1a9e9825b3d5"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "06b10e07-b243-9bcc-5ffb-8cb09f8c5263"
+   },
+   "outputs": [],
+   "source": [
+    "# import\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "\n",
+    "# instantiate\n",
+    "logreg = LogisticRegression()\n",
+    "\n",
+    "# fit\n",
+    "logreg.fit(X_train, y_train)\n",
+    "\n",
+    "# predict\n",
+    "y_pred = logreg.predict(X_test)\n",
+    "\n",
+    "print('LogReg %s' % metrics.accuracy_score(y_test, y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "267b86ef-6b10-828f-39b2-4ca222533360"
+   },
+   "outputs": [],
+   "source": [
+    "# KFolds and Cross_val_scores\n",
+    "kf = KFold(len(data), n_folds=10, shuffle=False)\n",
+    "print('KFold CrossValScore %s' % cross_val_score(logreg, X, y, cv=kf).mean())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "6dd648a7-7ba0-e8c0-c0ab-c53a02c64ce6"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "_cell_guid": "8508203b-5247-9385-6642-e57ca626083b"
+   },
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'np' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-1-90807eed3400>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mneighbors\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mKNeighborsClassifier\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mk_range\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m26\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mscores\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mk_range\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mknn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mKNeighborsClassifier\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_neighbors\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "k_range = np.arange(1, 26)\n",
+    "scores = []\n",
+    "for k in k_range:\n",
+    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
+    "    knn.fit(X_train, y_train)\n",
+    "    y_pred = knn.predict(X_test)\n",
+    "    scores.append(metrics.accuracy_score(y_test, y_pred))\n",
+    "print(scores.index(max(scores)), max(scores))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "0fc7b70c-d513-a44b-c8d3-d8834313228f"
+   },
+   "outputs": [],
+   "source": [
+    "# plot the relationship between K and testing accuracy\n",
+    "plt.plot(k_range, scores)\n",
+    "plt.xlabel('Value of K for KNN')\n",
+    "plt.ylabel('Testing Accuracy')\n",
+    "plt.grid(True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "d452ca66-0a99-fcd3-a489-dcbad4eabae5"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "1d170210-b581-ee34-485b-5c1e537d723e"
+   },
+   "outputs": [],
+   "source": [
+    "clf = tree.DecisionTreeClassifier()\n",
+    "clf = clf.fit(X_train, y_train)\n",
+    "y_pred = clf.predict(X_test)\n",
+    "metrics.accuracy_score(y_test, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "cbca0780-6beb-b2d1-996a-707f627582d8"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "e0ff4d85-703c-f7a7-04cf-adf464563c06"
+   },
+   "outputs": [],
+   "source": [
+    "# create the numerical dummy columns for the features\n",
+    "dummies = pd.get_dummies(raw_data)\n",
+    "\n",
+    "# del either the greater than 50K feature or less than 50K feature\n",
+    "del dummies['income_<=50K']\n",
+    "dummy_data = dummies.values\n",
+    "\n",
+    "# shape the features and response \n",
+    "X = dummy_data[:, :-1]\n",
+    "y = dummy_data[:, -1]\n",
+    "print(X.shape, y.shape)\n",
+    "\n",
+    "# fit\n",
+    "gbc = GradientBoostingClassifier().fit(X_train, y_train)\n",
+    "\n",
+    "print('GBC %s' % gbc.score(X_test, y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "39b60434-1361-de4c-39eb-72e18c22055d"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "8a668f04-bb31-4d13-a939-6808e4331c60",
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# create a feature numerically representative of different capital gains catergories \n",
+    "def cap_split(row):\n",
+    "    if row['capital.gain'] > 0 and row['over50K'] == 1:\n",
+    "        return 1\n",
+    "    elif row['capital.gain'] > 0 and row['over50K'] == 0:\n",
+    "        return 2\n",
+    "    elif row['capital.gain'] <= 0 and row['over50K'] == 1:\n",
+    "        return 3\n",
+    "    else:\n",
+    "        return 4\n",
+    "    \n",
+    "data['cap_split'] = data.apply (lambda row: cap_split (row), axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "c9e79439-be22-0f13-f2a8-fc01e4662cb1",
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# def that will display the percentage and absolute value on the pie chart\n",
+    "def make_autopct(values):\n",
+    "    def my_autopct(pct):\n",
+    "        total = sum(values)\n",
+    "        val = int(round(pct*total/100.0))\n",
+    "        return '{p:.2f}%  ({v:d})'.format(p=pct,v=val)\n",
+    "    return my_autopct"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "afa6d82e-9ba6-dfa8-b4f1-4854dca2f6b1"
+   },
+   "outputs": [],
+   "source": [
+    "# pie chart displaying breakdown of all types of cap in relation to making over 50K\n",
+    "cap_split = data.cap_split.value_counts().sort_index()\n",
+    "colors = ['lightgreen', 'darkseagreen', 'pink', 'lightcoral']\n",
+    "explode = [0.2, 0.2, 0, 0]\n",
+    "label = ['>  50K,  Pos Cap', '<= 50K, Pos Cap', '>  50K,  Neg/No Cap', '<= 50K, Neg/No Cap']\n",
+    "fig = plt.figure(figsize=(12, 12)) \n",
+    "ax = fig.add_subplot(1, 1, 1)\n",
+    "plt.pie(cap_split, shadow=True, colors=colors, explode=explode, autopct=make_autopct(cap_split))\n",
+    "plt.title('Income Breakdown Based on Capital Gains')\n",
+    "plt.axis('equal')\n",
+    "plt.legend(label, title='INCOME', bbox_to_anchor=(1.15, .95))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "8e3dc2bf-25ff-b028-58e1-e1d6323acfb7"
+   },
+   "outputs": [],
+   "source": [
+    "# pie charts separating the Pos Capital Gains vs. the Neg/No Capital Gains\n",
+    "import matplotlib.patches as mpatches\n",
+    "%matplotlib inline\n",
+    "\n",
+    "caphigh = data[data['capital.gain'] > 0]\n",
+    "caplow = data[data['capital.gain'] <= 0]\n",
+    "\n",
+    "caphigh_val = caphigh.over50K.value_counts()\n",
+    "caplow_val = caplow.over50K.value_counts()\n",
+    "colors1 = ['lightgreen', 'pink']\n",
+    "colors2 = ['pink', 'lightgreen']\n",
+    "\n",
+    "fig = plt.figure(figsize=(10, 10))\n",
+    "ax1 = fig.add_subplot(2, 1, 1)\n",
+    "plt.pie(caphigh_val, shadow=True, explode=[0.1, 0], colors=colors1, autopct=make_autopct(caphigh_val))\n",
+    "plt.axis('equal')\n",
+    "plt.title('Income Breakdown Based on Positive Capital Gains')\n",
+    "plt.legend(labels=['> 50K', '<= 50K'], frameon=True, shadow=True, title='INCOME')\n",
+    "\n",
+    "ax2 = fig.add_subplot(2, 1, 2)\n",
+    "plt.pie(caplow_val, shadow=True, explode=[0.1, 0], colors=colors2, autopct=make_autopct(caplow_val))\n",
+    "plt.axis('equal')\n",
+    "plt.title('Income Breakdown Based on No/Negative Capital Gains')\n",
+    "ax2_patch1 = mpatches.Patch(facecolor='lightgreen',  edgecolor='black', label='> 50K')\n",
+    "ax2_patch2 = mpatches.Patch(facecolor='pink',  edgecolor='black', label='<= 50K')\n",
+    "plt.legend(handles=[ax2_patch1, ax2_patch2], frameon=True, shadow=True, title='INCOME')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fairness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This DataFrame is created to stock differents models and fair metrics that we produce in this notebook\n",
+    "algo_metrics = pd.DataFrame(columns=['model', 'fair_metrics', 'prediction', 'probs'])\n",
+    "\n",
+    "def add_to_df_algo_metrics(algo_metrics, model, fair_metrics, preds, probs, name):\n",
+    "    return algo_metrics.append(pd.DataFrame(data=[[model, fair_metrics, preds, probs]], columns=['model', 'fair_metrics', 'prediction', 'probs'], index=[name]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fair_metrics(dataset, pred, pred_is_dataset=False):\n",
+    "    if pred_is_dataset:\n",
+    "        dataset_pred = pred\n",
+    "    else:\n",
+    "        dataset_pred = dataset.copy()\n",
+    "        dataset_pred.labels = pred\n",
+    "    \n",
+    "    cols = ['statistical_parity_difference', 'equal_opportunity_difference', 'average_abs_odds_difference',  'disparate_impact', 'theil_index']\n",
+    "    obj_fairness = [[0,0,0,1,0]]\n",
+    "    \n",
+    "    fair_metrics = pd.DataFrame(data=obj_fairness, index=['objective'], columns=cols)\n",
+    "    \n",
+    "    for attr in dataset_pred.protected_attribute_names:\n",
+    "        idx = dataset_pred.protected_attribute_names.index(attr)\n",
+    "        privileged_groups =  [{attr:dataset_pred.privileged_protected_attributes[idx][0]}] \n",
+    "        unprivileged_groups = [{attr:dataset_pred.unprivileged_protected_attributes[idx][0]}] \n",
+    "        \n",
+    "        classified_metric = ClassificationMetric(dataset, \n",
+    "                                                     dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        metric_pred = BinaryLabelDatasetMetric(dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        acc = classified_metric.accuracy()\n",
+    "\n",
+    "        row = pd.DataFrame([[metric_pred.mean_difference(),\n",
+    "                                classified_metric.equal_opportunity_difference(),\n",
+    "                                classified_metric.average_abs_odds_difference(),\n",
+    "                                metric_pred.disparate_impact(),\n",
+    "                                classified_metric.theil_index()]],\n",
+    "                           columns  = cols,\n",
+    "                           index = [attr]\n",
+    "                          )\n",
+    "        fair_metrics = fair_metrics.append(row)    \n",
+    "    \n",
+    "    fair_metrics = fair_metrics.replace([-np.inf, np.inf], 2)\n",
+    "        \n",
+    "    return fair_metrics\n",
+    "\n",
+    "def plot_fair_metrics(fair_metrics):\n",
+    "    fig, ax = plt.subplots(figsize=(20,4), ncols=5, nrows=1)\n",
+    "\n",
+    "    plt.subplots_adjust(\n",
+    "        left    =  0.125, \n",
+    "        bottom  =  0.1, \n",
+    "        right   =  0.9, \n",
+    "        top     =  0.9, \n",
+    "        wspace  =  .5, \n",
+    "        hspace  =  1.1\n",
+    "    )\n",
+    "\n",
+    "    y_title_margin = 1.2\n",
+    "\n",
+    "    plt.suptitle(\"Fairness metrics\", y = 1.09, fontsize=20)\n",
+    "    sns.set(style=\"dark\")\n",
+    "\n",
+    "    cols = fair_metrics.columns.values\n",
+    "    obj = fair_metrics.loc['objective']\n",
+    "    size_rect = [0.2,0.2,0.2,0.4,0.25]\n",
+    "    rect = [-0.1,-0.1,-0.1,0.8,0]\n",
+    "    bottom = [-1,-1,-1,0,0]\n",
+    "    top = [1,1,1,2,1]\n",
+    "    bound = [[-0.1,0.1],[-0.1,0.1],[-0.1,0.1],[0.8,1.2],[0,0.25]]\n",
+    "\n",
+    "    display(Markdown(\"### Check bias metrics :\"))\n",
+    "    display(Markdown(\"A model can be considered bias if just one of these five metrics show that this model is biased.\"))\n",
+    "    for attr in fair_metrics.index[1:len(fair_metrics)].values:\n",
+    "        display(Markdown(\"#### For the %s attribute :\"%attr))\n",
+    "        check = [bound[i][0] < fair_metrics.loc[attr][i] < bound[i][1] for i in range(0,5)]\n",
+    "        display(Markdown(\"With default thresholds, bias against unprivileged group detected in **%d** out of 5 metrics\"%(5 - sum(check))))\n",
+    "\n",
+    "    for i in range(0,5):\n",
+    "        plt.subplot(1, 5, i+1)\n",
+    "        ax = sns.barplot(x=fair_metrics.index[1:len(fair_metrics)], y=fair_metrics.iloc[1:len(fair_metrics)][cols[i]])\n",
+    "        \n",
+    "        for j in range(0,len(fair_metrics)-1):\n",
+    "            a, val = ax.patches[j], fair_metrics.iloc[j+1][cols[i]]\n",
+    "            marg = -0.2 if val < 0 else 0.1\n",
+    "            ax.text(a.get_x()+a.get_width()/5, a.get_y()+a.get_height()+marg, round(val, 3), fontsize=15,color='black')\n",
+    "\n",
+    "        plt.ylim(bottom[i], top[i])\n",
+    "        plt.setp(ax.patches, linewidth=0)\n",
+    "        ax.add_patch(patches.Rectangle((-5,rect[i]), 10, size_rect[i], alpha=0.3, facecolor=\"green\", linewidth=1, linestyle='solid'))\n",
+    "        plt.axhline(obj[i], color='black', alpha=0.3)\n",
+    "        plt.title(cols[i])\n",
+    "        ax.set_ylabel('')    \n",
+    "        ax.set_xlabel('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_fair_metrics_and_plot(data, model, plot=False, model_aif=False):\n",
+    "    pred = model.predict(data).labels if model_aif else model.predict(data.features)\n",
+    "    # fair_metrics function available in the metrics.py file\n",
+    "    fair = fair_metrics(data, pred)\n",
+    "\n",
+    "    if plot:\n",
+    "        # plot_fair_metrics function available in the visualisations.py file\n",
+    "        # The visualisation of this function is inspired by the dashboard on the demo of IBM aif360 \n",
+    "        plot_fair_metrics(fair)\n",
+    "        display(fair)\n",
+    "    \n",
+    "    return fair"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
+      "Try using .loc[row_indexer,col_indexer] = value instead\n",
+      "\n",
+      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n"
+     ]
+    }
+   ],
+   "source": [
+    "X['income'] = y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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>workclass_num</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>marital_num</th>\n",
+       "      <th>race_num</th>\n",
+       "      <th>sex_num</th>\n",
+       "      <th>rel_num</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>income</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0</td>\n",
+       "      <td>10</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3770</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3770</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32556</th>\n",
+       "      <td>0</td>\n",
+       "      <td>10</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32557</th>\n",
+       "      <td>0</td>\n",
+       "      <td>12</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32558</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32559</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32560</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>30718 rows × 9 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       workclass_num  education.num  marital_num  race_num  sex_num  rel_num  \\\n",
+       "1                  0              9            0         0        0        0   \n",
+       "3                  0              4            1         0        0        0   \n",
+       "4                  0             10            2         0        0        0   \n",
+       "5                  0              9            1         0        0        0   \n",
+       "6                  0              6            2         0        1        0   \n",
+       "...              ...            ...          ...       ...      ...      ...   \n",
+       "32556              0             10            3         0        1        0   \n",
+       "32557              0             12            4         0        0        1   \n",
+       "32558              0              9            4         0        1        1   \n",
+       "32559              0              9            0         0        0        0   \n",
+       "32560              0              9            3         0        1        0   \n",
+       "\n",
+       "       capital.gain  capital.loss  income  \n",
+       "1                 0          4356       0  \n",
+       "3                 0          3900       0  \n",
+       "4                 0          3900       0  \n",
+       "5                 0          3770       0  \n",
+       "6                 0          3770       0  \n",
+       "...             ...           ...     ...  \n",
+       "32556             0             0       0  \n",
+       "32557             0             0       0  \n",
+       "32558             0             0       1  \n",
+       "32559             0             0       0  \n",
+       "32560             0             0       0  \n",
+       "\n",
+       "[30718 rows x 9 columns]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#print(X)\n",
+    "\n",
+    "\n",
+    "#combine_final = [train_df, test_df]\n",
+    "#result = pd.concat(combine_final)\n",
+    "#print(result.ifany())\n",
+    "#print(result)\n",
+    "privileged_groups = [{'sex_num': 1}]\n",
+    "unprivileged_groups = [{'sex_num': 0}]\n",
+    "dataset_orig = StandardDataset(X,\n",
+    "                                  label_name='income',\n",
+    "                                  protected_attribute_names=['sex_num'],\n",
+    "                                  favorable_classes=[1],\n",
+    "                                  privileged_classes=[[1]])\n",
+    "\n",
+    "#metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "#                                             unprivileged_groups=unprivileged_groups,\n",
+    "#                                             privileged_groups=privileged_groups)\n",
+    "#display(Markdown(\"#### Original training dataset\"))\n",
+    "#print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "#### Original training dataset"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Difference in mean outcomes between unprivileged and privileged groups = -0.200292\n"
+     ]
+    }
+   ],
+   "source": [
+    "metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "                                             unprivileged_groups=unprivileged_groups,\n",
+    "                                             privileged_groups=privileged_groups)\n",
+    "display(Markdown(\"#### Original training dataset\"))\n",
+    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ipynbname\n",
+    "nb_fname = ipynbname.name()\n",
+    "nb_path = ipynbname.path()\n",
+    "\n",
+    "from xgboost import XGBClassifier\n",
+    "import pickle\n",
+    "\n",
+    "data_orig_train, data_orig_test = dataset_orig.split([0.7], shuffle=True)\n",
+    "X_train = data_orig_train.features\n",
+    "y_train = data_orig_train.labels.ravel()\n",
+    "\n",
+    "X_test = data_orig_test.features\n",
+    "y_test = data_orig_test.labels.ravel()\n",
+    "num_estimators = 100\n",
+    "\n",
+    "model = GradientBoostingClassifier(n_estimators= 1)\n",
+    "\n",
+    "mdl = model.fit(X_train, y_train)\n",
+    "with open('../../Results/GBC/' + nb_fname + '.pkl', 'wb') as f:\n",
+    "        pickle.dump(mdl, f)\n",
+    "\n",
+    "with open('../../Results/GBC/' + nb_fname + '_Train' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_train, f) \n",
+    "    \n",
+    "with open('../../Results/GBC/' + nb_fname + '_Test' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_test, f) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "invalid value encountered in double_scalars\n",
+      "invalid value encountered in double_scalars\n",
+      "invalid value encountered in double_scalars\n"
+     ]
+    }
+   ],
+   "source": [
+    "from csv import writer\n",
+    "from sklearn.metrics import accuracy_score, f1_score\n",
+    "\n",
+    "final_metrics = []\n",
+    "accuracy = []\n",
+    "f1= []\n",
+    "\n",
+    "for i in range(1,num_estimators+1):\n",
+    "    \n",
+    "    model = GradientBoostingClassifier(n_estimators= i)\n",
+    "    mdl = model.fit(X_train, y_train)\n",
+    "    yy = mdl.predict(X_test)\n",
+    "    accuracy.append(accuracy_score(y_test, yy))\n",
+    "    f1.append(f1_score(y_test, yy))\n",
+    "    fair = get_fair_metrics_and_plot(data_orig_test, mdl)                           \n",
+    "    fair_list = fair.iloc[1].tolist()\n",
+    "    #fair_list.insert(0, i)\n",
+    "    final_metrics.append(fair_list)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "           0         1         2         3         4\n",
+      "0   0.000000  0.000000  0.000000       NaN  0.282056\n",
+      "1   0.000000  0.000000  0.000000       NaN  0.282056\n",
+      "2   0.000000  0.000000  0.000000       NaN  0.282056\n",
+      "3  -0.033524  0.026489  0.014297  0.405867  0.225216\n",
+      "4  -0.033524  0.026489  0.014297  0.405867  0.225216\n",
+      "..       ...       ...       ...       ...       ...\n",
+      "95 -0.175809 -0.137035  0.098752  0.285825  0.120346\n",
+      "96 -0.175809 -0.137035  0.098752  0.285825  0.120346\n",
+      "97 -0.175648 -0.137035  0.098635  0.286012  0.120308\n",
+      "98 -0.176141 -0.137035  0.098939  0.284476  0.120308\n",
+      "99 -0.175980 -0.136516  0.098679  0.284663  0.120431\n",
+      "\n",
+      "[100 rows x 5 columns]\n"
+     ]
+    },
+    {
+     "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>classifier</th>\n",
+       "      <th>T0</th>\n",
+       "      <th>T1</th>\n",
+       "      <th>T2</th>\n",
+       "      <th>T3</th>\n",
+       "      <th>T4</th>\n",
+       "      <th>T5</th>\n",
+       "      <th>T6</th>\n",
+       "      <th>T7</th>\n",
+       "      <th>T8</th>\n",
+       "      <th>...</th>\n",
+       "      <th>T90</th>\n",
+       "      <th>T91</th>\n",
+       "      <th>T92</th>\n",
+       "      <th>T93</th>\n",
+       "      <th>T94</th>\n",
+       "      <th>T95</th>\n",
+       "      <th>T96</th>\n",
+       "      <th>T97</th>\n",
+       "      <th>T98</th>\n",
+       "      <th>T99</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>accuracy</th>\n",
+       "      <td>0.859158</td>\n",
+       "      <td>0.754232</td>\n",
+       "      <td>0.754232</td>\n",
+       "      <td>0.754232</td>\n",
+       "      <td>0.797743</td>\n",
+       "      <td>0.797743</td>\n",
+       "      <td>0.797743</td>\n",
+       "      <td>0.809896</td>\n",
+       "      <td>0.809896</td>\n",
+       "      <td>0.843641</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.858724</td>\n",
+       "      <td>0.858724</td>\n",
+       "      <td>0.858724</td>\n",
+       "      <td>0.858724</td>\n",
+       "      <td>0.859049</td>\n",
+       "      <td>0.859158</td>\n",
+       "      <td>0.859158</td>\n",
+       "      <td>0.859266</td>\n",
+       "      <td>0.859266</td>\n",
+       "      <td>0.859158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>f1</th>\n",
+       "      <td>0.675662</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.305514</td>\n",
+       "      <td>0.305514</td>\n",
+       "      <td>0.307063</td>\n",
+       "      <td>0.374732</td>\n",
+       "      <td>0.374732</td>\n",
+       "      <td>0.621288</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.674988</td>\n",
+       "      <td>0.674988</td>\n",
+       "      <td>0.674988</td>\n",
+       "      <td>0.674988</td>\n",
+       "      <td>0.675655</td>\n",
+       "      <td>0.675824</td>\n",
+       "      <td>0.675824</td>\n",
+       "      <td>0.675993</td>\n",
+       "      <td>0.675993</td>\n",
+       "      <td>0.675662</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistical_parity_difference</th>\n",
+       "      <td>-0.175980</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-0.033524</td>\n",
+       "      <td>-0.033524</td>\n",
+       "      <td>-0.033505</td>\n",
+       "      <td>-0.047616</td>\n",
+       "      <td>-0.047616</td>\n",
+       "      <td>-0.157535</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.176132</td>\n",
+       "      <td>-0.176132</td>\n",
+       "      <td>-0.176132</td>\n",
+       "      <td>-0.176132</td>\n",
+       "      <td>-0.175971</td>\n",
+       "      <td>-0.175809</td>\n",
+       "      <td>-0.175809</td>\n",
+       "      <td>-0.175648</td>\n",
+       "      <td>-0.176141</td>\n",
+       "      <td>-0.175980</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>equal_opportunity_difference</th>\n",
+       "      <td>-0.136516</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.026489</td>\n",
+       "      <td>0.026489</td>\n",
+       "      <td>0.024931</td>\n",
+       "      <td>-0.005468</td>\n",
+       "      <td>-0.005468</td>\n",
+       "      <td>-0.138445</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.136516</td>\n",
+       "      <td>-0.136516</td>\n",
+       "      <td>-0.136516</td>\n",
+       "      <td>-0.136516</td>\n",
+       "      <td>-0.137035</td>\n",
+       "      <td>-0.137035</td>\n",
+       "      <td>-0.137035</td>\n",
+       "      <td>-0.137035</td>\n",
+       "      <td>-0.137035</td>\n",
+       "      <td>-0.136516</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>average_abs_odds_difference</th>\n",
+       "      <td>0.098679</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.014297</td>\n",
+       "      <td>0.014297</td>\n",
+       "      <td>0.013261</td>\n",
+       "      <td>0.003529</td>\n",
+       "      <td>0.003529</td>\n",
+       "      <td>0.096792</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.098843</td>\n",
+       "      <td>0.098843</td>\n",
+       "      <td>0.098843</td>\n",
+       "      <td>0.098843</td>\n",
+       "      <td>0.098869</td>\n",
+       "      <td>0.098752</td>\n",
+       "      <td>0.098752</td>\n",
+       "      <td>0.098635</td>\n",
+       "      <td>0.098939</td>\n",
+       "      <td>0.098679</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>disparate_impact</th>\n",
+       "      <td>-1.256450</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>-0.901730</td>\n",
+       "      <td>-0.901730</td>\n",
+       "      <td>-0.884520</td>\n",
+       "      <td>-1.035325</td>\n",
+       "      <td>-1.035325</td>\n",
+       "      <td>-1.275262</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-1.253686</td>\n",
+       "      <td>-1.253686</td>\n",
+       "      <td>-1.253686</td>\n",
+       "      <td>-1.253686</td>\n",
+       "      <td>-1.253032</td>\n",
+       "      <td>-1.252377</td>\n",
+       "      <td>-1.252377</td>\n",
+       "      <td>-1.251722</td>\n",
+       "      <td>-1.257105</td>\n",
+       "      <td>-1.256450</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>theil_index</th>\n",
+       "      <td>0.120431</td>\n",
+       "      <td>0.282056</td>\n",
+       "      <td>0.282056</td>\n",
+       "      <td>0.282056</td>\n",
+       "      <td>0.225216</td>\n",
+       "      <td>0.225216</td>\n",
+       "      <td>0.224965</td>\n",
+       "      <td>0.209861</td>\n",
+       "      <td>0.209861</td>\n",
+       "      <td>0.140384</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.120580</td>\n",
+       "      <td>0.120580</td>\n",
+       "      <td>0.120580</td>\n",
+       "      <td>0.120580</td>\n",
+       "      <td>0.120383</td>\n",
+       "      <td>0.120346</td>\n",
+       "      <td>0.120346</td>\n",
+       "      <td>0.120308</td>\n",
+       "      <td>0.120308</td>\n",
+       "      <td>0.120431</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>7 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               classifier        T0        T1        T2  \\\n",
+       "accuracy                         0.859158  0.754232  0.754232  0.754232   \n",
+       "f1                               0.675662  0.000000  0.000000  0.000000   \n",
+       "statistical_parity_difference   -0.175980  0.000000  0.000000  0.000000   \n",
+       "equal_opportunity_difference    -0.136516  0.000000  0.000000  0.000000   \n",
+       "average_abs_odds_difference      0.098679  0.000000  0.000000  0.000000   \n",
+       "disparate_impact                -1.256450       NaN       NaN       NaN   \n",
+       "theil_index                      0.120431  0.282056  0.282056  0.282056   \n",
+       "\n",
+       "                                     T3        T4        T5        T6  \\\n",
+       "accuracy                       0.797743  0.797743  0.797743  0.809896   \n",
+       "f1                             0.305514  0.305514  0.307063  0.374732   \n",
+       "statistical_parity_difference -0.033524 -0.033524 -0.033505 -0.047616   \n",
+       "equal_opportunity_difference   0.026489  0.026489  0.024931 -0.005468   \n",
+       "average_abs_odds_difference    0.014297  0.014297  0.013261  0.003529   \n",
+       "disparate_impact              -0.901730 -0.901730 -0.884520 -1.035325   \n",
+       "theil_index                    0.225216  0.225216  0.224965  0.209861   \n",
+       "\n",
+       "                                     T7        T8  ...       T90       T91  \\\n",
+       "accuracy                       0.809896  0.843641  ...  0.858724  0.858724   \n",
+       "f1                             0.374732  0.621288  ...  0.674988  0.674988   \n",
+       "statistical_parity_difference -0.047616 -0.157535  ... -0.176132 -0.176132   \n",
+       "equal_opportunity_difference  -0.005468 -0.138445  ... -0.136516 -0.136516   \n",
+       "average_abs_odds_difference    0.003529  0.096792  ...  0.098843  0.098843   \n",
+       "disparate_impact              -1.035325 -1.275262  ... -1.253686 -1.253686   \n",
+       "theil_index                    0.209861  0.140384  ...  0.120580  0.120580   \n",
+       "\n",
+       "                                    T92       T93       T94       T95  \\\n",
+       "accuracy                       0.858724  0.858724  0.859049  0.859158   \n",
+       "f1                             0.674988  0.674988  0.675655  0.675824   \n",
+       "statistical_parity_difference -0.176132 -0.176132 -0.175971 -0.175809   \n",
+       "equal_opportunity_difference  -0.136516 -0.136516 -0.137035 -0.137035   \n",
+       "average_abs_odds_difference    0.098843  0.098843  0.098869  0.098752   \n",
+       "disparate_impact              -1.253686 -1.253686 -1.253032 -1.252377   \n",
+       "theil_index                    0.120580  0.120580  0.120383  0.120346   \n",
+       "\n",
+       "                                    T96       T97       T98       T99  \n",
+       "accuracy                       0.859158  0.859266  0.859266  0.859158  \n",
+       "f1                             0.675824  0.675993  0.675993  0.675662  \n",
+       "statistical_parity_difference -0.175809 -0.175648 -0.176141 -0.175980  \n",
+       "equal_opportunity_difference  -0.137035 -0.137035 -0.137035 -0.136516  \n",
+       "average_abs_odds_difference    0.098752  0.098635  0.098939  0.098679  \n",
+       "disparate_impact              -1.252377 -1.251722 -1.257105 -1.256450  \n",
+       "theil_index                    0.120346  0.120308  0.120308  0.120431  \n",
+       "\n",
+       "[7 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "final_result = pd.DataFrame(final_metrics)\n",
+    "#print(final_result)\n",
+    "final_result[3] = np.log(final_result[3])\n",
+    "final_result = final_result.transpose()\n",
+    "acc_f1 = pd.DataFrame(accuracy)\n",
+    "acc_f1['f1'] = f1\n",
+    "acc_f1 = pd.DataFrame(acc_f1).transpose()\n",
+    "acc = acc_f1.rename(index={0: 'accuracy', 1: 'f1'})\n",
+    "final_result = final_result.rename(index={0: 'statistical_parity_difference', 1: 'equal_opportunity_difference', 2: 'average_abs_odds_difference', 3: 'disparate_impact', 4: 'theil_index'})\n",
+    "final_result = pd.concat([acc,final_result])\n",
+    "final_result.columns = ['T' + str(col) for col in final_result.columns]\n",
+    "final_result.insert(0, \"classifier\", final_result['T' + str(num_estimators - 1)])   ##Add final metrics add the beginning of the df\n",
+    "final_result.to_csv('../../Results/GBC/' + nb_fname + '.csv')\n",
+    "final_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "_change_revision": 0,
+  "_is_fork": false,
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

AdultNoteBook/Kernels/GBC/.ipynb_checkpoints/11-ml-adult-income-checkpoint.ipynb

@@ -0,0 +1,1050 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "a2e5f6dc-3011-e73c-bd39-23f6909f2b37"
+   },
+   "source": [
+    "This is my first attempt on Kaggle so I decided to try using the sklearn framework that I am most comfortable with right now. So far, I am able to get the accuracy to about 86.73%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "_cell_guid": "df66acdf-db88-4292-922e-ad5a1ce53a67"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
+    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
+    "# For example, here's several helpful packages to load in\n",
+    "import numpy as np # linear algebra\n",
+    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
+    "import csv\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import LabelEncoder\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Input data files are available in the \"../input\" directory.\n",
+    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
+    "from subprocess import check_output\n",
+    "#print(check_output([\"ls\", \"../input\"]).decode(\"utf8\"))\n",
+    "# Any results you write to the current directory are saved as output.\"\n",
+    "\n",
+    "# set pandas chained_assignment flag = None here\n",
+    "pd.options.mode.chained_assignment = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from aif360.datasets import StandardDataset\n",
+    "from aif360.metrics import BinaryLabelDatasetMetric, ClassificationMetric\n",
+    "import matplotlib.patches as patches\n",
+    "from aif360.algorithms.preprocessing import Reweighing\n",
+    "#from packages import *\n",
+    "#from ml_fairness import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "\n",
+    "\n",
+    "from IPython.display import Markdown, display"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "_cell_guid": "278f91bf-0b55-dd81-e65f-85df55ec6ec0"
+   },
+   "outputs": [],
+   "source": [
+    "def preprocess_target(dframe, df_column_name):\n",
+    "    col = dframe[[df_column_name]]\n",
+    "    le_col = LabelEncoder()\n",
+    "    le_col.fit(np.ravel(col))\n",
+    "    return le_col.transform(np.ravel(col))\n",
+    "\n",
+    "def preprocess_features(dframe):\n",
+    "    for column in dframe:\n",
+    "        enc = LabelEncoder()\n",
+    "        if(column not in ['age','education.num','fnlwgt','capital.gain','capital.loss','hours.per.week']):\n",
+    "            dframe[column] = enc.fit_transform(dframe[column])\n",
+    "    return dframe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "_cell_guid": "b6bd1726-9220-487e-9e1a-ef06ef6c55ec"
+   },
+   "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>workclass</th>\n",
+       "      <th>education</th>\n",
+       "      <th>marital.status</th>\n",
+       "      <th>occupation</th>\n",
+       "      <th>education.num</th>\n",
+       "      <th>race</th>\n",
+       "      <th>sex</th>\n",
+       "      <th>relationship</th>\n",
+       "      <th>capital.gain</th>\n",
+       "      <th>capital.loss</th>\n",
+       "      <th>native.country</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90</td>\n",
+       "      <td>0</td>\n",
+       "      <td>11</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>82</td>\n",
+       "      <td>4</td>\n",
+       "      <td>11</td>\n",
+       "      <td>6</td>\n",
+       "      <td>4</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>66</td>\n",
+       "      <td>0</td>\n",
+       "      <td>15</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0</td>\n",
+       "      <td>10</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4356</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>54</td>\n",
+       "      <td>4</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>41</td>\n",
+       "      <td>4</td>\n",
+       "      <td>15</td>\n",
+       "      <td>5</td>\n",
+       "      <td>10</td>\n",
+       "      <td>10</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3900</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32556</th>\n",
+       "      <td>22</td>\n",
+       "      <td>4</td>\n",
+       "      <td>15</td>\n",
+       "      <td>4</td>\n",
+       "      <td>11</td>\n",
+       "      <td>10</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32557</th>\n",
+       "      <td>27</td>\n",
+       "      <td>4</td>\n",
+       "      <td>7</td>\n",
+       "      <td>2</td>\n",
+       "      <td>13</td>\n",
+       "      <td>12</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32558</th>\n",
+       "      <td>40</td>\n",
+       "      <td>4</td>\n",
+       "      <td>11</td>\n",
+       "      <td>2</td>\n",
+       "      <td>7</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32559</th>\n",
+       "      <td>58</td>\n",
+       "      <td>4</td>\n",
+       "      <td>11</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32560</th>\n",
+       "      <td>22</td>\n",
+       "      <td>4</td>\n",
+       "      <td>11</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>39</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>32561 rows × 12 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       age  workclass  education  marital.status  occupation  education.num  \\\n",
+       "0       90          0         11               6           0              9   \n",
+       "1       82          4         11               6           4              9   \n",
+       "2       66          0         15               6           0             10   \n",
+       "3       54          4          5               0           7              4   \n",
+       "4       41          4         15               5          10             10   \n",
+       "...    ...        ...        ...             ...         ...            ...   \n",
+       "32556   22          4         15               4          11             10   \n",
+       "32557   27          4          7               2          13             12   \n",
+       "32558   40          4         11               2           7              9   \n",
+       "32559   58          4         11               6           1              9   \n",
+       "32560   22          4         11               4           1              9   \n",
+       "\n",
+       "       race  sex  relationship  capital.gain  capital.loss  native.country  \n",
+       "0         4    0             1             0          4356              39  \n",
+       "1         4    0             1             0          4356              39  \n",
+       "2         2    0             4             0          4356              39  \n",
+       "3         4    0             4             0          3900              39  \n",
+       "4         4    0             3             0          3900              39  \n",
+       "...     ...  ...           ...           ...           ...             ...  \n",
+       "32556     4    1             1             0             0              39  \n",
+       "32557     4    0             5             0             0              39  \n",
+       "32558     4    1             0             0             0              39  \n",
+       "32559     4    0             4             0             0              39  \n",
+       "32560     4    1             3             0             0              39  \n",
+       "\n",
+       "[32561 rows x 12 columns]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# import data and preprocess\n",
+    "df = pd.read_csv('../../Data/adult.csv')\n",
+    "\n",
+    "# select and preprocess features\n",
+    "le_data = LabelEncoder()\n",
+    "features = ['age','workclass','education','marital.status','occupation','education.num','race','sex','relationship','capital.gain','capital.loss','native.country','income']\n",
+    "data = df[features]\n",
+    "data = preprocess_features(data)\n",
+    "\n",
+    "# select target\n",
+    "data_new = data\n",
+    "target = data['income']\n",
+    "data = data.drop('income', axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "bb1e318c-874c-9ffd-8161-f52da187f462"
+   },
+   "outputs": [],
+   "source": [
+    "# split train and test data\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    data, target, test_size=0.4, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "bab2adca-9f0a-00db-e5fe-f8b4584d8ea3"
+   },
+   "outputs": [],
+   "source": [
+    "# select algorithm\n",
+    "#from sklearn.tree import DecisionTreeClassifier\n",
+    "#from sklearn.ensemble import AdaBoostClassifier\n",
+    "#clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1),algorithm=\"SAMME\",n_estimators=200)\n",
+    "from sklearn.ensemble import GradientBoostingClassifier\n",
+    "clf = GradientBoostingClassifier(loss='deviance', n_estimators=100, learning_rate=1.0,max_depth=2, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "b6c87238-e66f-f13f-1d2c-61078074c8ae"
+   },
+   "outputs": [],
+   "source": [
+    "# fit and predict\n",
+    "clf.fit(X_train, y_train)\n",
+    "predictions = clf.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "1120a4c6-e3cb-e52c-da9e-a43979acf665"
+   },
+   "outputs": [],
+   "source": [
+    "# display the relative importance of each attribute\n",
+    "relval = clf.feature_importances_\n",
+    "\n",
+    "# horizontal bar plot of feature importance\n",
+    "pos = np.arange(12) + 0.5\n",
+    "plt.barh(pos, relval, align='center')\n",
+    "plt.title(\"Feature Importance\")\n",
+    "plt.xlabel(\"\")\n",
+    "plt.ylabel(\"Features\")\n",
+    "plt.yticks(pos, ('Age','Working Class','Education','Marital Status','Occupation','Education Grade','Race','Sex','Relationship Status','Capital Gain','Capital Loss','Native Country'))\n",
+    "plt.grid(True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "22c1bd91-5c08-6239-1f5b-8b78a812cd70"
+   },
+   "outputs": [],
+   "source": [
+    "# calc metrics\n",
+    "true_negatives = 0\n",
+    "false_negatives = 0\n",
+    "true_positives = 0\n",
+    "false_positives = 0\n",
+    "for prediction, truth in zip(predictions, y_test):\n",
+    "    if prediction == 0 and truth == 0:\n",
+    "        true_negatives += 1\n",
+    "    elif prediction == 0 and truth == 1:\n",
+    "        false_negatives += 1\n",
+    "    elif prediction == 1 and truth == 0:\n",
+    "        false_positives += 1\n",
+    "    elif prediction == 1 and truth == 1:\n",
+    "        true_positives += 1\n",
+    "    else:\n",
+    "        print (\"Warning: Found a predicted label not == 0 or 1.\")\n",
+    "        print (\"All predictions should take value 0 or 1.\")\n",
+    "        print (\"Evaluating performance for processed predictions:\")\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "e2f94bee-13b2-8b8b-3d0f-98cd67bf04d3"
+   },
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    print(\"Test Dataset (40%):\")\n",
+    "    print(\"true_positives\",true_positives)\n",
+    "    print(\"true_negatives\",true_negatives)\n",
+    "    print(\"false_positives\",false_positives)\n",
+    "    print(\"false_negatives\",false_negatives)\n",
+    "    total_predictions = true_negatives + false_negatives + false_positives + true_positives\n",
+    "    print(\"total predictions:\",total_predictions)\n",
+    "    accuracy = 1.0*(true_positives + true_negatives)/total_predictions\n",
+    "    print(\"accuracy:\",accuracy)\n",
+    "    precision = 1.0*true_positives/(true_positives+false_positives)\n",
+    "    print(\"precision:\",precision)\n",
+    "    recall = 1.0*true_positives/(true_positives+false_negatives)\n",
+    "    print(\"recall\",recall)\n",
+    "    f1 = 2.0 * true_positives/(2*true_positives + false_positives+false_negatives)\n",
+    "    print(\"f1\",f1)\n",
+    "    f2 = (1+2.0*2.0) * precision*recall/(4*precision + recall)\n",
+    "    print(\"f2\",f2)\n",
+    "    print (clf)\n",
+    "    #print (PERF_FORMAT_STRING.format(accuracy, precision, recall, f1, f2, display_precision = 5))\n",
+    "    #print (RESULTS_FORMAT_STRING.format(total_predictions, true_positives, false_positives, false_negatives, true_negatives))\n",
+    "    print (\"\")\n",
+    "except:\n",
+    "    print (\"Got a divide by zero when trying out:\", clf)\n",
+    "    print (\"Precision or recall may be undefined due to a lack of true positive predicitons.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fairness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This DataFrame is created to stock differents models and fair metrics that we produce in this notebook\n",
+    "algo_metrics = pd.DataFrame(columns=['model', 'fair_metrics', 'prediction', 'probs'])\n",
+    "\n",
+    "def add_to_df_algo_metrics(algo_metrics, model, fair_metrics, preds, probs, name):\n",
+    "    return algo_metrics.append(pd.DataFrame(data=[[model, fair_metrics, preds, probs]], columns=['model', 'fair_metrics', 'prediction', 'probs'], index=[name]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fair_metrics(dataset, pred, pred_is_dataset=False):\n",
+    "    if pred_is_dataset:\n",
+    "        dataset_pred = pred\n",
+    "    else:\n",
+    "        dataset_pred = dataset.copy()\n",
+    "        dataset_pred.labels = pred\n",
+    "    \n",
+    "    cols = ['statistical_parity_difference', 'equal_opportunity_difference', 'average_abs_odds_difference',  'disparate_impact', 'theil_index']\n",
+    "    obj_fairness = [[0,0,0,1,0]]\n",
+    "    \n",
+    "    fair_metrics = pd.DataFrame(data=obj_fairness, index=['objective'], columns=cols)\n",
+    "    \n",
+    "    for attr in dataset_pred.protected_attribute_names:\n",
+    "        idx = dataset_pred.protected_attribute_names.index(attr)\n",
+    "        privileged_groups =  [{attr:dataset_pred.privileged_protected_attributes[idx][0]}] \n",
+    "        unprivileged_groups = [{attr:dataset_pred.unprivileged_protected_attributes[idx][0]}] \n",
+    "        \n",
+    "        classified_metric = ClassificationMetric(dataset, \n",
+    "                                                     dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        metric_pred = BinaryLabelDatasetMetric(dataset_pred,\n",
+    "                                                     unprivileged_groups=unprivileged_groups,\n",
+    "                                                     privileged_groups=privileged_groups)\n",
+    "\n",
+    "        acc = classified_metric.accuracy()\n",
+    "\n",
+    "        row = pd.DataFrame([[metric_pred.mean_difference(),\n",
+    "                                classified_metric.equal_opportunity_difference(),\n",
+    "                                classified_metric.average_abs_odds_difference(),\n",
+    "                                metric_pred.disparate_impact(),\n",
+    "                                classified_metric.theil_index()]],\n",
+    "                           columns  = cols,\n",
+    "                           index = [attr]\n",
+    "                          )\n",
+    "        fair_metrics = fair_metrics.append(row)    \n",
+    "    \n",
+    "    fair_metrics = fair_metrics.replace([-np.inf, np.inf], 2)\n",
+    "        \n",
+    "    return fair_metrics\n",
+    "\n",
+    "def plot_fair_metrics(fair_metrics):\n",
+    "    fig, ax = plt.subplots(figsize=(20,4), ncols=5, nrows=1)\n",
+    "\n",
+    "    plt.subplots_adjust(\n",
+    "        left    =  0.125, \n",
+    "        bottom  =  0.1, \n",
+    "        right   =  0.9, \n",
+    "        top     =  0.9, \n",
+    "        wspace  =  .5, \n",
+    "        hspace  =  1.1\n",
+    "    )\n",
+    "\n",
+    "    y_title_margin = 1.2\n",
+    "\n",
+    "    plt.suptitle(\"Fairness metrics\", y = 1.09, fontsize=20)\n",
+    "    sns.set(style=\"dark\")\n",
+    "\n",
+    "    cols = fair_metrics.columns.values\n",
+    "    obj = fair_metrics.loc['objective']\n",
+    "    size_rect = [0.2,0.2,0.2,0.4,0.25]\n",
+    "    rect = [-0.1,-0.1,-0.1,0.8,0]\n",
+    "    bottom = [-1,-1,-1,0,0]\n",
+    "    top = [1,1,1,2,1]\n",
+    "    bound = [[-0.1,0.1],[-0.1,0.1],[-0.1,0.1],[0.8,1.2],[0,0.25]]\n",
+    "\n",
+    "    display(Markdown(\"### Check bias metrics :\"))\n",
+    "    display(Markdown(\"A model can be considered bias if just one of these five metrics show that this model is biased.\"))\n",
+    "    for attr in fair_metrics.index[1:len(fair_metrics)].values:\n",
+    "        display(Markdown(\"#### For the %s attribute :\"%attr))\n",
+    "        check = [bound[i][0] < fair_metrics.loc[attr][i] < bound[i][1] for i in range(0,5)]\n",
+    "        display(Markdown(\"With default thresholds, bias against unprivileged group detected in **%d** out of 5 metrics\"%(5 - sum(check))))\n",
+    "\n",
+    "    for i in range(0,5):\n",
+    "        plt.subplot(1, 5, i+1)\n",
+    "        ax = sns.barplot(x=fair_metrics.index[1:len(fair_metrics)], y=fair_metrics.iloc[1:len(fair_metrics)][cols[i]])\n",
+    "        \n",
+    "        for j in range(0,len(fair_metrics)-1):\n",
+    "            a, val = ax.patches[j], fair_metrics.iloc[j+1][cols[i]]\n",
+    "            marg = -0.2 if val < 0 else 0.1\n",
+    "            ax.text(a.get_x()+a.get_width()/5, a.get_y()+a.get_height()+marg, round(val, 3), fontsize=15,color='black')\n",
+    "\n",
+    "        plt.ylim(bottom[i], top[i])\n",
+    "        plt.setp(ax.patches, linewidth=0)\n",
+    "        ax.add_patch(patches.Rectangle((-5,rect[i]), 10, size_rect[i], alpha=0.3, facecolor=\"green\", linewidth=1, linestyle='solid'))\n",
+    "        plt.axhline(obj[i], color='black', alpha=0.3)\n",
+    "        plt.title(cols[i])\n",
+    "        ax.set_ylabel('')    \n",
+    "        ax.set_xlabel('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_fair_metrics_and_plot(data, model, plot=False, model_aif=False):\n",
+    "    pred = model.predict(data).labels if model_aif else model.predict(data.features)\n",
+    "    # fair_metrics function available in the metrics.py file\n",
+    "    fair = fair_metrics(data, pred)\n",
+    "\n",
+    "    if plot:\n",
+    "        # plot_fair_metrics function available in the visualisations.py file\n",
+    "        # The visualisation of this function is inspired by the dashboard on the demo of IBM aif360 \n",
+    "        plot_fair_metrics(fair)\n",
+    "        display(fair)\n",
+    "    \n",
+    "    return fair"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#print(X)\n",
+    "\n",
+    "\n",
+    "#combine_final = [train_df, test_df]\n",
+    "#result = pd.concat(combine_final)\n",
+    "#print(result.ifany())\n",
+    "#print(result)\n",
+    "privileged_groups = [{'sex': 1}]\n",
+    "unprivileged_groups = [{'sex': 0}]\n",
+    "dataset_orig = StandardDataset(data_new,\n",
+    "                                  label_name='income',\n",
+    "                                  protected_attribute_names=['sex'],\n",
+    "                                  favorable_classes=[1],\n",
+    "                                  privileged_classes=[[1]])\n",
+    "\n",
+    "#metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "#                                             unprivileged_groups=unprivileged_groups,\n",
+    "#                                             privileged_groups=privileged_groups)\n",
+    "#display(Markdown(\"#### Original training dataset\"))\n",
+    "#print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "#### Original training dataset"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Difference in mean outcomes between unprivileged and privileged groups = -0.196276\n"
+     ]
+    }
+   ],
+   "source": [
+    "metric_orig_train = BinaryLabelDatasetMetric(dataset_orig, \n",
+    "                                             unprivileged_groups=unprivileged_groups,\n",
+    "                                             privileged_groups=privileged_groups)\n",
+    "display(Markdown(\"#### Original training dataset\"))\n",
+    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ipynbname\n",
+    "nb_fname = ipynbname.name()\n",
+    "nb_path = ipynbname.path()\n",
+    "\n",
+    "from sklearn.ensemble import GradientBoostingClassifier\n",
+    "import pickle\n",
+    "\n",
+    "data_orig_train, data_orig_test = dataset_orig.split([0.7], shuffle=True)\n",
+    "X_train = data_orig_train.features\n",
+    "y_train = data_orig_train.labels.ravel()\n",
+    "\n",
+    "X_test = data_orig_test.features\n",
+    "y_test = data_orig_test.labels.ravel()\n",
+    "num_estimators = 100\n",
+    "\n",
+    "model = GradientBoostingClassifier(loss='deviance', n_estimators=1, learning_rate=1.0,max_depth=2, random_state=0)\n",
+    "\n",
+    "mdl = model.fit(X_train, y_train)\n",
+    "with open('../../Results/GBC/' + nb_fname + '.pkl', 'wb') as f:\n",
+    "        pickle.dump(mdl, f)\n",
+    "\n",
+    "with open('../../Results/GBC/' + nb_fname + '_Train' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_train, f) \n",
+    "    \n",
+    "with open('../../Results/GBC/' + nb_fname + '_Test' + '.pkl', 'wb') as f:\n",
+    "    pickle.dump(data_orig_test, f) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from csv import writer\n",
+    "from sklearn.metrics import accuracy_score, f1_score\n",
+    "\n",
+    "final_metrics = []\n",
+    "accuracy = []\n",
+    "f1= []\n",
+    "\n",
+    "for i in range(1,num_estimators+1):\n",
+    "    \n",
+    "    model = GradientBoostingClassifier(n_estimators= i, learning_rate=1.0,max_depth=2, random_state=0, loss='deviance')\n",
+    "    mdl = model.fit(X_train, y_train)\n",
+    "    yy = mdl.predict(X_test)\n",
+    "    accuracy.append(accuracy_score(y_test, yy))\n",
+    "    f1.append(f1_score(y_test, yy))\n",
+    "    fair = get_fair_metrics_and_plot(data_orig_test, mdl)                           \n",
+    "    fair_list = fair.iloc[1].tolist()\n",
+    "    fair_list.insert(0, i)\n",
+    "    final_metrics.append(fair_list)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "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>classifier</th>\n",
+       "      <th>T0</th>\n",
+       "      <th>T1</th>\n",
+       "      <th>T2</th>\n",
+       "      <th>T3</th>\n",
+       "      <th>T4</th>\n",
+       "      <th>T5</th>\n",
+       "      <th>T6</th>\n",
+       "      <th>T7</th>\n",
+       "      <th>T8</th>\n",
+       "      <th>...</th>\n",
+       "      <th>T90</th>\n",
+       "      <th>T91</th>\n",
+       "      <th>T92</th>\n",
+       "      <th>T93</th>\n",
+       "      <th>T94</th>\n",
+       "      <th>T95</th>\n",
+       "      <th>T96</th>\n",
+       "      <th>T97</th>\n",
+       "      <th>T98</th>\n",
+       "      <th>T99</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>accuracy</th>\n",
+       "      <td>0.869997</td>\n",
+       "      <td>0.821067</td>\n",
+       "      <td>0.839595</td>\n",
+       "      <td>0.846453</td>\n",
+       "      <td>0.843587</td>\n",
+       "      <td>0.843075</td>\n",
+       "      <td>0.844099</td>\n",
+       "      <td>0.845225</td>\n",
+       "      <td>0.847067</td>\n",
+       "      <td>0.848910</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.868871</td>\n",
+       "      <td>0.868871</td>\n",
+       "      <td>0.868666</td>\n",
+       "      <td>0.868871</td>\n",
+       "      <td>0.868769</td>\n",
+       "      <td>0.868769</td>\n",
+       "      <td>0.868564</td>\n",
+       "      <td>0.869178</td>\n",
+       "      <td>0.869280</td>\n",
+       "      <td>0.869997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>f1</th>\n",
+       "      <td>0.706968</td>\n",
+       "      <td>0.523186</td>\n",
+       "      <td>0.604792</td>\n",
+       "      <td>0.629080</td>\n",
+       "      <td>0.611986</td>\n",
+       "      <td>0.613367</td>\n",
+       "      <td>0.611975</td>\n",
+       "      <td>0.617796</td>\n",
+       "      <td>0.625564</td>\n",
+       "      <td>0.632470</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.705043</td>\n",
+       "      <td>0.704907</td>\n",
+       "      <td>0.703900</td>\n",
+       "      <td>0.704907</td>\n",
+       "      <td>0.704744</td>\n",
+       "      <td>0.704472</td>\n",
+       "      <td>0.703875</td>\n",
+       "      <td>0.705801</td>\n",
+       "      <td>0.705557</td>\n",
+       "      <td>0.706968</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistical_parity_difference</th>\n",
+       "      <td>-0.183827</td>\n",
+       "      <td>-0.166884</td>\n",
+       "      <td>-0.143830</td>\n",
+       "      <td>-0.150066</td>\n",
+       "      <td>-0.182743</td>\n",
+       "      <td>-0.185535</td>\n",
+       "      <td>-0.179820</td>\n",
+       "      <td>-0.161690</td>\n",
+       "      <td>-0.152730</td>\n",
+       "      <td>-0.153993</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.187507</td>\n",
+       "      <td>-0.187657</td>\n",
+       "      <td>-0.187339</td>\n",
+       "      <td>-0.187657</td>\n",
+       "      <td>-0.187811</td>\n",
+       "      <td>-0.183986</td>\n",
+       "      <td>-0.185510</td>\n",
+       "      <td>-0.184453</td>\n",
+       "      <td>-0.184290</td>\n",
+       "      <td>-0.183827</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>equal_opportunity_difference</th>\n",
+       "      <td>-0.072391</td>\n",
+       "      <td>-0.246539</td>\n",
+       "      <td>-0.056392</td>\n",
+       "      <td>-0.060173</td>\n",
+       "      <td>-0.238734</td>\n",
+       "      <td>-0.227913</td>\n",
+       "      <td>-0.223696</td>\n",
+       "      <td>-0.133076</td>\n",
+       "      <td>-0.077557</td>\n",
+       "      <td>-0.082003</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.084936</td>\n",
+       "      <td>-0.087698</td>\n",
+       "      <td>-0.091728</td>\n",
+       "      <td>-0.087698</td>\n",
+       "      <td>-0.087698</td>\n",
+       "      <td>-0.076918</td>\n",
+       "      <td>-0.085704</td>\n",
+       "      <td>-0.072889</td>\n",
+       "      <td>-0.071394</td>\n",
+       "      <td>-0.072391</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>average_abs_odds_difference</th>\n",
+       "      <td>0.070864</td>\n",
+       "      <td>0.160599</td>\n",
+       "      <td>0.056297</td>\n",
+       "      <td>0.058011</td>\n",
+       "      <td>0.154799</td>\n",
+       "      <td>0.151742</td>\n",
+       "      <td>0.146839</td>\n",
+       "      <td>0.097278</td>\n",
+       "      <td>0.067588</td>\n",
+       "      <td>0.069127</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.078537</td>\n",
+       "      <td>0.079806</td>\n",
+       "      <td>0.081486</td>\n",
+       "      <td>0.079806</td>\n",
+       "      <td>0.079918</td>\n",
+       "      <td>0.073174</td>\n",
+       "      <td>0.077850</td>\n",
+       "      <td>0.071554</td>\n",
+       "      <td>0.070924</td>\n",
+       "      <td>0.070864</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>disparate_impact</th>\n",
+       "      <td>-1.199121</td>\n",
+       "      <td>-2.142558</td>\n",
+       "      <td>-1.135429</td>\n",
+       "      <td>-1.125965</td>\n",
+       "      <td>-1.727185</td>\n",
+       "      <td>-1.720900</td>\n",
+       "      <td>-1.701447</td>\n",
+       "      <td>-1.366819</td>\n",
+       "      <td>-1.211665</td>\n",
+       "      <td>-1.197980</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-1.226642</td>\n",
+       "      <td>-1.229974</td>\n",
+       "      <td>-1.234349</td>\n",
+       "      <td>-1.229974</td>\n",
+       "      <td>-1.230556</td>\n",
+       "      <td>-1.197055</td>\n",
+       "      <td>-1.213610</td>\n",
+       "      <td>-1.196169</td>\n",
+       "      <td>-1.200879</td>\n",
+       "      <td>-1.199121</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>theil_index</th>\n",
+       "      <td>0.106252</td>\n",
+       "      <td>0.170030</td>\n",
+       "      <td>0.143530</td>\n",
+       "      <td>0.135172</td>\n",
+       "      <td>0.141621</td>\n",
+       "      <td>0.140911</td>\n",
+       "      <td>0.141760</td>\n",
+       "      <td>0.139657</td>\n",
+       "      <td>0.136899</td>\n",
+       "      <td>0.134469</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.106709</td>\n",
+       "      <td>0.106788</td>\n",
+       "      <td>0.107254</td>\n",
+       "      <td>0.106788</td>\n",
+       "      <td>0.106822</td>\n",
+       "      <td>0.106981</td>\n",
+       "      <td>0.107209</td>\n",
+       "      <td>0.106447</td>\n",
+       "      <td>0.106651</td>\n",
+       "      <td>0.106252</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>7 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                               classifier        T0        T1        T2  \\\n",
+       "accuracy                         0.869997  0.821067  0.839595  0.846453   \n",
+       "f1                               0.706968  0.523186  0.604792  0.629080   \n",
+       "statistical_parity_difference   -0.183827 -0.166884 -0.143830 -0.150066   \n",
+       "equal_opportunity_difference    -0.072391 -0.246539 -0.056392 -0.060173   \n",
+       "average_abs_odds_difference      0.070864  0.160599  0.056297  0.058011   \n",
+       "disparate_impact                -1.199121 -2.142558 -1.135429 -1.125965   \n",
+       "theil_index                      0.106252  0.170030  0.143530  0.135172   \n",
+       "\n",
+       "                                     T3        T4        T5        T6  \\\n",
+       "accuracy                       0.843587  0.843075  0.844099  0.845225   \n",
+       "f1                             0.611986  0.613367  0.611975  0.617796   \n",
+       "statistical_parity_difference -0.182743 -0.185535 -0.179820 -0.161690   \n",
+       "equal_opportunity_difference  -0.238734 -0.227913 -0.223696 -0.133076   \n",
+       "average_abs_odds_difference    0.154799  0.151742  0.146839  0.097278   \n",
+       "disparate_impact              -1.727185 -1.720900 -1.701447 -1.366819   \n",
+       "theil_index                    0.141621  0.140911  0.141760  0.139657   \n",
+       "\n",
+       "                                     T7        T8  ...       T90       T91  \\\n",
+       "accuracy                       0.847067  0.848910  ...  0.868871  0.868871   \n",
+       "f1                             0.625564  0.632470  ...  0.705043  0.704907   \n",
+       "statistical_parity_difference -0.152730 -0.153993  ... -0.187507 -0.187657   \n",
+       "equal_opportunity_difference  -0.077557 -0.082003  ... -0.084936 -0.087698   \n",
+       "average_abs_odds_difference    0.067588  0.069127  ...  0.078537  0.079806   \n",
+       "disparate_impact              -1.211665 -1.197980  ... -1.226642 -1.229974   \n",
+       "theil_index                    0.136899  0.134469  ...  0.106709  0.106788   \n",
+       "\n",
+       "                                    T92       T93       T94       T95  \\\n",
+       "accuracy                       0.868666  0.868871  0.868769  0.868769   \n",
+       "f1                             0.703900  0.704907  0.704744  0.704472   \n",
+       "statistical_parity_difference -0.187339 -0.187657 -0.187811 -0.183986   \n",
+       "equal_opportunity_difference  -0.091728 -0.087698 -0.087698 -0.076918   \n",
+       "average_abs_odds_difference    0.081486  0.079806  0.079918  0.073174   \n",
+       "disparate_impact              -1.234349 -1.229974 -1.230556 -1.197055   \n",
+       "theil_index                    0.107254  0.106788  0.106822  0.106981   \n",
+       "\n",
+       "                                    T96       T97       T98       T99  \n",
+       "accuracy                       0.868564  0.869178  0.869280  0.869997  \n",
+       "f1                             0.703875  0.705801  0.705557  0.706968  \n",
+       "statistical_parity_difference -0.185510 -0.184453 -0.184290 -0.183827  \n",
+       "equal_opportunity_difference  -0.085704 -0.072889 -0.071394 -0.072391  \n",
+       "average_abs_odds_difference    0.077850  0.071554  0.070924  0.070864  \n",
+       "disparate_impact              -1.213610 -1.196169 -1.200879 -1.199121  \n",
+       "theil_index                    0.107209  0.106447  0.106651  0.106252  \n",
+       "\n",
+       "[7 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "final_result = pd.DataFrame(final_metrics)\n",
+    "final_result[4] = np.log(final_result[4])\n",
+    "final_result = final_result.transpose()\n",
+    "final_result.loc[0] = f1  # add f1 and acc to df\n",
+    "acc = pd.DataFrame(accuracy).transpose()\n",
+    "acc = acc.rename(index={0: 'accuracy'})\n",
+    "final_result = pd.concat([acc,final_result])\n",
+    "final_result = final_result.rename(index={0: 'f1', 1: 'statistical_parity_difference', 2: 'equal_opportunity_difference', 3: 'average_abs_odds_difference', 4: 'disparate_impact', 5: 'theil_index'})\n",
+    "final_result.columns = ['T' + str(col) for col in final_result.columns]\n",
+    "final_result.insert(0, \"classifier\", final_result['T' + str(num_estimators - 1)])   ##Add final metrics add the beginning of the df\n",
+    "final_result.to_csv('../../Results/GBC/' + nb_fname + '.csv')\n",
+    "final_result"
+   ]
+  }
+ ],
+ "metadata": {
+  "_change_revision": 0,
+  "_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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}