models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Import required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from sklearn.svm import SVC\n",
    "import matplotlib.pyplot as plt\n",
    "from xgboost import XGBClassifier\n",
    "from catboost import CatBoostClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.linear_model import RidgeClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Define a custom confusion matrix illustrator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def show_confusion_matrix(y_test, y_pred):\n",
    "    labels = [\"tDCS\", \"sham\", \"control\"]\n",
    "    cf_matrix = confusion_matrix(y_test, y_pred)\n",
    "    cmap = sns.diverging_palette(220, 10, as_cmap=True)\n",
    "    sns.heatmap(cf_matrix/np.sum(cf_matrix), annot=True, fmt='.2%', cmap=cmap, cbar=False, yticklabels=labels, xticklabels=labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Load the data frame from the pickle file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"data\\DataFrame.pickle\", \"rb\") as file:\n",
    "    x, y, df= pickle.load(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Split the data frame into two sets: train and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\n",
    "test_rows = [3, 20, 1, 9, 8, 17, 16, 18]\n",
    "train_rows = [0, 14, 22, 15, 6, 13, 19, 4, 10, 5, 23, 11, 2, 21, 12, 7]\n",
    "x_test = x.iloc[test_rows]\n",
    "x_train = x.iloc[train_rows]\n",
    "y_test = y.iloc[test_rows]\n",
    "y_train = y.iloc[train_rows]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Define some variable for collecting results of the models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "predictions = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *k-nearest neighbors(KNN) Model*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "accuracy_scores = []\n",
    "for k in range(1, len(y_train)-1):\n",
    "    KNNModel = KNeighborsClassifier(n_neighbors=k)\n",
    "    KNNModel.fit(x_train, y_train)\n",
    "    y_pred = KNNModel.predict(x_test)\n",
    "    accuracy_scores.append(accuracy_score(y_test, y_pred))\n",
    "\n",
    "k = accuracy_scores.index(max(accuracy_scores))+1\n",
    "KNNModel = KNeighborsClassifier(n_neighbors=k)\n",
    "KNNModel.fit(x_train, y_train)\n",
    "y_pred = KNNModel.predict(x_test)\n",
    "predictions[\"KNN\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### *Random Forest Classifier Model*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "RFCModel = RandomForestClassifier(n_jobs=-1)\n",
    "RFCModel.fit(x_train, y_train)\n",
    "y_pred = RFCModel.predict(x_test)\n",
    "predictions[\"Random Forest\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *Logistic Regression Model*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "LRModel = LogisticRegression(solver=\"liblinear\")\n",
    "LRModel.fit(x_train, y_train)\n",
    "y_pred = LRModel.predict(x_test)\n",
    "predictions[\"Logistic Regression\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *Support Vector Machine Classifier Model*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "SVCModel = SVC()\n",
    "SVCModel.fit(x_train, y_train)\n",
    "y_pred = SVCModel.predict(x_test)\n",
    "predictions[\"SVC\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *XGBoost Model*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "XGBModel = XGBClassifier()\n",
    "XGBModel.fit(x_train, y_train)\n",
    "y_pred = XGBModel.predict(x_test)\n",
    "predictions[\"XGBoost\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Ridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "RidgeModel = RidgeClassifier()\n",
    "RidgeModel.fit(x_train, y_train)\n",
    "y_pred = RidgeModel.predict(x_test)\n",
    "predictions[\"Ridge\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *Catboost*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "CBCModel = CatBoostClassifier()\n",
    "CBCModel.fit(x_train, y_train)\n",
    "y_pred = CBCModel.predict(x_test)\n",
    "predictions[\"CatBoost\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### *Multi-layer Perceptron classifier(MLP classifier)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "MLPCModel = MLPClassifier()\n",
    "MLPCModel.fit(x_train, y_train)\n",
    "y_pred = MLPCModel.predict(x_test)\n",
    "predictions[\"MLP\"] = y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Show confusion matrix of each model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plot_index=1\n",
    "for response in predictions:\n",
    "    plt.figure(\"{0}\".format(plot_index), figsize=[3.5, 3.5])\n",
    "    show_confusion_matrix(y_test, predictions[response])\n",
    "    plt.savefig('results/confusion_matrices/{0}.png'.format(response))\n",
    "    plot_index+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "for prediction in predictions:\n",
    "    print(\"{0} :\".format(prediction))\n",
    "    print(classification_report(y_test, predictions[prediction], zero_division=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "accuracy_scores={}\n",
    "for prediction in predictions:\n",
    "    accuracy_scores[prediction]=accuracy_score(y_test, predictions[prediction])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=[12, 5])\n",
    "sns.barplot(x=list(accuracy_scores.keys()), y=list(accuracy_scores.values()), palette=\"viridis\")\n",
    "plt.ylim([0, 1])\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}