RandomForest.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "_You are currently looking at **version 1.1** of this notebook. To download notebooks and datafiles, as well as get help on Jupyter notebooks in the Coursera platform, visit the [Jupyter Notebook FAQ](https://www.coursera.org/learn/python-machine-learning/resources/bANLa) course resource._\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification-RandomForest-TicketPayment\n",
    "\n",
    "## Understanding and Predicting Property Maintenance Fines\n",
    "\n",
    "This assignment is based on a data challenge from the Michigan Data Science Team (MDST)(http://midas.umich.edu/mdst/). \n",
    "\n",
    "The Michigan Data Science Team (MDST) have partnered with the City of Detroit to help solve one of the most pressing problems facing Detroit - blight. Every year, the city of Detroit issues millions of dollars in fines to residents and every year, many of these fines remain unpaid. Enforcing unpaid blight fines is a costly and tedious process, so the city wants to know: how can we increase blight ticket compliance?\n",
    "\n",
    "The first step in answering this question is understanding when and why a resident might fail to comply with a blight ticket. This is where predictive modeling comes in. For this assignment, your task is to predict whether a given blight ticket will be paid on time.\n",
    "\n",
    "We provide you with two data files for use in training and validating your models: train.csv and test.csv. Each row in these two files corresponds to a single blight ticket, and includes information about when, why, and to whom each ticket was issued. The target variable is compliance, which is True if the ticket was paid early, on time, or within one month of the hearing data, False if the ticket was paid after the hearing date or not at all, and Null if the violator was found not responsible. Compliance, as well as a handful of other variables that will not be available at test-time, are only included in train.csv.\n",
    "\n",
    "Note: All tickets where the violators were found not responsible are not considered during evaluation. They are included in the training set as an additional source of data for visualization, and to enable unsupervised and semi-supervised approaches. However, they are not included in the test set.\n",
    "\n",
    "**File descriptions** (Use only this data for training your model!)\n",
    "\n",
    "    ./train.csv - the training set \n",
    "    ./test.csv - the test set \n",
    "\n",
    "A random forest classifier is trained and used to predict ticket payment.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report, roc_curve, auc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def ticket_classification():\n",
    "    \n",
    "    # Read the training set and choose which features to include\n",
    "    df = pd.read_csv('./train.csv', encoding = 'ISO-8859-1')\n",
    "    columns = ['agency_name', 'inspector_name', 'violation_street_name',\n",
    "               'mailing_address_str_name', 'city', 'state', 'zip_code', 'violation_code', \n",
    "               'violation_description', 'disposition', 'fine_amount', 'late_fee', 'discount_amount', \n",
    "               'judgment_amount', 'compliance']\n",
    "    X = df[columns]\n",
    "    print(\"number of examples in the data set = {}\".format(df.shape[0]))\n",
    "    \n",
    "    print(50*'=')\n",
    "    # Number of Nan entries in each column\n",
    "    print(\"number of Nan entries in each feature column of training data:\")\n",
    "    print(X.isnull().sum())\n",
    "    \n",
    "    # Now drop the rows containing Nan\n",
    "    X = X.dropna()\n",
    "    print(\"number of examples in the data set after dropping Nan = {}\".format(X.shape[0]))\n",
    "    \n",
    "    # Build target and feature arrays\n",
    "    y = X['compliance']\n",
    "    X = X.drop('compliance', 1)   \n",
    "    \n",
    "    #print(X.info())     # information about data types in each column\n",
    "    #print(X.describe()) # some stats about numerical columns\n",
    "    \n",
    "    # Here we need to decide which categorical features should be one-hot-ecoded\n",
    "    # It's not reasonbale to include categorical features which many categories for the sake of computational cost\n",
    "    print(50*'=')\n",
    "    for column in X:\n",
    "        print(\"{0:30}{1}\".format(column, len(X[column].unique())))\n",
    "    columns_to_drop = ['violation_street_name','mailing_address_str_name','city','zip_code',\n",
    "                       'inspector_name', 'violation_code', 'violation_description', 'state']\n",
    "    X = X.drop(columns_to_drop, 1)\n",
    "    \n",
    "    X = pd.get_dummies(X)\n",
    "    print(\"Final number of features of the dataset after one-hot-encoding is = {}\".format(X.shape[1]))\n",
    "    \n",
    "    # Read the test set for prediction only (test.csv set does not include target labels)\n",
    "    data_test = pd.read_csv('./test.csv', encoding = 'ISO-8859-1')\n",
    "    data_test_new = data_test[columns[:-1]]\n",
    "    data_test_new = data_test_new.drop(columns_to_drop, 1)\n",
    "    data_test_new = pd.get_dummies(data_test_new)\n",
    "    \n",
    "    # align the columns of train and test to be able to use the trained model on the test set\n",
    "    X_aligned, data_test_aligned = X.align(data_test_new, join='outer', fill_value=0, axis=1)\n",
    "    \n",
    "    # Training random forest model\n",
    "    print(50*'=')\n",
    "    X_train, X_val, y_train, y_val = train_test_split(X_aligned, y, random_state=0)\n",
    "    print(\"Trainig of the model begins .....\")\n",
    "    clf = RandomForestClassifier(random_state=0).fit(X_train, y_train)\n",
    "    print(\"Model training completed!\")\n",
    "    print('Accuracy of RF classifier on training set: {:.2f}'.format(clf.score(X_train, y_train)))\n",
    "    print('Accuracy of RF classifier on validation set: {:.2f}'.format(clf.score(X_val, y_val)))\n",
    "    \n",
    "    # Predicting validation set labels\n",
    "    y_proba = clf.predict_proba(X_val)\n",
    "    fpr, tpr, _ = roc_curve(y_val, y_proba[:,1])\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.xlim([-0.01, 1.01])\n",
    "    plt.ylim([-0.01, 1.01])\n",
    "    plt.plot(fpr, tpr, lw=2, label='Random Forest ROC curve (area = {:0.2f})'.format(roc_auc))\n",
    "    plt.xlabel('False Positive Rate', fontsize=12)\n",
    "    plt.ylabel('True Positive Rate', fontsize=12)\n",
    "    plt.title('ROC curve (1-of-10 digits classifier)', fontsize=12)\n",
    "    plt.legend(loc='lower right', fontsize=12)\n",
    "    plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "    plt.show()\n",
    "    \n",
    "    # Compute some metrics for the predictions\n",
    "    print(50*'=')\n",
    "    print(\"Now let's print some metrics:\")\n",
    "    y_pred = clf.predict(X_val)\n",
    "    acc_score = accuracy_score(y_val, y_pred)\n",
    "    conf_matrix = confusion_matrix(y_val, y_pred)\n",
    "    class_report = classification_report(y_val, y_pred)\n",
    "    print('Accuracy:', acc_score)\n",
    "    print('-------')\n",
    "    print('Confusion matrix:')\n",
    "    print(conf_matrix)\n",
    "    print('-------')\n",
    "    print('Classification report:')\n",
    "    print(class_report)\n",
    "  \n",
    "    # Making prediction on test set (unfortunately the test set file does not include the true labels)\n",
    "    data_test_proba = clf.predict_proba(data_test_aligned)\n",
    "    final_result = pd.Series(data_test_proba[:,1], index=data_test['ticket_id'])\n",
    "    \n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3242: DtypeWarning: Columns (11,12,31) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  if (await self.run_code(code, result,  async_=asy)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of examples in the data set = 250306\n",
      "==================================================\n",
      "number of Nan entries in each feature column of training data:\n",
      "agency_name                     0\n",
      "inspector_name                  0\n",
      "violation_street_name           0\n",
      "mailing_address_str_name        4\n",
      "city                            0\n",
      "state                          93\n",
      "zip_code                        1\n",
      "violation_code                  0\n",
      "violation_description           0\n",
      "disposition                     0\n",
      "fine_amount                     1\n",
      "late_fee                        0\n",
      "discount_amount                 0\n",
      "judgment_amount                 0\n",
      "compliance                  90426\n",
      "dtype: int64\n",
      "number of examples in the data set after dropping Nan = 159792\n",
      "==================================================\n",
      "agency_name                   5\n",
      "inspector_name                159\n",
      "violation_street_name         1716\n",
      "mailing_address_str_name      28378\n",
      "city                          4042\n",
      "state                         59\n",
      "zip_code                      4592\n",
      "violation_code                189\n",
      "violation_description         207\n",
      "disposition                   4\n",
      "fine_amount                   40\n",
      "late_fee                      37\n",
      "discount_amount               13\n",
      "judgment_amount               57\n",
      "Final number of features of the dataset after one-hot-encoding is = 13\n",
      "==================================================\n",
      "Trainig of the model begins .....\n",
      "Model training completed!\n",
      "Accuracy of RF classifier on training set: 0.94\n",
      "Accuracy of RF classifier on validation set: 0.94\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================================\n",
      "Now let's print some metrics:\n",
      "Accuracy: 0.9438269750675878\n",
      "-------\n",
      "Confusion matrix:\n",
      "[[37002    75]\n",
      " [ 2169   702]]\n",
      "-------\n",
      "Classification report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.94      1.00      0.97     37077\n",
      "         1.0       0.90      0.24      0.38      2871\n",
      "\n",
      "    accuracy                           0.94     39948\n",
      "   macro avg       0.92      0.62      0.68     39948\n",
      "weighted avg       0.94      0.94      0.93     39948\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ticket_classification()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "python-machine-learning",
   "graded_item_id": "nNS8l",
   "launcher_item_id": "yWWk7",
   "part_id": "w8BSS"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}