Adaboost Persistent Model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the Adaboost classifier with HOG&LBP features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda2\\lib\\site-packages\\sklearn\\cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HOGLBP dataset loaded\n",
      "labels loading completed\n",
      "Accuracy in the training data:  100.0 %\n",
      "Accuracy in the test data 83.3333333333 %\n",
      "\n",
      "Training classification report\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       1.00      1.00      1.00        38\n",
      "          1       1.00      1.00      1.00        58\n",
      "\n",
      "avg / total       1.00      1.00      1.00        96\n",
      "\n",
      "\n",
      " Confusion matrix of training \n",
      "[[38  0]\n",
      " [ 0 58]]\n",
      "\n",
      "Testing classification report\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.84      0.80      0.82        20\n",
      "          1       0.83      0.86      0.84        22\n",
      "\n",
      "avg / total       0.83      0.83      0.83        42\n",
      "\n",
      "\n",
      "Confusion matrix of the testing\n",
      "[[16  4]\n",
      " [ 3 19]]\n",
      "\n",
      "Area Under the ROC curve:  0.877272727273\n",
      "Mean True Positive rate (testing):  0.729946524064\n",
      "Mean False Positive rate (testing):  0.305882352941\n"
     ]
    }
   ],
   "source": [
    "import scipy\n",
    "import numpy as np\n",
    "from scipy import interp\n",
    "from sklearn import preprocessing, cross_validation, neighbors,datasets, svm\n",
    "from sklearn import datasets\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from sklearn.datasets import make_hastie_10_2\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "\n",
    "fileName = 'HOGLBP'\n",
    "x = scipy.io.loadmat(fileName)\n",
    "cc = [x][0]\n",
    "HOGLBP = cc['HOGLBP']\n",
    "HOGLBP = np.asarray(HOGLBP)\n",
    "print \"HOGLBP dataset loaded\"\n",
    "\n",
    "fileName = 'LBPlabels'\n",
    "x = scipy.io.loadmat(fileName)\n",
    "cc = [x][0]\n",
    "LBPlabels = cc['WW']\n",
    "LBPlabels = np.asarray(LBPlabels)\n",
    "print 'labels loading completed'\n",
    "\n",
    "c, r = LBPlabels.shape\n",
    "LBPlabels = LBPlabels.reshape(c,)\n",
    "\n",
    "X_train, X_test, y_train, y_test = cross_validation.train_test_split(HOGLBP, LBPlabels, test_size=0.3, random_state=0)\n",
    "\n",
    "#scaling\n",
    "scaler = StandardScaler()\n",
    "#scaler = preprocessing.MinMaxScaler()\n",
    "\n",
    "# Fit only on training data\n",
    "scaler.fit(X_train)\n",
    "X_train = scaler.transform(X_train)\n",
    "# apply same transformation to test data\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "clf = AdaBoostClassifier(n_estimators=500)\n",
    "scores = cross_val_score(clf, X_train, y_train)\n",
    "scores.mean()\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "Accuracy = clf.score(X_train, y_train)\n",
    "print \"Accuracy in the training data: \", Accuracy*100, \"%\"\n",
    "\n",
    "accuracy = clf.score(X_test, y_test)\n",
    "print \"Accuracy in the test data\", accuracy*100, \"%\"\n",
    "\n",
    "y_pred = clf.predict(X_train)\n",
    "print '\\nTraining classification report\\n', classification_report(y_train, y_pred)\n",
    "print \"\\n Confusion matrix of training \\n\", confusion_matrix(y_train, y_pred)\n",
    "\n",
    "y_pred = clf.predict(X_test)\n",
    "print '\\nTesting classification report\\n', classification_report(y_test, y_pred)\n",
    "print \"\\nConfusion matrix of the testing\\n\", confusion_matrix(y_test, y_pred)\n",
    "\n",
    "probas = clf.fit(X_train, y_train).predict_proba(X_test)\n",
    "fpr, tpr, thresholds = roc_curve(y_test, probas[:, 1])\n",
    "mean_tpr = 0.0\n",
    "mean_fpr = np.linspace(0, 1, 100)\n",
    "\n",
    "mean_tpr += interp(mean_fpr, fpr, tpr)\n",
    "mean_tpr[0] = 0.0\n",
    "roc_auc = auc(fpr, tpr)\n",
    "print \"\\nArea Under the ROC curve: \", roc_auc\n",
    "\n",
    "meanTP = 0\n",
    "for t in tpr:\n",
    "    meanTP += t\n",
    "print \"Mean True Positive rate (testing): \", meanTP/len(tpr)\n",
    "\n",
    "meanFP = 0\n",
    "for t in fpr:\n",
    "    meanFP += t\n",
    "print \"Mean False Positive rate (testing): \", meanFP/len(fpr)\n",
    "\n",
    "plt.title('Receiver Operating Characteristic')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Persisting the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AdaBoostTBModel Generated\n"
     ]
    }
   ],
   "source": [
    "from sklearn.externals import joblib\n",
    "joblib.dump(clf, 'AdaBoostTBModel.pkl')\n",
    "print \"AdaBoostTBModel Generated\"\n",
    "\n",
    "#X is the sample you want to classify (HOG &LBP features of an x-ray)\n",
    "#Image size used in the training is 100*100pixels\n",
    "#You can pass one image or a numpy array of more than one\n",
    "#to use the model for testing uncomment the following lines:\n",
    "\n",
    "#clf = joblib.load('AdaBoostTBModel.pkl') \n",
    "#clf.predict(X)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}