happiness_survey.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background\n",
    "\n",
    "`I conduted this project for one of the fastest growing startups, XYG (not real name of company) in the logistics and delivery domain. Company XYG works with several partners and make on-demand delivery to their customers. During the COVID-19 pandemic, they were faced with several different challenges and everyday they tried to address these challenges. As a growing startup, with a global expansion strategy XYG's primary strategy was to make their customers happy and the only way to do that was to measure the happiness of each of their customer. They were intereted in predicting what made their customers happy or unhappy so as to take the necessary actions to improve customer's satisfaction. Getting feedback from their customers was not easy either, but they had a culture of getting constant feedbacks from their customers. They did a survey to a select customer cohort. I was presented with a subset of this data with the goal to predict if a customer is happy or not based on the answers they give to questions asked.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data processing\n",
    "import pandas as pd\n",
    "\n",
    "# data visualization\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# data wrangling\n",
    "from scipy.stats import randint as sp_randint\n",
    "import numpy as np\n",
    "\n",
    "# Algorithms\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import linear_model\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, ExtraTreesClassifier\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC, LinearSVC\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "from sklearn.model_selection import RandomizedSearchCV, cross_val_score"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load the Data..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the data\n",
    "survey_df = pd.read_csv(\"ACME-HappinessSurvey2020.csv\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>Y</th>\n",
       "      <th>X1</th>\n",
       "      <th>X2</th>\n",
       "      <th>X3</th>\n",
       "      <th>X4</th>\n",
       "      <th>X5</th>\n",
       "      <th>X6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Y  X1  X2  X3  X4  X5  X6\n",
       "0  0   3   3   3   4   2   4\n",
       "1  0   3   2   3   5   4   3\n",
       "2  1   5   3   3   3   3   5\n",
       "3  0   5   4   3   3   3   5\n",
       "4  0   5   4   3   3   3   5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display the data\n",
    "survey_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Y     int64\n",
       "X1    int64\n",
       "X2    int64\n",
       "X3    int64\n",
       "X4    int64\n",
       "X5    int64\n",
       "X6    int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display data type\n",
    "survey_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Y     0\n",
       "X1    0\n",
       "X2    0\n",
       "X3    0\n",
       "X4    0\n",
       "X5    0\n",
       "X6    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find missing values\n",
    "survey_df.isna().sum()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "` We can already observe that there are no missing values in the dataset and that all the columns are integers. `"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A description of the features is listed below:\n",
    "\n",
    "---\n",
    "\n",
    "   Attributes X1 to X6 indicate the responses for each question and have values from 1 to 5 where the smaller number indicates less and the higher number indicates more towards the answer.\n",
    "   \n",
    "      Y = target attribute (Y) with values indicating 0 (unhappy) and 1 (happy) customers\n",
    "      X1 = my order was delivered on time\n",
    "      X2 = contents of my order was as I expected\n",
    "      X3 = I ordered everything I wanted to order\n",
    "      X4 = I paid a good price for my order\n",
    "      X5 = I am satisfied with my courier\n",
    "      X6 = the app makes ordering easy for me"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>Y</th>\n",
       "      <th>X1</th>\n",
       "      <th>X2</th>\n",
       "      <th>X3</th>\n",
       "      <th>X4</th>\n",
       "      <th>X5</th>\n",
       "      <th>X6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "      <td>126.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.547619</td>\n",
       "      <td>4.333333</td>\n",
       "      <td>2.531746</td>\n",
       "      <td>3.309524</td>\n",
       "      <td>3.746032</td>\n",
       "      <td>3.650794</td>\n",
       "      <td>4.253968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.499714</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>1.114892</td>\n",
       "      <td>1.023440</td>\n",
       "      <td>0.875776</td>\n",
       "      <td>1.147641</td>\n",
       "      <td>0.809311</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>4.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>5.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>5.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Y          X1          X2          X3          X4          X5  \\\n",
       "count  126.000000  126.000000  126.000000  126.000000  126.000000  126.000000   \n",
       "mean     0.547619    4.333333    2.531746    3.309524    3.746032    3.650794   \n",
       "std      0.499714    0.800000    1.114892    1.023440    0.875776    1.147641   \n",
       "min      0.000000    1.000000    1.000000    1.000000    1.000000    1.000000   \n",
       "25%      0.000000    4.000000    2.000000    3.000000    3.000000    3.000000   \n",
       "50%      1.000000    5.000000    3.000000    3.000000    4.000000    4.000000   \n",
       "75%      1.000000    5.000000    3.000000    4.000000    4.000000    4.000000   \n",
       "max      1.000000    5.000000    5.000000    5.000000    5.000000    5.000000   \n",
       "\n",
       "               X6  \n",
       "count  126.000000  \n",
       "mean     4.253968  \n",
       "std      0.809311  \n",
       "min      1.000000  \n",
       "25%      4.000000  \n",
       "50%      4.000000  \n",
       "75%      5.000000  \n",
       "max      5.000000  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# display general statistics of data\n",
    "survey_df.describe()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`From the statistics above, in terms of ordered content, most of the customers expectations were sort of dashed. This metric received the lowest average in terms of satisfaction (2.5)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Y', 'X1', 'X2', 'X3', 'X4', 'X5', 'X6'], dtype='object')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show column names\n",
    "survey_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a correlation matrix\n",
    "corr_matrix = survey_df.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visual representation of correlation matrix\n",
    "sns.heatmap(corr_matrix, annot=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter the unhappy and happy customers\n",
    "unhappy = survey_df.loc[survey_df[\"Y\"]==0, :]\n",
    "happy = survey_df.loc[survey_df[\"Y\"]==1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:3: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:4: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  after removing the cwd from sys.path.\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:6: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  \n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:7: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  import sys\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:9: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  if __name__ == '__main__':\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:10: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  # Remove the CWD from sys.path while we load stuff.\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:12: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  if sys.path[0] == '':\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:13: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  del sys.path[0]\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:15: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  from ipykernel import kernelapp as app\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:16: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  app.launch_new_instance()\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:18: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\ipykernel_launcher.py:19: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x720 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a histogram distribution of all features according to customers satisfaction\n",
    "fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(15,10))\n",
    "ax = sns.distplot(unhappy[\"X1\"], label = \"unhappy\", kde=False, bins =5, ax = axes[0,0])\n",
    "ax = sns.distplot(happy[\"X1\"], label = \"happy\", kde=False, bins =10, ax = axes[0,0])\n",
    "ax.legend()\n",
    "ax = sns.distplot(unhappy[\"X2\"], label = \"unhappy\", kde=False, bins =5, ax = axes[0,1])\n",
    "ax = sns.distplot(happy[\"X2\"], label = \"happy\", kde=False, bins =10, ax = axes[0,1])\n",
    "ax.legend()\n",
    "ax = sns.distplot(unhappy[\"X3\"], label = \"unhappy\", kde=False, bins =5, ax = axes[0,2])\n",
    "ax = sns.distplot(happy[\"X3\"], label = \"happy\", kde=False, bins =10, ax = axes[0,2])\n",
    "ax.legend()\n",
    "ax = sns.distplot(unhappy[\"X4\"], label = \"unhappy\", kde=False, bins =5, ax = axes[1,0])\n",
    "ax = sns.distplot(happy[\"X4\"], label = \"happy\", kde=False, bins =10, ax = axes[1,0])\n",
    "ax.legend()\n",
    "ax = sns.distplot(unhappy[\"X5\"], label = \"unhappy\", kde=False, bins =5, ax = axes[1,1])\n",
    "ax = sns.distplot(happy[\"X5\"], label = \"happy\", kde=False, bins =10, ax = axes[1,1])\n",
    "ax.legend()\n",
    "ax = sns.distplot(unhappy[\"X6\"], label = \"unhappy\", kde=False, bins =5, ax = axes[1,2])\n",
    "ax = sns.distplot(happy[\"X6\"], label = \"happy\", kde=False, bins =10, ax = axes[1,2])\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pre - Modelling"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the features set, by copying the `surver_df` DataFrame and dropping the `Y` column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>X1</th>\n",
       "      <th>X2</th>\n",
       "      <th>X3</th>\n",
       "      <th>X4</th>\n",
       "      <th>X5</th>\n",
       "      <th>X6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   X1  X2  X3  X4  X5  X6\n",
       "0   3   3   3   4   2   4\n",
       "1   3   2   3   5   4   3\n",
       "2   5   3   3   3   3   5\n",
       "3   5   4   3   3   3   5\n",
       "4   5   4   3   3   3   5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define features set\n",
    "X = survey_df.copy()\n",
    "X.drop('Y', axis=1, inplace=True)\n",
    "X.head()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the target vector by assigning the values of the `Y` column from the `survey_df` DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 0, 0], dtype=int64)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define target vector\n",
    "y = np.ravel(survey_df[\"Y\"])\n",
    "y[:5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the dataset using train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0, test_size = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 6)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shape of training data\n",
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26, 6)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shape of testing data\n",
    "X_test.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Machine Learning Models\n",
    "`Below, lets try out different models and compare their accuracy score`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stochastic gradient descent (SGD) learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 57.69 %\n"
     ]
    }
   ],
   "source": [
    "# create a SGD classifier instance\n",
    "sgd = linear_model.SGDClassifier(max_iter=200, tol=None, random_state=50)\n",
    "\n",
    "# Fitting the model\n",
    "sgd.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = sgd.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_sgd = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_sgd,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 53.85 %\n"
     ]
    }
   ],
   "source": [
    "# create a random forest instance\n",
    "random_forest = RandomForestClassifier(n_estimators=100, random_state=50)\n",
    "\n",
    "# Fitting the model\n",
    "random_forest.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = random_forest.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_random_forest = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_random_forest,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Regression Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 61.54 %\n"
     ]
    }
   ],
   "source": [
    "# create a logistic regression instance\n",
    "logreg = LogisticRegression(max_iter=200, random_state=78)\n",
    "\n",
    "# Fitting the model\n",
    "logreg.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = logreg.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_log = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_log,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Perceptron Learning Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 50.0 %\n"
     ]
    }
   ],
   "source": [
    "# create a perceptron instance\n",
    "perc = Perceptron(random_state=101)\n",
    "\n",
    "# Fitting the model\n",
    "perc.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = perc.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_perc = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_perc,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Linear Support Vector Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 61.54 %\n"
     ]
    }
   ],
   "source": [
    "# create a linear SVC instance\n",
    "linear_svc = LinearSVC( max_iter=5000)\n",
    "\n",
    "# Fitting the model\n",
    "linear_svc.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = linear_svc.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_linear_svc = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_linear_svc,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gradient Boosting Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 50.0 %\n"
     ]
    }
   ],
   "source": [
    "# create a gradient boosting instance\n",
    "gbc=GradientBoostingClassifier(n_estimators=100, random_state=50)\n",
    "\n",
    "# Fitting the model\n",
    "gbc.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = gbc.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_gbc = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_gbc,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decision Tree Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 50.0 %\n"
     ]
    }
   ],
   "source": [
    "# create a decision tree classifier instance\n",
    "decision_tree = DecisionTreeClassifier(random_state=50)\n",
    "# Fitting the model\n",
    "decision_tree.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred = decision_tree.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_decision_tree = accuracy_score(y_test, y_pred) * 100\n",
    "print(f\"accuracy_score: {round(acc_decision_tree,2,)} %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>Model</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Score</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>61.538462</th>\n",
       "      <td>Logistic Regression</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61.538462</th>\n",
       "      <td>Support Vector Machines</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>57.692308</th>\n",
       "      <td>Stochastic Gradient Decent</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>53.846154</th>\n",
       "      <td>Random Forest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50.000000</th>\n",
       "      <td>Gradient Boosting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50.000000</th>\n",
       "      <td>Perceptron</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50.000000</th>\n",
       "      <td>Decision Tree</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                Model\n",
       "Score                                \n",
       "61.538462         Logistic Regression\n",
       "61.538462     Support Vector Machines\n",
       "57.692308  Stochastic Gradient Decent\n",
       "53.846154               Random Forest\n",
       "50.000000           Gradient Boosting\n",
       "50.000000                  Perceptron\n",
       "50.000000               Decision Tree"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compile scores for all models into a dataframe\n",
    "results = pd.DataFrame({\n",
    "    'Model': ['Gradient Boosting','Logistic Regression', 'Support Vector Machines',\n",
    "              'Random Forest', 'Perceptron', \n",
    "              'Stochastic Gradient Decent', \n",
    "              'Decision Tree'],\n",
    "    'Score': [acc_gbc, acc_log, acc_linear_svc,\n",
    "              acc_random_forest, acc_perc, \n",
    "              acc_sgd, acc_decision_tree]})\n",
    "result_df = results.sort_values(by='Score', ascending=False).set_index('Score')\n",
    "result_df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`From the table above, Logistic Regression Model had the highest accuracy score while the Decision Tree Model had the least accuracy score. Let's perform resampling using \"Cross-validation\" on both models (i.e., the logistic regression and decision tree model) to protect against overfitting because of the small size of our data.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Cross-validation for logistic regression Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores_logreg: [0.5  0.45 0.55 0.6  0.5 ]\n",
      "Mean_logreg: 0.52\n",
      "Standard Deviation_logreg: 0.05099019513592784\n"
     ]
    }
   ],
   "source": [
    "# Import cross val score \n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# create a stochastic gradient descent model instance\n",
    "logreg = LogisticRegression(max_iter=200, random_state=78)\n",
    "\n",
    "# set cross validation splitting strategy to 5\n",
    "scores_logreg = cross_val_score(logreg, X_train, y_train, \n",
    "                                        cv=5, scoring = \"accuracy\")\n",
    "\n",
    "# cross validation score for stochastic gradient descent model\n",
    "print(\"Scores_logreg:\", scores_logreg)\n",
    "print(\"Mean_logreg:\", scores_logreg.mean())\n",
    "print(\"Standard Deviation_logreg:\", scores_logreg.std())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Cross-validation for decision tree Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scores_dec_tree: [0.55 0.55 0.7  0.65 0.55]\n",
      "Mean_dec_tree: 0.6\n",
      "Standard Deviation_dec_tree: 0.06324555320336755\n"
     ]
    }
   ],
   "source": [
    "# Import cross val score \n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# create a stochastic gradient descent model instance\n",
    "decision_tree = DecisionTreeClassifier(random_state=50)\n",
    "\n",
    "# set cross validation splitting strategy to 5\n",
    "scores_decision_tree = cross_val_score(decision_tree, X_train, y_train, \n",
    "                                        cv=5, scoring = \"accuracy\")\n",
    "\n",
    "# cross validation score for stochastic gradient descent model\n",
    "print(\"Scores_dec_tree:\", scores_decision_tree)\n",
    "print(\"Mean_dec_tree:\", scores_decision_tree.mean())\n",
    "print(\"Standard Deviation_dec_tree:\", scores_decision_tree.std())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Under cross-validation, Logistic Regression Model had an accuracy score of approx. 52% with a margin error of 5%, while the Deicion Tree model had an accuracy score of approx. 60% with an error margin of 6%.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Importance\n",
    "`To futher improve accuracy score, decide on which feature to drop from dataset?`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>importance</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>feature</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>X3</th>\n",
       "      <td>0.203152</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>X6</th>\n",
       "      <td>0.172898</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>X2</th>\n",
       "      <td>0.165996</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>X1</th>\n",
       "      <td>0.154654</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>X5</th>\n",
       "      <td>0.154514</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>X4</th>\n",
       "      <td>0.148786</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         importance\n",
       "feature            \n",
       "X3         0.203152\n",
       "X6         0.172898\n",
       "X2         0.165996\n",
       "X1         0.154654\n",
       "X5         0.154514\n",
       "X4         0.148786"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Random Forests in sklearn will automatically calculate feature importance\n",
    "# We can then sort the features by their importance\n",
    "importances = pd.DataFrame(sorted(zip(random_forest.feature_importances_, X.columns), reverse=True))\n",
    "importances = importances.rename(columns={0:'importance', 1:'feature'})\n",
    "importances = importances.set_index(['feature'])\n",
    "importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1b747370688>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEaCAYAAAAYOoCaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAcr0lEQVR4nO3df5wdZWHv8c/XQPyBWAIskOaHoRh/xNeViDHYorcCYgO9NdFeaNAictFIJQVaqEbrbWntqyIFUSqSBo2GiqJVkb02Chh/oBU0AREJSFlCIEtCEgH5IRYI+d4/ZrYOh5PdOdmTbHbn+369zmtnnmeemefJwvnuPHPOjGwTERHN86yR7kBERIyMBEBEREMlACIiGioBEBHRUAmAiIiGSgBERDRUAiAioqESANEVktZK+rWkRyuv3+7CPt/QrT4Oox/TJFnSbiPdF4CyLy8a6X7E6JcAiG76I9vPr7zWj2RndpU37G4Za+OJkZcAiB1K0m9J+rSkDZLulfQPksaVdQdJ+rak+yX9QtJlkvYq6/4VmAr8v/Js4r2SXi+pv2X//32WIOlsSV+W9DlJDwPvGOL4L5L0PUkPlcf/Ys0xfVbSJyV9o+zbf0g6QNLHJD0o6eeSXtnSx/dLurWs/4yk51Tq3yWpT9IDknqrZ07lX/unSroDuEPStWXVT8tj/4mkCZK+Lmlzuf+vS5pc2cd3JX2o7Ocjkq6WtG+l/rWSfijpl5LWSXpHWf5sSedJukfSRkmLJT23rNu3PM4vy35/X1LeT0aZ/MJiR1sGbAFeBLwSeCPwzrJOwIeB3wZeBkwBzgawfQJwD785qzi35vHmAl8G9gIuG+L4HwKuBiYAk4F/7mBcxwEfBPYFHgeuA24s178MfLRl+7cBfwAcBLy4bIukIyj+DY4DJgJ3A5e3tJ0HHArMsP0/y7KDy3+XL1L8f/wZ4IUUoflr4BMt+3grcBKwHzAeOKs8/lTgG+XYe4CZwE1lm4+UfZ1J8e83Cfibsu5MoL9ssz/wASD3lRltbOeV17BfwFrgUeCX5etrFG8MjwPPrWx3PPCdbexjHvCTln2+obL+eqC/zXHfUC6fDVxbqRv0+MClwBJg8hBjm0bx5rZbuf5Z4JJK/Z8Dt1XW/wfwy5Y+nlJZPwa4s1z+NHBupe75wJPAtHLdwBEt/THwokH6OxN4sLL+XeCDlfX3AN8sl98PXNFmHwJ+BRxUKftd4K5y+e+BKwfrR167/itzitFN82x/a2BF0mxgd2CDpIHiZwHryvr9gAuB1wF7lnUPDrMP6yrLLxzs+MB7Kc4CfizpQeB820trHmdjZfnXbdafP0i/7qY466H8eeNAhe1HJd1P8df22jZtn0HS84ALgDkUZzMAe0oaZ/upcv2+SpPHKv2bAtzZZrc9wPOAGyr/dgLGlcv/RBG4V5f1S2yfM1g/Y9eTAIgdaR3FX+D72t7Spv7DFH/NvsL2/ZLm8fSpi9YphV9RvCkBUM7l97RsU20z6PFt3we8q9zXa4FvSbrWdl+dwXVoSmV5KjBwgXw9RVBR9mMPYB/g3mpXh9j3mcBLgENt3ydpJvATijfsoawDZrcp/wVFkL3c9r2tlbYfKY97pqSXA9+RtNL2ihrHjF1ErgHEDmN7A8Uc+/mSXiDpWeWF398vN9mTctpI0iTgr1p2sRH4ncr6fwLPkfSHknanmEd/9vYeX9KxlYulD1K80T61jd0N16mSJkvam2K+fOCC8+eBkyTNlPRs4B+BH9leO8i+Wv9d9qR4s/5luf+/7aBflwFvkHScpN0k7SNppu2twCXABeWZGpImSfqDcvl/lRfRBTxM8e+2o/7tYgdJAMSO9naKi463UrzJfpniYifA3wGHAA8B/w58taXth4EPlp80Ocv2QxTz15+i+Av5VxQXIrf3+K8GfiTpUaAXON32Xds5zqF8niKM1pSvfwAo/2L+v8BXgA0UF4nnD7Gvs4Fl5b/LccDHgOdS/NV+PfDNup2yfQ/FNYkzgQcoLgAfXFa/D+gDri8/VfUtijMNgOnl+qMUF8A/afu7dY8buwbZuXAfsSNJWgu8s3p9JGJXkDOAiIiGSgBERDRUpoAiIhoqZwAREQ2VAIiIaKhR9UWwfffd19OmTRvpbkREjCo33HDDL2y3fmlydAXAtGnTWLVq1Uh3IyJiVJF0d7vyTAFFRDRUAiAioqESABERDZUAiIhoqARARERDJQAiIhoqARAR0VAJgIiIhqr1RTBJc4CPUzwP9FOtz/6U9DaKh0dA8YCIP7P908Halk8u+iLFA7fXAsfZHu7zYNv6+IMf3xG73abTJ5y+U48XEbE9hjwDKJ+7ehFwNDADOF7SjJbN7gJ+3/YrKB6yvaRG20XACtvTgRXlekRE7CR1poBmA32219h+ArgcmFvdwPYPK3+9Xw9MrtF2LrCsXF4GzNv+YURERKfqBMAkYF1lvb8s25aTgW/UaLt/+dDugYd371enwxER0R11rgGoTVnbp8hIOpwiAF7badttHlxaACwAmDp1aidNIyJiEHXOAPqBKZX1ycD61o0kvQL4FDDX9v012m6UNLFsOxHY1O7gtpfYnmV7Vk/PM+5mGhER26lOAKwEpks6UNJ4YD7QW91A0lTgq8AJtv+zZtte4MRy+UTgyu0fRkREdGrIKSDbWyQtBK6i+CjnUturJZ1S1i8G/gbYB/ikJIAt5V/tbduWuz4H+JKkk4F7gGO7PLaIiBhEre8B2F4OLG8pW1xZfifwzrpty/L7gSM76WxERHRPvgkcEdFQCYCIiIZKAERENFQCICKioRIAERENlQCIiGioBEBEREMlACIiGioBEBHRUAmAiIiGSgBERDRUAiAioqESABERDZUAiIhoqARARERDJQAiIhqqVgBImiPpdkl9kha1qX+ppOskPS7prEr5SyTdVHk9LOmMsu5sSfdW6o7p3rAiImIoQz4RTNI44CLgKIqHvK+U1Gv71spmDwCnAfOqbW3fDsys7Ode4IrKJhfYPm9YI4iIiO1S5wxgNtBne43tJ4DLgbnVDWxvsr0SeHKQ/RwJ3Gn77u3ubUREdE2dAJgErKus95dlnZoPfKGlbKGkmyUtlTRhO/YZERHbqU4AqE2ZOzmIpPHAm4B/qxRfDBxEMUW0ATh/G20XSFoladXmzZs7OWxERAyiTgD0A1Mq65OB9R0e52jgRtsbBwpsb7T9lO2twCUUU03PYHuJ7Vm2Z/X09HR42IiI2JYhLwIDK4Hpkg6kuIg7H3hrh8c5npbpH0kTbW8oV98M3NLhPqP08Qc/vlOPd/qE03fq8SJixxgyAGxvkbQQuAoYByy1vVrSKWX9YkkHAKuAFwBby496zrD9sKTnUXyC6N0tuz5X0kyK6aS1beojImIHqnMGgO3lwPKWssWV5fsopobatX0M2KdN+Qkd9TQiIroq3wSOiGioBEBEREMlACIiGioBEBHRULUuAkeMpJ35Mdd8xDWaJGcAERENlQCIiGioBEBEREMlACIiGioBEBHRUAmAiIiGSgBERDRUAiAioqESABERDZUAiIhoqARARERD5V5AESNorD/Oc6yPb7SrdQYgaY6k2yX1SVrUpv6lkq6T9Liks1rq1kr6maSbJK2qlO8t6RpJd5Q/Jwx/OBERUdeQASBpHHARcDQwAzhe0oyWzR4ATgPO28ZuDrc90/asStkiYIXt6cCKcj0iInaSOmcAs4E+22tsPwFcDsytbmB7k+2VwJMdHHsusKxcXgbM66BtREQMU50AmASsq6z3l2V1Gbha0g2SFlTK97e9AaD8uV8H+4yIiGGqcxFYbcrcwTEOs71e0n7ANZJ+bvvauo3L0FgAMHXq1A4OGxERg6kTAP3AlMr6ZGB93QPYXl/+3CTpCooppWuBjZIm2t4gaSKwaRvtlwBLAGbNmtVJ8ERE7FCj/VNOdaaAVgLTJR0oaTwwH+its3NJe0jac2AZeCNwS1ndC5xYLp8IXNlJxyMiYniGPAOwvUXSQuAqYByw1PZqSaeU9YslHQCsAl4AbJV0BsUnhvYFrpA0cKzP2/5muetzgC9JOhm4Bzi2u0OLiIjB1PoimO3lwPKWssWV5fsopoZaPQwcvI193g8cWbunERHRVbkVREREQyUAIiIaKgEQEdFQCYCIiIZKAERENFQCICKioRIAERENlQCIiGioBEBEREMlACIiGioBEBHRUAmAiIiGSgBERDRUAiAioqESABERDZUAiIhoqFoBIGmOpNsl9Ula1Kb+pZKuk/S4pLMq5VMkfUfSbZJWSzq9Une2pHsl3VS+junOkCIioo4hnwgmaRxwEXAUxQPiV0rqtX1rZbMHgNOAeS3NtwBn2r6xfDbwDZKuqbS9wPZ5wx5FRER0rM4ZwGygz/Ya208AlwNzqxvY3mR7JfBkS/kG2zeWy48AtwGTutLziIgYljoBMAlYV1nvZzvexCVNA14J/KhSvFDSzZKWSprQ6T4jImL71QkAtSlzJweR9HzgK8AZth8uiy8GDgJmAhuA87fRdoGkVZJWbd68uZPDRkTEIOoEQD8wpbI+GVhf9wCSdqd487/M9lcHym1vtP2U7a3AJRRTTc9ge4ntWbZn9fT01D1sREQMoU4ArASmSzpQ0nhgPtBbZ+eSBHwauM32R1vqJlZW3wzcUq/LERHRDUN+Csj2FkkLgauAccBS26slnVLWL5Z0ALAKeAGwVdIZwAzgFcAJwM8k3VTu8gO2lwPnSppJMZ20Fnh3d4cWERGDGTIAAMo37OUtZYsry/dRTA21+gHtryFg+4T63YyIiG7LN4EjIhoqARAR0VAJgIiIhkoAREQ0VAIgIqKhEgAREQ2VAIiIaKgEQEREQyUAIiIaKgEQEdFQCYCIiIZKAERENFQCICKioRIAERENlQCIiGioBEBEREMlACIiGqpWAEiaI+l2SX2SFrWpf6mk6yQ9LumsOm0l7S3pGkl3lD8nDH84ERFR15ABIGkccBFwNMVzfo+XNKNlsweA04DzOmi7CFhhezqwolyPiIidpM4ZwGygz/Ya208AlwNzqxvY3mR7JfBkB23nAsvK5WXAvO0cQ0REbIc6ATAJWFdZ7y/L6his7f62NwCUP/eruc+IiOiCOgGgNmWuuf/htC12IC2QtErSqs2bN3fSNCIiBlEnAPqBKZX1ycD6mvsfrO1GSRMByp+b2u3A9hLbs2zP6unpqXnYiIgYSp0AWAlMl3SgpPHAfKC35v4Ha9sLnFgunwhcWb/bERExXLsNtYHtLZIWAlcB44CltldLOqWsXyzpAGAV8AJgq6QzgBm2H27Xttz1OcCXJJ0M3AMc2+3BRUTEtg0ZAAC2lwPLW8oWV5bvo5jeqdW2LL8fOLKTzkZERPfkm8AREQ2VAIiIaKgEQEREQyUAIiIaKgEQEdFQCYCIiIZKAERENFQCICKioRIAERENlQCIiGioBEBEREMlACIiGioBEBHRUAmAiIiGSgBERDRUAiAioqFqBYCkOZJul9QnaVGbekm6sKy/WdIhZflLJN1UeT1cPi0MSWdLurdSd0x3hxYREYMZ8olgksYBFwFHUTzkfaWkXtu3VjY7Gphevg4FLgYOtX07MLOyn3uBKyrtLrB9XjcGEhERnalzBjAb6LO9xvYTwOXA3JZt5gKXunA9sJekiS3bHAncafvuYfc6IiKGrU4ATALWVdb7y7JOt5kPfKGlbGE5ZbRU0oQafYmIiC6pEwBqU+ZOtpE0HngT8G+V+ouBgyimiDYA57c9uLRA0ipJqzZv3lyjuxERUUedAOgHplTWJwPrO9zmaOBG2xsHCmxvtP2U7a3AJRRTTc9ge4ntWbZn9fT01OhuRETUUScAVgLTJR1Y/iU/H+ht2aYXeHv5aaDXAA/Z3lCpP56W6Z+WawRvBm7puPcREbHdhvwUkO0tkhYCVwHjgKW2V0s6paxfDCwHjgH6gMeAkwbaS3oexSeI3t2y63MlzaSYKlrbpj4iInagIQMAwPZyijf5atniyrKBU7fR9jFgnzblJ3TU04iI6Kp8EzgioqESABERDZUAiIhoqARARERDJQAiIhoqARAR0VAJgIiIhkoAREQ0VAIgIqKhEgAREQ2VAIiIaKgEQEREQyUAIiIaKgEQEdFQCYCIiIZKAERENFQCICKioWoFgKQ5km6X1CdpUZt6SbqwrL9Z0iGVurWSfibpJkmrKuV7S7pG0h3lzwndGVJERNQxZABIGgdcBBwNzACOlzSjZbOjgenlawFwcUv94bZn2p5VKVsErLA9HVhRrkdExE5S5wxgNtBne43tJ4DLgbkt28wFLnXhemAvSROH2O9cYFm5vAyY10G/IyJimOoEwCRgXWW9vyyru42BqyXdIGlBZZv9bW8AKH/u10nHIyJieHarsY3alLmDbQ6zvV7SfsA1kn5u+9q6HSxDYwHA1KlT6zaLiIgh1DkD6AemVNYnA+vrbmN74Ocm4AqKKSWAjQPTROXPTe0ObnuJ7Vm2Z/X09NTobkRE1FEnAFYC0yUdKGk8MB/obdmmF3h7+Wmg1wAP2d4gaQ9JewJI2gN4I3BLpc2J5fKJwJXDHEtERHRgyCkg21skLQSuAsYBS22vlnRKWb8YWA4cA/QBjwEnlc33B66QNHCsz9v+Zll3DvAlSScD9wDHdm1UERExpDrXALC9nOJNvlq2uLJs4NQ27dYAB29jn/cDR3bS2YiI6J58EzgioqESABERDZUAiIhoqARARERDJQAiIhoqARAR0VAJgIiIhkoAREQ0VAIgIqKhEgAREQ2VAIiIaKgEQEREQyUAIiIaKgEQEdFQCYCIiIZKAERENFStAJA0R9LtkvokLWpTL0kXlvU3SzqkLJ8i6TuSbpO0WtLplTZnS7pX0k3l65juDSsiIoYy5BPBJI0DLgKOonj4+0pJvbZvrWx2NDC9fB0KXFz+3AKcafvG8tnAN0i6ptL2AtvndW84ERFRV50zgNlAn+01tp8ALgfmtmwzF7jUheuBvSRNtL3B9o0Ath8BbgMmdbH/ERGxneoEwCRgXWW9n2e+iQ+5jaRpwCuBH1WKF5ZTRkslTajZ54iI6II6AaA2Ze5kG0nPB74CnGH74bL4YuAgYCawATi/7cGlBZJWSVq1efPmGt2NiIg66gRAPzClsj4ZWF93G0m7U7z5X2b7qwMb2N5o+ynbW4FLKKaansH2EtuzbM/q6emp0d2IiKijTgCsBKZLOlDSeGA+0NuyTS/w9vLTQK8BHrK9QZKATwO32f5otYGkiZXVNwO3bPcoIiKiY0N+Csj2FkkLgauAccBS26slnVLWLwaWA8cAfcBjwEll88OAE4CfSbqpLPuA7eXAuZJmUkwVrQXe3bVRRUTEkIYMAIDyDXt5S9niyrKBU9u0+wHtrw9g+4SOehoREV2VbwJHRDRUAiAioqESABERDZUAiIhoqARARERDJQAiIhoqARAR0VAJgIiIhkoAREQ0VAIgIqKhEgAREQ2VAIiIaKgEQEREQyUAIiIaKgEQEdFQCYCIiIZKAERENFStAJA0R9LtkvokLWpTL0kXlvU3SzpkqLaS9pZ0jaQ7yp8TujOkiIioY8gAkDQOuAg4GpgBHC9pRstmRwPTy9cC4OIabRcBK2xPB1aU6xERsZPUOQOYDfTZXmP7CeByYG7LNnOBS124HthL0sQh2s4FlpXLy4B5wxxLRER0oE4ATALWVdb7y7I62wzWdn/bGwDKn/vV73ZERAzXbjW2UZsy19ymTtvBDy4toJhWAnhU0u2dtB+mfYFfdNroDM7YAV3ZIcby+Mby2CDjayvj26YXtiusEwD9wJTK+mRgfc1txg/SdqOkibY3lNNFm9od3PYSYEmNfnadpFW2Z43EsXeGsTy+sTw2yPhGu11lfHWmgFYC0yUdKGk8MB/obdmmF3h7+Wmg1wAPldM6g7XtBU4sl08ErhzmWCIiogNDngHY3iJpIXAVMA5Yanu1pFPK+sXAcuAYoA94DDhpsLblrs8BviTpZOAe4NiujiwiIgZVZwoI28sp3uSrZYsrywZOrdu2LL8fOLKTzo6AEZl62onG8vjG8tgg4xvtdonxqXjvjoiIpsmtICIiGioBEBHRUAmAiIiGSgCUJB0g6YByuUfSWyS9fKT71Q2Spkp6TrksSSdJ+mdJfyap1gcBdnWSXiDpoDblrxiJ/uwsko4a6T50U/mR8bdIeulI92VHkfSPI92HAbkIDEh6N8XN6AR8BHgHsBo4DDjX9qdHrnfDJ+kWYLbtxyR9BDgI+BpwBIDt/zOS/RsuSccBH6P4MuHuwDtsryzrbrR9yGDtRzNJ99ieOtL92F6SvmZ7Xrk8l+L3+F3g94AP2/7syPVu+CRd2FoEnABcCmD7tJ3eqYox8ddfFywEXg48F7gbeJHt+8pbVH8HGNUBADzL9mPl8huAV9veCnxO0k9HsF/d8gHgVeW3ymcD/yrpA7a/SvvbkYwqklq/ePnfVcA+O7MvO0D1FgXvA46wfZekfSnuEvzZEelV97yFItCu5jf/Lc4HbhipDlUlAApPlm+Qj0m60/Z9ALYflDQWTpHWSTrC9reBtRS357hb0mh/8xiwW+XGgj+WdDjwdUmT6fDeU7uo1wF/CjzaUi6KO+6OZtXfz2627wKw/QtJW0eoT930MuBDwBzgr2zfK+lvbS8bot1OkQAobJW0u+0ngT8cKCznzcfCdZJ3ApdKOht4CLhJ0k+ACcBfjmTHuuRhSQfZvhOKu8tKej3FNNdYuI5zPfCY7e+1VuzkmyPuCAdLepgizJ4t6YDy7Hs8xd0DRjXbjwBnSHoVxRn3v7MLvackAApvpvxLxHZ/pXwf4Msj0qMus324pJcBL6Y4re6nuFfTYSPZry55Hy1TPbYfkTQHeP/IdKmrFthet426v96pPem+A23f06b8uWzj7gKjiaQpttfZvkHSEcB7gB+Uda+z/f2R7N8uk0Qj7HvAX1Y/ESNpf4oLwm8asV51z/ckvRe4w/aVtr9CMRV0KfDREe1ZdywD/rjN7+8zwB+NWK+653uS3ts6PkmfY/T//r7bbmwUTxIc7WODyu+ufGDWRcBZu8rvLgFQeBXFJ2N+IukISacDPwauAw4d0Z51RxPGdyBje3xj9fc3lscG7cd3PbvI+PIx0Iryl3MBxTMLXtMyHTTqZXyj21ge31geG+y648sZACBpL0n/QnEb6zkU8/7fKOfsRr2Mb3Qby+Mby2ODUTA+241/AWuAsyg+hjZQNhP4IfCFke5fxpfxjdXxjeWxjYbxZQoIkDTZ2zglk/Qu25fs7D51U8aX8e2qxvLYYNcfXwIgIqKhcg0gIqKhEgAREQ2VAIgAJJ0m6TZJl3XYbpqkt+6ofkXsSAmAiMJ7gGNsv63DdtOAjgNA0qi/z02MfgmAaDxJi4HfAXol/bWkpZJWSvpJeY/6gb/0vy/pxvL1e2Xzc4DXSbpJ0l9IeoekT1T2/fXyxnRIelTS30v6EfC7kv5U0o/Ltv+SUIidLQEQjWf7FIpvaB4O7AF82/ary/V/krQHxcNmjnLxcJk/AQYe9LEI+L7tmbYvGOJQewC32D4UuL/cz2G2ZwJPAZ2efUQMS+4GGvF0bwTeJOmscv05wFSKgPiEpIE36xdvx76fAr5SLh9JcZ+YlZKguPvlpmH0O6JjCYCIpxPwx7afdp/98lkKG4GDKc6c/2sb7bfw9DPr51SW/8v2U5XjLLM9Fm5XHaNUpoAinu4q4M9V/lku6ZVl+W8BG1w8SvMEfvOwkkeAPSvt1wIzJT1L0hS2/cSuFcD/lrRfeZy9Jb1wG9tG7BAJgIin+xDFg+VvlnRLuQ7wSeBESddTTP/8qiy/Gdgi6aeS/gL4D+Au4GfAecCN7Q5i+1bgg8DVkm4GrgEm7pghRbSXW0FERDRUzgAiIhoqARAR0VAJgIiIhkoAREQ0VAIgIqKhEgAREQ2VAIiIaKgEQEREQ/1/n6YTBpNVjqUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the features by importance\n",
    "importances.plot.bar(color='lightgreen', title= 'Features Importances', legend=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`From the feature importance chart, it appears that all feature may be significant when predicting a customer's happiness since their feature ranks in the same range. Thus all feature needs to be preserved in the next survey.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### K Nearest Neighbors Model\n",
    "`Let's try K_Nearest Neighbors Model `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_neighbors: 23 ---> Best accuracy Score: 0.7444\n"
     ]
    }
   ],
   "source": [
    "# loop through selected range to determine best score\n",
    "# initialize variable to hold highest accuracy score\n",
    "highest_score = 0\n",
    "\n",
    "# loop \n",
    "for i in range(1,30):\n",
    "    kNN_model=KNeighborsClassifier(n_neighbors=i).fit(X_train, y_train)\n",
    "    y_pred=kNN_model.predict(X_test)\n",
    "    # print accuracy score for each n_neighbors\n",
    "    score = balanced_accuracy_score(y_pred, y_test)\n",
    "    \n",
    "    if score > highest_score:\n",
    "        highest_score = score\n",
    "        n_neighbors = i\n",
    "# print best accuracy score\n",
    "print(f\"n_neighbors: {n_neighbors} ---> Best accuracy Score: {round(highest_score,4)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.744360902255639\n"
     ]
    }
   ],
   "source": [
    "# create a knn model and fit data\n",
    "kNN_model=KNeighborsClassifier(n_neighbors=23).fit(X_train, y_train)\n",
    "# predict using the test data\n",
    "y_pred=kNN_model.predict(X_test)\n",
    "# Display the accuracy score for the test dataset.\n",
    "print(balanced_accuracy_score(y_pred, y_test))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HyperParameter Tuning"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Now let's tune the logistic regression model to estimate the best hyperparameters that could further improve the accuracy score.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Randomized SearchCV Tuning with logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Fine-tuning logistic regression classifier --\n",
      "--------------------- RandomizedSearchCV begins\n",
      "Fitting 30 folds for each of 10 candidates, totalling 300 fits\n",
      "--------------------- RandomizedSearchCV ends\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\evans\\anaconda3\\envs\\PythonData\\lib\\site-packages\\sklearn\\linear_model\\_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
      "  ConvergenceWarning,\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({'C': 71, 'penalty': 'l2', 'solver': 'saga'}, 0.6166107966107965)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tune the parameters to improve the accuracy\n",
    "def tune_logreg_hyper_params( X_train, y_train):\n",
    "    # Import modules\n",
    "    from sklearn import linear_model\n",
    "    from sklearn.linear_model import LogisticRegression\n",
    "    from sklearn.model_selection import RepeatedStratifiedKFold\n",
    "    from sklearn.model_selection import RandomizedSearchCV\n",
    "    \n",
    "    print (\"-- {} --\".format(\"Fine-tuning logistic regression classifier\"))\n",
    "    \n",
    "    # initialize the hyperparameters\n",
    "    penalty = [ 'l2'] \n",
    "    solvers = ['lbfgs', 'liblinear', 'newton-cg', 'sag', 'saga']\n",
    "    c_values = sp_randint(0.01, 100)\n",
    "    cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\n",
    "\n",
    "    # input parameters\n",
    "    param_dist = dict(\n",
    "                        solver = solvers,\n",
    "                        penalty=penalty,\n",
    "                        C = c_values\n",
    "                )\n",
    "\n",
    "    # build logistic regression instance \n",
    "    logreg = LogisticRegression(max_iter=200, random_state=78)\n",
    "\n",
    "    # Randomized search\n",
    "    random_search = RandomizedSearchCV(estimator=logreg, \n",
    "                                        param_distributions=param_dist, \n",
    "                                        n_jobs=-1,\n",
    "                                        scoring='f1',\n",
    "                                        error_score=0,\n",
    "                                        cv= cv,\n",
    "                                        verbose= 1)\n",
    "\n",
    "    print (\"--------------------- RandomizedSearchCV begins\")\n",
    "    random_search.fit(X_train, y_train)\n",
    "    print (\"--------------------- RandomizedSearchCV ends\")\n",
    "\n",
    "    return random_search.best_params_, random_search.best_score_ \n",
    "\n",
    "tune_logreg_hyper_params(X_train, y_train)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Best hyper parameter using RandomizedSearchCV with logistic regression classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 61.54 %\n"
     ]
    }
   ],
   "source": [
    "  # build logistic regression instance \n",
    "logreg = LogisticRegression(max_iter=200, \n",
    "                              random_state=78,\n",
    "                              penalty= 'l2',\n",
    "                              solver ='liblinear',\n",
    "                              C= 48\n",
    "                         )\n",
    "\n",
    "# # Fitting the model\n",
    "logreg.fit(X_train, y_train)\n",
    "\n",
    "# # Making predictions using the testing data\n",
    "y_pred_tuned = logreg.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_logreg_tuned = accuracy_score(y_test, y_pred_tuned) * 100\n",
    "print(f\"accuracy_score: {round(acc_logreg_tuned,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`The logistic regression when tuned had a best score of approx. 62%. However when the logistic regression model was re-evaluated using the tuned hyperparameters, the accuracy score did not change. Because our cross validation showed a better accuracy score under decision tree Model, I therefore decided to repeat the tuning below using the Decision tree classifier`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Randomized SearchCV Tuning with Decision Tree Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Fine-tuning decision tree Classifier --\n",
      "--------------------- RandomizedSearchCV begins\n",
      "Fitting 10 folds for each of 1000 candidates, totalling 10000 fits\n",
      "--------------------- RandomizedSearchCV ends\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "({'criterion': 'gini',\n",
       "  'max_leaf_nodes': 38,\n",
       "  'min_samples_leaf': 5,\n",
       "  'min_samples_split': 7,\n",
       "  'splitter': 'random'},\n",
       " 0.6499999999999999)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tune the parameters to improve the accuracy\n",
    "def tune_decision_tree_hyperparams( X_train, y_train):\n",
    "    # Import modules\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "    from sklearn.model_selection import RandomizedSearchCV\n",
    "    \n",
    "    print (\"-- {} --\".format(\"Fine-tuning decision tree Classifier\"))\n",
    "    \n",
    "    # initialize the hyperparameters\n",
    "    criterion = ['gini', 'entropy']\n",
    "    splitter = ['best', 'random']\n",
    "    min_samples_leaf= sp_randint(1,500)\n",
    "    min_samples_split= sp_randint(2,700) \n",
    "    max_leaf_nodes = sp_randint(2,1000)\n",
    "    n_iter_search = 1000\n",
    "\n",
    "    # input parameters\n",
    "    param_dist = dict(\n",
    "                        criterion=criterion,\n",
    "                        splitter=splitter,\n",
    "                        min_samples_leaf = min_samples_leaf,\n",
    "                        min_samples_split =min_samples_split,\n",
    "                        max_leaf_nodes=max_leaf_nodes\n",
    "                    )\n",
    "\n",
    "    # create decisionTree instance \n",
    "    decision_tree = DecisionTreeClassifier(random_state = 78)\n",
    "\n",
    "    # Randomized search\n",
    "    random_search = RandomizedSearchCV(estimator=decision_tree, \n",
    "                                        param_distributions=param_dist, \n",
    "                                        n_jobs=-1,\n",
    "                                        n_iter= n_iter_search, \n",
    "                                        cv=10,\n",
    "                                        verbose =1 )\n",
    "\n",
    "    print (\"--------------------- RandomizedSearchCV begins\")\n",
    "    random_search.fit(X_train, y_train)\n",
    "    print (\"--------------------- RandomizedSearchCV ends\")\n",
    "\n",
    "    return random_search.best_params_, random_search.best_score_ \n",
    "\n",
    "tune_decision_tree_hyperparams(X_train, y_train)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Best hyper parameter for RandomizedSearchCV with DecisionTree classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy_score: 73.08 %\n"
     ]
    }
   ],
   "source": [
    "# build decisionTree instance with tuned paramaters\n",
    "decision_tree_tuned =DecisionTreeClassifier (criterion='gini',\n",
    "                                             splitter='best',\n",
    "                                             min_samples_leaf = 21,\n",
    "                                             min_samples_split =38,\n",
    "                                             max_leaf_nodes =179\n",
    "                                        )\n",
    "\n",
    "# Fitting the model\n",
    "decision_tree_tuned.fit(X_train, y_train)\n",
    "\n",
    "# Making predictions using the testing data\n",
    "y_pred_tuned = decision_tree_tuned.predict(X_test)\n",
    "\n",
    "# Display the accuracy score for the test dataset.\n",
    "acc_decision_tree = accuracy_score(y_test, y_pred_tuned) * 100\n",
    "print(f\"accuracy_score: {round(acc_decision_tree,2,)} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`The accuracy score improves further under decision tree model. Now that we have a proper model, we can start evaluating it's performace in a more accurate way.`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further evaluation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to plot heatmap of confusion matrix\n",
    "def plot_conf_matrix (conf_matrix, dtype):\n",
    "    class_names = [\"Unhappy\",\"Happy\"]\n",
    "    fontsize=14\n",
    "    df_conf_matrix = pd.DataFrame(\n",
    "            conf_matrix, index=class_names, columns=class_names, \n",
    "        )\n",
    "    fig = plt.figure()\n",
    "    heatmap = sns.heatmap(df_conf_matrix, annot=True, fmt=\"d\")\n",
    "    heatmap.yaxis.set_ticklabels(heatmap.yaxis.get_ticklabels(), rotation=45, ha='right', fontsize=fontsize)\n",
    "    heatmap.xaxis.set_ticklabels(heatmap.xaxis.get_ticklabels(), rotation=45, ha='right', fontsize=fontsize)\n",
    "    plt.ylabel('Actual label', size =18)\n",
    "    plt.xlabel('Predicted label', size =18)\n",
    "    plt.title('Confusion Matrix for {0}'.format(dtype), size =20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fitting the model using the tuned Decision Tree model\n",
    "decision_tree_tuned.fit(X_train, y_train)\n",
    "# plot confusion matrix\n",
    "plot_conf_matrix(confusion_matrix(y_test, decision_tree_tuned.predict(X_test)), \"Test data\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`The first row is about the unhappy customers: 9 customers were correctly classified as not happyy (i.e., true negatives) and 4 customers were wrongly classified as unhappy (false negatives). In the second row, 3 customers were wrongly classified as happy (i.e., false positives) and 10 were correctly classed as happy customers (i.e., true positives).`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classification Report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   precision    recall  f1-score   support\n",
      "\n",
      "unhappy customers       0.75      0.69      0.72        13\n",
      "  happy customers       0.71      0.77      0.74        13\n",
      "\n",
      "         accuracy                           0.73        26\n",
      "        macro avg       0.73      0.73      0.73        26\n",
      "     weighted avg       0.73      0.73      0.73        26\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Import module for classification\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# create target names for classification\n",
    "target_names = [\"unhappy customers\", \"happy customers\"]\n",
    "print(classification_report(y_test, y_pred_tuned, target_names=target_names))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Our model predicts 75% of the time that the customers are unhappy and 71% of the time that the customers are happy. The recall measures the correctness of the model in identifying true positives. Thus, the recall reveals that it predicted 69% of customers were unhappy out of actual unhappy customers while 77% were happy out of the actual happy customers.`\n",
    "`We have a F-score of 72% and 74% for unhappy and happy customers, respectively. The score is not that high, because we have a recall of 69% for the unhappy customers and a precision of 71% for the happy customers. As a result of that, the classifier will only get a high F-score, if both recall and precision are high`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Precision Recall Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "# getting the probabilities of our predictions\n",
    "y_scores = decision_tree_tuned.predict_proba(X_test)\n",
    "y_scores = y_scores[:,1]\n",
    "\n",
    "precision, recall, threshold = precision_recall_curve(y_test, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.precision_recall_curve.PrecisionRecallDisplay at 0x1b747557088>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the precision and recall curve\n",
    "from sklearn.metrics import PrecisionRecallDisplay\n",
    "prd = PrecisionRecallDisplay(precision, recall)\n",
    "prd.plot()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "`This project aimed to predict if a customer was happy or not based on the answers they give to a series of survey on customer cohort. `\n",
    "\n",
    "`The first step of this project was data exploration where I learnt about the structure of the dataset, checked for missing data estimated the correlation between each feature.  Afterwards I built 7 models and trained each of them. I also built a KNN classifier which returned an accuracy score of  74%. Further, I determined the accuracy score of the 7 models and selected the best (logistic regression model) as well as the least best (decision tree). The accuracy score estimated from the cross-validation method informed my decision to also tune the decision tree model for the best hyperparameters. The accuracy score under the cross-validation method was 60% and 52% but 50% and 62% without the cross-validation approach for the decision tree model and logistic regression model, respectively. After tuning both models, only the decision tree model achieved a higher accuracy score of 73%. Lastly I took a look at it's confusion matrix and computed the model's precision, recall and F-score`\n",
    "\n",
    "`Further improvement can still be done to improve the result. For example, an extensive hyperparameter tuning on each of the other learning models. `"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PythonData",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}