Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Pandas Packages\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "#from sklearn.cross_validation import cross_val_score\n",
    "from sklearn import preprocessing\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn import svm\n",
    "from sklearn.svm import SVC\n",
    "import matplotlib.pyplot as plt \n",
    "from sklearn.ensemble import GradientBoostingRegressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing Train File \n",
    "data= pd.read_csv(\"Employeechurn.csv\")\n",
    "del data['EmployeeNumber']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert the string data to int (LabelEncoding)\n",
    "le = preprocessing.LabelEncoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "convert = data.apply(le.fit_transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = convert.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=dataset[:,1:] #Independent Variable\n",
    "y=dataset[:,0] #Dependent Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Splitting of Data \n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = data.columns[[i for i in range(1,34)]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Logistic Regression Classifier Parameter Selection \n",
      "\n",
      "Max_iter :  0 , Accuracy :  0.8483965014577259\n",
      "Max_iter :  100 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  200 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  300 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  400 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  500 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  600 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  700 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  800 , Accuracy :  0.8794946550048591\n",
      "Max_iter :  900 , Accuracy :  0.8794946550048591\n",
      "\n",
      " Random Forest Parameter Selection \n",
      "\n",
      "n_estimators : "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\svm\\base.py:929: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  \"the number of iterations.\", ConvergenceWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 30 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  30 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  25 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  20 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  15 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  10 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 70 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 140 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 210 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 280 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 350 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 420 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 490 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 560 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 630 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 700 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 770 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 840 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 910 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 980 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1050 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1120 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1190 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1260 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1330 , Accuracy :  0.8483965014577259\n",
      "n_estimators :  5 min_samples_leaf : 1400 , Accuracy :  0.8483965014577259\n",
      "\n",
      " Gradient Boosting Parameter Selection \n",
      "\n",
      "n_estimators :  30 , Accuracy :  0.891156462585034\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators :  25 , Accuracy :  0.8843537414965986\n",
      "n_estimators :  20 , Accuracy :  0.8746355685131195\n",
      "n_estimators :  15 , Accuracy :  0.8658892128279884\n",
      "n_estimators :  10 , Accuracy :  0.8561710398445093\n",
      "n_estimators :  5 , Accuracy :  0.8483965014577259\n",
      "\n",
      " Nueral Nets Parameter Selection \n",
      "\n",
      "max_iter :  1 , Accuracy :  0.8396501457725948\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\neural_network\\multilayer_perceptron.py:566: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (1) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_iter :  101 , Accuracy :  0.8658892128279884\n",
      "max_iter :  201 , Accuracy :  0.8658892128279884\n",
      "max_iter :  301 , Accuracy :  0.8658892128279884\n",
      "max_iter :  401 , Accuracy :  0.8658892128279884\n",
      "max_iter :  501 , Accuracy :  0.8658892128279884\n",
      "max_iter :  601 , Accuracy :  0.8658892128279884\n",
      "max_iter :  701 , Accuracy :  0.8658892128279884\n",
      "max_iter :  801 , Accuracy :  0.8658892128279884\n",
      "max_iter :  901 , Accuracy :  0.8658892128279884\n"
     ]
    }
   ],
   "source": [
    "#Parameters Selection Grid \n",
    "print(\"\\n\",\"Logistic Regression Classifier Parameter Selection\",\"\\n\")\n",
    "\n",
    "for i in range(0,1000,100):\n",
    "    def log_classifier(features,target):\n",
    "        \"\"\"Logistic Regression Classifier\n",
    "        max_iter = maximum number of iterations\"\"\"\n",
    "        logReg = LogisticRegression(random_state=46,max_iter = i)\n",
    "        log_trained_model = logReg.fit(x_train, y_train)\n",
    "        return logReg\n",
    "    log_trained_model = log_classifier(x_train, y_train)\n",
    "    log_predictions = log_trained_model.predict(x_train)\n",
    "    Accuracy = accuracy_score(y_train, log_predictions)\n",
    "    print(\"Max_iter : \",i,\", Accuracy : \",Accuracy)\n",
    "\n",
    "print(\"\\n\",\"Random Forest Parameter Selection\",\"\\n\")\n",
    "for i in range(30,1,-5):\n",
    "    for j in range(70,1470,70):\n",
    "        def rf_classifier(features,target):\n",
    "            \"\"\"\n",
    "            Random Forest Classifier\n",
    "            n_estimators = number of trees in the foreset\n",
    "            min_samples_leaf = min number of data points allowed in a leaf node\n",
    "            max_depth = max number of levels in each decision tree\n",
    "            \"\"\"\n",
    "            clf = RandomForestClassifier(n_estimators = i, min_samples_leaf = j, random_state = 46)\n",
    "            clf.fit(features,target)\n",
    "            return clf\n",
    "        rf_trained_model = rf_classifier(x_train, y_train)\n",
    "        rf_predictions = rf_trained_model.predict(x_train)\n",
    "        Accuracy = accuracy_score(y_train, rf_predictions)\n",
    "        print(\"n_estimators : \",i,\"min_samples_leaf :\",j,\", Accuracy : \",Accuracy)\n",
    "\n",
    "print(\"\\n\",\"Gradient Boosting Parameter Selection\",\"\\n\")\n",
    "for i in range(30,1,-5):\n",
    "    def gbm_classifier(features,target):\n",
    "        \"\"\"Gradient Boosting \"\"\"\n",
    "        clf = GradientBoostingRegressor(n_estimators = i)\n",
    "        clf.fit(features,target)\n",
    "        return clf\n",
    "    gbm_trained_model = gbm_classifier(x_train, y_train)\n",
    "    gbm_pred = gbm_trained_model.predict(x_train)\n",
    "    gbm_predictions = [int(round(value)) for value in gbm_pred]\n",
    "    Accuracy = accuracy_score(y_train, gbm_predictions)\n",
    "    print(\"n_estimators : \",i,\", Accuracy : \",Accuracy)\n",
    "    \n",
    "print(\"\\n\",\"Nueral Nets Parameter Selection\",\"\\n\")\n",
    "for i in range(1,1000,100):\n",
    "    def nn_classifier(features,target):\n",
    "        \"\"\"Neural Net Classifier\"\"\"\n",
    "        clf = MLPClassifier(hidden_layer_sizes = (40,40,40),max_iter=i,random_state=546)\n",
    "        clf.fit(features,target)\n",
    "        return clf\n",
    "    nn_trained_model = nn_classifier(x_train, y_train)\n",
    "    nn_predictions = nn_trained_model.predict(x_train)\n",
    "    Accuracy = accuracy_score(y_train, nn_predictions)\n",
    "    print(\"max_iter : \",i,\", Accuracy : \",Accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The parameter values we have chosen for all the models is providing the best possible accuracy results thus making our predictions more accurate.\n",
    "#These values are obtained by doing the simple grid search over the parameter space.\n",
    "def log_classifier(features,target):\n",
    "    \"\"\"Logistic Regression with parameter values providing best prossible accuracy\n",
    "    random_state: random_state is the seed used by the random number generator,\n",
    "    Maximum number of iterations taken for the solvers to converge.\"\"\"\n",
    "    logReg = LogisticRegression(random_state=46,max_iter = 200)\n",
    "    logReg.fit(features,target)\n",
    "    return logReg\n",
    "\n",
    "def rf_classifier(features,target):\n",
    "    \"\"\"Random Forest Classifier \n",
    "    n_estimators: list of DecisionTreeClassifier,\n",
    "    random_state: random_state is the seed used by the random number generator,\n",
    "    min_samples_leaf:The minimum number of samples required to be at a leaf node \"\"\"\n",
    "    clf = RandomForestClassifier(n_estimators = 20, min_samples_leaf = 20, random_state = 46)\n",
    "    clf.fit(features,target)\n",
    "    return clf\n",
    "\n",
    "def gbm_classifier(features,target):\n",
    "    \"\"\"This is gradient boosting model classifier.Decision trees are usually used when doing gradient boosting.\n",
    "    n_estimators: The number of boosting stages to perform.\n",
    "    random_state: random_state is the seed used by the random number generator.\n",
    "    max_depth:The maximum depth limits the number of nodes in the tree.\n",
    "    \"\"\"\n",
    "    clf = GradientBoostingRegressor(n_estimators = 30)\n",
    "    clf.fit(features,target)\n",
    "    return clf\t\n",
    "\n",
    "def nn_classifier(features,target):\n",
    "    \"\"\"Neural Net Classifier \n",
    "    MLP with hidden layers have a non-convex loss function where there exists more than one local minimum,\n",
    "    random_state: random_state is the seed used by the random number generator,\n",
    "    Maximum number of iterations taken for the solvers to converge.\n",
    "    \"\"\"\n",
    "    clf = MLPClassifier(hidden_layer_sizes = (40,40,40),max_iter=501,random_state=546)\n",
    "    clf.fit(features,target)\n",
    "    return clf\n",
    "\n",
    "##random_state: random_state is the seed used by the random number generator\n",
    "def svm_classifier(features,target):\n",
    "    clf = SVC(random_state = 400)\n",
    "    clf.fit(features,target) \n",
    "    return clf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train the logistic model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "log_trained_model = log_classifier(x_train, y_train)\n",
    "log_predictions = log_trained_model.predict(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion_Matrix/precision/F1_Score for Logistic Model\n",
      "\n",
      " Predicted    0   1   All\n",
      "Actual                  \n",
      "0          852  21   873\n",
      "1          103  53   156\n",
      "All        955  74  1029\n",
      "\n",
      "Precision = 71.62162162162163 %\n",
      "\n",
      "Recall = 33.97435897435898 %\n",
      "\n",
      "F1_Score = 46.086956521739125 %\n"
     ]
    }
   ],
   "source": [
    "#Confusion_Matrix/precision/F1_Score for Logistic Model\n",
    "Confusion_Matrix = pd.crosstab(y_train,log_predictions, rownames=['Actual'], colnames=['Predicted'], margins=True)\n",
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))\n",
    "recall = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[0][1]))\n",
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))\n",
    "print(\"Confusion_Matrix/precision/F1_Score for Logistic Model\")\n",
    "print(\"\\n\",Confusion_Matrix)\n",
    "print(\"\\nPrecision =\",precision *100,\"%\")\n",
    "print(\"\\nRecall =\", recall*100,\"%\")\n",
    "print(\"\\nF1_Score =\",F1_Score *100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train the Random Forest model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf_trained_model = rf_classifier(x_train, y_train)\n",
    "rf_predictions = rf_trained_model.predict(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion_Matrix/precision/F1_Score for Logistic Model\n",
      "\n",
      " Predicted     0  1   All\n",
      "Actual                  \n",
      "0           873  0   873\n",
      "1           153  3   156\n",
      "All        1026  3  1029\n",
      "\n",
      "Precision = 100.0 %\n",
      "\n",
      "Recall = 1.9230769230769231 %\n",
      "\n",
      "F1_Score = 3.773584905660378 %\n"
     ]
    }
   ],
   "source": [
    "#Confusion_Matrix/precision/F1_Score for Random Forest Model\n",
    "# the RF model predicts very different results after this step. Hence we had to try a lot of different parameters to get a workable demo\n",
    "Confusion_Matrix = pd.crosstab(y_train,rf_predictions, rownames=['Actual'], colnames=['Predicted'], margins=True)\n",
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))\n",
    "recall = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[0][1]))\n",
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))\n",
    "print(\"Confusion_Matrix/precision/F1_Score for Logistic Model\")\n",
    "print(\"\\n\",Confusion_Matrix)\n",
    "print(\"\\nPrecision =\",precision *100,\"%\")\n",
    "print(\"\\nRecall =\", recall*100,\"%\")\n",
    "print(\"\\nF1_Score =\",F1_Score *100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable Importance based on Random Forest**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age = 0.08730009892864417\n",
      "BusinessTravel = 0.013857455068307772\n",
      "DailyRate = 0.03208048851514695\n",
      "Department = 0.012171653309348818\n",
      "DistanceFromHome = 0.027215279739476555\n",
      "Education = 0.010198865173286529\n",
      "EducationField = 0.0028821063232459727\n",
      "EmployeeCount = 0.0\n",
      "EnvironmentSatisfaction = 0.02361899122413335\n",
      "Gender = 0.0007400158810740562\n",
      "HourlyRate = 0.024685175377624692\n",
      "JobInvolvement = 0.014473247613575052\n",
      "JobLevel = 0.016558101483794177\n",
      "JobRole = 0.03671020536261004\n",
      "JobSatisfaction = 0.039321259878882374\n",
      "MaritalStatus = 0.033355069315100246\n",
      "MonthlyIncome = 0.06918134146593866\n",
      "MonthlyRate = 0.04263897045950162\n",
      "NumCompaniesWorked = 0.011797709643419493\n",
      "Over18 = 0.0\n",
      "OverTime = 0.11652540774852634\n",
      "PercentSalaryHike = 0.009685767194760471\n",
      "PerformanceRating = 0.0\n",
      "RelationshipSatisfaction = 0.025680786538929613\n",
      "StandardHours = 0.0\n",
      "StockOptionLevel = 0.06395266304198635\n",
      "TotalWorkingYears = 0.08981263491845516\n",
      "TrainingTimesLastYear = 0.006617991432638935\n",
      "WorkLifeBalance = 0.0252128935502558\n",
      "YearsAtCompany = 0.06984295524939257\n",
      "YearsInCurrentRole = 0.028561734498992623\n",
      "YearsSinceLastPromotion = 0.019013236262688242\n",
      "YearsWithCurrManager = 0.04630789480026337\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name, importance in zip(features, rf_trained_model.feature_importances_):\n",
    "    print(name, \"=\", importance)\n",
    "importances = rf_trained_model.feature_importances_\n",
    "indices = np.argsort(importances)\n",
    "plt.title('Feature Importances')\n",
    "plt.barh(range(len(indices)), importances[indices], color='b', align='center')\n",
    "plt.yticks(range(len(indices)), features[indices])\n",
    "plt.xlabel('Relative Importance')\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 5\n",
    "fig_size[1] = 8\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train the gbm classifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "gbm_trained_model = gbm_classifier(x_train, y_train)\n",
    "gbm_pred = gbm_trained_model.predict(x_train)\n",
    "gbm_predictions = np.array([int(round(value)) for value in gbm_pred])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(gbm_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion_Matrix/precision/F1_Score for Random Forest Model\n",
      "\n",
      " Predicted    0   1   All\n",
      "Actual                  \n",
      "0          850   1   851\n",
      "1          121  57   178\n",
      "All        971  58  1029\n",
      "\n",
      "Precision = 98.27586206896551 %\n",
      "\n",
      "Recall = 11.797752808988763 %\n",
      "\n",
      "F1_Score = 21.06652587117212 %\n"
     ]
    }
   ],
   "source": [
    "#Confusion_Matrix/precision/F1_Score for gbm classifier Model\n",
    "Confusion_Matrix = pd.crosstab(y_train,gbm_predictions, rownames=['Actual'], colnames=['Predicted'], margins=True)\n",
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))\n",
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))\n",
    "print(\"Confusion_Matrix/precision/F1_Score for Random Forest Model\")\n",
    "print(\"\\n\",Confusion_Matrix)\n",
    "print(\"\\nPrecision =\",precision *100,\"%\")\n",
    "print(\"\\nRecall =\", recall*100,\"%\")\n",
    "print(\"\\nF1_Score =\",F1_Score *100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable Importance Using Gradient Boosting Forest**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age = 0.08756927319615346\n",
      "BusinessTravel = 0.007076048328270319\n",
      "DailyRate = 0.06873152486804517\n",
      "Department = 0.0\n",
      "DistanceFromHome = 0.07513696846712274\n",
      "Education = 0.0022799658791850972\n",
      "EducationField = 0.013642644417348374\n",
      "EmployeeCount = 0.0\n",
      "EnvironmentSatisfaction = 0.03675992338258533\n",
      "Gender = 0.0\n",
      "HourlyRate = 0.005185102848685963\n",
      "JobInvolvement = 0.030052805847447014\n",
      "JobLevel = 0.010859625478329615\n",
      "JobRole = 0.05748115135488365\n",
      "JobSatisfaction = 0.004581741459439756\n",
      "MaritalStatus = 0.007556579842894354\n",
      "MonthlyIncome = 0.12193597091818553\n",
      "MonthlyRate = 0.007120861819146626\n",
      "NumCompaniesWorked = 0.012939216612801277\n",
      "Over18 = 0.0\n",
      "OverTime = 0.13803331050812537\n",
      "PercentSalaryHike = 0.006557166055400218\n",
      "PerformanceRating = 0.0\n",
      "RelationshipSatisfaction = 0.019476160521121222\n",
      "StandardHours = 0.0\n",
      "StockOptionLevel = 0.0929998581751555\n",
      "TotalWorkingYears = 0.04761476034171274\n",
      "TrainingTimesLastYear = 0.0071792339168686705\n",
      "WorkLifeBalance = 0.03741100555820842\n",
      "YearsAtCompany = 0.046669549215545156\n",
      "YearsInCurrentRole = 0.020443092376283004\n",
      "YearsSinceLastPromotion = 0.0017777195561341876\n",
      "YearsWithCurrManager = 0.03292873905492138\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name, importance in zip(features, gbm_trained_model.feature_importances_):\n",
    "    print(name, \"=\", importance)\n",
    "importances = gbm_trained_model.feature_importances_\n",
    "indices = np.argsort(importances)\n",
    "plt.title('Feature Importances')\n",
    "plt.barh(range(len(indices)), importances[indices], color='b', align='center')\n",
    "plt.yticks(range(len(indices)), features[indices])\n",
    "plt.xlabel('Relative Importance')\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 5\n",
    "fig_size[1] = 8\n",
    "plt.rcParams[\"figure.figsize\"] = fig_size\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train the neural net classifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "nn_trained_model = nn_classifier(x_train, y_train)\n",
    "nn_predictions = nn_trained_model.predict(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion_Matrix/precision/F1_Score for Neural Net Model\n",
      "\n",
      " Predicted    0   1   All\n",
      "Actual                  \n",
      "0          863  10   873\n",
      "1          128  28   156\n",
      "All        991  38  1029\n",
      "\n",
      "Precision = 73.68421052631578 %\n",
      "\n",
      "Recall = 1.9230769230769231 %\n",
      "\n",
      "F1_Score = 3.748326639892905 %\n"
     ]
    }
   ],
   "source": [
    "#Confusion_Matrix/precision/F1_Score for gbm classifier Model\n",
    "Confusion_Matrix = pd.crosstab(y_train,nn_predictions, rownames=['Actual'], colnames=['Predicted'], margins=True)\n",
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))\n",
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))\n",
    "print(\"Confusion_Matrix/precision/F1_Score for Neural Net Model\")\n",
    "print(\"\\n\",Confusion_Matrix)\n",
    "print(\"\\nPrecision =\",precision *100,\"%\")\n",
    "print(\"\\nRecall =\", recall*100,\"%\")\n",
    "print(\"\\nF1_Score =\",F1_Score *100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train the SVM classifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\akshe\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "svm_trained_model = svm_classifier(x_train, y_train)\n",
    "svm_predictions = svm_trained_model.predict(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion_Matrix/precision/F1_Score for SVM Classifier Model\n",
      "\n",
      " Predicted    0    1   All\n",
      "Actual                   \n",
      "0          873    0   873\n",
      "1            0  156   156\n",
      "All        873  156  1029\n",
      "\n",
      "Precision = 100.0 %\n",
      "\n",
      "Recall = 1.9230769230769231 %\n",
      "\n",
      "F1_Score = 3.773584905660378 %\n"
     ]
    }
   ],
   "source": [
    "#Confusion_Matrix/precision/F1_Score for SVM classifier Model\n",
    "Confusion_Matrix = pd.crosstab(y_train,svm_predictions, rownames=['Actual'], colnames=['Predicted'], margins=True)\n",
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))\n",
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))\n",
    "print(\"Confusion_Matrix/precision/F1_Score for SVM Classifier Model\")\n",
    "print(\"\\n\",Confusion_Matrix)\n",
    "print(\"\\nPrecision =\",precision *100,\"%\")\n",
    "print(\"\\nRecall =\", recall*100,\"%\")\n",
    "print(\"\\nF1_Score =\",F1_Score *100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ensembling Method is a machine learning technique that combines several base models \n",
    "in order to produce one optimal predictive model.**\n",
    "**Bagging gets its name because it combines Bootstrapping and Aggregation to form one ensemble model.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data frame with predicted values\n",
    "log_predict = list(log_predictions)\n",
    "data_predict =  pd.DataFrame(log_predict)\n",
    "data_predict['log_pred'] = pd.Series(log_predict, index=data_predict.index)\n",
    "data_predict['rf_pred'] = pd.Series(list(rf_predictions), index=data_predict.index)\n",
    "data_predict['gbm_pred'] = pd.Series(list(gbm_predictions), index=data_predict.index)\n",
    "data_predict['nn_pred'] = pd.Series(list(nn_predictions), index=data_predict.index)\n",
    "data_predict['svm_pred'] = pd.Series(list(svm_predictions), index=data_predict.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Independent Variable\n",
    "X_train = data_predict "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train the Ensemble model\n",
    "ensemble_trained_model = rf_classifier(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Predictions on Test Data \n",
    "tst_log_predictions = log_trained_model.predict(x_test)\n",
    "tst_rf_predictions = rf_trained_model.predict(x_test)\n",
    "tgbm_pred = gbm_trained_model.predict(x_test)\n",
    "tst_gbm_predictions = [int(round(value)) for value in tgbm_pred]\n",
    "tst_nn_predictions = nn_trained_model.predict(x_test)\n",
    "tst_svm_predictions = svm_trained_model.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data frame with test predicted values\n",
    "log_predict = list(tst_log_predictions)\n",
    "testdata_predict =  pd.DataFrame(log_predict)\n",
    "testdata_predict['log_pred'] = pd.Series(log_predict, index=testdata_predict.index)\n",
    "testdata_predict['rf_pred'] = pd.Series(list(tst_rf_predictions), index=testdata_predict.index)\n",
    "testdata_predict['gbm_pred'] = pd.Series(list(tst_gbm_predictions), index=testdata_predict.index)\n",
    "testdata_predict['nn_pred'] = pd.Series(list(tst_nn_predictions), index=testdata_predict.index)\n",
    "testdata_predict['svm_pred'] = pd.Series(list(tst_svm_predictions), index=testdata_predict.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prediction on Test Predicted Values\n",
    "tst_ensemble_predictions = ensemble_trained_model.predict(testdata_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ensemble Model Test Accuracy  : 81.86%\n"
     ]
    }
   ],
   "source": [
    "Test_Ensemble_Model_Accuracy   = accuracy_score(y_test, tst_ensemble_predictions)\n",
    "print (\"Ensemble Model Test Accuracy  : %.2f%%\" %  (Test_Ensemble_Model_Accuracy * 100.0) ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Predictions on Main Data \n",
    "fn_log_predictions = log_trained_model.predict(x)\n",
    "fn_rf_predictions = rf_trained_model.predict(x)\n",
    "fgbm_pred = gbm_trained_model.predict(x)\n",
    "fn_gbm_predictions = [int(round(value)) for value in fgbm_pred]\n",
    "fn_nn_predictions = nn_trained_model.predict(x)\n",
    "fn_svm_predictions = svm_trained_model.predict(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data frame with final predicted values\n",
    "log_predict = list(fn_log_predictions)\n",
    "final_predict =  pd.DataFrame(log_predict)\n",
    "final_predict['log_pred'] = pd.Series(log_predict, index=final_predict.index)\n",
    "final_predict['rf_pred'] = pd.Series(list(fn_rf_predictions), index=final_predict.index)\n",
    "final_predict['gbm_pred'] = pd.Series(list(fn_gbm_predictions), index=final_predict.index)\n",
    "final_predict['nn_pred'] = pd.Series(list(fn_nn_predictions), index=final_predict.index)\n",
    "final_predict['svm_pred'] = pd.Series(list(fn_svm_predictions), index=final_predict.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prediction on Test Predicted Values\n",
    "final_ensemble_predictions = ensemble_trained_model.predict(final_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall Accuracy  : 94.56%\n"
     ]
    }
   ],
   "source": [
    "Accuracy   = accuracy_score(y, final_ensemble_predictions)\n",
    "print (\"Overall Accuracy  : %.2f%%\" %  (Accuracy * 100.0) ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "Confusion_Matrix = pd.crosstab(final_ensemble_predictions, y, rownames=['Actual'], colnames=['Predicted'], margins=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted     0    1   All\n",
      "Actual                    \n",
      "0          1233   80  1313\n",
      "1             0  157   157\n",
      "All        1233  237  1470\n"
     ]
    }
   ],
   "source": [
    "print(Confusion_Matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "precision = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[1][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "recall = float((Confusion_Matrix[1][1])/(Confusion_Matrix[1][1]+ Confusion_Matrix[0][1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1_Score = float((2 * (precision * recall) / (precision + recall)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1_Score: 79.69543147208121\n"
     ]
    }
   ],
   "source": [
    "print(\"F1_Score:\",F1_Score*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absl-py==0.9.0\n",
      "alabaster==0.7.12\n",
      "anaconda-client==1.7.2\n",
      "anaconda-navigator==1.9.7\n",
      "anaconda-project==0.8.3\n",
      "APScheduler==3.6.3\n",
      "asn1crypto==1.0.1\n",
      "astor==0.8.1\n",
      "astroid==2.3.1\n",
      "astropy==3.2.1\n",
      "atomicwrites==1.3.0\n",
      "attrs==19.2.0\n",
      "Babel==2.7.0\n",
      "backcall==0.1.0\n",
      "backports.functools-lru-cache==1.5\n",
      "backports.os==0.1.1\n",
      "backports.shutil-get-terminal-size==1.0.0\n",
      "backports.tempfile==1.0\n",
      "backports.weakref==1.0.post1\n",
      "beautifulsoup4==4.8.0\n",
      "bitarray==1.0.1\n",
      "bkcharts==0.2\n",
      "bleach==3.1.0\n",
      "blis==0.4.1\n",
      "bokeh==1.3.4\n",
      "boto==2.49.0\n",
      "Bottleneck==1.2.1\n",
      "cachetools==4.0.0\n",
      "Camelot==12.6.29\n",
      "camelot-py==0.7.3\n",
      "catalogue==1.0.0\n",
      "certifi==2019.9.11\n",
      "cffi==1.12.3\n",
      "chardet==3.0.4\n",
      "Click==7.0\n",
      "cloudpickle==1.2.2\n",
      "clyent==1.2.2\n",
      "colorama==0.4.1\n",
      "comtypes==1.1.7\n",
      "conda==4.8.2\n",
      "conda-build==3.18.9\n",
      "conda-package-handling==1.6.0\n",
      "conda-verify==3.4.2\n",
      "contextlib2==0.6.0\n",
      "cryptography==2.7\n",
      "cvlib==0.2.3\n",
      "cycler==0.10.0\n",
      "cymem==2.0.3\n",
      "Cython==0.29.13\n",
      "cytoolz==0.10.0\n",
      "dask==2.5.2\n",
      "decorator==4.4.0\n",
      "defusedxml==0.6.0\n",
      "distributed==2.5.2\n",
      "distro==1.4.0\n",
      "docopt==0.6.2\n",
      "docutils==0.15.2\n",
      "elasticsearch==7.5.1\n",
      "Elixir==0.7.1\n",
      "en-core-web-sm==2.2.5\n",
      "entrypoints==0.3\n",
      "et-xmlfile==1.0.1\n",
      "fastcache==1.1.0\n",
      "feedparser==5.2.1\n",
      "filelock==3.0.12\n",
      "Flask==1.1.1\n",
      "fsspec==0.5.2\n",
      "future==0.17.1\n",
      "fuzzywuzzy==0.17.0\n",
      "gast==0.2.2\n",
      "gevent==1.4.0\n",
      "glob2==0.7\n",
      "google==2.0.3\n",
      "google-auth==1.10.0\n",
      "google-auth-oauthlib==0.4.1\n",
      "google-pasta==0.1.8\n",
      "googletrans==2.4.0\n",
      "greenlet==0.4.15\n",
      "grpcio==1.26.0\n",
      "gTTS==2.1.1\n",
      "gTTS-token==1.1.3\n",
      "h5py==2.9.0\n",
      "HeapDict==1.0.1\n",
      "html5lib==1.0.1\n",
      "idna==2.8\n",
      "imageai==2.0.1\n",
      "imageio==2.6.0\n",
      "imagesize==1.1.0\n",
      "importlib-metadata==0.23\n",
      "imutils==0.5.3\n",
      "inflect==4.1.0\n",
      "ipykernel==5.1.2\n",
      "ipython==7.8.0\n",
      "ipython-genutils==0.2.0\n",
      "ipywidgets==7.5.1\n",
      "isort==4.3.21\n",
      "itsdangerous==1.1.0\n",
      "jdcal==1.4.1\n",
      "jedi==0.15.1\n",
      "Jinja2==2.10.3\n",
      "joblib==0.13.2\n",
      "Js2Py==0.67\n",
      "json5==0.8.5\n",
      "jsonschema==3.0.2\n",
      "jupyter==1.0.0\n",
      "jupyter-client==5.3.3\n",
      "jupyter-console==6.0.0\n",
      "jupyter-core==4.5.0\n",
      "jupyterlab==1.1.4\n",
      "jupyterlab-server==1.0.6\n",
      "Keras==2.3.1\n",
      "Keras-Applications==1.0.8\n",
      "Keras-Preprocessing==1.1.0\n",
      "keyring==18.0.0\n",
      "kiwisolver==1.1.0\n",
      "lazy-object-proxy==1.4.2\n",
      "libarchive-c==2.8\n",
      "llvmlite==0.29.0\n",
      "locket==0.2.0\n",
      "lxml==4.4.1\n",
      "Markdown==3.1.1\n",
      "MarkupSafe==1.1.1\n",
      "matplotlib==3.1.1\n",
      "mccabe==0.6.1\n",
      "menuinst==1.4.16\n",
      "mistune==0.8.4\n",
      "mkl-fft==1.0.14\n",
      "mkl-random==1.1.0\n",
      "mkl-service==2.3.0\n",
      "mock==3.0.5\n",
      "more-itertools==7.2.0\n",
      "mpmath==1.1.0\n",
      "msgpack==0.6.1\n",
      "multipledispatch==0.6.0\n",
      "murmurhash==1.0.0\n",
      "mysql-connector-python==8.0.19\n",
      "navigator-updater==0.2.1\n",
      "nbconvert==5.6.0\n",
      "nbformat==4.4.0\n",
      "networkx==2.3\n",
      "nltk==3.4.5\n",
      "nose==1.3.7\n",
      "notebook==6.0.1\n",
      "num2words==0.5.10\n",
      "numba==0.45.1\n",
      "numexpr==2.7.0\n",
      "numpy==1.16.5\n",
      "numpydoc==0.9.1\n",
      "oauthlib==3.1.0\n",
      "olefile==0.46\n",
      "opencv-python==4.1.2.30\n",
      "openpyxl==3.0.0\n",
      "opt-einsum==3.1.0\n",
      "packaging==19.2\n",
      "pandas==0.25.1\n",
      "pandocfilters==1.4.2\n",
      "parsedatetime==2.4\n",
      "parso==0.5.1\n",
      "partd==1.0.0\n",
      "path.py==12.0.1\n",
      "pathlib2==2.3.5\n",
      "patsy==0.5.1\n",
      "pbr==5.4.4\n",
      "pdf2image==1.12.1\n",
      "pdfminer.six==20200124\n",
      "pep8==1.7.1\n",
      "pickleshare==0.7.5\n",
      "Pillow==6.2.0\n",
      "pipwin==0.4.6\n",
      "pkginfo==1.5.0.1\n",
      "plac==0.9.6\n",
      "plotly==4.4.1\n",
      "pluggy==0.13.0\n",
      "ply==3.11\n",
      "preshed==3.0.2\n",
      "progressbar==2.5\n",
      "prometheus-client==0.7.1\n",
      "prompt-toolkit==2.0.10\n",
      "protobuf==3.11.2\n",
      "psutil==5.6.3\n",
      "py==1.8.0\n",
      "pyasn1==0.4.8\n",
      "pyasn1-modules==0.2.7\n",
      "PyAudio==0.2.11\n",
      "pycodestyle==2.5.0\n",
      "pycosat==0.6.3\n",
      "pycparser==2.19\n",
      "pycrypto==2.6.1\n",
      "pycryptodome==3.9.7\n",
      "pycurl==7.43.0.3\n",
      "pyflakes==2.1.1\n",
      "Pygments==2.4.2\n",
      "pyjsparser==2.7.1\n",
      "pylint==2.4.2\n",
      "pyodbc==4.0.27\n",
      "pyOpenSSL==19.0.0\n",
      "pyparsing==2.4.2\n",
      "PyPDF2==1.26.0\n",
      "PyPrind==2.11.2\n",
      "pyreadline==2.1\n",
      "pyrsistent==0.15.4\n",
      "PySocks==1.7.1\n",
      "pytesseract==0.3.2\n",
      "pytest==5.2.1\n",
      "pytest-arraydiff==0.3\n",
      "pytest-astropy==0.5.0\n",
      "pytest-doctestplus==0.4.0\n",
      "pytest-openfiles==0.4.0\n",
      "pytest-remotedata==0.3.2\n",
      "python-dateutil==2.8.0\n",
      "python-Levenshtein==0.12.0\n",
      "pytz==2019.3\n",
      "PyWavelets==1.0.3\n",
      "pywin32==223\n",
      "pywinpty==0.5.5\n",
      "PyYAML==5.1.2\n",
      "pyzmq==18.1.0\n",
      "QtAwesome==0.6.0\n",
      "qtconsole==4.5.5\n",
      "QtPy==1.9.0\n",
      "quantulum==0.1.13\n",
      "quantulum3==0.7.3\n",
      "requests==2.22.0\n",
      "requests-oauthlib==1.3.0\n",
      "retrying==1.3.3\n",
      "robobrowser==0.5.3\n",
      "rope==0.14.0\n",
      "rsa==4.0\n",
      "ruamel-yaml==0.15.46\n",
      "scikit-image==0.15.0\n",
      "scikit-learn==0.21.3\n",
      "scipy==1.3.1\n",
      "seaborn==0.9.0\n",
      "Send2Trash==1.5.0\n",
      "simplegeneric==0.8.1\n",
      "singledispatch==3.4.0.3\n",
      "six==1.12.0\n",
      "snowballstemmer==2.0.0\n",
      "sortedcollections==1.1.2\n",
      "sortedcontainers==2.1.0\n",
      "soupsieve==1.9.3\n",
      "spacy==2.2.3\n",
      "SpeechRecognition==3.8.1\n",
      "Sphinx==2.2.0\n",
      "sphinxcontrib-applehelp==1.0.1\n",
      "sphinxcontrib-devhelp==1.0.1\n",
      "sphinxcontrib-htmlhelp==1.0.2\n",
      "sphinxcontrib-jsmath==1.0.1\n",
      "sphinxcontrib-qthelp==1.0.2\n",
      "sphinxcontrib-serializinghtml==1.1.3\n",
      "sphinxcontrib-websupport==1.1.2\n",
      "spyder==3.3.6\n",
      "spyder-kernels==0.5.2\n",
      "SQLAlchemy==0.7.10\n",
      "sqlalchemy-migrate==0.13.0\n",
      "sqlparse==0.3.0\n",
      "srsly==1.0.0\n",
      "statsmodels==0.10.1\n",
      "stemming==1.0.1\n",
      "sympy==1.4\n",
      "tables==3.5.2\n",
      "tabula-py==2.0.4\n",
      "tblib==1.4.0\n",
      "Tempita==0.5.2\n",
      "tensorboard==1.14.0\n",
      "tensorflow==1.14.0\n",
      "tensorflow-estimator==1.14.0\n",
      "termcolor==1.1.0\n",
      "terminado==0.8.2\n",
      "tesseract==0.1.3\n",
      "testpath==0.4.2\n",
      "textblob==0.15.3\n",
      "thinc==7.3.0\n",
      "toolz==0.10.0\n",
      "tornado==6.0.3\n",
      "tqdm==4.36.1\n",
      "traitlets==4.3.3\n",
      "tweepy==3.8.0\n",
      "tzlocal==2.0.0\n",
      "unicodecsv==0.14.1\n",
      "urllib3==1.24.2\n",
      "wasabi==0.6.0\n",
      "wcwidth==0.1.7\n",
      "webencodings==0.5.1\n",
      "Werkzeug==0.16.0\n",
      "widgetsnbextension==3.5.1\n",
      "wikipedia==1.4.0\n",
      "win-inet-pton==1.1.0\n",
      "win-unicode-console==0.5\n",
      "wincertstore==0.2\n",
      "wrapt==1.11.2\n",
      "xlrd==0.7.1\n",
      "XlsxWriter==1.2.1\n",
      "xlwings==0.15.10\n",
      "xlwt==0.7.2\n",
      "zict==1.0.0\n",
      "zipp==0.6.0\n"
     ]
    }
   ],
   "source": [
    "!pip3 freeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}