IDBMIOT-Vertebral-Column.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/prasad/anaconda3/lib/python3.7/site-packages/sklearn/cross_validation.py:41: 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",
      "/home/prasad/anaconda3/lib/python3.7/site-packages/sklearn/grid_search.py:42: 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. This module will be removed in 0.20.\n",
      "  DeprecationWarning)\n",
      "/home/prasad/anaconda3/lib/python3.7/site-packages/sklearn/ensemble/weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "#import all required modules\n",
    "from idbmiot import IDBMIOT\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from resampling import resample\n",
    "from chooseSample import chooseSample\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "import random\n",
    "import math\n",
    "from sklearn.cross_validation import KFold, train_test_split\n",
    "from sklearn.grid_search import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from collections import Counter\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score  \n",
    "from sklearn.metrics import roc_auc_score\n",
    "import time\n",
    "import matplotlib.pyplot as plt \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Data size: 310\n"
     ]
    }
   ],
   "source": [
    "# import dataset\n",
    "loc = \"data/column_2C.csv\"\n",
    "df = pd.read_csv(loc, sep=',', header=None)\n",
    "columns = ['pelvic_incidence','pelvic_tilt','lumbar_lordosis_angle','sacral_slope','pelvic_radius','grade_of_spondylolisthesis','Class']\n",
    "df.columns = columns\n",
    "\n",
    "\n",
    "S = df\n",
    "\n",
    "\n",
    "class AttributeIndicator(object):\n",
    "    def __init__(self):\n",
    "        self.nominal = [6]\n",
    "        self.numeric = [0,1,2,3,4,5]\n",
    "\n",
    "A = AttributeIndicator()\n",
    "\n",
    "k1 = 4\n",
    "k2 = 9\n",
    "\n",
    "print(\"Total Data size: \" + str(len(S)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "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>pelvic_incidence</th>\n",
       "      <th>pelvic_tilt</th>\n",
       "      <th>lumbar_lordosis_angle</th>\n",
       "      <th>sacral_slope</th>\n",
       "      <th>pelvic_radius</th>\n",
       "      <th>grade_of_spondylolisthesis</th>\n",
       "      <th>Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>63.03</td>\n",
       "      <td>22.55</td>\n",
       "      <td>39.61</td>\n",
       "      <td>40.48</td>\n",
       "      <td>98.67</td>\n",
       "      <td>-0.25</td>\n",
       "      <td>AB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>39.06</td>\n",
       "      <td>10.06</td>\n",
       "      <td>25.02</td>\n",
       "      <td>29.00</td>\n",
       "      <td>114.41</td>\n",
       "      <td>4.56</td>\n",
       "      <td>AB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>68.83</td>\n",
       "      <td>22.22</td>\n",
       "      <td>50.09</td>\n",
       "      <td>46.61</td>\n",
       "      <td>105.99</td>\n",
       "      <td>-3.53</td>\n",
       "      <td>AB</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   pelvic_incidence  pelvic_tilt  lumbar_lordosis_angle  sacral_slope  \\\n",
       "0             63.03        22.55                  39.61         40.48   \n",
       "1             39.06        10.06                  25.02         29.00   \n",
       "2             68.83        22.22                  50.09         46.61   \n",
       "\n",
       "   pelvic_radius  grade_of_spondylolisthesis Class  \n",
       "0          98.67                       -0.25    AB  \n",
       "1         114.41                        4.56    AB  \n",
       "2         105.99                       -3.53    AB  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    " c = pd.Series.sort_values(S['Class'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NO    100\n",
       "AB    210\n",
       "Name: Class, dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oversampling rate: NO    100\n",
      "AB      0\n",
      "Name: Class, dtype: int64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/prasad/Documents/project/project-algo/amdo/code/idbmiot.py:122: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  randomSample['principal component 1']  = randomSample['principal component 1'] + rs\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of class labels before resampling AB    210\n",
      "NO    100\n",
      "Name: Class, dtype: int64\n",
      "Distribution of class labels after resampling AB    210\n",
      "NO    200\n",
      "Name: Class, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "beforeTimeInMillis = int(round(time.time() * 1000))\n",
    "\n",
    "#Perform oversampling\n",
    "try:\n",
    "    newS = IDBMIOT(S,A, k1, k2)\n",
    "except Exception as error:\n",
    "    print(\"Error Message:\" + str(error))\n",
    "    newS = S\n",
    "\n",
    "afterTimeInMillis = int(round(time.time() * 1000))\n",
    "\n",
    "excutionTime = afterTimeInMillis - beforeTimeInMillis\n",
    "\n",
    "#Get distribution for sample original/after sampling\n",
    "print (\"Distribution of class labels before resampling {}\".format(S['Class'].value_counts()))\n",
    "print (\"Distribution of class labels after resampling {}\".format(newS['Class'].value_counts()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BeforeTimeInMillis: (in ms): 1543330350886\n",
      "AfterTimeInMillis: (in ms): 1543330356229\n",
      "Total Time spent: (in ms): 5343, for datasize of: 310\n"
     ]
    }
   ],
   "source": [
    "print(\"BeforeTimeInMillis: (in ms): \" + str(beforeTimeInMillis))\n",
    "print(\"AfterTimeInMillis: (in ms): \" + str(afterTimeInMillis))\n",
    "print(\"Total Time spent: (in ms): \" + str(excutionTime) + \", for datasize of: \" + str(len(df)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "S.Class.value_counts().plot(kind='bar', title='Count (Class)');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "newS.Class.value_counts().plot(kind='bar', title='Count (Class)');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#difference increase\n",
    "dis_new = newS.Class.value_counts()\n",
    "dis_S = S.Class.value_counts()\n",
    "\n",
    "diff = dis_new - dis_S\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AB      0\n",
       "NO    100\n",
       "Name: Class, dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#diff\n",
    "diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = newS.Class\n",
    "\n",
    "X = newS.drop('Class', axis=1)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7)\n",
    "\n",
    "y_train, y_test = np.asarray(y_train), np.asarray(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(n_estimators=100, max_depth=2,\n",
    "                             random_state=0)\n",
    "\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "report = classification_report(y_test, clf.predict(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "         AB       0.90      0.70      0.79        63\n",
      "         NO       0.74      0.92      0.82        60\n",
      "\n",
      "avg / total       0.82      0.80      0.80       123\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "def plot_classification_report(cr, title='Classification report ', with_avg_total=False, cmap=plt.cm.Blues):\n",
    "\n",
    "    lines = cr.split('\\n')\n",
    "\n",
    "    classes = []\n",
    "    plotMat = []\n",
    "    for line in lines[2 : (len(lines) - 3)]:\n",
    "        #print(line)\n",
    "        t = line.split()\n",
    "        # print(t)\n",
    "        classes.append(t[0])\n",
    "        v = [float(x) for x in t[1: len(t) - 1]]\n",
    "        print(v)\n",
    "        plotMat.append(v)\n",
    "\n",
    "    if with_avg_total:\n",
    "        aveTotal = lines[len(lines) - 1].split()\n",
    "        classes.append('avg/total')\n",
    "        vAveTotal = [float(x) for x in t[1:len(aveTotal) - 1]]\n",
    "        plotMat.append(vAveTotal)\n",
    "\n",
    "\n",
    "    plt.imshow(plotMat, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    x_tick_marks = np.arange(3)\n",
    "    y_tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(x_tick_marks, ['precision', 'recall', 'f1-score'], rotation=45)\n",
    "    plt.yticks(y_tick_marks, classes)\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('Classes')\n",
    "    plt.xlabel('Measures')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9, 0.7, 0.79]\n",
      "[0.74, 0.92, 0.82]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_classification_report(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "score=accuracy_score(y_test, clf.predict(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8048780487804879"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}