hotel_demand_analysis_FINAL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Big Data Analytics of Hotel Bookings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Data Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import modules\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from pyspark.sql import SparkSession\n",
    "\n",
    "# build spark session and spark context\n",
    "spark = SparkSession.builder \\\n",
    "        .master(\"local[4]\") \\\n",
    "        .appName(\"hotel\") \\\n",
    "        .getOrCreate()\n",
    "sc = spark.sparkContext\n",
    "\n",
    "df = spark.read.csv('hotel_bookings.csv',  inferSchema=True, header = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from pyspark.sql.functions import *\n",
    "import pyspark.sql.functions as f\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-------------------+\n",
      "|summary|        is_canceled|\n",
      "+-------+-------------------+\n",
      "|  count|             119390|\n",
      "|   mean|0.37041628277075134|\n",
      "| stddev| 0.4829182265925992|\n",
      "|    min|                  0|\n",
      "|    max|                  1|\n",
      "+-------+-------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.select(['is_canceled']).describe().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-----+\n",
      "|is_canceled|count|\n",
      "+-----------+-----+\n",
      "|          1|44224|\n",
      "|          0|75166|\n",
      "+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.groupBy('is_canceled').count().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>summary</th>\n",
       "      <td>count</td>\n",
       "      <td>mean</td>\n",
       "      <td>stddev</td>\n",
       "      <td>min</td>\n",
       "      <td>max</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>is_canceled</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.37041628277075134</td>\n",
       "      <td>0.4829182265925992</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lead_time</th>\n",
       "      <td>119390</td>\n",
       "      <td>104.01141636652986</td>\n",
       "      <td>106.86309704798789</td>\n",
       "      <td>0</td>\n",
       "      <td>737</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>arrival_date_year</th>\n",
       "      <td>119390</td>\n",
       "      <td>2016.156554150264</td>\n",
       "      <td>0.7074759445197123</td>\n",
       "      <td>2015</td>\n",
       "      <td>2017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>arrival_date_week_number</th>\n",
       "      <td>119390</td>\n",
       "      <td>27.16517296255968</td>\n",
       "      <td>13.605138355497637</td>\n",
       "      <td>1</td>\n",
       "      <td>53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>arrival_date_day_of_month</th>\n",
       "      <td>119390</td>\n",
       "      <td>15.798241058715135</td>\n",
       "      <td>8.780829470578368</td>\n",
       "      <td>1</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>stays_in_weekend_nights</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.9275986263506156</td>\n",
       "      <td>0.9986134945978752</td>\n",
       "      <td>0</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>stays_in_week_nights</th>\n",
       "      <td>119390</td>\n",
       "      <td>2.500301532791691</td>\n",
       "      <td>1.9082856150479115</td>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>adults</th>\n",
       "      <td>119390</td>\n",
       "      <td>1.8564033838679956</td>\n",
       "      <td>0.5792609988327535</td>\n",
       "      <td>0</td>\n",
       "      <td>55</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>babies</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.007948739425412514</td>\n",
       "      <td>0.09743619130126421</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>is_repeated_guest</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.03191222045397437</td>\n",
       "      <td>0.17576714541065686</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>previous_cancellations</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.08711784906608594</td>\n",
       "      <td>0.8443363841545107</td>\n",
       "      <td>0</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>previous_bookings_not_canceled</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.13709690928888515</td>\n",
       "      <td>1.4974368477076778</td>\n",
       "      <td>0</td>\n",
       "      <td>72</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>booking_changes</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.22112404724013737</td>\n",
       "      <td>0.652305572674772</td>\n",
       "      <td>0</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>days_in_waiting_list</th>\n",
       "      <td>119390</td>\n",
       "      <td>2.321149174972778</td>\n",
       "      <td>17.59472087877621</td>\n",
       "      <td>0</td>\n",
       "      <td>391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>required_car_parking_spaces</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.06251779881062065</td>\n",
       "      <td>0.24529114746749242</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_of_special_requests</th>\n",
       "      <td>119390</td>\n",
       "      <td>0.5713627607002262</td>\n",
       "      <td>0.7927984228094119</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                     0                     1  \\\n",
       "summary                          count                  mean   \n",
       "is_canceled                     119390   0.37041628277075134   \n",
       "lead_time                       119390    104.01141636652986   \n",
       "arrival_date_year               119390     2016.156554150264   \n",
       "arrival_date_week_number        119390     27.16517296255968   \n",
       "arrival_date_day_of_month       119390    15.798241058715135   \n",
       "stays_in_weekend_nights         119390    0.9275986263506156   \n",
       "stays_in_week_nights            119390     2.500301532791691   \n",
       "adults                          119390    1.8564033838679956   \n",
       "babies                          119390  0.007948739425412514   \n",
       "is_repeated_guest               119390   0.03191222045397437   \n",
       "previous_cancellations          119390   0.08711784906608594   \n",
       "previous_bookings_not_canceled  119390   0.13709690928888515   \n",
       "booking_changes                 119390   0.22112404724013737   \n",
       "days_in_waiting_list            119390     2.321149174972778   \n",
       "required_car_parking_spaces     119390   0.06251779881062065   \n",
       "total_of_special_requests       119390    0.5713627607002262   \n",
       "\n",
       "                                                  2     3     4  \n",
       "summary                                      stddev   min   max  \n",
       "is_canceled                      0.4829182265925992     0     1  \n",
       "lead_time                        106.86309704798789     0   737  \n",
       "arrival_date_year                0.7074759445197123  2015  2017  \n",
       "arrival_date_week_number         13.605138355497637     1    53  \n",
       "arrival_date_day_of_month         8.780829470578368     1    31  \n",
       "stays_in_weekend_nights          0.9986134945978752     0    19  \n",
       "stays_in_week_nights             1.9082856150479115     0    50  \n",
       "adults                           0.5792609988327535     0    55  \n",
       "babies                          0.09743619130126421     0    10  \n",
       "is_repeated_guest               0.17576714541065686     0     1  \n",
       "previous_cancellations           0.8443363841545107     0    26  \n",
       "previous_bookings_not_canceled   1.4974368477076778     0    72  \n",
       "booking_changes                   0.652305572674772     0    21  \n",
       "days_in_waiting_list              17.59472087877621     0   391  \n",
       "required_car_parking_spaces     0.24529114746749242     0     8  \n",
       "total_of_special_requests        0.7927984228094119     0     5  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# descriptives of numeric variables\n",
    "numeric_features = [t[0] for t in df.dtypes if t[1] == 'int']\n",
    "df.select(numeric_features).describe().toPandas().transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------------+-----------------------+--------------------+------------------+\n",
      "|summary|               adr|stays_in_weekend_nights|stays_in_week_nights|         lead_time|\n",
      "+-------+------------------+-----------------------+--------------------+------------------+\n",
      "|  count|            119390|                 119390|              119390|            119390|\n",
      "|   mean|101.83112153446551|     0.9275986263506156|   2.500301532791691|104.01141636652986|\n",
      "| stddev|50.535790285548764|     0.9986134945978752|  1.9082856150479115|106.86309704798789|\n",
      "|    min|             -6.38|                      0|                   0|                 0|\n",
      "|    max|            5400.0|                     19|                  50|               737|\n",
      "+-------+------------------+-----------------------+--------------------+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# average daily rate (ADR): defined by dividing the sum of all lodging transactions by the total number of staying nights\n",
    "# Number of stays in the weekday/weekend\n",
    "# lead_time: Number of days that elapsed between the entering date of the booking into the PMS and the arrival date\n",
    "df.select(['adr','stays_in_weekend_nights', 'stays_in_week_nights', 'lead_time']).describe().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "# value counts of stays_in_weekend_nights\n",
    "df_stayweekend = [val.stays_in_weekend_nights for val in df.select('stays_in_weekend_nights').collect()] \n",
    "\n",
    "# Histogram of stay_in_weekend_nights\n",
    "num_bins = 20\n",
    "n, bins, patches = plt.hist(df_stayweekend, num_bins, facecolor='purple', alpha=0.5)\n",
    "\n",
    "# Add title and axis names\n",
    "plt.title('Histogram of Stays in Weekend Nights')\n",
    "plt.xlabel('Days')\n",
    "plt.ylabel('Count')\n",
    "\n",
    "# Limits for the X axis\n",
    "# plt.xlim(0,10)\n",
    "\n",
    "# plt.savefig(\"Hist_Weekends.png\")\n",
    "plt.show()"
   ]
  },
  {
   "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": [
    "#list of stays_in_week_nights values\n",
    "df_stayweek = [val.stays_in_week_nights for val in df.select('stays_in_week_nights').collect()] \n",
    "\n",
    "#Histogram of stays_in_week_nights\n",
    "num_bins = 20\n",
    "n, bins, patches = plt.hist(df_stayweek, num_bins, facecolor='red', alpha=0.5)\n",
    "\n",
    "# Add title and axis names\n",
    "plt.title('Histogram of Stays in Week Nights')\n",
    "plt.xlabel('Days')\n",
    "plt.ylabel('Count')\n",
    "\n",
    "plt.savefig(\"Hist_Weeknights.png\")\n",
    "plt.show()"
   ]
  },
  {
   "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": [
    "#list of lead_time values\n",
    "df_lt = [val.lead_time for val in df.select('lead_time').collect()] \n",
    "\n",
    "#Histogram of lead_time\n",
    "num_bins = 20\n",
    "n, bins, patches = plt.hist(df_lt, num_bins, facecolor='blue', alpha=0.5)\n",
    "\n",
    "# Add title and axis names\n",
    "plt.title('Histogram of Days Between Booking and Arrival')\n",
    "plt.xlabel('Days')\n",
    "plt.ylabel('Count')\n",
    "\n",
    "# plt.savefig(\"Hist_LeadTime.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------------+-------------------+--------------------+\n",
      "|summary|            adults|           children|              babies|\n",
      "+-------+------------------+-------------------+--------------------+\n",
      "|  count|            119390|             119390|              119390|\n",
      "|   mean|1.8564033838679956|0.10388990333874994|0.007948739425412514|\n",
      "| stddev|0.5792609988327535|0.39856144478644145| 0.09743619130126421|\n",
      "|    min|                 0|                  0|                   0|\n",
      "|    max|                55|                 NA|                  10|\n",
      "+-------+------------------+-------------------+--------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Whether patrons/customers were adults with children\n",
    "df.select(['adults', 'children', 'babies']).describe().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------------+------------------+\n",
      "|summary|arrival_date_month| arrival_date_year|\n",
      "+-------+------------------+------------------+\n",
      "|  count|            119390|            119390|\n",
      "|   mean|              null| 2016.156554150264|\n",
      "| stddev|              null|0.7074759445197123|\n",
      "|    min|             April|              2015|\n",
      "|    max|         September|              2017|\n",
      "+-------+------------------+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Arrival month and year to hotel\n",
    "df.select(['arrival_date_month', 'arrival_date_year']).describe().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------+-----------+-----+\n",
      "|arrival_date_year|is_canceled|count|\n",
      "+-----------------+-----------+-----+\n",
      "|             2015|          0|13854|\n",
      "|             2015|          1| 8142|\n",
      "|             2016|          0|36370|\n",
      "|             2016|          1|20337|\n",
      "|             2017|          0|24942|\n",
      "|             2017|          1|15745|\n",
      "+-----------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# view counts of cancelation by year\n",
    "df.groupBy('arrival_date_year', 'is_canceled')\\\n",
    "    .count()\\\n",
    "    .sort('arrival_date_year', 'is_canceled')\\\n",
    "    .show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get counts of cancel or not cancel by hotel type\n",
    "nocancel_2015 = df.filter((col('arrival_date_year') == '2015') & (col('is_canceled') == 0)).count()\n",
    "cancel_2015 = df.filter((col('arrival_date_year') == '2015') & (col('is_canceled') == 1)).count()\n",
    "nocancel_2016 = df.filter((col('arrival_date_year') == '2016') & (col('is_canceled') == 0)).count()\n",
    "cancel_2016 = df.filter((col('arrival_date_year') == '2016') & (col('is_canceled') == 1)).count()\n",
    "nocancel_2017 = df.filter((col('arrival_date_year') == '2017') & (col('is_canceled') == 0)).count()\n",
    "cancel_2017 = df.filter((col('arrival_date_year') == '2017') & (col('is_canceled') == 1)).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEICAYAAAB1f3LfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deZwV1Zn/8c+XRSAKuIFBGgWDJoIKshiX6DhilDhGJW4YoiJGjNGJjiZR/DkRJ8EYNRGJiTM6GhGJiPuSYFyicYxEFoOKW8CA0ojIoghRiODz+6NOt5fm9gLVt5umv+/Xq1637lPnnDp1q/s+t07VrauIwMzMbFO1aOwOmJlZ0+ZEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJHYZkfSEEkLJK2StO9m0J/bJP2ksfuxMSSFpJ5pPlf/037Yrf56V+v6Rku6o6HWZ/k5kWzBJH1T0oz0RrBI0hRJX2mA9Va+iW2ia4HzImKbiPhrXdrfmDcfSU9L+naO/lVtr4ukW9JrvFLS65KukLR1fa2joRR7bdJ++Htj9WlTSZoo6dYqsX+RtExSl8bq15bIiWQLJelCYCxwJbATsAvwa+DYxuxXHe0KvNLYnagLSdsDU4F2wAER0R74KrAt8IXG7JvxPeAoSV8FkNQWuBm4KCIW1eeKJLWsz/aaGieSLZCkjsB/AedGxH0R8Y+I+CQiHo6IH6QybSSNlfROmsZKapOWDZf0bJU2qw6V/ErS79In8OclfSEteyZVeTEdCZ1cpH8tJF0m6S1J70m6XVLH1KdVQMtU/80cr8GBkqZLWpEeD0zxMcDBwA2pfzek+JckPS5puaQ3JJ1Ux1VdCKwEvhUR8wEiYkFEnB8RL6W2r09DdR9Kminp4IJ+jpY0Ob0GKyW9ImlAwfJuku6TtCR9kr6hYNkISa9Jel/SHyTtWofXZTtJj6T23k/zZbW8NoX7vmPq65K0/y6T1CItGy7pWUnXprbnSfpawbqHS/p72s55kobV0NW2ku5KZV+Q1Ce18QNJ91bZpl9KGlu1gYhYBvw7cFM6OrwceDMibkv1Wki6VNKbkpZKmiRpu4Jl90h6V9IH6Uhtz4J13pH+Bx6V9I/0ujVfEeFpC5uAwcBaoFUNZf4L+AvQGegEPAf8OC0bDjxbpXwAPdP8bcByYD+gFTARmFSsbDXrHgHMBXYDtgHuAyZsRP0NlgOjgTvS/PbA+8CpqX+npOc7pOVPA98uqLs1sAA4I5XvBywFehds70+q6ctfgCtq2R/fAnZIbV8EvAu0Lej3auAosgT6U+AvaVlL4EXgutTHtsBX0rLj0mu4Z2r3MuC5GvbXT9L8DsDxwOeA9sDdwAMF9dZ7bYq0dTvwYKrbHfgbcGbB380nwFmp7+cA7wBK/f8Q+GIq26Xi9S3yeo1O7ZwAtAa+D8xL812AfwDbprKtgPeA/jW8/vcADwHLgF0K4t8H/gx0Ta/tLaS/Q7IP2cPTdrYFbgBmFNS9g+xv6oBUtk1j/9835tToHfBUgp0Kw4B3aynzJnBUwfMjgflpfji1J5L/LVh2FPB6sbLVrPtJ4LsFz7+Y3jha1bF+pDelDwqm1XyWSE4FplWpMxUYnubXe7METgb+r0r5/wEuL9je6hLJHOA7G7l/3gf6pPnRwBMFy3oBH6f5A4AlFPlAAEwhvYGn5y2Aj4Bdq9lf1fW/L/B+wfP1XpvCtsiSwxqgV8Gys4GnC/5u5hYs+1yq+3myRPIBWRJrV8vrM5qUTAu2bRFwcMG2n5XmjwZeraW9nYBVwPlF9t2/FDzvlravRZE2dkzbsnV6fgdw68bs9y158tDWlmkZsKOkVjWU2Rl4q+D5WylWV+8WzH9EdmRRV8XW3YrsH76u+kXEthUTcFUN7Veso2s1be0KfDkNYXwg6QOyZPz5OvRjGdmn5GpJuigNQa1IbXcke2OqUPW1bJv2XTfgrYhYW02fry/o73KyT/7VbWNFXz4n6X/SsNSHwDPAtqrbGP+OwFZsuO8K11m5LRHxUZrdJiL+QZawvwMsSsOiX6phXQsK2vkUKOezv8/xZEd5pMcJNXU6IhaTHWFWPe+2C/BwwWv4Mlmy6CyppaSr01Dch2RHf7D+fluAAT5HsqWaSvYJ/bgayrxD9mZUYZcUg2zo4HMVCyTV5Q11YxRb91pgcYnar1jHwjRf9ZbXC4A/FSamyK5UOqcO63oCGFJxnqCqdD7kYuAkYLuU9FaQvenXZgGwSzUfCBYAZ1fpc7uIeK6WNi8iOwL8ckR0AA6p6Gp6rOl24EvJjhyr7ruFxYuvLyL+EBFfJUu8r5Od+K5Ot4qZ9NqW8dnf5wPAPpL2IjsimViX9RdRDny1ymvYNiLeBU4jO9I+jCzxV1wlWLjffOv0xIlkCxQRK4AfAb+SdFz6FNpa0tckXZ2K3QlcJqmTpB1T+YrLZ18Eekvqq+xKl9Eb2YXFZOc/qnMn8B+SekjahuzKsruq+eS9KX4P7KHs8udWyk749wIeqaZ/j6Typ6bXqbWkgYUnV2vwC6ADML7iZLekrpJ+IWkfsjH2taQhKkk/SuXrYhrZkM5VkraW1FbSQWnZfwOjJPVO6+wo6cQ6tNke+Bj4QNkVZ5dXWV7tvouIdcBkYIyk9ml7L+Szv5tqSdpJ0jHppPcasqGmdTVU6S/pGymJXpDq/CX1YzXZeY/fkg1hvl3b+qvx38CVknZJfews6Zi0rH1a5zKyD1VjNnEdzYITyRYqIn5B9k9+Gdmb2ALgPLJPcwA/AWYAL5Ed0r+QYkTE38hOxj9BNo683hVcdTCa7I31AxW/+ulWsuGIZ8hOoq4mu7qmXkR2tc7RZJ++lwE/BI6OiKWpyPXACenKonERsRI4AhhK9qn3XeBnQJs6rGs5cCDZJ/XnJa0kOwe0gmw45A9kY/p/IxsGWk0dh0TSG/fXyT4Nv032CfrktOz+1MdJaehlNvC1apoqNJbsUuWlZG/Mj1ZZvt5rU6T+v5Mdsf6d7O/it2T7szYtyPbHO2TDcP8CfLeG8g+SbWvFRRPfiIhPCpaPB/amlmGtWvyCbPufTPvtOWBgWvab1Nd3yIbEajvSa9aUThyZmTUZ6SjideDzEfFhY/enufMRiZk1KemcyYVkl5w7iWwGarqqx8xss5LOsSwmGyYc3MjdscRDW2ZmlouHtszMLJdmN7S14447Rvfu3Ru7G2ZmTcrMmTOXRkSnYsuaXSLp3r07M2bMaOxumJk1KZKq3i2ikoe2zMwsFycSMzPLxYnEzMxyaXbnSMxs433yySeUl5ezevXqxu6KlVjbtm0pKyujdevWda7jRGJmtSovL6d9+/Z0794dqS43LramKCJYtmwZ5eXl9OjRo871PLRlZrVavXo1O+ywg5PIFk4SO+yww0YfeTqRmFmdOIk0D5uyn51IzMwsF58jMbON1v2S39Vre/Ov+rdayzz66KOcf/75rFu3jm9/+9tccskludcriQsvvJCf//znAFx77bWsWrWK0aNHV1vngQceYI899qBXr15Fl99+++1cffXVlb9nPmLECL7//e/n7mttRo8ezTbbbLNR69pmm21YtWpV7nU7kVizUt9vgPWpLm+mzdW6des499xzefzxxykrK2PgwIEcc8wx1b6Z11WbNm247777GDVqFDvuuGPtFcgSydFHH1103VOmTGHs2LE89thj7LzzzqxevZoJE/L89lbT4KEtM9vsTZs2jZ49e7Lbbrux1VZbMXToUB588MHc7bZq1YqRI0dy3XXXbbDsrbfeYtCgQeyzzz4MGjSIt99+m+eee46HHnqIH/zgB/Tt25c333xzvTo//elPufbaa9l5552B7FLas846C4Cbb76ZgQMH0qdPH44//ng++ugjAIYPH873vvc9DjzwQHbbbTfuueeeyvauvvpq9t57b/r06VN5BPbmm28yePBg+vfvz8EHH8zrr7++Qd+rKzNv3jwOOOAABg4cyH/+53/mfv0qOJGY2WZv4cKFdOvWrfJ5WVkZCxcu3KDcxIkT6du37wbTCSecUG3b5557LhMnTmTFihXrxc877zxOO+00XnrpJYYNG1b5Zn/MMcdwzTXXMGvWLL7whS+sV2f27Nn079+/6Hq+8Y1vMH36dF588UX23HNPbrnllsplixYt4tlnn+WRRx6pTBhTpkzhgQce4Pnnn+fFF1/khz/8IQAjR47kl7/8JTNnzuTaa6/lu9/d8BeLqytz/vnnc8455zB9+nQ+//nPV/uabCwPbZnZZq/Y7yYVu7po2LBhDBs2bKPa7tChA6eddhrjxo2jXbt2lfGpU6dy3333AXDqqadWvpFvqtmzZ3PZZZfxwQcfsGrVKo488sjKZccddxwtWrSgV69eLF68GIAnnniCM844g8997nMAbL/99qxatYrnnnuOE088sbLumjVr1ltPTWX+/Oc/c++991Zu08UXX5xrmyqULJFIags8A7RJ67knIi6XNBo4C1iSil4aEb9PdUYBZwLrgO9FxB9SvD9wG9AO+D1wfkSEpDbA7UB/YBlwckTML9U2mVnjKCsrY8GCBZXPy8vLK4ePCk2cOJFrrrlmg3jPnj3XGzKq6oILLqBfv36cccYZ1Zapy2WxvXv3ZubMmRx22GEbLBs+fDgPPPAAffr04bbbbuPpp5+uXNamTZvK+YqkGREbrPPTTz9l2223ZdasWdX2obYypbiMu5RDW2uAwyKiD9AXGCxp/7Tsuojom6aKJNILGAr0JvsJzV9LapnK3wiMBHZPU8VPbJ4JvB8RPYHrgJ+VcHvMrJEMHDiQOXPmMG/ePP75z38yadIkjjnmmA3KDRs2jFmzZm0w1ZREIPu0f9JJJ6033HTggQcyadIkIEtQX/nKVwBo3749K1euLNrOqFGj+OEPf8i7774LZEcC48aNA2DlypV06dKFTz75hIkTJ9a6zUcccQS33npr5bmU5cuX06FDB3r06MHdd98NZMnmxRdfXK9eTWUOOuig9bapvpTsiCSytFpxXVnrNNX0u77HApMiYg0wT9JcYD9J84EOETEVQNLtwHHAlFRndKp/D3CDJIV/P9ispBr6CrNWrVpxww03cOSRR7Ju3TpGjBhB796963UdF110ETfccEPl83HjxjFixAiuueYaOnXqxG9+8xsAhg4dyllnncW4ceO455571jtPctRRR7F48WIOP/zwyiOKESNGAPDjH/+YL3/5y+y6667svffe1SajCoMHD2bWrFkMGDCArbbaiqOOOoorr7ySiRMncs455/CTn/yETz75hKFDh9KnT5/16lZX5vrrr+eb3/wm119/Pccff3x9vXSl/c32dEQxE+gJ/CoiLk5DW8OBD4EZwEUR8b6kG4C/RMQdqe4tZMliPnBVRBye4gcDF0fE0ZJmA4MjojwtexP4ckQsra5PAwYMCP+wVfPly383zWuvvcaee+7Z2N2wBlJsf0uaGREDipUv6VVbEbEuIvoCZWRHF3uRDVN9gWy4axHw84p+FmuihnhNddYjaaSkGZJmLFmypEgVMzPbVA1y+W9EfAA8TXb0sDglmE+Bm4H9UrFyoFtBtTLgnRQvKxJfr46kVkBHYHmR9d8UEQMiYkCnTkV/ctjMzDZRyRKJpE6Stk3z7YDDgdcldSkoNgSYneYfAoZKaiOpB9lJ9WkRsQhYKWl/ZZcbnAY8WFDn9DR/AvBHnx8xM2tYpfweSRdgfDpP0gKYHBGPSJogqS/ZENR84GyAiHhF0mTgVWAtcG5ErEttncNnl/9OSRPALcCEdGJ+OdlVX2Zm1oBKedXWS8C+ReKn1lBnDDCmSHwGsFeR+GrgxKpxMzNrOL5FipmZ5eJbpJjZxhvdsZ7bW1FrkREjRvDII4/QuXNnZs+eXWv5unj33Xe54IILmD59Om3atKF79+6MHTuWPfbYo17ar8nG3sJ9U24T31B8RGJmTcLw4cN59NFH6629iGDIkCEceuihvPnmm7z66qtceeWVlfe6srpzIjGzJuGQQw5h++23r7f2nnrqKVq3bs13vvOdyljfvn05+OCDWbVqFYMGDaJfv37svffelbesnz9/PnvuuSdnnXUWvXv35ogjjuDjjz8GYO7cuRx++OH06dOHfv36Vd5i/pprrmHgwIHss88+XH755UX7Ul2ZMWPG8MUvfpHDDz+cN954o962vb55aMvMthgbc9PGmm753rZtW+6//346dOjA0qVL2X///Svv7TVnzhzuvPNObr75Zk466STuvfdevvWtbzFs2DAuueQShgwZwurVq/n000957LHHmDNnDtOmTSMiOOaYY3jmmWc45JBDKtdVXZmtt96aSZMm8de//pW1a9fSr1+/avvb2JxIzGyLsSm3kS8mIrj00kt55plnaNGiBQsXLqwc8urRowd9+/YFoH///syfP5+VK1eycOFChgwZAmSJCLIk8dhjj7HvvtkFrKtWrWLOnDkbJJJiZVauXMmQIUMqbyNf7CaVmwsnEjPbYmzMEUnv3r2rvSvwxIkTWbJkCTNnzqR169Z0796d1atXA+vf8r1ly5Z8/PHHRX8vBbKENGrUKM4+++xq+1xdmbFjx5bklu+l4HMkZrbF2JjbyB922GGsWbOGm2++uTI2ffp0/vSnP7FixQo6d+5M69ateeqpp3jrrbdqXG+HDh0oKyvjgQceALLbx3/00UcceeSR3HrrrZVXZy1cuJD33ntvvbrVlTnkkEO4//77+fjjj1m5ciUPP/xwrtemlHxEYmYbrw6X69a3U045haeffpqlS5dSVlbGFVdcwZlnnrnJ7Uni/vvv54ILLuCqq66ibdu2lZf/9u7dm69//esMGDCAvn378qUvfanW9iZMmMDZZ5/Nj370I1q3bs3dd9/NEUccwWuvvcYBBxwAZJf83nHHHXTu3LmyXnVl+vXrx8knn0zfvn3ZddddOfjggzd5W0utpLeR3xz5NvLNm28jv2l8G/nmZbO6jbyZmW35nEjMzCwXJxIzq5PmNgzeXG3KfnYiMbNatW3blmXLljmZbOEigmXLllV+D6aufNWWmdWqrKyM8vJy/FPVW762bdtSVlZWe8ECTiRmVqvWrVvTo0ePxu6GbaY8tGVmZrk4kZiZWS5OJGZmlosTiZmZ5VKyRCKpraRpkl6U9IqkK1J8e0mPS5qTHrcrqDNK0lxJb0g6siDeX9LLadk4pVtiSmoj6a4Uf15S91Jtj5mZFVfKI5I1wGER0QfoCwyWtD9wCfBkROwOPJmeI6kXMBToDQwGfi2pZWrrRmAksHuaBqf4mcD7EdETuA74WQm3x8zMiihZIolMxS/bt05TAMcC41N8PHBcmj8WmBQRayJiHjAX2E9SF6BDREyN7NtQt1epU9HWPcCgiqMVMzNrGCU9RyKppaRZwHvA4xHxPLBTRCwCSI8V91PuCiwoqF6eYl3TfNX4enUiYi2wAtihSD9GSpohaYa/UGVmVr9KmkgiYl1E9AXKyI4u9qqheLEjiaghXlOdqv24KSIGRMSATp061dZtMzPbCA1y1VZEfAA8TXZuY3EariI9VvxcWDnQraBaGfBOipcVia9XR1IroCOwvCQbYWZmRZXyqq1OkrZN8+2Aw4HXgYeA01Ox04EH0/xDwNB0JVYPspPq09Lw10pJ+6fzH6dVqVPR1gnAH8N3lTMza1ClvNdWF2B8uvKqBTA5Ih6RNBWYLOlM4G3gRICIeEXSZOBVYC1wbkSsS22dA9wGtAOmpAngFmCCpLlkRyJDS7g9ZmZWRMkSSUS8BOxbJL4MGFRNnTHAmCLxGcAG51ciYjUpEZmZWePwN9vNzCwXJxIzM8vFicTMzHJxIjEzs1ycSMzMLBcnEjMzy8WJxMzMcnEiMTOzXJxIzMwsFycSMzPLxYnEzMxycSIxM7NcnEjMzCwXJxIzM8vFicTMzHJxIjEzs1ycSMzMLBcnEjMzy8WJxMzMcilZIpHUTdJTkl6T9Iqk81N8tKSFkmal6aiCOqMkzZX0hqQjC+L9Jb2clo2TpBRvI+muFH9eUvdSbY+ZmRVXyiOStcBFEbEnsD9wrqReadl1EdE3Tb8HSMuGAr2BwcCvJbVM5W8ERgK7p2lwip8JvB8RPYHrgJ+VcHvMzKyIkiWSiFgUES+k+ZXAa0DXGqocC0yKiDURMQ+YC+wnqQvQISKmRkQAtwPHFdQZn+bvAQZVHK2YmVnDaJBzJGnIaV/g+RQ6T9JLkm6VtF2KdQUWFFQrT7Guab5qfL06EbEWWAHsUGT9IyXNkDRjyZIl9bJNZmaWaVXqFUjaBrgXuCAiPpR0I/BjINLjz4ERQLEjiaghTi3LPgtE3ATcBDBgwIANlptZ09H9kt81dheqNf+qf2vsLjSKkh6RSGpNlkQmRsR9ABGxOCLWRcSnwM3Afql4OdCtoHoZ8E6KlxWJr1dHUiugI7C8NFtjZmbFlPKqLQG3AK9FxC8K4l0Kig0BZqf5h4Ch6UqsHmQn1adFxCJgpaT9U5unAQ8W1Dk9zZ8A/DGdRzEzswZSyqGtg4BTgZclzUqxS4FTJPUlG4KaD5wNEBGvSJoMvEp2xde5EbEu1TsHuA1oB0xJE2SJaoKkuWRHIkNLuD1mZlZEyRJJRDxL8XMYv6+hzhhgTJH4DGCvIvHVwIk5umlmZjn5m+1mZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS51SiSSDqpLzMzMmp+6HpH8so4xMzNrZmr8qV1JBwAHAp0kXViwqAPQspQdMzOzpqG232zfCtgmlWtfEP8QOKFUnTIzs6ajxkQSEX8C/iTptoh4a2MaltQNuB34PPApcFNEXC9pe+AuoDswHzgpIt5PdUYBZwLrgO9FxB9SvD9wG9AO+D1wfkSEpDZpHf2BZcDJETF/Y/ppZmb51HZEUqGNpJvI3vwr60TEYTXUWQtcFBEvSGoPzJT0ODAceDIirpJ0CXAJcLGkXsBQoDewM/CEpD0iYh1wIzAS+AtZIhkMTCFLOu9HRE9JQ4GfASfXcZvMNi+jOzZ2D2o2ekVj98A2U3VNJHcD/w38L9nRQq0iYhGwKM2vlPQa0BU4Fjg0FRsPPA1cnOKTImINME/SXGA/SfOBDhExFUDS7cBxZInkWGB0ause4AZJioio43aZmVlOdU0kayPixk1diaTuwL7A88BOKckQEYskdU7FupIdcVQoT7FP0nzVeEWdBamttZJWADsAS6usfyTZEQ277LLLpm6GmZkVUdfLfx+W9F1JXSRtXzHVpaKkbYB7gQsi4sOaihaJRQ3xmuqsH4i4KSIGRMSATp061dZlMzPbCHU9Ijk9Pf6gIBbAbjVVktSaLIlMjIj7UnixpC7paKQL8F6KlwPdCqqXAe+keFmReGGdckmtgI7A8jpuk5mZ1YM6HZFERI8iU21JRMAtwGsR8YuCRQ/xWWI6HXiwID5UUhtJPYDdgWlpGGylpP1Tm6dVqVPR1gnAH31+xMysYdXpiETSacXiEXF7DdUOAk4FXpY0K8UuBa4CJks6E3gbODG19YqkycCrZFd8nZuu2AI4h88u/52SJsgS1YR0Yn452VVfZmbWgOo6tDWwYL4tMAh4gew7HEVFxLMUP4dBql+szhhgTJH4DGCvIvHVpERkZmaNo06JJCL+vfC5pI7AhJL0yMzMmpRNvY38R2TnMMzMrJmr6zmSh/nsstqWwJ7A5FJ1yszMmo66niO5tmB+LfBWRJRXV9jMzJqPul7++yfgdbI7AG8H/LOUnTIzs6ajrr+QeBIwjewKqZOA5yX5NvJmZlbnoa3/BwyMiPcAJHUCniC7UaKZmTVjdb1qq0VFEkmWbURdMzPbgtX1iORRSX8A7kzPTyb7XRAzM2vmavvN9p5kt33/gaRvAF8h+7b6VGBiA/TPzMw2c7UNT40FVgJExH0RcWFE/AfZ0cjYUnfOzMw2f7Ulku4R8VLVYLr3VfeS9MjMzJqU2hJJ2xqWtavPjpiZWdNUWyKZLumsqsF0C/iZpemSmZk1JbVdtXUBcL+kYXyWOAYAWwFDStkxMzNrGmpMJBGxGDhQ0r/y2e+B/C4i/ljynpmZWZNQ198jeQp4qsR9MTOzJsjfTjczs1zq+s12MzOrzeiOjd2Dmo1eUZJmS3ZEIulWSe9Jml0QGy1poaRZaTqqYNkoSXMlvSHpyIJ4f0kvp2XjJCnF20i6K8Wfl9S9VNtiZmbVK+XQ1m3A4CLx6yKib5p+DyCpFzAU6J3q/FpSy1T+RmAk2U/77l7Q5pnA+xHRE7gO+FmpNsTMzKpXskQSEc8Ay+tY/FhgUkSsiYh5wFxgP0ldgA4RMTUiArgdOK6gzvg0fw8wqOJoxczMGk5jnGw/T9JLaehruxTrCiwoKFOeYl3TfNX4enUiYi2wAtih2AoljZQ0Q9KMJUuW1N+WmJlZgyeSG4EvAH2BRcDPU7zYkUTUEK+pzobBiJsiYkBEDOjUqdPG9djMzGrUoIkkIhZHxLqI+BS4GdgvLSoHuhUULQPeSfGyIvH16khqBXSk7kNpZmZWTxo0kaRzHhWGABVXdD0EDE1XYvUgO6k+LSIWASsl7Z/Of5wGPFhQ5/Q0fwLwx3QexczMGlDJvkci6U7gUGBHSeXA5cChkvqSDUHNB84GiIhXJE0GXgXWAudGxLrU1DlkV4C1A6akCeAWYIKkuWRHIkNLtS1mZla9kiWSiDilSPiWGsqPAcYUic/gs/t8FcZXAyfm6aOZmeXnW6SYmVkuvkXKRuh+ye8auws1mn/VvzV2F8ysGfIRiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5lCyRSLpV0nuSZhfEtpf0uKQ56XG7gmWjJM2V9IakIwvi/SW9nJaNk6QUbyPprhR/XlL3Um2LmZlVr5RHJLcBg6vELgGejIjdgSfTcyT1AoYCvVOdX0tqmercCAqguUQAAAd3SURBVIwEdk9TRZtnAu9HRE/gOuBnJdsSMzOrVskSSUQ8AyyvEj4WGJ/mxwPHFcQnRcSaiJgHzAX2k9QF6BARUyMigNur1Klo6x5gUMXRipmZNZyGPkeyU0QsAkiPnVO8K7CgoFx5inVN81Xj69WJiLXACmCHYiuVNFLSDEkzlixZUk+bYmZmsPmcbC92JBE1xGuqs2Ew4qaIGBARAzp16rSJXTQzs2IaOpEsTsNVpMf3Urwc6FZQrgx4J8XLisTXqyOpFdCRDYfSzMysxBo6kTwEnJ7mTwceLIgPTVdi9SA7qT4tDX+tlLR/Ov9xWpU6FW2dAPwxnUcxM7MG1KpUDUu6EzgU2FFSOXA5cBUwWdKZwNvAiQAR8YqkycCrwFrg3IhYl5o6h+wKsHbAlDQB3AJMkDSX7EhkaKm2xczMqleyRBIRp1SzaFA15ccAY4rEZwB7FYmvJiUiMzNrPJvLyXYzM2uinEjMzCwXJxIzM8vFicTMzHIp2cl2awSjOzZ2D6o3ekVj98DMSsRHJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5dIoiUTSfEkvS5olaUaKbS/pcUlz0uN2BeVHSZor6Q1JRxbE+6d25koaJ0mNsT1mZs1ZYx6R/GtE9I2IAen5JcCTEbE78GR6jqRewFCgNzAY+LWklqnOjcBIYPc0DW7A/puZGZvX0NaxwPg0Px44riA+KSLWRMQ8YC6wn6QuQIeImBoRAdxeUMfMzBpIYyWSAB6TNFPSyBTbKSIWAaTHzineFVhQULc8xbqm+arxDUgaKWmGpBlLliypx80wM7PG+qndgyLiHUmdgcclvV5D2WLnPaKG+IbBiJuAmwAGDBhQtIyZmW2aRjkiiYh30uN7wP3AfsDiNFxFenwvFS8HuhVULwPeSfGyInEzM2tADZ5IJG0tqX3FPHAEMBt4CDg9FTsdeDDNPwQMldRGUg+yk+rT0vDXSkn7p6u1TiuoY2ZmDaQxhrZ2Au5PV+q2An4bEY9Kmg5MlnQm8DZwIkBEvCJpMvAqsBY4NyLWpbbOAW4D2gFT0mRmZg2owRNJRPwd6FMkvgwYVE2dMcCYIvEZwF713UczM6u7zenyXzMza4KcSMzMLBcnEjMzy8WJxMzMcnEiMTOzXJxIzMwsFycSMzPLxYnEzMxycSIxM7NcnEjMzCwXJxIzM8vFicTMzHJxIjEzs1ycSMzMLBcnEjMzy8WJxMzMcnEiMTOzXJxIzMwsFycSMzPLxYnEzMxyafKJRNJgSW9Imivpksbuj5lZc9OkE4mklsCvgK8BvYBTJPVq3F6ZmTUvTTqRAPsBcyPi7xHxT2AScGwj98nMrFlp1dgdyKkrsKDgeTnw5aqFJI0ERqanqyS90QB9a3CCHYGljd2Poq5QY/dgs7dZ7z/wPqyDLXwf7lrdgqaeSIq9KrFBIOIm4KbSd6dxSZoREQMaux+2abz/mr7mug+b+tBWOdCt4HkZ8E4j9cXMrFlq6olkOrC7pB6StgKGAg81cp/MzJqVJj20FRFrJZ0H/AFoCdwaEa80crca0xY/fLeF8/5r+prlPlTEBqcUzMzM6qypD22ZmVkjcyIxM7NcnEg2Y5K6SXpK0muSXpF0fopvL+lxSXPS43YpvkMqv0rSDVXaejrdSmZWmjo3xjY1J/W8/7aSdJOkv0l6XdLxjbFNzU197UNJ7Qv+92ZJWippbGNtV33zOZLNmKQuQJeIeEFSe2AmcBwwHFgeEVel+4ttFxEXS9oa2BfYC9grIs4raOtp4PsRMaOht6O5quf9dwXQMiIuk9QC2D4iNt8vvm0h6nMfVml3JvAfEfFMg2xIifmIZDMWEYsi4oU0vxJ4jezb/McC41Ox8WR/2ETEPyLiWWB1I3TXqqjn/TcC+Gkq96mTSMMoxf+gpN2BzsD/lbDrDcqJpImQ1J3sk87zwE4RsQiyP3SyP8q6+E06rP5PSb7fRQPKs/8kbZtmfyzpBUl3S9qphN21IurpfxDgFOCu2IKGg5xImgBJ2wD3AhdExIeb2MywiNgbODhNp9ZX/6xm9bD/WpHdteHPEdEPmApcW49dtFrU0/9ghaHAnfl7tflwItnMSWpN9gc8MSLuS+HFaey2Ygz3vdraiYiF6XEl8FuyOydbidXT/lsGfATcn57fDfQrQXetiPr6H0xl+wCtImJmSTrbSJxINmNp+OkW4LWI+EXBooeA09P86cCDtbTTStKOab41cDQwu/57bIXqa/+lIZCHgUNTaBDwar121oqqr31Y4BS2sKMR8FVbmzVJXyE7Ifcy8GkKX0o2RjsZ2AV4GzgxIpanOvOBDsBWwAfAEcBbwDNAa7JbyTwBXBgR6xpqW5qj+tp/EfGqpF2BCcC2wBLgjIh4u+G2pnmqz32Ylv0dOCoiXm/AzSg5JxIzM8vFQ1tmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmufx/QtMEGAr0KEoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Visualize cancellations by year\n",
    "\n",
    "x_year = [val.arrival_date_year for val in df.select('arrival_date_year').distinct().collect()]\n",
    "labels = x_year\n",
    "cancel0_count = [nocancel_2015, nocancel_2016, nocancel_2017]\n",
    "cancel1_count = [cancel_2015, cancel_2016, cancel_2017]\n",
    "\n",
    "x = np.arange(len(x_year))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, cancel0_count, width, label='0 = Not Canceled')\n",
    "rects2 = ax.bar(x + width/2, cancel1_count, width, label='1 = Canceled')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('Count of Hotel Cancellations by Year')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "# plt.savefig(\"Cancel_by_Year.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+------------+-----------+------------------+\n",
      "|deposit_type|       hotel|is_canceled|          avg(adr)|\n",
      "+------------+------------+-----------+------------------+\n",
      "|  No Deposit|  City Hotel|          0| 105.7526466513691|\n",
      "|  No Deposit|  City Hotel|          1|112.00739824145536|\n",
      "|  No Deposit|Resort Hotel|          0| 90.93364290931946|\n",
      "|  No Deposit|Resort Hotel|          1|112.77001693121677|\n",
      "|  Non Refund|  City Hotel|          0| 99.77833333333335|\n",
      "|  Non Refund|  City Hotel|          1| 93.12289551541605|\n",
      "|  Non Refund|Resort Hotel|          0|  69.8572463768116|\n",
      "|  Non Refund|Resort Hotel|          1| 66.07261818181843|\n",
      "|  Refundable|  City Hotel|          0| 78.04166666666667|\n",
      "|  Refundable|  City Hotel|          1|130.80714285714285|\n",
      "|  Refundable|Resort Hotel|          0| 68.16483333333333|\n",
      "|  Refundable|Resort Hotel|          1| 84.84772727272728|\n",
      "+------------+------------+-----------+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Indication on if the customer made a deposit to guarantee the booking.\n",
    "#No Deposit – no deposit was made\n",
    "#Non Refund – a deposit was made in the value of the total stay cost\n",
    "#Refundable – a deposit was made with a value under the total cost of stay.\n",
    "\n",
    "df.groupBy(\"deposit_type\", 'hotel', 'is_canceled').avg('adr').sort(\"deposit_type\", 'hotel', 'is_canceled').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+-----------+-----+\n",
      "|deposit_type|is_canceled|count|\n",
      "+------------+-----------+-----+\n",
      "|  No Deposit|          1|29694|\n",
      "|  No Deposit|          0|74947|\n",
      "|  Non Refund|          0|   93|\n",
      "|  Non Refund|          1|14494|\n",
      "|  Refundable|          1|   36|\n",
      "|  Refundable|          0|  126|\n",
      "+------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# view count of cancellation by deposit type\n",
    "df.groupBy(\"deposit_type\", 'is_canceled').count().sort(\"deposit_type\").show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+------------+-----------+-----+\n",
      "|deposit_type|       hotel|is_canceled|count|\n",
      "+------------+------------+-----------+-----+\n",
      "|  No Deposit|  City Hotel|          0|46198|\n",
      "|  No Deposit|  City Hotel|          1|20244|\n",
      "|  No Deposit|Resort Hotel|          0|28749|\n",
      "|  No Deposit|Resort Hotel|          1| 9450|\n",
      "|  Non Refund|  City Hotel|          0|   24|\n",
      "|  Non Refund|  City Hotel|          1|12844|\n",
      "|  Non Refund|Resort Hotel|          0|   69|\n",
      "|  Non Refund|Resort Hotel|          1| 1650|\n",
      "|  Refundable|  City Hotel|          0|    6|\n",
      "|  Refundable|  City Hotel|          1|   14|\n",
      "|  Refundable|Resort Hotel|          0|  120|\n",
      "|  Refundable|Resort Hotel|          1|   22|\n",
      "+------------+------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# heck count of cancellations for deposit type\n",
    "df.groupBy(\"deposit_type\", 'hotel', 'is_canceled').count().sort(\"deposit_type\", 'hotel', 'is_canceled').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data frame filtered by 0/1\n",
    "df_cancel0 = df.filter(col('is_canceled') == 0)\n",
    "df_cancel1 = df.filter(col('is_canceled') == 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[29694, 14494, 36]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Deposit types\n",
    "deposit0 = df_cancel0.groupBy('deposit_type').count().sort('deposit_type')\n",
    "deposit1 = df_cancel1.groupBy('deposit_type').count().sort('deposit_type')\n",
    "\n",
    "#List of counts for non-cancelled deposity types\n",
    "deposit0_list = deposit0.select(\"count\").rdd.flatMap(lambda x: x).collect()\n",
    "deposit0_list\n",
    "\n",
    "#List of counts for cancelled deposity types\n",
    "deposit1_list = deposit1.select(\"count\").rdd.flatMap(lambda x: x).collect()\n",
    "deposit1_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No Deposit', 'Non Refund', 'Refundable']\n"
     ]
    }
   ],
   "source": [
    "x_deposit = [val.deposit_type for val in df.select('deposit_type').groupBy('deposit_type').count().collect()]\n",
    "x_deposit.sort()\n",
    "print(x_deposit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": [
    "#visualize deposit_type cancellation\n",
    "\n",
    "#Sorted in this order: 'Contract', 'Group', 'Transient', 'Transient-Party'\n",
    "labels = x_deposit\n",
    "cancel0_count = deposit0_list\n",
    "cancel1_count = deposit1_list\n",
    "\n",
    "x = np.arange(len(x_deposit))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, cancel0_count, width, label='0 = Not Canceled')\n",
    "rects2 = ax.bar(x + width/2, cancel1_count, width, label='1 = Canceled')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('Count of Hotel Cancellations by Deposit Type')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "# plt.savefig(\"Cancel_by_Deposit.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+-----------+-----+\n",
      "|  customer_type|is_canceled|count|\n",
      "+---------------+-----------+-----+\n",
      "|       Contract|          0| 2814|\n",
      "|       Contract|          1| 1262|\n",
      "|          Group|          0|  518|\n",
      "|          Group|          1|   59|\n",
      "|      Transient|          0|53099|\n",
      "|      Transient|          1|36514|\n",
      "|Transient-Party|          0|18735|\n",
      "|Transient-Party|          1| 6389|\n",
      "+---------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Type of booking, assuming one of four categories\n",
    "#Contract - when the booking has an allotment or other type of contract associated to it\n",
    "#Group – when the booking is associated to a group\n",
    "#Transient – when the booking is not part of a group or contract, and is not associated to other transient booking\n",
    "#Transient-party – when the booking is transient, but is associated to at least other transient booking\n",
    "\n",
    "df.groupBy(\"customer_type\", 'is_canceled').count().sort('customer_type', 'is_canceled').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Contract', 'Group', 'Transient', 'Transient-Party']\n"
     ]
    }
   ],
   "source": [
    "# count distinct levels of customer type\n",
    "x_customer = [val.customer_type for val in df.select('customer_type').groupBy('customer_type').count().collect()]\n",
    "x_customer.sort()\n",
    "print(x_customer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+-----+\n",
      "|  customer_type|count|\n",
      "+---------------+-----+\n",
      "|       Contract| 2814|\n",
      "|          Group|  518|\n",
      "|      Transient|53099|\n",
      "|Transient-Party|18735|\n",
      "+---------------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# count of non-cancelled hotel booking by customer type\n",
    "customer0 = df_cancel0.groupBy('customer_type').count().sort('customer_type')\n",
    "customer0.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+-----+\n",
      "|  customer_type|count|\n",
      "+---------------+-----+\n",
      "|       Contract| 1262|\n",
      "|          Group|   59|\n",
      "|      Transient|36514|\n",
      "|Transient-Party| 6389|\n",
      "+---------------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# count of cancelled hotel booking by customer type\n",
    "customer1 = df_cancel1.groupBy('customer_type').count().sort('customer_type')\n",
    "customer1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list of count of count of non-cancelled hotel booking by customer type\n",
    "customer0_list = customer0.select(\"count\").rdd.flatMap(lambda x: x).collect()\n",
    "\n",
    "# list of count of count of cancelled hotel booking by customer type\n",
    "customer1_list = customer1.select(\"count\").rdd.flatMap(lambda x: x).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": [
    "#visualize customer_type cancellation\n",
    "\n",
    "#Sorted in this order: 'Contract', 'Group', 'Transient', 'Transient-Party'\n",
    "labels = x_customer\n",
    "cancel0_count = customer0_list\n",
    "cancel1_count = customer1_list\n",
    "\n",
    "x = np.arange(len(x_customer))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, cancel0_count, width, label='0 = Not Canceled')\n",
    "rects2 = ax.bar(x + width/2, cancel1_count, width, label='1 = Canceled')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('Count of Hotel Cancellations by Cutomer Type')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "# plt.savefig(\"Cancel_by_CustomerType.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+------------+------------------+\n",
      "|arrival_date_month|       hotel|          avg(adr)|\n",
      "+------------------+------------+------------------+\n",
      "|             April|  City Hotel|111.25183823529385|\n",
      "|             April|Resort Hotel| 77.84949570518152|\n",
      "|            August|  City Hotel|114.68045530446365|\n",
      "|            August|Resort Hotel|186.79057417245596|\n",
      "|          December|  City Hotel| 88.82630687318493|\n",
      "|          December|Resort Hotel| 68.98422960725051|\n",
      "|          February|  City Hotel| 85.08827794561917|\n",
      "|          February|Resort Hotel| 55.17193038994517|\n",
      "|           January|  City Hotel| 82.62898554603852|\n",
      "|           January|Resort Hotel|49.461883264933924|\n",
      "|              July|  City Hotel|110.73429154302673|\n",
      "|              July|Resort Hotel|155.18129892849296|\n",
      "|              June|  City Hotel|119.07434127185202|\n",
      "|              June|Resort Hotel|110.44474876847272|\n",
      "|             March|  City Hotel| 92.64311551563968|\n",
      "|             March|Resort Hotel|57.520146882493776|\n",
      "|               May|  City Hotel|121.63856049562638|\n",
      "|               May|Resort Hotel| 78.75813430739011|\n",
      "|          November|  City Hotel| 88.06960064264416|\n",
      "|          November|Resort Hotel|48.273992613869645|\n",
      "+------------------+------------+------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Average hotel daily average rates per month by hotel\n",
    "df.groupBy('arrival_date_month','hotel').avg('adr').sort('arrival_date_month','hotel').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+------------+-----------+-----+\n",
      "|arrival_date_month|       hotel|is_canceled|count|\n",
      "+------------------+------------+-----------+-----+\n",
      "|             April|  City Hotel|          0| 4015|\n",
      "|             April|  City Hotel|          1| 3465|\n",
      "|             April|Resort Hotel|          0| 2550|\n",
      "|             April|Resort Hotel|          1| 1059|\n",
      "|            August|  City Hotel|          0| 5381|\n",
      "|            August|  City Hotel|          1| 3602|\n",
      "|            August|Resort Hotel|          0| 3257|\n",
      "|            August|Resort Hotel|          1| 1637|\n",
      "|          December|  City Hotel|          0| 2392|\n",
      "|          December|  City Hotel|          1| 1740|\n",
      "|          December|Resort Hotel|          0| 2017|\n",
      "|          December|Resort Hotel|          1|  631|\n",
      "|          February|  City Hotel|          0| 3064|\n",
      "|          February|  City Hotel|          1| 1901|\n",
      "|          February|Resort Hotel|          0| 2308|\n",
      "|          February|Resort Hotel|          1|  795|\n",
      "|           January|  City Hotel|          0| 2254|\n",
      "|           January|  City Hotel|          1| 1482|\n",
      "|           January|Resort Hotel|          0| 1868|\n",
      "|           January|Resort Hotel|          1|  325|\n",
      "+------------------+------------+-----------+-----+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Hotel cancellation counts by hotel atype and month\n",
    "df.groupBy('arrival_date_month','hotel', 'is_canceled')\\\n",
    "    .count().sort('arrival_date_month','hotel', 'is_canceled').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['April',\n",
       " 'August',\n",
       " 'December',\n",
       " 'February',\n",
       " 'January',\n",
       " 'July',\n",
       " 'June',\n",
       " 'March',\n",
       " 'May',\n",
       " 'November',\n",
       " 'October',\n",
       " 'September']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# unordered original appeared months\n",
    "months_label = [val.arrival_date_month for val in df.select('arrival_date_month').distinct().collect()] \n",
    "months_label.sort()\n",
    "months_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['04', '08', '12', '02', '01', '07', '06', '03', '05', '11', '10', '09']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reorder months\n",
    "months_label[0] = '04'\n",
    "months_label[1] = '08'\n",
    "months_label[2] = '12'\n",
    "months_label[3] = '02'\n",
    "months_label[4] = '01'\n",
    "months_label[5] = '07'\n",
    "months_label[6] = '06'\n",
    "months_label[7] = '03'\n",
    "months_label[8] = '05'\n",
    "months_label[9] = '11'\n",
    "months_label[10] = '10'\n",
    "months_label[11] = '09'\n",
    "months_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12']\n"
     ]
    }
   ],
   "source": [
    "months_label.sort()\n",
    "print(months_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['January',\n",
       " 'February',\n",
       " 'March',\n",
       " 'April',\n",
       " 'May',\n",
       " 'June',\n",
       " 'July',\n",
       " 'August',\n",
       " 'September',\n",
       " 'October',\n",
       " 'November',\n",
       " 'December']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reorder2\n",
    "months_label[0] = 'January'\n",
    "months_label[1] = 'February'\n",
    "months_label[2] = 'March'\n",
    "months_label[3] = 'April'\n",
    "months_label[4] = 'May'\n",
    "months_label[5] = 'June'\n",
    "months_label[6] = 'July'\n",
    "months_label[7] = 'August'\n",
    "months_label[8] = 'September'\n",
    "months_label[9] = 'October'\n",
    "months_label[10] = 'November'\n",
    "months_label[11] = 'December'\n",
    "months_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+-----+\n",
      "|arrival_date_month|count|\n",
      "+------------------+-----+\n",
      "|             April| 6565|\n",
      "|            August| 8638|\n",
      "|          December| 4409|\n",
      "|          February| 5372|\n",
      "|           January| 4122|\n",
      "|              July| 7919|\n",
      "|              June| 6404|\n",
      "|             March| 6645|\n",
      "|               May| 7114|\n",
      "|          November| 4672|\n",
      "|           October| 6914|\n",
      "|         September| 6392|\n",
      "+------------------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# count of non-cancellation by month\n",
    "months_cancel0 = df_cancel0.groupBy('arrival_date_month')\\\n",
    "    .count().sort('arrival_date_month')\n",
    "months_cancel0.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get list of counts for months when not canceled\n",
    "month0_list = months_cancel0.select(\"count\").rdd.flatMap(lambda x: x).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4122, 5372, 6645, 6565, 7114, 6404, 7919, 8638, 6392, 6914, 4672, 4409]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reorder month canceled list counts for Jan-Dec\n",
    "month0_list2 = [0] * 12\n",
    "month0_list2[0] = month0_list[4]  #Apr spot for Jan\n",
    "month0_list2[1] = month0_list[3]  #Aug spot for Feb\n",
    "month0_list2[2] = month0_list[7]  #Dec spot for Mar\n",
    "month0_list2[3] = month0_list[0]  #Feb spot for Apr\n",
    "month0_list2[4] = month0_list[8]  #Jan spot for May\n",
    "month0_list2[5] = month0_list[6]  #Jul spot for Jun\n",
    "month0_list2[6] = month0_list[5]  #Jun spot for Jul\n",
    "month0_list2[7] = month0_list[1]  #Mar spot for Aug\n",
    "month0_list2[8] = month0_list[11]  #May spot for Sep\n",
    "month0_list2[9] = month0_list[10]  #Nov spot for Oct\n",
    "month0_list2[10] = month0_list[9]  #Oct spot for Nov\n",
    "month0_list2[11] = month0_list[2]  #Sep spot for Dec\n",
    "month0_list2\n",
    "\n",
    "# Now list of counts matches Jan-Dec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+-----+\n",
      "|arrival_date_month|count|\n",
      "+------------------+-----+\n",
      "|             April| 4524|\n",
      "|            August| 5239|\n",
      "|          December| 2371|\n",
      "|          February| 2696|\n",
      "|           January| 1807|\n",
      "|              July| 4742|\n",
      "|              June| 4535|\n",
      "|             March| 3149|\n",
      "|               May| 4677|\n",
      "|          November| 2122|\n",
      "|           October| 4246|\n",
      "|         September| 4116|\n",
      "+------------------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# counts of cancelled booking by month\n",
    "months_cancel1 = df_cancel1.groupBy('arrival_date_month')\\\n",
    "    .count().sort('arrival_date_month')\n",
    "months_cancel1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4524, 5239, 2371, 2696, 1807, 4742, 4535, 3149, 4677, 2122, 4246, 4116]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get list of counts for months when canceled\n",
    "month1_list = months_cancel1.select(\"count\").rdd.flatMap(lambda x: x).collect()\n",
    "month1_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1807, 2696, 3149, 4524, 4677, 4535, 4742, 5239, 4116, 4246, 2122, 2371]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reorder month canceled list counts for Jan-Dec\n",
    "month1_list2 = [0] * 12\n",
    "month1_list2[0] = month1_list[4]  #Apr spot for Jan\n",
    "month1_list2[1] = month1_list[3]  #Aug spot for Feb\n",
    "month1_list2[2] = month1_list[7]  #Dec spot for Mar\n",
    "month1_list2[3] = month1_list[0]  #Feb spot for Apr\n",
    "month1_list2[4] = month1_list[8]  #Jan spot for May\n",
    "month1_list2[5] = month1_list[6]  #Jul spot for Jun\n",
    "month1_list2[6] = month1_list[5]  #Jun spot for Jul\n",
    "month1_list2[7] = month1_list[1]  #Mar spot for Aug\n",
    "month1_list2[8] = month1_list[11]  #May spot for Sep\n",
    "month1_list2[9] = month1_list[10]  #Nov spot for Oct\n",
    "month1_list2[10] = month1_list[9]  #Oct spot for Nov\n",
    "month1_list2[11] = month1_list[2]  #Sep spot for Dec\n",
    "month1_list2\n",
    "\n",
    "# Now list of counts matches Jan-Dec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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": [
    "# visualize non cancellations and cancellations by month\n",
    "\n",
    "# Ordered: Jan, Feb, Mar...\n",
    "labels = months_label\n",
    "cancel0_count = month0_list2\n",
    "cancel1_count = month1_list2\n",
    "\n",
    "x = np.arange(len(months_label))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, cancel0_count, width, label='0 = Not Canceled')\n",
    "rects2 = ax.bar(x + width/2, cancel1_count, width, label='1 = Canceled')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('Count of Hotel Cancellations by Month')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels, rotation = 45, ha=\"right\")\n",
    "ax.legend()\n",
    "\n",
    "# plt.savefig(\"Cancel_by_Month.png\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------+------------+-----------+-----+\n",
      "|arrival_date_year|       hotel|is_canceled|count|\n",
      "+-----------------+------------+-----------+-----+\n",
      "|             2015|  City Hotel|          0| 7678|\n",
      "|             2015|  City Hotel|          1| 6004|\n",
      "|             2015|Resort Hotel|          0| 6176|\n",
      "|             2015|Resort Hotel|          1| 2138|\n",
      "|             2016|  City Hotel|          0|22733|\n",
      "|             2016|  City Hotel|          1|15407|\n",
      "|             2016|Resort Hotel|          0|13637|\n",
      "|             2016|Resort Hotel|          1| 4930|\n",
      "|             2017|  City Hotel|          0|15817|\n",
      "|             2017|  City Hotel|          1|11691|\n",
      "|             2017|Resort Hotel|          0| 9125|\n",
      "|             2017|Resort Hotel|          1| 4054|\n",
      "+-----------------+------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Count of cancellations by hotel type and year\n",
    "# 2015-2017\n",
    "df.groupBy('arrival_date_year','hotel', 'is_canceled')\\\n",
    "    .count().sort('arrival_date_year','hotel', 'is_canceled').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+-----+\n",
      "|       hotel|count|\n",
      "+------------+-----+\n",
      "|  City Hotel|79330|\n",
      "|Resort Hotel|40060|\n",
      "+------------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# count of cancellation by hotel\n",
    "df.groupBy('hotel').count().select('hotel', f.col('count')).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get counts of cancel or not cancel by hotel type\n",
    "resort_0 = df.filter((col('hotel') == 'Resort Hotel') & (col('is_canceled') == 0)).count()\n",
    "resort_1 = df.filter((col('hotel') == 'Resort Hotel') & (col('is_canceled') == 1)).count()\n",
    "city_0 = df.filter((col('hotel') == 'City Hotel') & (col('is_canceled') == 0)).count()\n",
    "city_1 = df.filter((col('hotel') == 'City Hotel') & (col('is_canceled') == 1)).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+-----------+-----+\n",
      "|       hotel|is_canceled|count|\n",
      "+------------+-----------+-----+\n",
      "|Resort Hotel|          0|28938|\n",
      "|  City Hotel|          0|46228|\n",
      "|Resort Hotel|          1|11122|\n",
      "|  City Hotel|          1|33102|\n",
      "+------------+-----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# cancellations by hotel type in dataframe\n",
    "df.groupBy('hotel', 'is_canceled').count().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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": [
    "# to visualize, we use matplotlib\n",
    "# Hotel cancellations by hotel type\n",
    "\n",
    "# y_iscancel = [val.is_canceled for val in df.select('is_canceled').distinct().collect()]   #gets [0,1]\n",
    "x_hoteltype = [val.hotel for val in df.select('hotel').groupBy('hotel').count().collect()]\n",
    "\n",
    "labels = ['City Hotel', 'Resort Hotel']\n",
    "cancel0_count = [city_0, resort_0]\n",
    "cancel1_count = [city_1, resort_1]\n",
    "\n",
    "x = np.arange(len(x_hoteltype))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, cancel0_count, width, label='0 = Not Canceled')\n",
    "rects2 = ax.bar(x + width/2, cancel1_count, width, label='1 = Canceled')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('Count of hotel cancellations by hotel type')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "plt.savefig(\"Cancel_by_HotelType.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import col\n",
    "\n",
    "# replace the strings \"NULL\" and \"NA\" with null value\n",
    "df_withNull = df.replace('NULL', None).replace('NA', None)\n",
    "\n",
    "# replace null values in 'children' to 0 since there are only 4\n",
    "df2 = df_withNull.fillna({'children':0})\n",
    "\n",
    "# replace 'children' datatype to int\n",
    "df2 = df2.withColumn('children', col('children').cast(\"Int\"))\n",
    "df2 = df2.withColumn('arrival_date_year', col('arrival_date_year').cast(\"Int\")-2015)\n",
    "\n",
    "# drop 'company' and 'agent' due to high null count\n",
    "df2 = df2.drop('agent', 'company','country', 'arrival_date_week_number', 'reservation_status', 'reservation_status_date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specifying which columns to encode in which way\n",
    "from pyspark.ml.feature import OneHotEncoder, OneHotEncoderModel, Normalizer\n",
    "from pyspark.ml.feature import StringIndexer, VectorAssembler\n",
    "from pyspark.ml import Pipeline\n",
    "from pyspark.mllib.linalg import Vectors\n",
    "\n",
    "# list of columns to numerically encode\n",
    "col_string=['hotel', 'meal','market_segment',\n",
    "            'distribution_channel','reserved_room_type','assigned_room_type',\n",
    "            'deposit_type','customer_type']\n",
    "col_stringwmonth = col_string+['arrival_date_month']\n",
    "\n",
    "# list of new column names being changed into numeric\n",
    "col_num=[x+\"_NUMERIC\" for x in col_string]\n",
    "\n",
    "# list of columns being one-hot encoded\n",
    "col_oh=[x+\"_oh\" for x in col_string]\n",
    "\n",
    "# list of columns to normalize\n",
    "norm_to_columns = ['lead_time', 'stays_in_weekend_nights', 'stays_in_week_nights', 'adults', 'children', 'babies', \n",
    "                'previous_cancellations', 'previous_bookings_not_canceled', 'booking_changes', 'adr', \n",
    "                'required_car_parking_spaces', 'total_of_special_requests']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numerical Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine string index encoding on each specified column\n",
    "all_string_index = [StringIndexer(inputCol=column, outputCol=column+\"_NUMERIC\").fit(df2) for column in col_stringwmonth]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One Hot Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ohe columns\n",
    "ohe = OneHotEncoder(dropLast=False).setInputCols(col_num).setOutputCols(col_oh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine all to-norm columns into one vector named \"norm_features\"\n",
    "assembler = VectorAssembler(inputCols=norm_to_columns, outputCol=\"to_norm_features\")\n",
    "\n",
    "# normalize continuous columns\n",
    "normalizer = Normalizer(inputCol=\"to_norm_features\", outputCol=\"norm_features\", p=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify final variables\n",
    "final_variables = ['lead_time', \n",
    "                   'arrival_date_year',\n",
    "                   'arrival_date_day_of_month',\n",
    "                   'stays_in_weekend_nights',\n",
    "                   'stays_in_week_nights',\n",
    "                   'adults',\n",
    "                   'children', \n",
    "                   'babies',\n",
    "                   'is_repeated_guest',\n",
    "                   'previous_cancellations',\n",
    "                   'previous_bookings_not_canceled',\n",
    "                   'booking_changes',\n",
    "                   'days_in_waiting_list',\n",
    "                   'adr',\n",
    "                   'required_car_parking_spaces',\n",
    "                   'total_of_special_requests',\n",
    "                   'arrival_date_month_NUMERIC',\n",
    "                   'distribution_channel_oh',\n",
    "                   'customer_type_oh',\n",
    "                   'market_segment_oh',\n",
    "                   'reserved_room_type_oh',\n",
    "                   'assigned_room_type_oh',\n",
    "                   'meal_oh',\n",
    "                   'hotel_oh',\n",
    "                   'deposit_type_oh']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine all feature columns (non-label columns) into one vector named \"feature\"\n",
    "assembler2 = VectorAssembler(inputCols=final_variables, outputCol=\"features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Construct Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct pipeline\n",
    "pipeline = Pipeline(stages=all_string_index + [ohe, assembler, normalizer, assembler2])\n",
    "df3 = pipeline.fit(df2).transform(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert to RDD\n",
    "dataRdd = df3.select(col(\"is_canceled\").alias(\"label\"), col(\"features\")).rdd.map(tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Construct LabeledPoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.regression import LabeledPoint\n",
    "\n",
    "# map features as floats, then input all into a DenseVector, as well as mapping labels as floats\n",
    "# then map into LabeledPoint object\n",
    "lp = dataRdd.map(lambda row: (float(row[0]), Vectors.dense([float(c) for c in row[1]])))\\\n",
    "            .map(lambda row: LabeledPoint(row[0], row[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Split Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 70/30 test train split\n",
    "seed = 314\n",
    "train, test = lp.randomSplit([0.7, 0.3], seed=seed)\n",
    "\n",
    "# store test and train counts\n",
    "test_count = test.count()\n",
    "train_count = train.count()\n",
    "\n",
    "from pyspark.mllib.evaluation import MulticlassMetrics\n",
    "from pyspark.mllib.evaluation import BinaryClassificationMetrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Model Fitting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Base Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.classification import LogisticRegressionWithLBFGS\n",
    "\n",
    "# train logistic regression model with training data\n",
    "model = LogisticRegressionWithLBFGS.train(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8128138236696681\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te = test.map(lambda p: (p.label, float(model.predict(p.features))))\n",
    "accuracy_te = 1.0 * labelsAndPreds_te.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_int = LogisticRegressionWithLBFGS.train(train, intercept=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8131504390024966\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_int = test.map(lambda p: (p.label, float(model_lr_int.predict(p.features))))\n",
    "accuracy_te_int = 1.0 * labelsAndPreds_te_int.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with iterations=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it10 = LogisticRegressionWithLBFGS.train(train, iterations=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.7997699795225672\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it10 = test.map(lambda p: (p.label, float(model_lr_it10.predict(p.features))))\n",
    "accuracy_te_it10 = 1.0 * labelsAndPreds_te_it10.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with iterations=50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it50 = LogisticRegressionWithLBFGS.train(train, iterations=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.812729669836461\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it50 = test.map(lambda p: (p.label, float(model_lr_it50.predict(p.features))))\n",
    "accuracy_te_it50 = 1.0 * labelsAndPreds_te_it50.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it200 = LogisticRegressionWithLBFGS.train(train, iterations=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8129260287806109\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it200 = test.map(lambda p: (p.label, float(model_lr_it200.predict(p.features))))\n",
    "accuracy_te_it200 = 1.0 * labelsAndPreds_te_it200.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it200))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept, iterations=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it10_int = LogisticRegressionWithLBFGS.train(train, iterations=10, intercept=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.7993492103565317\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it10_int = test.map(lambda p: (p.label, float(model_lr_it10_int.predict(p.features))))\n",
    "accuracy_te_it10_int = 1.0 * labelsAndPreds_te_it10_int.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it10_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept, iterations=50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it50_int = LogisticRegressionWithLBFGS.train(train, iterations=50, intercept=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8130101826138181\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it50_int = test.map(lambda p: (p.label, float(model_lr_it50_int.predict(p.features))))\n",
    "accuracy_te_it50_int = 1.0 * labelsAndPreds_te_it50_int.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it50_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept, iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train logistic regression model with training data\n",
    "model_lr_it200_int = LogisticRegressionWithLBFGS.train(train, iterations=200, intercept=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8128418749474039\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it200_int = test.map(lambda p: (p.label, float(model_lr_it200_int.predict(p.features))))\n",
    "accuracy_te_it200_int = 1.0 * labelsAndPreds_te_it200_int.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_it200_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression Model Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Base Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20736.  4971.]\n",
      " [ 1702.  8240.]]\n",
      "False negative rate 17.12%\n",
      "False positive rate 19.34%\n",
      "Precision(TP/all positives) 62.37%\n",
      "Recall(TP/all positive ground truth) 82.88%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 71.18%\n",
      "Area under PR for Logistic regression = 59.42%\n",
      "Area under ROC for Logistic regression = 81.77%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for base logistic model\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20769.  4992.]\n",
      " [ 1669.  8219.]]\n",
      "False negative rate 16.88%\n",
      "False positive rate 19.38%\n",
      "Precision(TP/all positives) 62.21%\n",
      "Recall(TP/all positive ground truth) 83.12%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 71.16%\n",
      "Area under PR for Logistic regression = 59.30%\n",
      "Area under ROC for Logistic regression = 81.87%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for logistic model with intercept\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te_int)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te_int)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with iterations=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20183.  4883.]\n",
      " [ 2255.  8328.]]\n",
      "False negative rate 21.31%\n",
      "False positive rate 19.48%\n",
      "Precision(TP/all positives) 63.04%\n",
      "Recall(TP/all positive ground truth) 78.69%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 70.00%\n",
      "Area under PR for Logistic regression = 59.49%\n",
      "Area under ROC for Logistic regression = 79.61%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for logistic model with iterations=10\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te_it10)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te_it10)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20751.  4982.]\n",
      " [ 1687.  8229.]]\n",
      "False negative rate 17.01%\n",
      "False positive rate 19.36%\n",
      "Precision(TP/all positives) 62.29%\n",
      "Recall(TP/all positive ground truth) 82.99%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 71.16%\n",
      "Area under PR for Logistic regression = 59.36%\n",
      "Area under ROC for Logistic regression = 81.81%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for logistic model with iterations=100\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te_it200)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te_it200)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept, iterations=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20199.  4914.]\n",
      " [ 2239.  8297.]]\n",
      "False negative rate 21.25%\n",
      "False positive rate 19.57%\n",
      "Precision(TP/all positives) 62.80%\n",
      "Recall(TP/all positive ground truth) 78.75%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 69.88%\n",
      "Area under PR for Logistic regression = 59.27%\n",
      "Area under ROC for Logistic regression = 79.59%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for logistic model with intercept, iterations=10\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te_it10_int)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te_it10_int)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept, iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20750.  4984.]\n",
      " [ 1688.  8227.]]\n",
      "False negative rate 17.02%\n",
      "False positive rate 19.37%\n",
      "Precision(TP/all positives) 62.27%\n",
      "Recall(TP/all positive ground truth) 82.98%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 71.15%\n",
      "Area under PR for Logistic regression = 59.34%\n",
      "Area under ROC for Logistic regression = 81.80%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for logistic model with intercept, iterations=100\n",
    "\n",
    "metrix1 = MulticlassMetrics(labelsAndPreds_te_it200_int)\n",
    "con_metrix1=metrix1.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix1)\n",
    "\n",
    "FN1=metrix1.falsePositiveRate(0.0)\n",
    "FP1=metrix1.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN1))\n",
    "print('False positive rate {:2.2%}'.format(FP1))\n",
    "\n",
    "precision1=metrix1.precision(1.0)\n",
    "recall1=metrix1.recall(1.0)\n",
    "f1score=(2*precision1*recall1) / (precision1+recall1)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score))\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te_it200_int)\n",
    "\n",
    "print(\"Area under PR for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Logistic regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.tree import RandomForest, RandomForestModel\n",
    "from pyspark.mllib.util import MLUtils\n",
    "# converting to LibSVM file (only run once)\n",
    "# MLUtils.saveAsLibSVMFile(lp, \"libsvm.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read LibSVM file\n",
    "data = MLUtils.loadLibSVMFile(sc, 'libsvm.txt')\n",
    "data.take(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 70/30 test train split for libsvm data\n",
    "seed = 314\n",
    "train_sparse, test_sparse = data.randomSplit([0.7, 0.3], seed=seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest Base Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train a RandomForest model.\n",
    "#  Empty categoricalFeaturesInfo indicates all features are continuous.\n",
    "#  Setting featureSubsetStrategy=\"auto\" lets the algorithm choose.\n",
    "model_rf = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=5, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=5, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5581643243849758\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions = model_rf.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te2 = test_sparse.map(lambda lp: lp.label).zip(predictions)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te2 = 1.0 * labelsAndPreds_te2.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with numTrees=50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rf_nt50 = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=50, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=5, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5716850402535836\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions_nt50 = model_rf_nt50.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te_nt50 = test_sparse.map(lambda lp: lp.label).zip(predictions_nt50)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te_nt50 = 1.0 * labelsAndPreds_te_nt50.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_nt50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with numTrees=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rf_nt100 = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=100, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=5, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.573985245027911\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions_nt100 = model_rf_nt100.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te_nt100 = test_sparse.map(lambda lp: lp.label).zip(predictions_nt100)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te_nt100 = 1.0 * labelsAndPreds_te_nt100.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_nt100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with maxDepth=15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rf_md15 = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=5, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=15, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5989228309349491\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions_md15 = model_rf_md15.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te_md15 = test_sparse.map(lambda lp: lp.label).zip(predictions_md15)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te_md15 = 1.0 * labelsAndPreds_te_md15.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_md15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with maxDepth=30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rf_md30 = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=5, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=30, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.6106763163062078\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions_md30 = model_rf_md30.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te_md30 = test_sparse.map(lambda lp: lp.label).zip(predictions_md30)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te_md30 = 1.0 * labelsAndPreds_te_md30.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_md30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with numTrees=50, maxDepth=15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rf_nt50md15 = RandomForest.trainClassifier(train_sparse, numClasses=2, categoricalFeaturesInfo={},\n",
    "                                     numTrees=50, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=15, maxBins=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.6087407781424444\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute accuracy\n",
    "predictions_nt50md15 = model_rf_nt50md15.predict(test_sparse.map(lambda x: x.features))\n",
    "labelsAndPreds_te_nt50md15 = test_sparse.map(lambda lp: lp.label).zip(predictions_nt50md15)\n",
    "# labelsAndPreds_te3 = test_sparse.map(lambda p: (p.label, float(model_rf.predict(p.features))))\n",
    "\n",
    "accuracy_te_nt50md15 = 1.0 * labelsAndPreds_te_nt50md15.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te_nt50md15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest Model Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest Base Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[11759.  5127.]\n",
      " [ 1559.  8139.]]\n",
      "False negative rate 16.08%\n",
      "False positive rate 30.36%\n",
      "Precision(TP/all positives) 61.35%\n",
      "Recall(TP/all positive ground truth) 83.92%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 70.88%\n",
      "Area under PR for Random Forest = 59.35%\n",
      "Area under ROC for Random Forest = 76.78%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for base random forest\n",
    "\n",
    "metrix2 = MulticlassMetrics(labelsAndPreds_te2)\n",
    "con_metrix2=metrix2.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix2)\n",
    "\n",
    "FN2=metrix2.falsePositiveRate(0.0)\n",
    "FP2=metrix2.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN2))\n",
    "print('False positive rate {:2.2%}'.format(FP2))\n",
    "\n",
    "precision2=metrix2.precision(1.0)\n",
    "recall2=metrix2.recall(1.0)\n",
    "f1score2=(2*precision2*recall2) / (precision2+recall2)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision2))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall2))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score2))\n",
    "\n",
    "\n",
    "metrics_tr2 = BinaryClassificationMetrics(labelsAndPreds_te2)\n",
    "\n",
    "print(\"Area under PR for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with numTrees=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[12394.  5198.]\n",
      " [  924.  8068.]]\n",
      "False negative rate 10.28%\n",
      "False positive rate 29.55%\n",
      "Precision(TP/all positives) 60.82%\n",
      "Recall(TP/all positive ground truth) 89.72%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 72.50%\n",
      "Area under PR for Random Forest = 59.43%\n",
      "Area under ROC for Random Forest = 80.09%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for random forest\n",
    "\n",
    "metrix2 = MulticlassMetrics(labelsAndPreds_te_nt100)\n",
    "con_metrix2=metrix2.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix2)\n",
    "\n",
    "FN2=metrix2.falsePositiveRate(0.0)\n",
    "FP2=metrix2.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN2))\n",
    "print('False positive rate {:2.2%}'.format(FP2))\n",
    "\n",
    "precision2=metrix2.precision(1.0)\n",
    "recall2=metrix2.recall(1.0)\n",
    "f1score2=(2*precision2*recall2) / (precision2+recall2)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision2))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall2))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score2))\n",
    "\n",
    "\n",
    "metrics_tr2 = BinaryClassificationMetrics(labelsAndPreds_te_nt100)\n",
    "\n",
    "print(\"Area under PR for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with maxDepth=30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[11147.  2643.]\n",
      " [ 2171. 10623.]]\n",
      "False negative rate 16.97%\n",
      "False positive rate 19.17%\n",
      "Precision(TP/all positives) 80.08%\n",
      "Recall(TP/all positive ground truth) 83.03%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 81.53%\n",
      "Area under PR for Random Forest = 77.37%\n",
      "Area under ROC for Random Forest = 81.93%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for random forest\n",
    "\n",
    "metrix2 = MulticlassMetrics(labelsAndPreds_te_md30)\n",
    "con_metrix2=metrix2.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix2)\n",
    "\n",
    "FN2=metrix2.falsePositiveRate(0.0)\n",
    "FP2=metrix2.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN2))\n",
    "print('False positive rate {:2.2%}'.format(FP2))\n",
    "\n",
    "precision2=metrix2.precision(1.0)\n",
    "recall2=metrix2.recall(1.0)\n",
    "f1score2=(2*precision2*recall2) / (precision2+recall2)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision2))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall2))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score2))\n",
    "\n",
    "\n",
    "metrics_tr2 = BinaryClassificationMetrics(labelsAndPreds_te_md30)\n",
    "\n",
    "print(\"Area under PR for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest with numTrees=50, maxDepth=15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[11726.  3291.]\n",
      " [ 1592.  9975.]]\n",
      "False negative rate 13.76%\n",
      "False positive rate 21.92%\n",
      "Precision(TP/all positives) 75.19%\n",
      "Recall(TP/all positive ground truth) 86.24%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 80.34%\n",
      "Area under PR for Random Forest = 73.01%\n",
      "Area under ROC for Random Forest = 82.16%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for random forest\n",
    "\n",
    "metrix2 = MulticlassMetrics(labelsAndPreds_te_nt50md15)\n",
    "con_metrix2=metrix2.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix2)\n",
    "\n",
    "FN2=metrix2.falsePositiveRate(0.0)\n",
    "FP2=metrix2.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN2))\n",
    "print('False positive rate {:2.2%}'.format(FP2))\n",
    "\n",
    "precision2=metrix2.precision(1.0)\n",
    "recall2=metrix2.recall(1.0)\n",
    "f1score2=(2*precision2*recall2) / (precision2+recall2)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision2))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall2))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score2))\n",
    "\n",
    "\n",
    "metrics_tr2 = BinaryClassificationMetrics(labelsAndPreds_te_nt50md15)\n",
    "\n",
    "print(\"Area under PR for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Random Forest = {:2.2%}\".format(metrics_tr2.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Support Vector Machine (SVM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM Base Model (iterations=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5484024797329519\n"
     ]
    }
   ],
   "source": [
    "from pyspark.mllib.classification import SVMWithSGD\n",
    "\n",
    "# build SVM model, default is iterations=100\n",
    "model_svm = SVMWithSGD.train(train,iterations=100)\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm1 = test.map(lambda p: (p.label, float(model_svm.predict(p.features))))\n",
    "accuracy_svm1 = 1.0 * labelsAndPreds_svm1.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.6377738505988948\n"
     ]
    }
   ],
   "source": [
    "# build SVM model\n",
    "model_svm_2 = SVMWithSGD.train(train, intercept=True)\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm2 = test.map(lambda p: (p.label, float(model_svm_2.predict(p.features))))\n",
    "accuracy_svm2 = 1.0 * labelsAndPreds_svm2.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5537883250582064\n"
     ]
    }
   ],
   "source": [
    "# build SVM model\n",
    "model_svm3 = SVMWithSGD.train(train, iterations=200)\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm3 = test.map(lambda p: (p.label, float(model_svm3.predict(p.features))))\n",
    "accuracy_svm3 = 1.0 * labelsAndPreds_svm3.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.6328368257174114\n"
     ]
    }
   ],
   "source": [
    "# build SVM model\n",
    "model_svm4 = SVMWithSGD.train(train, iterations=200, intercept=True)\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm4 = test.map(lambda p: (p.label, float(model_svm4.predict(p.features))))\n",
    "accuracy_svm4 = 1.0 * labelsAndPreds_svm4.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=200, regType='l1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.634379645992875\n"
     ]
    }
   ],
   "source": [
    "# build SVM model\n",
    "model_svm_5 = SVMWithSGD.train(train,iterations=200,intercept=True, regType='l1')\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm5 = test.map(lambda p: (p.label, float(model_svm_5.predict(p.features))))\n",
    "accuracy_svm5 = 1.0 * labelsAndPreds_svm5.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=100, regType='l1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.6378019018766304\n"
     ]
    }
   ],
   "source": [
    "# build SVM model\n",
    "model_svm_6 = SVMWithSGD.train(train,iterations=100,intercept=True, regType='l1')\n",
    "\n",
    "# evaluate predictions and model accuracy\n",
    "labelsAndPreds_svm6 = test.map(lambda p: (p.label, float(model_svm_6.predict(p.features))))\n",
    "accuracy_svm6 = 1.0 * labelsAndPreds_svm6.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_svm6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM Model Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM Base Model (iterations=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[ 7891.  1552.]\n",
      " [14547. 11659.]]\n",
      "False negative rate 55.51%\n",
      "False positive rate 16.44%\n",
      "Precision(TP/all positives) 88.25%\n",
      "Recall(TP/all positive ground truth) 44.49%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 59.16%\n",
      "Area under PR for Linear regression = 84.16%\n",
      "Area under ROC for Linear regression = 64.03%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm1)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm1)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[22281. 12756.]\n",
      " [  157.   455.]]\n",
      "False negative rate 25.65%\n",
      "False positive rate 36.41%\n",
      "Precision(TP/all positives) 3.44%\n",
      "Recall(TP/all positive ground truth) 74.35%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 6.58%\n",
      "Area under PR for Linear regression = 3.22%\n",
      "Area under ROC for Linear regression = 68.97%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm2)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm2)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[ 8178.  1647.]\n",
      " [14260. 11564.]]\n",
      "False negative rate 55.22%\n",
      "False positive rate 16.76%\n",
      "Precision(TP/all positives) 87.53%\n",
      "Recall(TP/all positive ground truth) 44.78%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 59.25%\n",
      "Area under PR for Linear regression = 83.37%\n",
      "Area under ROC for Linear regression = 64.01%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm3)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm3)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[22364. 13015.]\n",
      " [   74.   196.]]\n",
      "False negative rate 27.41%\n",
      "False positive rate 36.79%\n",
      "Precision(TP/all positives) 1.48%\n",
      "Recall(TP/all positive ground truth) 72.59%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 2.91%\n",
      "Area under PR for Linear regression = 1.38%\n",
      "Area under ROC for Linear regression = 67.90%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm4)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm4)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=200, regType='l1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[22359. 12955.]\n",
      " [   79.   256.]]\n",
      "False negative rate 23.58%\n",
      "False positive rate 36.69%\n",
      "Precision(TP/all positives) 1.94%\n",
      "Recall(TP/all positive ground truth) 76.42%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 3.78%\n",
      "Area under PR for Linear regression = 1.82%\n",
      "Area under ROC for Linear regression = 69.87%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm5)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm5)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SVM with intercept, iterations=200, regType='l1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[22282. 12756.]\n",
      " [  156.   455.]]\n",
      "False negative rate 25.53%\n",
      "False positive rate 36.41%\n",
      "Precision(TP/all positives) 3.44%\n",
      "Recall(TP/all positive ground truth) 74.47%\n",
      "F1 Score(2*Precision*Recall/(Precision+Recall)) 6.58%\n",
      "Area under PR for Linear regression = 3.22%\n",
      "Area under ROC for Linear regression = 69.03%\n"
     ]
    }
   ],
   "source": [
    "# calculate confusion matrix and AUROC for SVM\n",
    "\n",
    "metrix3 = MulticlassMetrics(labelsAndPreds_svm6)\n",
    "con_metrix3=metrix3.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix3)\n",
    "\n",
    "FN3=metrix3.falsePositiveRate(0.0)\n",
    "FP3=metrix3.falsePositiveRate(1.0)\n",
    "\n",
    "print('False negative rate {:2.2%}'.format(FN3))\n",
    "print('False positive rate {:2.2%}'.format(FP3))\n",
    "\n",
    "precision3=metrix3.precision(1.0)\n",
    "recall3=metrix3.recall(1.0)\n",
    "f1score3=(2*precision3*recall3) / (precision3+recall3)\n",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "print('F1 Score(2*Precision*Recall/(Precision+Recall)) {:0.2%}'.format(f1score3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_svm6)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr3.areaUnderROC))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}