classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import sys\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn import tree\n",
    "from sklearn import metrics\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.preprocessing import label_binarize\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import roc_curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and Cleaning Data\n",
    "In the following secution..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Data:\n",
    "    \"\"\" This class handles everthing related to the data analysis. \n",
    "    \n",
    "    The Data object holds the train- and testdatasets as well as the column names and the names of the \n",
    "    categorical features which are required for categorical classification.\\n\n",
    "    It contains the following object variables:\n",
    "    names: list of strings containing the labels of the columns\n",
    "    learndata: pd array of a converted csv file. This data is used for the training.\n",
    "    testdata: pd array of a converted csv file. This data is used for the testing.\n",
    "    categorical_features: list of strings containing the labels of all categorical features.\n",
    "    target: string of the label of the row that contains the target variables of the pd arrays learndata and testdata.\n",
    "    x_train: pd array that contains the training features.\n",
    "    y_train: pd array that contains the training targets.\n",
    "    x_test: pd array that contains the test features.\n",
    "    y_test: pd array that contains the test targets.\n",
    "\n",
    "\n",
    "    The following Methods can be used to generate classifier objects of the Data object,\n",
    "    which can get used for predicting scores and plotting performances and so on.\n",
    "    They always use the Data object which contains the data they get trained on. \\n\n",
    "    do_log_regr(self): returns a logistical regression classifier object of the Data.\n",
    "    do_gradient_boosting_trees(self): create a gradient boosting trees classifier object of the Data.\n",
    "    do_decission_tree(self): returns a decission tree classifier object of the Data.\n",
    "    do_neural_network(self): returns a neural network classifier object of the Data.\n",
    "    do_svm(self): returns a support vector machine classifier object of the Data.\n",
    "    do_kneighbors(self): returns a k-nearest neighbor classifier object of the Data.\n",
    "    do_naive_bayes(self): returns a naive bayes classifier object of the Data.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, files, names, categorical_features, target, sep = \",\"):\n",
    "        \"\"\" Takes files, names and categorical_features as an array of strings as an input. \n",
    "\n",
    "        The files have to be entered in a list as following: 1. item is the traindata, 2. item is the testdata.\n",
    "        (optionally 3. item but this is only important if you want to safe the classification report.)\n",
    "        The names are used as the names of the rows in the data (last name is always the target).\n",
    "        The categorical features must be defined as the names of the data which is categorical.\n",
    "        target: The name of the target value (must be included in names). \"\"\"\n",
    "        # This data will be used to analyse the dataset (add variability maybe).\n",
    "        self.names = names\n",
    "\n",
    "        self.traindata = pd.read_csv((files[0]), names=self.names, sep=sep)\n",
    "        self.testdata = pd.read_csv((files[1]), names=self.names, sep=sep)\n",
    "\n",
    "        self.categorical_features = categorical_features\n",
    "\n",
    "        self.target = target\n",
    "        \n",
    "        self.setup_data()\n",
    "\n",
    "    def setup_data(self):\n",
    "        \"\"\" set up the data for classification \"\"\"\n",
    "        traindata = self.remove_incomplete_data(self.traindata)\n",
    "        testdata = self.remove_incomplete_data(self.testdata)\n",
    "        \n",
    "        self.y_train = self.set_target(traindata)\n",
    "        self.y_test = self.set_target(testdata)\n",
    "\n",
    "        # set dummies of combined train and test data with removed target variable\n",
    "        fulldata = self.get_dummies(traindata.append(testdata, ignore_index=True).drop(self.target, axis=1).drop(\"fnlwgt\", axis=1), self.categorical_features)\n",
    "        self.x_train = fulldata[0:len(traindata)]\n",
    "        self.x_test = fulldata[len(traindata):len(fulldata)]\n",
    "\n",
    "    def get_categorical_features(self):\n",
    "        \"\"\" Return the categorical features of the data as array. \"\"\"\n",
    "        return self.categorical_features\n",
    "\n",
    "    def remove_incomplete_data(self, data):\n",
    "        \"\"\" Remove every row of the data that contains atleast 1 \"?\". \"\"\"\n",
    "        return data.replace(\"?\", np.nan).dropna(0, \"any\")\n",
    "\n",
    "    def get_dummies(self, data, categorical_features):\n",
    "        \"\"\" Get the dummies of the categorical features for the given data. \"\"\"\n",
    "        for feature in self.categorical_features:\n",
    "            # create dummyvariable with pd.get_dummies and drop all categorical variables with dataframe.drop\n",
    "            data = data.join(pd.get_dummies(data[feature], prefix=feature, drop_first=True)).drop(feature, axis=1)\n",
    "        return data\n",
    "\n",
    "    def set_target(self, data):\n",
    "        \"\"\" Set the target values of the target variables (0,1 for either case). \"\"\"\n",
    "        for i in range(len(data[self.target].unique())):\n",
    "            data[self.target] = np.where(data[self.target] == data[self.target].unique()[i], i, data[self.target])\n",
    "        return data[self.target].astype(\"int\")\n",
    "\n",
    "    def do_log_regr(self):\n",
    "        \"\"\" Return a logistic regression classifier object. \"\"\"\n",
    "        clf = LogisticRegression(solver=\"lbfgs\")\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "    \n",
    "    def do_gradient_boosting_trees(self):\n",
    "        \"\"\" Return a gradient boosting trees classifier object. \"\"\"\n",
    "        clf = GradientBoostingClassifier(n_estimators=4000, learning_rate=0.04, max_depth=2, random_state=0)\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def do_decission_tree(self):\n",
    "        \"\"\" Return a decission tree classifier object. \"\"\"\n",
    "        clf = tree.DecisionTreeClassifier()\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "    \n",
    "    def do_neural_network(self, hidden_layer_size=(100,), max_iter=200):\n",
    "        \"\"\" Return a nn classifier object. \n",
    "        \n",
    "        Optional arguments:\\n \n",
    "        hidden_layer_size: Tuple of ints that defines the size and the amount of hidden layers. (default (100,))) \n",
    "        max_iter: Int that defines the maximum amount of training iterations. (default 200) \"\"\"\n",
    "        clf = MLPClassifier(hidden_layer_sizes=hidden_layer_size,\\\n",
    "             max_iter=max_iter, tol=0.000001, n_iter_no_change=250, early_stopping=False, verbose=False,\n",
    "              learning_rate=\"adaptive\", validation_fraction=0)\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def do_svm(self):\n",
    "        \"\"\"  Return an svm classifier object.  \"\"\"        \n",
    "        clf = SVC(gamma=\"auto\")\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def do_kneighbors(self):\n",
    "        \"\"\" Return a k-nn object. \"\"\"\n",
    "        clf = KNeighborsClassifier(n_neighbors=5)\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def do_naive_bayes(self):\n",
    "        \"\"\" Return a native bayes classifier object. \"\"\"\n",
    "        clf = GaussianNB()\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def do_gaussian_process_regressor(self):\n",
    "        \"\"\" Return a gaussian process regressor classifier object. \"\"\"\n",
    "        clf = GaussianProcessRegressor()\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "    \n",
    "    def do_dummy_classifier(self):\n",
    "        \"\"\" Return a dummy classifier object. \"\"\"\n",
    "        clf = DummyClassifier()\n",
    "        return clf.fit(self.x_train, self.y_train)\n",
    "\n",
    "    def get_classification_report(self, clf, x, y, label=\"\"):\n",
    "        \"\"\" Return a ClassificationReport object. \n",
    "\n",
    "        Arguments:\\n\n",
    "        clf: The classifier to be reported.\\n\n",
    "        x: The feature values.\\n\n",
    "        y: The target values to validate the predictions. \\n\n",
    "        label: (optionally) sets a label.\"\"\"\n",
    "        roc_auc = roc_auc_score(y, clf.predict_proba(x)[:,1])\n",
    "        fpr, tpr, thresholds = roc_curve(y, clf.predict_proba(x)[:,1])\n",
    "        return ClassificationReport(metrics.confusion_matrix(y, clf.predict(x)), \n",
    "        metrics.classification_report(y, clf.predict(x)), roc_auc, fpr, tpr, thresholds , label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating the Output plots\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Plotting:\n",
    "    \"\"\" Contains the stuff for plotting. \"\"\"\n",
    "    def plot_roc_curve(self, classification_reports):\n",
    "        \"\"\" Plot the as an array given classification reports roc curves. \"\"\"\n",
    "        #create the plots\n",
    "        if len(classification_reports) > 2:\n",
    "            fig, ax = plt.subplots(ncols=2, nrows=int(len(classification_reports)/2) + len(classification_reports) % 2)\n",
    "            #removes last ax if uneven:\n",
    "            if (len(classification_reports) % 2) == 1:\n",
    "                fig.delaxes(ax[int(len(ax) - 1), 1])\n",
    "            for i in range(len(classification_reports)):\n",
    "                ax[int(i/2), i%2].plot(classification_reports[i].fpr, classification_reports[i].tpr, \\\n",
    "                    label='%s (area = %0.2f)' % (classification_reports[i].label, classification_reports[i].roc_auc),\\\n",
    "                        color=Plotting.color2)\n",
    "                # plots the f(x) = x line:\n",
    "                ax[int(i/2), i%2].plot([0, 1], [0, 1], color=Plotting.color1)\n",
    "                ax[int(i/2), i%2].set_xlim([0.0, 1.0])\n",
    "                ax[int(i/2), i%2].set_ylim([0.0, 1.0])\n",
    "                ax[int(i/2), i%2].set_title(classification_reports[i].label)\n",
    "                ax[int(i/2), i%2].set_ylabel('True Positive Rate')\n",
    "                ax[int(i/2), i%2].set_xlabel('False Positive Rate')\n",
    "                ax[int(i/2), i%2].legend(loc=\"lower right\")\n",
    "\n",
    "        elif len(classification_reports) == 2:\n",
    "            fig, ax = plt.subplots(ncols=2, nrows=1)\n",
    "            for i in range(len(classification_reports)):\n",
    "                ax[i].plot(classification_reports[i].fpr, classification_reports[i].tpr, \\\n",
    "                    label='%s (area = %0.2f)' % (classification_reports[i].label, classification_reports[i].roc_auc),\\\n",
    "                        color=Plotting.color2)\n",
    "                # plots the f(x) = x line:\n",
    "                ax[i].plot([0, 1], [0, 1], color=Plotting.color1)\n",
    "                ax[i].set_xlim([0.0, 1.0])\n",
    "                ax[i].set_ylim([0.0, 1.0])\n",
    "                ax[i].set_title(classification_reports[i].label)\n",
    "                ax[i].set_ylabel('True Positive Rate')\n",
    "                ax[i].set_xlabel('False Positive Rate')\n",
    "                ax[i].legend(loc=\"lower right\")\n",
    "\n",
    "        elif len(classification_reports) == 1:\n",
    "            fig, ax = plt.subplots(ncols=1, nrows=1)\n",
    "            ax.plot(classification_reports[0].fpr, classification_reports[0].tpr, \\\n",
    "                    label='%s (area = %0.2f)' % (classification_reports[0].label, classification_reports[0].roc_auc),\\\n",
    "                        color=Plotting.color2)\n",
    "                # plots the f(x) = x line:\n",
    "            ax.plot([0, 1], [0, 1], color=Plotting.color1)\n",
    "            ax.set_xlim([0.0, 1.0])\n",
    "            ax.set_ylim([0.0, 1.0])\n",
    "            ax.set_title(classification_reports[0].label)\n",
    "            ax.set_ylabel('True Positive Rate')\n",
    "            ax.set_xlabel('False Positive Rate')\n",
    "            ax.legend(loc=\"lower right\")\n",
    "        \n",
    "        plt.suptitle('Receiver operating characteristic')\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "        return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification Report\n",
    "This class handles everything that is related to displaying the performance of a classificator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassificationReport:\n",
    "    \"\"\" Object to Print the classification report data. \"\"\"\n",
    "    def __init__(self, matrix, report, roc_auc, fpr, tpr, thresholds, label):\n",
    "        \"\"\" Takes sklearn matrix and report as arguments. \"\"\"\n",
    "        self.matrix = matrix\n",
    "        self.report = report\n",
    "        self.roc_auc = roc_auc\n",
    "        self.fpr = fpr\n",
    "        self.tpr = tpr\n",
    "        self.thresholds = thresholds\n",
    "        if label == \"\":\n",
    "            self.label = None\n",
    "        else:\n",
    "            self.label = label\n",
    "        \n",
    "    def __repr__(self):\n",
    "        \"\"\" Represent object as string containing its information. \"\"\"\n",
    "        x = \"\\tt\\t\" + \"f\\n\" + \"n\\t\" + str(self.matrix[0][0]) + \"\\t\" + str(self.matrix[0][1]) + \\\n",
    "            \"\\n\" + \"p\\t\" + str(self.matrix[1][1]) + \"\\t\" + str(self.matrix[1][0])\n",
    "        x += (\"\\n\" + self.report)\n",
    "        return x\n",
    "\n",
    "    def write_to_file(self, file, additional = []):\n",
    "        \"\"\" Write a ClassificationReport object to a file. \n",
    "\n",
    "        Arguments:\n",
    "        file: The file to write to.\n",
    "        additional: (optional) to display additional information at the beginning. \"\"\"\n",
    "        if additional == []:\n",
    "            with open(file, \"a\") as file:\n",
    "                file.write(self.__repr__())\n",
    "        else:\n",
    "            with open(file, \"a\") as file:\n",
    "                file.write(str(additional) + \"\\n\" + self.__repr__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   age          workclass  fnlwgt   education  education-num  \\\n",
      "0   39          State-gov   77516   Bachelors             13   \n",
      "1   50   Self-emp-not-inc   83311   Bachelors             13   \n",
      "\n",
      "        marital-status        occupation    relationship    race    sex  \\\n",
      "0        Never-married      Adm-clerical   Not-in-family   White   Male   \n",
      "1   Married-civ-spouse   Exec-managerial         Husband   White   Male   \n",
      "\n",
      "   capital-gain  capital-loss  hours-per-week  native-country  \n",
      "0          2174             0              40   United-States  \n",
      "1             0             0              13   United-States  \n",
      "   age  fnlwgt  education-num  capital-gain  capital-loss  hours-per-week  \\\n",
      "0   39   77516             13          2174             0              40   \n",
      "1   50   83311             13             0             0              13   \n",
      "\n",
      "   workclass_Federal-gov  workclass_Local-gov  workclass_Never-worked  \\\n",
      "0                      0                    0                       0   \n",
      "1                      0                    0                       0   \n",
      "\n",
      "   workclass_Private  ...  native-country_Portugal  \\\n",
      "0                  0  ...                        0   \n",
      "1                  0  ...                        0   \n",
      "\n",
      "   native-country_Puerto-Rico  native-country_Scotland  native-country_South  \\\n",
      "0                           0                        0                     0   \n",
      "1                           0                        0                     0   \n",
      "\n",
      "   native-country_Taiwan  native-country_Thailand  \\\n",
      "0                      0                        0   \n",
      "1                      0                        0   \n",
      "\n",
      "   native-country_Trinadad&Tobago  native-country_United-States  \\\n",
      "0                               0                             1   \n",
      "1                               0                             1   \n",
      "\n",
      "   native-country_Vietnam  native-country_Yugoslavia  \n",
      "0                       0                          0  \n",
      "1                       0                          0  \n",
      "\n",
      "[2 rows x 100 columns]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "log \n",
      " 0.7978011178674529\n",
      "decision tree\n",
      " 0.8109452736318408\n",
      "knn\n",
      " 0.7767950371598796\n",
      "naive bayes\n",
      " 0.7957127940544193\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    files = [\"./repo/data_files/adult.data.txt\", \\\n",
    "        \"./repo/data_files/adult.test.txt\"]\n",
    "    names = [\"age\",\"workclass\",\"fnlwgt\",\"education\",\"education-num\",\n",
    "                \"marital-status\",\"occupation\",\"relationship\",\"race\",\"sex\",\n",
    "                \"capital-gain\",\"capital-loss\",\"hours-per-week\",\"native-country\",\n",
    "                \"income\"]\n",
    "    categorical_features = [\"workclass\",\"education\",\"race\",\"sex\",\"marital-status\",\"occupation\",\"relationship\",\n",
    "            \"native-country\"]\n",
    "    data = Data(files, names, categorical_features, \"income\")\n",
    "\n",
    "    log_time = time.time()\n",
    "    log = data.do_log_regr()\n",
    "    log_time = time.time() - log_time\n",
    "    dec_tree_time = time.time()\n",
    "    dec_tree = data.do_decission_tree()\n",
    "    dec_tree_time = time.time() - dec_tree_time\n",
    "    # svm = data.do_svm()\n",
    "    gbt_time = time.time()\n",
    "    gbt = data.do_gradient_boosting_trees()\n",
    "    gbt_time = time.time() - gbt_time\n",
    "    knn_time = time.time()\n",
    "    knn = data.do_kneighbors()\n",
    "    knn_time = time.time() - knn_time\n",
    "    naive_bayes_time = time.time()\n",
    "    naive_bayes = data.do_naive_bayes()\n",
    "    naive_bayes_time = time.time() - naive_bayes_time\n",
    "    nn_time = time.time()\n",
    "    nn = data.do_neural_network((20,20,20,20,20,20,20,20,20,),5000)\n",
    "    nn_time = time.time() - nn_time\n",
    "    # dummy = data.do_dummy_classifier()\n",
    "    classification_reports = []\n",
    "    classification_reports.append(data.get_classification_report(log, data.x_test, data.y_test, label = \"Logistische Regression\"))    \n",
    "    classification_reports.append(data.get_classification_report(dec_tree, data.x_test, data.y_test, label=\"Decision Tree\"))\n",
    "    # classification_reports.append(data.get_classification_report(svm, data.x_test, data.y_test, label = \"svm\"))\n",
    "    classification_reports.append(data.get_classification_report(gbt, data.x_test, data.y_test, label = \"Gradient Boosting Trees\"))    \n",
    "    classification_reports.append(data.get_classification_report(knn, data.x_test, data.y_test, label=\"k-nearest Neighbors\"))    \n",
    "    classification_reports.append(data.get_classification_report(naive_bayes, data.x_test, data.y_test, label=\"Naive Bayes\"))\n",
    "    classification_reports.append(data.get_classification_report(nn, data.x_test, data.y_test, label = \"Neuronales Netz\"))\n",
    "    # classification_reports.append(data.get_classification_report(dummy, data.x_test, data.y_test, label = \"dummy\"))\n",
    "    Plotting.plot_roc_curve(Plotting, classification_reports)\n",
    "    print(\"log \\n\", log.score(data.x_test, data.y_test), log_time, \"\\n\", classification_reports[0])\n",
    "    print(\"decision tree\\n\", dec_tree.score(data.x_test, data.y_test), dec_tree_time, \"\\n\", classification_reports[1])\n",
    "    print(\"gradient boosting\\n\" , gbt.score(data.x_test, data.y_test), gbt_time, \"\\n\", classification_reports[2])\n",
    "    print(\"knn\\n\", knn.score(data.x_test, data.y_test), knn_time, \"\\n\", classification_reports[3])\n",
    "    print(\"naive bayes\\n\", naive_bayes.score(data.x_test, data.y_test), naive_bayes_time, \"\\n\", classification_reports[4])\n",
    "    print(\"nn\\n\", nn.score(data.x_test, data.y_test), nn_time, \"\\n\", classification_reports[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main()"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}