8(d) Final Classification - Gradient Boosting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ae5be26a",
   "metadata": {},
   "source": [
    "# Final classification with Gradient Boosting\n",
    "### This file contains the training and testing of Gradient Boosting with and without fusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b726d5b",
   "metadata": {},
   "source": [
    "## Without fusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eca6fceb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6a3d154e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel(\"cnn.xlsx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5fdc701a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index([       1,        2,        3,        4,        5,        6,        7,\n",
       "              8,        9,       10,       11,       12,       13,       14,\n",
       "             15,       16,       17,       18,       19,       20,       21,\n",
       "             22,       23,       24,       25,       26,       27,       28,\n",
       "             29,       30,       31,       32,       33,       34,       35,\n",
       "             36,       37,       38,       39,       40,       41,       42,\n",
       "             43,       44,       45,       46,       47,       48,       49,\n",
       "             50, 'target'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_names = df.columns\n",
    "\n",
    "col_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d3d502ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop(['target'], axis=1)\n",
    "\n",
    "y = df['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bfc11646",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fb5624bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((438, 50), (189, 50))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "276cd54f",
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = X_train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7c220061",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaler = StandardScaler()\n",
    "\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4e704301",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = pd.DataFrame(X_train, columns=[cols])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "79b59941",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = pd.DataFrame(X_test, columns=[cols])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "46def344",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report\n",
    "\n",
    "def evaluate(model, X_train, X_test, y_train, y_test):\n",
    "    \n",
    "    y_test_pred = model.predict(X_test)\n",
    "    y_train_pred = model.predict(X_train)\n",
    "\n",
    "    print(\"Training:\\n\")\n",
    "    clf_report = pd.DataFrame(classification_report(y_train, y_train_pred, output_dict=True))\n",
    "    print(f\"Accuracy:\\n{accuracy_score(y_train, y_train_pred):.4f}\")\n",
    "\n",
    "    print(\"Testing:\\n\")\n",
    "    clf_report = pd.DataFrame(classification_report(y_test, y_test_pred, output_dict=True))\n",
    "    print(f\"Accuracy:\\n{accuracy_score(y_test, y_test_pred):.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "019ca50a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training:\n",
      "\n",
      "Accuracy:\n",
      "1.0000\n",
      "Testing:\n",
      "\n",
      "Accuracy:\n",
      "0.8995\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "\n",
    "grad_boost_clf = GradientBoostingClassifier(n_estimators=1500, random_state=42)\n",
    "grad_boost_clf.fit(X_train, y_train)\n",
    "evaluate(grad_boost_clf, X_train, X_test, y_train, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cdbe50c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = grad_boost_clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2bad75a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set score: 1.0000\n",
      "Test set score: 0.8995\n"
     ]
    }
   ],
   "source": [
    "print('Training set score: {:.4f}'.format(grad_boost_clf.score(X_train, y_train)))\n",
    "\n",
    "print('Test set score: {:.4f}'.format(grad_boost_clf.score(X_test, y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "820424fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "\n",
      " [[85  8]\n",
      " [11 85]]\n",
      "\n",
      "True Positives(TP) =  85\n",
      "\n",
      "True Negatives(TN) =  85\n",
      "\n",
      "False Positives(FP) =  8\n",
      "\n",
      "False Negatives(FN) =  11\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "print('Confusion matrix\\n\\n', cm)\n",
    "\n",
    "print('\\nTrue Positives(TP) = ', cm[0,0])\n",
    "\n",
    "print('\\nTrue Negatives(TN) = ', cm[1,1])\n",
    "\n",
    "print('\\nFalse Positives(FP) = ', cm[0,1])\n",
    "\n",
    "print('\\nFalse Negatives(FN) = ', cm[1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8d1edef6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.91      0.90        93\n",
      "           1       0.91      0.89      0.90        96\n",
      "\n",
      "    accuracy                           0.90       189\n",
      "   macro avg       0.90      0.90      0.90       189\n",
      "weighted avg       0.90      0.90      0.90       189\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5115b6",
   "metadata": {},
   "source": [
    "## With Fusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1facd4d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel(\"cnn_abcd.xlsx\",sheet_name=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "48554f6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index([       1,        2,        3,        4,        5,        6,        7,\n",
       "              8,        9,       10,       11,       12,       13,       14,\n",
       "             15,       16,       17,       18,       19,       20,       21,\n",
       "             22,       23,       24,       25,       26,       27,       28,\n",
       "             29,       30,       31,       32,       33,       34,       35,\n",
       "             36,       37,       38,       39,       40,       41,       42,\n",
       "             43,       44,       45,       46,       47,       48,       49,\n",
       "             50,       51,       52,       53,       54, 'target'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_names = df.columns\n",
    "\n",
    "col_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ea6cff85",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop(['target'], axis=1)\n",
    "\n",
    "y = df['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "b6e54bd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "acc7a145",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((432, 54), (186, 54))"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ff96a188",
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = X_train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "1cbc5514",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaler = StandardScaler()\n",
    "\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2efb3162",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRAINING RESULTS: \n",
      "===============================\n",
      "ACCURACY SCORE:\n",
      "1.0000\n",
      "CLASSIFICATION REPORT:\n",
      "               0      1  accuracy  macro avg  weighted avg\n",
      "precision    1.0    1.0       1.0        1.0           1.0\n",
      "recall       1.0    1.0       1.0        1.0           1.0\n",
      "f1-score     1.0    1.0       1.0        1.0           1.0\n",
      "support    211.0  227.0       1.0      438.0         438.0\n",
      "TESTING RESULTS: \n",
      "===============================\n",
      "ACCURACY SCORE:\n",
      "0.9048\n",
      "CLASSIFICATION REPORT:\n",
      "                    0          1  accuracy   macro avg  weighted avg\n",
      "precision    0.938144   0.869565  0.904762    0.903855      0.906939\n",
      "recall       0.883495   0.930233  0.904762    0.906864      0.904762\n",
      "f1-score     0.910000   0.898876  0.904762    0.904438      0.904938\n",
      "support    103.000000  86.000000  0.904762  189.000000    189.000000\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "\n",
    "grad_boost_clf = GradientBoostingClassifier(n_estimators=1500, random_state=42)\n",
    "grad_boost_clf.fit(X_train, y_train)\n",
    "evaluate(grad_boost_clf, X_train, X_test, y_train, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a8ae8228",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = grad_boost_clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "82c6cad0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn import datasets, metrics, model_selection\n",
    "import matplotlib\n",
    "matplotlib.rcParams.update(matplotlib.rcParamsDefault)\n",
    "\n",
    "y_pred_proba = v.predict_proba(X_test)[::,1]\n",
    "fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred_proba)\n",
    "auc = metrics.roc_auc_score(y_test, y_pred_proba)\n",
    "\n",
    "plt.rcParams['axes.facecolor'] = 'white'\n",
    "ax.patch.set_edgecolor('black')  \n",
    "ax.patch.set_linewidth('0.5')  \n",
    "\n",
    "plt.plot(fpr,tpr,label=\"AUC=\"+str(auc))\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.legend(loc=4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "61ad5e3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9582862948746896"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "auc = metrics.roc_auc_score(y_test, y_pred_proba)\n",
    "auc"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}