Model building for deployment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Building For Deployment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing necessary libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pickle\n",
    "from pickle import dump\n",
    "\n",
    "# Display all columns\n",
    "pd.set_option('max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing dataset\n",
    "train_data = pd.read_csv('http://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data',header=None)\n",
    "\n",
    "# Columns name we can find from data description \n",
    "col_labels = ['age', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital_status','occupation','relationship', \n",
    "              'race', 'sex', 'capital_gain', 'capital_loss', 'hours_per_week', 'native_country', 'income']\n",
    "\n",
    "train_data.columns = col_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making sure that the data does not contain unecessary spaces.\n",
    "train_data=train_data.apply(lambda x: x.str.strip() if x.dtype == \"object\" else x)\n",
    "\n",
    "# Before any analysis, let's convert the target column into numerical classes.\n",
    "train_data['income'] = train_data['income'].replace({'<=50K':0,'>50K':1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As the columns which have missing values, they are only categorical, we'll use the categorical imputer\n",
    "from sklearn_pandas import CategoricalImputer\n",
    "imputer = CategoricalImputer()\n",
    "\n",
    "# Imputing the missing values\n",
    "train_data['workclass'] = imputer.fit_transform(train_data['workclass'])\n",
    "train_data['occupation'] = imputer.fit_transform(train_data['occupation'])\n",
    "train_data['native_country'] = imputer.fit_transform(train_data['native_country'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transforming Maritial Status column with value as either married or not married.\n",
    "train_data = train_data.replace({'Married-civ-spouse':'married','Married-AF-spouse':'married','Married-spouse-absent':'married',\n",
    "                    'Never-married':'not married','Divorced':'not married','Separated':'not married','Widowed':'not married'})\n",
    "\n",
    "# Transforming native country column with value as either United States or Other.\n",
    "countries = train_data['native_country'].unique()[1:]\n",
    "train_data['native_country'] = train_data['native_country'].replace(to_replace=countries, value='Other')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Droping those feature which we are not going to use\n",
    "clean_data = train_data.drop(['workclass', 'fnlwgt', 'occupation', 'relationship', 'race', 'education_num'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating dummies variables\n",
    "dummie_data= pd.get_dummies(clean_data, drop_first=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaring dependent and independent variable\n",
    "X = dummie_data.drop(['income'],axis=1)\n",
    "y = dummie_data['income']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StandardScaler()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# feature scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X[['age', 'capital_gain', 'capital_loss', 'hours_per_week']])\n",
    "input_scaled = scaler.transform(X[['age', 'capital_gain', 'capital_loss', 'hours_per_week']])\n",
    "scaled_data = pd.DataFrame(input_scaled,columns=['age','hours_per_week','capital_gain','capital_loss'])\n",
    "X_scaled = scaled_data.join(X.drop(['age', 'hours_per_week','capital_gain','capital_loss'],axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fixing imbalanced dataset by oversampling\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "rd_over_sample = RandomOverSampler()\n",
    "X_sampled, y_sampled = rd_over_sample.fit_sample(X_scaled,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data into train and test\n",
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_test, y_train, y_test = train_test_split(X_sampled, y_sampled, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Building\n",
    "from xgboost import XGBClassifier\n",
    "xgb = XGBClassifier(random_state=0,min_child_weight=3,max_depth= 15,\n",
    "                    learning_rate = 0.1,gamma= 0.1,\n",
    "                    colsample_bytree= 0.7)\n",
    "\n",
    "# Training Model\n",
    "xgb.fit(x_train.values, y_train.values)\n",
    "\n",
    "# Mode summary\n",
    "y_pred_xgb = xgb.predict(x_test.values)\n",
    "y_pred_train_xgb = xgb.predict(x_train.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----Test Data Accuracy----\n",
      "XGB Classifier:\n",
      "Accuracy score: 0.8572\n",
      "F1 score: 0.8626\n",
      "\n",
      "-----Train Data Accuracy----\n",
      "Accuracy score: 0.8725\n",
      "F1 score: 0.879\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
    "print(\"-----Test Data Accuracy----\")\n",
    "print('XGB Classifier:')\n",
    "print('Accuracy score:',round(accuracy_score(y_test, y_pred_xgb), 4))\n",
    "print('F1 score:',round(f1_score(y_test, y_pred_xgb), 4))\n",
    "\n",
    "print(\"\\n-----Train Data Accuracy----\")\n",
    "print('Accuracy score:',round(accuracy_score(y_train, y_pred_train_xgb), 4))\n",
    "print('F1 score:',round(f1_score(y_train, y_pred_train_xgb), 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save Model & Data Scaler to reuse it again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "# Save Model and Data Scaler\n",
    "from pickle import dump\n",
    "from pickle import load\n",
    "\n",
    "# save the model\n",
    "dump(xgb, open('xgb_model.pkl', 'wb'))\n",
    "\n",
    "# save the scaler\n",
    "dump(scaler, open('scaler.pkl', 'wb'))\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Model and Data Scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "import pickle\n",
    "# load the model\n",
    "model = pickle.load(open('xgb_model.pkl', 'rb'))\n",
    "# load the scaler\n",
    "scalers = pickle.load(open('scaler.pkl', 'rb'))\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test the Model by giving input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predictin function\n",
    "def prediction(age, capital_gain, capital_loss, hours_per_week, education, sex, marital_status, country):\n",
    "    age = int(age)\n",
    "    hours = int(hours_per_week)\n",
    "    gain = int(capital_gain)\n",
    "    loss = int(capital_loss)\n",
    "    sex = 1 if sex=='Male' else 0\n",
    "    marital = 0 if marital_status=='Married' else 1\n",
    "    country = 1 if country=='United States' else 0\n",
    "    \n",
    "    # if condition match only assighn '1' to that variable \n",
    "    _11th     = 1 if education=='_11th' else 0\n",
    "    _12th     = 1 if education=='_12th' else 0\n",
    "    _1st_4th  = 1 if education=='_1st_4th' else 0\n",
    "    _5th_6th  = 1 if education=='_5th_6th' else 0\n",
    "    _7th_8th  = 1 if education=='_7th_8th' else 0\n",
    "    _9th      = 1 if education=='_9th' else 0\n",
    "    _Assoc_acdm = 1 if education=='Assoc_acdm' else 0\n",
    "    assoc_voc = 1 if education=='assoc_voc' else 0\n",
    "    bachelors = 1 if education=='bachelors' else 0\n",
    "    doctorate = 1 if education=='doctorate' else 0\n",
    "    HS_grad = 1 if education=='HS_grad' else 0\n",
    "    masters = 1 if education=='masters' else 0\n",
    "    preschool = 1 if education=='preschool' else 0\n",
    "    prof_school = 1 if education=='prof_school' else 0\n",
    "    college = 1 if education=='college' else 0\n",
    "    \n",
    "    # load the model\n",
    "    model = load(open('xgb_model.pkl', 'rb'))\n",
    "    # load the scaler\n",
    "    scaler = load(open('scaler.pkl', 'rb'))\n",
    "        \n",
    "    # feature scaling on age,capital_gain, capital_loss, hours per week\n",
    "    scaled_value = scaler.transform([[age,gain,loss,hours]])\n",
    "    age, gain, loss, hours = scaled_value[0,0],scaled_value[0,1],scaled_value[0,2],scaled_value[0,3]\n",
    "    \n",
    "    '''print([age, hours, gain, loss, _11th, _12th, _1st_4th, _5th_6th, _7th_8th,_9th,_Assoc_acdm,\n",
    "                  assoc_voc, bachelors,doctorate, HS_grad, masters, preschool, prof_school, college,\n",
    "                  marital, sex, country])'''\n",
    "    return model.predict(np.array([[age, hours, gain, loss, _11th, _12th, _1st_4th, _5th_6th, _7th_8th,_9th,_Assoc_acdm,\n",
    "                  assoc_voc, bachelors,doctorate, HS_grad, masters, preschool, prof_school, college,\n",
    "                  marital, sex, country]]))[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction(71,0,0,20,'doctorate','Male','Married','United States')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# age, capital_gain, capital_loss, hours_per_week, education, sex, marital_status, country\n",
    "prediction(53,0,0, 40,'masters','Male','Married','United States')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction(39,0,0,10,'Assoc_acdm','feMale','Married','United States')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction(39,0,0,10,'Assoc_acdm','feMale','Married','United States')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}