Results_Boosting_Approach_4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data analysis packages:\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "#from datetime import datetime as dt\n",
    "\n",
    "# Visualization packages:\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "filename = 'df_imputed_scaled_OHE_reducedv1.pkl'\n",
    "df = pd.read_pickle(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing all the required ML packages\n",
    "from sklearn.linear_model import LogisticRegression #logistic regression\n",
    "from sklearn import svm #support vector Machine\n",
    "from sklearn.ensemble import RandomForestClassifier #Random Forest\n",
    "from sklearn.neighbors import KNeighborsClassifier #KNN\n",
    "from sklearn.naive_bayes import GaussianNB #Naive bayes\n",
    "from sklearn.tree import DecisionTreeClassifier #Decision Tree\n",
    "from sklearn.model_selection import train_test_split #training and testing data split\n",
    "from sklearn import metrics #accuracy measure\n",
    "from sklearn.metrics import confusion_matrix #for confusion matrix\n",
    "from sklearn.metrics import f1_score\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "\n",
    "\n",
    "X = df[df.columns[:-1]]\n",
    "y = pd.Series(df['heartdisease'])\n",
    "\n",
    "\n",
    "#train_X,test_X,train_y,test_y =train_test_split(X,y,test_size=0.2, random_state=45)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Building Models according to the best hyperparameters\n",
    "#found by RandomSearchCV\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "from sklearn.model_selection import KFold,StratifiedKFold #for K-fold cross validation\n",
    "import xgboost as xg\n",
    "from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier\n",
    "XGB_clf = xg.XGBClassifier(subsample = 0.7,\n",
    "                           reg_alpha =  10.0, \n",
    "                           learning_rate =0.1, \n",
    "                           gamma=0.2, \n",
    "                           colsample_bytree =  0.8 ,\n",
    "                           objective= 'binary:logistic',\n",
    "                           nthread=4, \n",
    "                           scale_pos_weight=1, \n",
    "                           seed=27, \n",
    "                           n_estimators = 80, \n",
    "                           max_depth = 3,\n",
    "                           min_child_weight = 3)\n",
    "model_Logistic_Regression = LogisticRegression(penalty= 'l2', C = 1, solver = 'lbfgs') \n",
    "model_Decision_Tree =DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
    "            max_features=None, max_leaf_nodes=10, min_samples_leaf=10,\n",
    "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
    "            presort=False, random_state=None, splitter='random')\n",
    "AdaBoost_DT_model = AdaBoostClassifier(base_estimator= model_Decision_Tree, n_estimators =  900, learning_rate = 0.001, random_state = 34)\n",
    "AdaBoost_Logistic_Regression_model = AdaBoostClassifier(base_estimator=model_Logistic_Regression,  n_estimators =  1000, learning_rate = 0.01, random_state = 38)\n",
    "grad_boosting_model = GradientBoostingClassifier(learning_rate=0.1, n_estimators=70,max_depth=5, min_samples_split=600, min_samples_leaf=40, subsample=0.75, random_state=10,max_features = 3)\n",
    "from sklearn.model_selection import KFold,StratifiedKFold #for K-fold cross validation\n",
    "from sklearn.model_selection import cross_val_score, cross_validate #score evaluation\n",
    "from sklearn.model_selection import cross_val_predict #prediction\n",
    "from sklearn.metrics import recall_score, f1_score, precision_score, accuracy_score\n",
    "from sklearn.metrics.scorer import make_scorer\n",
    "from IPython.display import display, HTML\n",
    "#importing all the required ML packages\n",
    "from sklearn.linear_model import LogisticRegression #logistic regression\n",
    "from sklearn import svm #support vector Machine\n",
    "from sklearn.ensemble import RandomForestClassifier #Random Forest\n",
    "from sklearn.neighbors import KNeighborsClassifier #KNN\n",
    "from sklearn.naive_bayes import GaussianNB #Naive bayes\n",
    "from sklearn.tree import DecisionTreeClassifier #Decision Tree\n",
    "from sklearn.model_selection import train_test_split #training and testing data split\n",
    "from sklearn import metrics #accuracy measure\n",
    "from sklearn.metrics import confusion_matrix #for confusion matrix\n",
    "from sklearn.metrics import f1_score\n",
    "scoring = {'precision': make_scorer(precision_score),\n",
    "           'recall': make_scorer(recall_score),\n",
    "           'F-score': make_scorer( f1_score),\n",
    "           'accuracy': make_scorer(accuracy_score)}\n",
    "\n",
    "\n",
    "#Building Models according to the best hyperparameters\n",
    "#found by RandomSearchCV\n",
    "\n",
    "model_Linear_SVM=svm.SVC(kernel='linear',C=0.1,gamma=1e-05, probability=True)\n",
    "\n",
    "model_RBF_SVM = svm.SVC(kernel='rbf',C=10,gamma=0.01, probability=True)\n",
    "model_Logistic_Regression = LogisticRegression(penalty= 'l2', C = 1, solver = 'lbfgs') \n",
    "\n",
    "\n",
    "model_Decision_Tree =DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
    "            max_features=None, max_leaf_nodes=10, min_samples_leaf=10,\n",
    "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
    "            presort=False, random_state=None, splitter='random')\n",
    "\n",
    "'''\n",
    "-- Best Parameters: DT_randomSEARCH\n",
    "parameters: max_depth            setting: 1\n",
    "parameters: min_samples_split    setting: 4\n",
    "parameters: max_leaf_nodes       setting: 8\n",
    "parameters: min_samples_leaf     setting: 13\n",
    "parameters: criterion            setting: gini\n",
    "'''\n",
    "\n",
    "    \n",
    "    \n",
    "model_RandomForest = RandomForestClassifier(n_estimators= 600,\n",
    "               max_features= 'sqrt',\n",
    "               max_depth= 30,\n",
    "               min_samples_split= 2,\n",
    "               min_samples_leaf= 4,\n",
    "               bootstrap= True)\n",
    "\n",
    "model_KNN = KNeighborsClassifier(n_neighbors=22)\n",
    "\n",
    "\n",
    "voting_clf=VotingClassifier(estimators=[('KNN',model_KNN),\n",
    "                                              ('RBF',model_RBF_SVM),\n",
    "                                              ('RFor',model_RandomForest),\n",
    "                                              ('LR',model_Logistic_Regression),\n",
    "                                              ('DT',model_Decision_Tree),\n",
    "                                              ('svm',model_Linear_SVM)\n",
    "                                             ],voting='soft')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paso1\n",
      "paso2\n",
      "paso3\n",
      "paso4\n",
      "Model: AdaBoostClassifier(algorithm='SAMME.R',\n",
      "          base_estimator=DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
      "            max_features=None, max_leaf_nodes=10,\n",
      "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "            min_samples_leaf=10, min_samples_split=2,\n",
      "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
      "            splitter='random'),\n",
      "          learning_rate=0.001, n_estimators=900, random_state=34)\n",
      "paso3\n",
      "paso4\n",
      "Model: AdaBoostClassifier(algorithm='SAMME.R',\n",
      "          base_estimator=LogisticRegression(C=1, class_weight=None, dual=False, fit_intercept=True,\n",
      "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
      "          penalty='l2', random_state=None, solver='lbfgs', tol=0.0001,\n",
      "          verbose=0, warm_start=False),\n",
      "          learning_rate=0.01, n_estimators=1000, random_state=38)\n",
      "paso3\n",
      "paso4\n",
      "Model: GradientBoostingClassifier(criterion='friedman_mse', init=None,\n",
      "              learning_rate=0.1, loss='deviance', max_depth=5,\n",
      "              max_features=3, max_leaf_nodes=None,\n",
      "              min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "              min_samples_leaf=40, min_samples_split=600,\n",
      "              min_weight_fraction_leaf=0.0, n_estimators=70,\n",
      "              presort='auto', random_state=10, subsample=0.75, verbose=0,\n",
      "              warm_start=False)\n",
      "paso3\n",
      "paso4\n",
      "Model: XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
      "       colsample_bytree=0.8, gamma=0.2, learning_rate=0.1,\n",
      "       max_delta_step=0, max_depth=3, min_child_weight=3, missing=None,\n",
      "       n_estimators=80, n_jobs=1, nthread=4, objective='binary:logistic',\n",
      "       random_state=0, reg_alpha=10.0, reg_lambda=1, scale_pos_weight=1,\n",
      "       seed=27, silent=True, subsample=0.7)\n",
      "paso3\n",
      "paso4\n",
      "Model: VotingClassifier(estimators=[('KNN', KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_jobs=1, n_neighbors=22, p=2,\n",
      "           weights='uniform')), ('RBF', SVC(C=10, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma=...',\n",
      "  max_iter=-1, probability=True, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False))],\n",
      "         flatten_transform=None, n_jobs=1, voting='soft', weights=None)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Test_accuracy</th>\n",
       "      <th>Test_accuracy_std</th>\n",
       "      <th>Train_accuracy</th>\n",
       "      <th>Train_accuracy_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost - DT</th>\n",
       "      <td>0.781468</td>\n",
       "      <td>0.048331</td>\n",
       "      <td>0.801690</td>\n",
       "      <td>0.008362</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost - LR</th>\n",
       "      <td>0.792302</td>\n",
       "      <td>0.051406</td>\n",
       "      <td>0.803984</td>\n",
       "      <td>0.006085</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Tree Boosting</th>\n",
       "      <td>0.792290</td>\n",
       "      <td>0.064569</td>\n",
       "      <td>0.812317</td>\n",
       "      <td>0.009334</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.795516</td>\n",
       "      <td>0.062917</td>\n",
       "      <td>0.827898</td>\n",
       "      <td>0.006431</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Voting \\n Classifier</th>\n",
       "      <td>0.792290</td>\n",
       "      <td>0.057977</td>\n",
       "      <td>0.827655</td>\n",
       "      <td>0.007178</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Test_accuracy  Test_accuracy_std  Train_accuracy  \\\n",
       "AdaBoost - DT                0.781468           0.048331        0.801690   \n",
       "AdaBoost - LR                0.792302           0.051406        0.803984   \n",
       "Gradient Tree Boosting       0.792290           0.064569        0.812317   \n",
       "XGBoost                      0.795516           0.062917        0.827898   \n",
       "Voting \\n Classifier         0.792290           0.057977        0.827655   \n",
       "\n",
       "                        Train_accuracy_std  \n",
       "AdaBoost - DT                     0.008362  \n",
       "AdaBoost - LR                     0.006085  \n",
       "Gradient Tree Boosting            0.009334  \n",
       "XGBoost                           0.006431  \n",
       "Voting \\n Classifier              0.007178  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_F_score</th>\n",
       "      <th>Test_F_score_std</th>\n",
       "      <th>Train_F_score</th>\n",
       "      <th>Train_F_score_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost - DT</th>\n",
       "      <td>0.804607</td>\n",
       "      <td>0.038315</td>\n",
       "      <td>0.823456</td>\n",
       "      <td>0.008499</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost - LR</th>\n",
       "      <td>0.813710</td>\n",
       "      <td>0.042367</td>\n",
       "      <td>0.823997</td>\n",
       "      <td>0.005087</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Tree Boosting</th>\n",
       "      <td>0.818352</td>\n",
       "      <td>0.049432</td>\n",
       "      <td>0.835145</td>\n",
       "      <td>0.007957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.820520</td>\n",
       "      <td>0.047810</td>\n",
       "      <td>0.848689</td>\n",
       "      <td>0.006112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Voting \\n Classifier</th>\n",
       "      <td>0.819672</td>\n",
       "      <td>0.041219</td>\n",
       "      <td>0.849454</td>\n",
       "      <td>0.006288</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Test_F_score  Test_F_score_std  Train_F_score  \\\n",
       "AdaBoost - DT               0.804607          0.038315       0.823456   \n",
       "AdaBoost - LR               0.813710          0.042367       0.823997   \n",
       "Gradient Tree Boosting      0.818352          0.049432       0.835145   \n",
       "XGBoost                     0.820520          0.047810       0.848689   \n",
       "Voting \\n Classifier        0.819672          0.041219       0.849454   \n",
       "\n",
       "                        Train_F_score_std  \n",
       "AdaBoost - DT                    0.008499  \n",
       "AdaBoost - LR                    0.005087  \n",
       "Gradient Tree Boosting           0.007957  \n",
       "XGBoost                          0.006112  \n",
       "Voting \\n Classifier             0.006288  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_precision</th>\n",
       "      <th>Test_precision_std</th>\n",
       "      <th>Train_precision</th>\n",
       "      <th>Train_precision_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost - DT</th>\n",
       "      <td>0.802777</td>\n",
       "      <td>0.059967</td>\n",
       "      <td>0.811298</td>\n",
       "      <td>0.009500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost - LR</th>\n",
       "      <td>0.819200</td>\n",
       "      <td>0.074648</td>\n",
       "      <td>0.818818</td>\n",
       "      <td>0.007984</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Tree Boosting</th>\n",
       "      <td>0.806656</td>\n",
       "      <td>0.079782</td>\n",
       "      <td>0.812494</td>\n",
       "      <td>0.010767</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.811740</td>\n",
       "      <td>0.078738</td>\n",
       "      <td>0.826205</td>\n",
       "      <td>0.006031</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Voting \\n Classifier</th>\n",
       "      <td>0.803674</td>\n",
       "      <td>0.077880</td>\n",
       "      <td>0.821982</td>\n",
       "      <td>0.006643</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Test_precision  Test_precision_std  Train_precision  \\\n",
       "AdaBoost - DT                 0.802777            0.059967         0.811298   \n",
       "AdaBoost - LR                 0.819200            0.074648         0.818818   \n",
       "Gradient Tree Boosting        0.806656            0.079782         0.812494   \n",
       "XGBoost                       0.811740            0.078738         0.826205   \n",
       "Voting \\n Classifier          0.803674            0.077880         0.821982   \n",
       "\n",
       "                        Train_precision_std  \n",
       "AdaBoost - DT                      0.009500  \n",
       "AdaBoost - LR                      0.007984  \n",
       "Gradient Tree Boosting             0.010767  \n",
       "XGBoost                            0.006031  \n",
       "Voting \\n Classifier               0.006643  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_Sensitivity</th>\n",
       "      <th>Test_Sensitivity_std</th>\n",
       "      <th>Train_Sensitivity</th>\n",
       "      <th>Train_Sensitivity_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost - DT</th>\n",
       "      <td>0.809529</td>\n",
       "      <td>0.039878</td>\n",
       "      <td>0.836278</td>\n",
       "      <td>0.017158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost - LR</th>\n",
       "      <td>0.821490</td>\n",
       "      <td>0.091199</td>\n",
       "      <td>0.829295</td>\n",
       "      <td>0.005596</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Tree Boosting</th>\n",
       "      <td>0.839098</td>\n",
       "      <td>0.068762</td>\n",
       "      <td>0.859200</td>\n",
       "      <td>0.009590</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.839098</td>\n",
       "      <td>0.072038</td>\n",
       "      <td>0.872517</td>\n",
       "      <td>0.010702</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Voting \\n Classifier</th>\n",
       "      <td>0.844980</td>\n",
       "      <td>0.058270</td>\n",
       "      <td>0.878845</td>\n",
       "      <td>0.007099</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Test_Sensitivity  Test_Sensitivity_std  \\\n",
       "AdaBoost - DT                   0.809529              0.039878   \n",
       "AdaBoost - LR                   0.821490              0.091199   \n",
       "Gradient Tree Boosting          0.839098              0.068762   \n",
       "XGBoost                         0.839098              0.072038   \n",
       "Voting \\n Classifier            0.844980              0.058270   \n",
       "\n",
       "                        Train_Sensitivity  Train_Sensitivity_std  \n",
       "AdaBoost - DT                    0.836278               0.017158  \n",
       "AdaBoost - LR                    0.829295               0.005596  \n",
       "Gradient Tree Boosting           0.859200               0.009590  \n",
       "XGBoost                          0.872517               0.010702  \n",
       "Voting \\n Classifier             0.878845               0.007099  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Fit_time</th>\n",
       "      <th>Scoring Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AdaBoost - DT</th>\n",
       "      <td>1.535792</td>\n",
       "      <td>0.310508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost - LR</th>\n",
       "      <td>3.839715</td>\n",
       "      <td>0.330011</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Tree Boosting</th>\n",
       "      <td>0.042498</td>\n",
       "      <td>0.003312</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>XGBoost</th>\n",
       "      <td>0.028786</td>\n",
       "      <td>0.005347</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Voting \\n Classifier</th>\n",
       "      <td>1.187977</td>\n",
       "      <td>0.194576</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        Fit_time  Scoring Time\n",
       "AdaBoost - DT           1.535792      0.310508\n",
       "AdaBoost - LR           3.839715      0.330011\n",
       "Gradient Tree Boosting  0.042498      0.003312\n",
       "XGBoost                 0.028786      0.005347\n",
       "Voting \\n Classifier    1.187977      0.194576"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold,StratifiedKFold #for K-fold cross validation\n",
    "from sklearn.model_selection import cross_val_score, cross_validate #score evaluation\n",
    "from sklearn.model_selection import cross_val_predict #prediction\n",
    "from sklearn.metrics import recall_score, f1_score, precision_score, accuracy_score\n",
    "from sklearn.metrics.scorer import make_scorer\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "scoring = {'precision': make_scorer(precision_score),\n",
    "           'recall': make_scorer(recall_score),\n",
    "           'F-score': make_scorer( f1_score),\n",
    "           'accuracy': make_scorer(accuracy_score)}\n",
    "print('paso1')\n",
    "kfold = StratifiedKFold(n_splits=10, random_state=1) # k=10, split the data into 10 equal parts\n",
    "xyz=[]\n",
    "accuracy=[]\n",
    "std=[]\n",
    "classifiers=['AdaBoost - DT','AdaBoost - LR','Gradient Tree Boosting','XGBoost', 'Voting \\n Classifier']\n",
    "models=[AdaBoost_DT_model, AdaBoost_Logistic_Regression_model, grad_boosting_model, XGB_clf, voting_clf]\n",
    "\n",
    "fit_time = []\n",
    "score_time = []\n",
    "\n",
    "test_accuracy = []\n",
    "test_accuracy_total = []\n",
    "\n",
    "test_accuracy_std = []\n",
    "train_accuracy = []\n",
    "train_accuracy_total = []\n",
    "train_accuracy_std = []\n",
    "\n",
    "\n",
    "test_F_score = []\n",
    "test_F_score_total = []\n",
    "\n",
    "\n",
    "test_F_score_std = []\n",
    "train_F_score = []\n",
    "train_F_score_total = []\n",
    "\n",
    "train_F_score_std = []\n",
    "\n",
    "\n",
    "test_precision = []\n",
    "test_precision_std = []\n",
    "train_precision = []\n",
    "train_precision_std = []\n",
    "\n",
    "\n",
    "test_recall = []\n",
    "test_recall_std = []\n",
    "train_recall = []\n",
    "train_recall_std = []\n",
    "\n",
    "\n",
    "\n",
    "print('paso2')\n",
    "\n",
    "\n",
    "for i in models:\n",
    "    model = i\n",
    "    print('paso3')\n",
    "    scores = cross_validate(model,X,y, cv = kfold, scoring = scoring, return_train_score=True)\n",
    "    print('paso4')\n",
    "    fit_time.append(scores['fit_time'].mean())\n",
    "    score_time.append(scores['score_time'].mean())\n",
    "    \n",
    "    test_accuracy.append(scores['test_accuracy'].mean())\n",
    "    test_accuracy_total.append(scores['test_accuracy'])\n",
    "    \n",
    "    test_accuracy_std.append(scores['test_accuracy'].std())\n",
    "    train_accuracy.append(scores['train_accuracy'].mean())\n",
    "    train_accuracy_total.append(scores['train_accuracy'])\n",
    "                          \n",
    "    train_accuracy_std.append(scores['train_accuracy'].std())\n",
    "    \n",
    "    test_F_score.append(scores['test_F-score'].mean())\n",
    "    test_F_score_total.append(scores['test_F-score'])\n",
    "    \n",
    "    test_F_score_std.append(scores['test_F-score'].std())\n",
    "    train_F_score.append(scores['train_F-score'].mean())\n",
    "    train_F_score_total.append(scores['train_F-score'])\n",
    "                         \n",
    "                         \n",
    "    train_F_score_std.append(scores['train_F-score'].std())\n",
    "    \n",
    "    test_precision.append(scores['test_precision'].mean())\n",
    "    test_precision_std.append(scores['test_precision'].std())\n",
    "    train_precision.append(scores['train_precision'].mean())\n",
    "    train_precision_std.append(scores['train_precision'].std())\n",
    "    \n",
    "    test_recall.append(scores['test_recall'].mean())\n",
    "    test_recall_std.append(scores['test_recall'].std())\n",
    "    train_recall.append(scores['train_recall'].mean())\n",
    "    train_recall_std.append(scores['train_recall'].std())\n",
    "    \n",
    "\n",
    "    print('Model: ' + str(i))\n",
    "\n",
    "sorted(scores.keys())     \n",
    "dct_acc = {'Test_accuracy':test_accuracy,\n",
    "               'Test_accuracy_std':test_accuracy_std,\n",
    "               'Train_accuracy':train_accuracy,\n",
    "               'Train_accuracy_std':train_accuracy_std, }\n",
    "dct_Fscore = {'Test_F_score':test_F_score,\n",
    "               'Test_F_score_std':test_F_score_std,\n",
    "               'Train_F_score': train_F_score,\n",
    "               'Train_F_score_std': train_F_score_std}\n",
    "dct_precision = {'Test_precision': test_precision,\n",
    "               'Test_precision_std': test_precision_std,\n",
    "               'Train_precision': train_precision,\n",
    "               'Train_precision_std': train_precision_std}\n",
    "dct_recall = {'Test_Sensitivity': test_recall, \n",
    "               'Test_Sensitivity_std': test_recall_std,\n",
    "               'Train_Sensitivity': train_recall,\n",
    "               'Train_Sensitivity_std': train_recall_std}\n",
    "dct_time = {'Fit_time': fit_time, 'Scoring Time':score_time}\n",
    "\n",
    "metrics_acc=pd.DataFrame(dct_acc,index=classifiers)       \n",
    "metrics_Fsc = pd.DataFrame(dct_Fscore,index=classifiers)\n",
    "metrics_precision = pd.DataFrame(dct_precision,index=classifiers) \n",
    "metrics_recall = pd.DataFrame(dct_recall,index=classifiers)\n",
    "metrics_time = pd.DataFrame(dct_time,index=classifiers)\n",
    "           \n",
    "display(metrics_acc)\n",
    "display(metrics_Fsc)\n",
    "display(metrics_precision)\n",
    "display(metrics_recall)\n",
    "display(metrics_time)\n",
    "\n",
    "\n",
    "\n",
    "#new_models_dataframe2=pd.DataFrame({'CV Mean':xyz,'Std':std},index=classifiers)       \n",
    "#new_models_dataframe2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paso1\n",
      "paso2\n",
      "paso3\n",
      "paso4\n",
      "Model: VotingClassifier(estimators=[('KNN', KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_jobs=1, n_neighbors=22, p=2,\n",
      "           weights='uniform')), ('RBF', SVC(C=10, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma=...',\n",
      "  max_iter=-1, probability=True, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False))],\n",
      "         flatten_transform=None, n_jobs=1, voting='soft', weights=None)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Test_accuracy</th>\n",
       "      <th>Test_accuracy_std</th>\n",
       "      <th>Train_accuracy</th>\n",
       "      <th>Train_accuracy_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Voting Classifier</th>\n",
       "      <td>0.797737</td>\n",
       "      <td>0.055094</td>\n",
       "      <td>0.827657</td>\n",
       "      <td>0.005575</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Test_accuracy  Test_accuracy_std  Train_accuracy  \\\n",
       "Voting Classifier       0.797737           0.055094        0.827657   \n",
       "\n",
       "                   Train_accuracy_std  \n",
       "Voting Classifier            0.005575  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_F_score</th>\n",
       "      <th>Test_F_score_std</th>\n",
       "      <th>Train_F_score</th>\n",
       "      <th>Train_F_score_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Voting Classifier</th>\n",
       "      <td>0.82342</td>\n",
       "      <td>0.041815</td>\n",
       "      <td>0.849039</td>\n",
       "      <td>0.00495</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Test_F_score  Test_F_score_std  Train_F_score  \\\n",
       "Voting Classifier       0.82342          0.041815       0.849039   \n",
       "\n",
       "                   Train_F_score_std  \n",
       "Voting Classifier            0.00495  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_precision</th>\n",
       "      <th>Test_precision_std</th>\n",
       "      <th>Train_precision</th>\n",
       "      <th>Train_precision_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Voting Classifier</th>\n",
       "      <td>0.808259</td>\n",
       "      <td>0.073056</td>\n",
       "      <td>0.823704</td>\n",
       "      <td>0.005443</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Test_precision  Test_precision_std  Train_precision  \\\n",
       "Voting Classifier        0.808259            0.073056         0.823704   \n",
       "\n",
       "                   Train_precision_std  \n",
       "Voting Classifier             0.005443  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Test_Sensitivity</th>\n",
       "      <th>Test_Sensitivity_std</th>\n",
       "      <th>Train_Sensitivity</th>\n",
       "      <th>Train_Sensitivity_std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Voting Classifier</th>\n",
       "      <td>0.846941</td>\n",
       "      <td>0.062323</td>\n",
       "      <td>0.876009</td>\n",
       "      <td>0.00647</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Test_Sensitivity  Test_Sensitivity_std  Train_Sensitivity  \\\n",
       "Voting Classifier          0.846941              0.062323           0.876009   \n",
       "\n",
       "                   Train_Sensitivity_std  \n",
       "Voting Classifier                0.00647  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>Fit_time</th>\n",
       "      <th>Scoring Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Voting Classifier</th>\n",
       "      <td>1.136681</td>\n",
       "      <td>0.187983</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Fit_time  Scoring Time\n",
       "Voting Classifier  1.136681      0.187983"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold,StratifiedKFold #for K-fold cross validation\n",
    "from sklearn.model_selection import cross_val_score, cross_validate #score evaluation\n",
    "from sklearn.model_selection import cross_val_predict #prediction\n",
    "from sklearn.metrics import recall_score, f1_score, precision_score, accuracy_score\n",
    "from sklearn.metrics.scorer import make_scorer\n",
    "from IPython.display import display, HTML\n",
    "#importing all the required ML packages\n",
    "from sklearn.linear_model import LogisticRegression #logistic regression\n",
    "from sklearn import svm #support vector Machine\n",
    "from sklearn.ensemble import RandomForestClassifier #Random Forest\n",
    "from sklearn.neighbors import KNeighborsClassifier #KNN\n",
    "from sklearn.naive_bayes import GaussianNB #Naive bayes\n",
    "from sklearn.tree import DecisionTreeClassifier #Decision Tree\n",
    "from sklearn.model_selection import train_test_split #training and testing data split\n",
    "from sklearn import metrics #accuracy measure\n",
    "from sklearn.metrics import confusion_matrix #for confusion matrix\n",
    "from sklearn.metrics import f1_score\n",
    "scoring = {'precision': make_scorer(precision_score),\n",
    "           'recall': make_scorer(recall_score),\n",
    "           'F-score': make_scorer( f1_score),\n",
    "           'accuracy': make_scorer(accuracy_score)}\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "\n",
    "#Building Models according to the best hyperparameters\n",
    "#found by RandomSearchCV\n",
    "\n",
    "model_Linear_SVM=svm.SVC(kernel='linear',C=0.1,gamma=1e-05, probability=True)\n",
    "\n",
    "model_RBF_SVM = svm.SVC(kernel='rbf',C=10,gamma=0.01, probability=True)\n",
    "model_Logistic_Regression = LogisticRegression(penalty= 'l2', C = 1, solver = 'lbfgs') \n",
    "\n",
    "\n",
    "model_Decision_Tree =DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=2,\n",
    "            max_features=None, max_leaf_nodes=10, min_samples_leaf=10,\n",
    "            min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
    "            presort=False, random_state=None, splitter='random')\n",
    "\n",
    "'''\n",
    "-- Best Parameters: DT_randomSEARCH\n",
    "parameters: max_depth            setting: 1\n",
    "parameters: min_samples_split    setting: 4\n",
    "parameters: max_leaf_nodes       setting: 8\n",
    "parameters: min_samples_leaf     setting: 13\n",
    "parameters: criterion            setting: gini\n",
    "'''\n",
    "\n",
    "    \n",
    "    \n",
    "model_RandomForest = RandomForestClassifier(n_estimators= 600,\n",
    "               max_features= 'sqrt',\n",
    "               max_depth= 30,\n",
    "               min_samples_split= 2,\n",
    "               min_samples_leaf= 4,\n",
    "               bootstrap= True)\n",
    "\n",
    "model_KNN = KNeighborsClassifier(n_neighbors=22)\n",
    "\n",
    "kfold = StratifiedKFold(n_splits=10, random_state=1)\n",
    "voting_clf=VotingClassifier(estimators=[('KNN',model_KNN),\n",
    "                                              ('RBF',model_RBF_SVM),\n",
    "                                              ('RFor',model_RandomForest),\n",
    "                                              ('LR',model_Logistic_Regression),\n",
    "                                              ('DT',model_Decision_Tree),\n",
    "                                              ('svm',model_Linear_SVM)\n",
    "                                             ],voting='soft')\n",
    "\n",
    "\n",
    "print('paso1')\n",
    "kfold = StratifiedKFold(n_splits=10, random_state=1) # k=10, split the data into 10 equal parts\n",
    "xyz=[]\n",
    "accuracy=[]\n",
    "std=[]\n",
    "classifiers=['Voting Classifier']\n",
    "models=[voting_clf]\n",
    "\n",
    "fit_time = []\n",
    "score_time = []\n",
    "\n",
    "test_accuracy = []\n",
    "test_accuracy_total = []\n",
    "\n",
    "test_accuracy_std = []\n",
    "train_accuracy = []\n",
    "train_accuracy_total = []\n",
    "train_accuracy_std = []\n",
    "\n",
    "\n",
    "test_F_score = []\n",
    "test_F_score_total = []\n",
    "\n",
    "\n",
    "test_F_score_std = []\n",
    "train_F_score = []\n",
    "train_F_score_total = []\n",
    "\n",
    "train_F_score_std = []\n",
    "\n",
    "\n",
    "test_precision = []\n",
    "test_precision_std = []\n",
    "train_precision = []\n",
    "train_precision_std = []\n",
    "\n",
    "\n",
    "test_recall = []\n",
    "test_recall_std = []\n",
    "train_recall = []\n",
    "train_recall_std = []\n",
    "\n",
    "\n",
    "\n",
    "print('paso2')\n",
    "\n",
    "\n",
    "for i in models:\n",
    "    model = i\n",
    "    print('paso3')\n",
    "    scores = cross_validate(model,X,y, cv = kfold, scoring = scoring, return_train_score=True)\n",
    "    print('paso4')\n",
    "    fit_time.append(scores['fit_time'].mean())\n",
    "    score_time.append(scores['score_time'].mean())\n",
    "    \n",
    "    test_accuracy.append(scores['test_accuracy'].mean())\n",
    "    test_accuracy_total.append(scores['test_accuracy'])\n",
    "    \n",
    "    test_accuracy_std.append(scores['test_accuracy'].std())\n",
    "    train_accuracy.append(scores['train_accuracy'].mean())\n",
    "    train_accuracy_total.append(scores['train_accuracy'])\n",
    "                          \n",
    "    train_accuracy_std.append(scores['train_accuracy'].std())\n",
    "    \n",
    "    test_F_score.append(scores['test_F-score'].mean())\n",
    "    test_F_score_total.append(scores['test_F-score'])\n",
    "    \n",
    "    test_F_score_std.append(scores['test_F-score'].std())\n",
    "    train_F_score.append(scores['train_F-score'].mean())\n",
    "    train_F_score_total.append(scores['train_F-score'])\n",
    "                         \n",
    "                         \n",
    "    train_F_score_std.append(scores['train_F-score'].std())\n",
    "    \n",
    "    test_precision.append(scores['test_precision'].mean())\n",
    "    test_precision_std.append(scores['test_precision'].std())\n",
    "    train_precision.append(scores['train_precision'].mean())\n",
    "    train_precision_std.append(scores['train_precision'].std())\n",
    "    \n",
    "    test_recall.append(scores['test_recall'].mean())\n",
    "    test_recall_std.append(scores['test_recall'].std())\n",
    "    train_recall.append(scores['train_recall'].mean())\n",
    "    train_recall_std.append(scores['train_recall'].std())\n",
    "    \n",
    "\n",
    "    print('Model: ' + str(i))\n",
    "\n",
    "sorted(scores.keys())     \n",
    "dct_acc = {'Test_accuracy':test_accuracy,\n",
    "               'Test_accuracy_std':test_accuracy_std,\n",
    "               'Train_accuracy':train_accuracy,\n",
    "               'Train_accuracy_std':train_accuracy_std, }\n",
    "dct_Fscore = {'Test_F_score':test_F_score,\n",
    "               'Test_F_score_std':test_F_score_std,\n",
    "               'Train_F_score': train_F_score,\n",
    "               'Train_F_score_std': train_F_score_std}\n",
    "dct_precision = {'Test_precision': test_precision,\n",
    "               'Test_precision_std': test_precision_std,\n",
    "               'Train_precision': train_precision,\n",
    "               'Train_precision_std': train_precision_std}\n",
    "dct_recall = {'Test_Sensitivity': test_recall, \n",
    "               'Test_Sensitivity_std': test_recall_std,\n",
    "               'Train_Sensitivity': train_recall,\n",
    "               'Train_Sensitivity_std': train_recall_std}\n",
    "dct_time = {'Fit_time': fit_time, 'Scoring Time':score_time}\n",
    "\n",
    "metrics_acc=pd.DataFrame(dct_acc,index=classifiers)       \n",
    "metrics_Fsc = pd.DataFrame(dct_Fscore,index=classifiers)\n",
    "metrics_precision = pd.DataFrame(dct_precision,index=classifiers) \n",
    "metrics_recall = pd.DataFrame(dct_recall,index=classifiers)\n",
    "metrics_time = pd.DataFrame(dct_time,index=classifiers)\n",
    "           \n",
    "display(metrics_acc)\n",
    "display(metrics_Fsc)\n",
    "display(metrics_precision)\n",
    "display(metrics_recall)\n",
    "display(metrics_time)\n",
    "\n",
    "\n",
    "\n",
    "#new_models_dataframe2=pd.DataFrame({'CV Mean':xyz,'Std':std},index=classifiers)       \n",
    "#new_models_dataframe2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcf2770a208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcf28f43cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "classifiers=['AdaBoost - DT','AdaBoost - LR','Gradient \\n Tree Boosting','XGBoost', 'Voting \\n Classifier']\n",
    "plt.figure(figsize=(12,6))\n",
    "box_test_F_score=pd.DataFrame(test_F_score_total,index=[classifiers][0])\n",
    "box_test_F_score.T.boxplot(fontsize=14)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(12,6))\n",
    "plt.title('TRAIN F-SCORE', fontsize=14)\n",
    "box_train_F_score=pd.DataFrame(train_F_score_total,index=[classifiers][0])\n",
    "box_train_F_score.T.boxplot(fontsize=14)\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Fold 1/10]\n",
      "[Fold 2/10]\n",
      "[Fold 3/10]\n",
      "[Fold 4/10]\n",
      "[Fold 5/10]\n",
      "[Fold 6/10]\n",
      "[Fold 7/10]\n",
      "[Fold 8/10]\n",
      "[Fold 9/10]\n",
      "[Fold 10/10]\n",
      "[Fold 1/10]\n",
      "[Fold 2/10]\n",
      "[Fold 3/10]\n",
      "[Fold 4/10]\n",
      "[Fold 5/10]\n",
      "[Fold 6/10]\n",
      "[Fold 7/10]\n",
      "[Fold 8/10]\n",
      "[Fold 9/10]\n",
      "[Fold 10/10]\n",
      "[Fold 1/10]\n",
      "[Fold 2/10]\n",
      "[Fold 3/10]\n",
      "[Fold 4/10]\n",
      "[Fold 5/10]\n",
      "[Fold 6/10]\n",
      "[Fold 7/10]\n",
      "[Fold 8/10]\n",
      "[Fold 9/10]\n",
      "[Fold 10/10]\n",
      "[Fold 1/10]\n",
      "[Fold 2/10]\n",
      "[Fold 3/10]\n",
      "[Fold 4/10]\n",
      "[Fold 5/10]\n",
      "[Fold 6/10]\n",
      "[Fold 7/10]\n",
      "[Fold 8/10]\n",
      "[Fold 9/10]\n",
      "[Fold 10/10]\n",
      "[Fold 1/10]\n",
      "[Fold 2/10]\n",
      "[Fold 3/10]\n",
      "[Fold 4/10]\n",
      "[Fold 5/10]\n",
      "[Fold 6/10]\n",
      "[Fold 7/10]\n",
      "[Fold 8/10]\n",
      "[Fold 9/10]\n",
      "[Fold 10/10]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7e5cf95a58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>AUC Mean</th>\n",
       "      <th>std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>rbf-SVM</th>\n",
       "      <td>0.876178</td>\n",
       "      <td>0.058087</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Linear-SVM</th>\n",
       "      <td>0.875281</td>\n",
       "      <td>0.055777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNN</th>\n",
       "      <td>0.871800</td>\n",
       "      <td>0.057668</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LogisticRegression</th>\n",
       "      <td>0.872977</td>\n",
       "      <td>0.056359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Decision Tree</th>\n",
       "      <td>0.860915</td>\n",
       "      <td>0.061437</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    AUC Mean       std\n",
       "rbf-SVM             0.876178  0.058087\n",
       "Linear-SVM          0.875281  0.055777\n",
       "KNN                 0.871800  0.057668\n",
       "LogisticRegression  0.872977  0.056359\n",
       "Decision Tree       0.860915  0.061437"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import interp\n",
    "import matplotlib.pyplot as plt\n",
    "from itertools import cycle\n",
    "\n",
    "from sklearn import svm, datasets\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "#'aqua', 'darkorange', 'cornflowerblue'\n",
    "models = [\n",
    "    {\n",
    "        'label' : 'rbf-SVM',\n",
    "        'model': model_RBF_SVM,\n",
    "        'color': '#1b9e77',\n",
    "        'linestyle': 'solid', \n",
    "        'markers': 'H',\n",
    "         \n",
    "    },\n",
    "    {\n",
    "        'label' : 'Linear-SVM',\n",
    "        'model': model_Linear_SVM,\n",
    "        'color': '#d95f02',\n",
    "        'linestyle': 'dashed',\n",
    "        'markers': ',',\n",
    "    },\n",
    "    {\n",
    "        'label' : 'KNN',\n",
    "        'model': model_KNN, \n",
    "        'color': '#8da0cb',\n",
    "        'linestyle': 'dashdot',\n",
    "        'markers': '',\n",
    "    },    \n",
    "    \n",
    "    {\n",
    "        'label' : 'LogisticRegression',\n",
    "        'model': model_Logistic_Regression,\n",
    "        'color': '#e7298a',\n",
    "        'linestyle': '-',\n",
    "        'markers': ''\n",
    " \n",
    "    },\n",
    "    {\n",
    "        'label' : 'Decision Tree',\n",
    "        'model': model_Decision_Tree, \n",
    "        'color': '#66a61e',\n",
    "        'linestyle': '-.',\n",
    "        'markers': ''\n",
    "    },\n",
    "\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# #############################################################################\n",
    "# Classification and ROC analysis\n",
    "random_state = np.random.RandomState(0)\n",
    "# Run classifier with cross-validation and plot ROC curves\n",
    "splits = 10\n",
    "cv = StratifiedKFold(n_splits=splits)\n",
    "\n",
    "\n",
    "tprs = []\n",
    "aucs = []\n",
    "mean_fpr = np.linspace(0, 1, 100)\n",
    "\n",
    "aucs_mean = []\n",
    "labels = []\n",
    "std_mean = []\n",
    "\n",
    "\n",
    "   \n",
    "\n",
    "\n",
    "plt.figure(figsize=(12,12))\n",
    "for m in models:\n",
    "    i = 0\n",
    "    for i,(train_index, test_index) in enumerate(cv.split(X, y)):\n",
    "        \n",
    "        print('[Fold %d/%d]' % (i + 1, splits))\n",
    "        #print(\"TRAIN:\", train_index, \"\\nTEST:\", test_index)\n",
    "        train_X = X.iloc[train_index]\n",
    "        train_y = y.iloc[train_index]\n",
    "        test_X = X.iloc[test_index]\n",
    "        test_y = y.iloc[test_index]\n",
    "        probas_ = m['model'].fit(train_X, train_y).predict_proba(test_X)\n",
    "        \n",
    "        # Compute ROC curve and area the curve\n",
    "        fpr, tpr, thresholds = roc_curve(test_y, probas_[:, 1])\n",
    "        tprs.append(interp(mean_fpr, fpr, tpr))\n",
    "        tprs[-1][0] = 0.0\n",
    "        roc_auc = auc(fpr, tpr)\n",
    "        aucs.append(roc_auc)\n",
    "        #plt.plot(fpr, tpr, lw=1, alpha=0.3,\n",
    "        #         label='ROC fold %d (AUC = %0.2f)' % (i, roc_auc))\n",
    "\n",
    "        i += 1\n",
    "    \n",
    "\n",
    "    mean_tpr = np.mean(tprs, axis=0)\n",
    "    mean_tpr[-1] = 1.0\n",
    "    mean_auc = auc(mean_fpr, mean_tpr)\n",
    "    std_auc = np.std(aucs)\n",
    "\n",
    "    plt.plot(mean_fpr, mean_tpr, color= m['color'], linestyle = m['linestyle'], marker= m['markers'],\n",
    "             label=r'[%s]  AUC = %0.5f $\\pm$ %0.4f ' % (m['label'] ,mean_auc, std_auc),\n",
    "             lw=2, alpha=.8)\n",
    "\n",
    "    aucs_mean.append(mean_auc)\n",
    "    std_mean.append(std_auc)\n",
    "    labels.append(m['label']) \n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    #plt.fill_between(mean_fpr, tprs_lower, tprs_upper, color='grey', alpha=.2,\n",
    "                    # label=r'$\\pm$ 1 std. dev.')\n",
    "    \n",
    "    plt.xlim([-0.05, 1.05])\n",
    "    plt.ylim([-0.05, 1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('Receiver Operating Characteristic (ROC)')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r',\n",
    "             label='Luck', alpha=.8)\n",
    "plt.show()\n",
    "AUCs=pd.DataFrame({'AUC Mean':aucs_mean, 'std':std_mean },index = labels)       \n",
    "AUCs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cross validated score is 0.7912036537562485\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "train_X,test_X,train_Y,test_Y =train_test_split(X,y,test_size=0.33,shuffle = True, random_state=45)\n",
    "models=[model_Linear_SVM, model_RBF_SVM, model_Logistic_Regression, model_KNN, model_Decision_Tree,  model_RandomForest ]\n",
    "\n",
    "kfold = StratifiedKFold(n_splits=10, random_state=1)\n",
    "ensemble_lin_rbf=VotingClassifier(estimators=[('KNN',model_KNN),\n",
    "                                              ('RBF',model_RBF_SVM),\n",
    "                                              ('RFor',model_RandomForest),\n",
    "                                              ('LR',model_Logistic_Regression),\n",
    "                                              ('DT',model_Decision_Tree),\n",
    "                                              ('svm',model_Linear_SVM)\n",
    "                                             ], \n",
    "                       voting='soft').fit(X,y)\n",
    "#print('The accuracy for ensembled model is:',ensemble_lin_rbf.score(test_X,test_Y))\n",
    "cross=cross_val_score(ensemble_lin_rbf,X,y, cv = kfold,scoring = \"accuracy\")\n",
    "print('The cross validated score is',cross.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import FeatureAgglomeration\n",
    "correlations =df.corr()\n",
    "\n",
    "def extract_numerical_features(df):\n",
    "    df = df.copy()\n",
    "    # Identify numerical columns which are of type object\n",
    "    numerical_features = pd.Series(data=False, index=df.columns, dtype=bool)\n",
    "\n",
    "    for feature in df.columns:\n",
    "        if any(tuple(df[feature].apply(lambda x: type(x)) == int)) or \\\n",
    "                any(tuple(df[feature].apply(lambda x: type(x)) == float)) & \\\n",
    "                (not any(tuple(df[feature].apply(lambda x: type(x)) == str))):\n",
    "            numerical_features[feature] = 1\n",
    "    return numerical_features[numerical_features == 1].index\n",
    "\n",
    "num_features = extract_numerical_features(df)\n",
    "df_aglo = pd.DataFrame(data=df.values, columns=df.columns)\n",
    "\n",
    "\n",
    "df_total = df_aglo[X.columns]\n",
    "\n",
    "plt.figure(figsize=(20, 12))\n",
    "top_features = 10\n",
    "\n",
    "correlation_coeff = np.corrcoef(df_total.astype(float).values.T)\n",
    "sns.set(font_scale=1.20)\n",
    "coeff_heatmap = sns.heatmap(correlation_coeff, annot=True, cmap='YlGn', cbar=True,\n",
    "                            square=True, fmt='.2f', annot_kws={'size': 10}, yticklabels=df_total.columns, xticklabels=df_total.columns)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "number_of_clusters=int(df_total.shape[1]/1.2)\n",
    "# Create Dendrogram\n",
    "agglomerated_features = FeatureAgglomeration(n_clusters=number_of_clusters)\n",
    "used_networks = np.arange(0, number_of_clusters, dtype=int)\n",
    "# used_networks = np.unique(agglomerated_features.labels_)\n",
    "\n",
    "# In our case all columns are clustered, which means used_columns is true in every element\n",
    "# used_columns = (df.columns.get_level_values(None)\n",
    "                # .astype(int)\n",
    "                # .isin(used_networks))\n",
    "# used_columns = (agglomerated_feature_labels.astype(int).isin(used_networks))\n",
    "# df = df.loc[:, used_columns]\n",
    "\n",
    "# Create a custom palette to identify the networks\n",
    "network_pal = sns.cubehelix_palette(len(used_networks),\n",
    "                                    light=.9, dark=.1, reverse=True,\n",
    "                                    start=1, rot=-2)\n",
    "network_lut = dict(zip(map(str, df_total.columns), network_pal))\n",
    "\n",
    "# Convert the palette to vectors that will be drawn on the side of the matrix\n",
    "networks = df_total.columns.get_level_values(None)\n",
    "network_colors = pd.Series(networks, index=df_total.columns).map(network_lut)\n",
    "sns.set(font=\"monospace\")\n",
    "# Create custom colormap\n",
    "cmap = sns.diverging_palette(h_neg=210, h_pos=350, s=90, l=30, as_cmap=True)\n",
    "cg = sns.clustermap(df_total.astype(float).corr(), cmap=cmap, linewidths=.5,\n",
    "                    row_colors=network_colors, col_colors=network_colors)\n",
    "plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)\n",
    "plt.setp(cg.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}