ROC_Curve.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'findspark'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-f7685f0985e4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mfindspark\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpyspark\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msql\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mSparkSession\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mhandyspark\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mmatplotlib\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_line_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'matplotlib'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'inline'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'findspark'"
     ]
    }
   ],
   "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": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Parameters for defining code below\n",
    "target = 'is_canceled'\n",
    "cancel_label = 1\n",
    "noncancel_label = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# addressing reservation_status_date, which gives the date at which the last \n",
    "# reservation status was set. I'm transforming it into number of days since reservation\n",
    "# status was set, so day of arrival - reservation_status_date\n",
    "# from pyspark.sql.types import DateType\n",
    "\n",
    "# convert reservation_status_date into datetype dtype\n",
    "# temp = df2.withColumn(\"reservation_status_date\", df2[\"reservation_status_date\"].cast(DateType()))\n",
    "\n",
    "# need to combine arrival_date_year, arrival_date_month, and arrival_date_day_of_month\n",
    "# into one column and cast it to DateType, then replacing reservation_status_date column\n",
    "# with number of days since reservation.\n",
    "# until then, dropping reservation_status_date\n",
    "df2 = df2 .drop('reservation_status_date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#numerically encode all columns of type string\n",
    "from pyspark.ml import Pipeline\n",
    "from pyspark.ml.feature import OneHotEncoder, OneHotEncoderModel, StringIndexer\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','arrival_date_month']\n",
    "\n",
    "# col_num = list of new column names being changed into numeric\n",
    "col_num=[x+\"_NUMERIC\" for x in col_string]+['arrival_date_year']\n",
    "# don't need to change dates into numeric col_num=col_num+['arrival_date_year','arrival_date_day_of_month']\n",
    "\n",
    "# col_oh = list of columns being one-hot encoded\n",
    "col_oh=[x+\"_oh\" for x in col_string]+['arrival_date_year_oh']\n",
    "# dont need to ohencode dates col_oh=col_oh+['arrival_date_year_oh','arrival_date_day_of_month_oh']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexers = [StringIndexer(inputCol=column, outputCol=column+\"_NUMERIC\").fit(df2) for column in col_string]\n",
    "pipeline = Pipeline(stages=indexers)\n",
    "df_indexed = pipeline.fit(df2).transform(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#one-hot encode all columns in col_num\n",
    "ohe = OneHotEncoder(dropLast=False)\n",
    "ohe.setInputCols(col_num)\n",
    "ohe.setOutputCols(col_oh)\n",
    "model = ohe.fit(df_indexed)\n",
    "\n",
    "df_casted=model.transform(df_indexed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop the original, non-ohencoded variables\n",
    "df_encoded=df_casted.drop(*col_string)\n",
    "df_encoded=df_encoded.drop(*col_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized using L^1 norm\n"
     ]
    }
   ],
   "source": [
    "#removed normalization step for now\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.mllib.linalg import Vectors\n",
    "from pyspark.ml.feature import Normalizer\n",
    "\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']\n",
    "\n",
    "# combine all to-norm columns into one vector named \"norm_features\"\n",
    "assembler = VectorAssembler(inputCols=norm_to_columns, outputCol=\"norm_features\")\n",
    "transformed = assembler.transform(df_encoded) \n",
    "transformed = transformed.drop(*norm_to_columns)\n",
    "\n",
    "# in the end, new column named normFeatures combined all features that are normalized\n",
    "normalizer = Normalizer(inputCol=\"norm_features\", outputCol=\"normFeatures\", p=1.0)\n",
    "l1NormData = normalizer.transform(transformed)\n",
    "l1NormData = l1NormData.drop(*norm_to_columns + ['norm_features'])\n",
    "print(\"Normalized using L^1 norm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine all feature columns (non-label columns) into one vector named \"feature\"\n",
    "assembler = VectorAssembler(inputCols=df_encoded.columns[1:], outputCol=\"features\")\n",
    "all_transformed = assembler.transform(df_encoded)\n",
    "\n",
    "# convert to rdd with 2 columns, label and features, where features is a DenseVector combination of all other features\n",
    "dataRdd = all_transformed.select(col(\"is_canceled\").alias(\"label\"), col(\"features\")).rdd.map(tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LabeledPoint(0.0, [342.0,1.0,0.0,0.0,2.0,0.0,0.0,0.0,0.0,0.0,3.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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]))\n",
    "lp.take(1)"
   ]
  },
  {
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use these variables in place of test/train.count() bc those methods take a long time, instead just call once\n",
    "test_count = test.count()\n",
    "train_count = train.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.evaluation import MulticlassMetrics\n",
    "from pyspark.mllib.evaluation import BinaryClassificationMetrics\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.812790893287725\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_lr_int = LogisticRegressionWithLBFGS.train(train, intercept=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8131834239892335\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_int = test.map(lambda p: (p.label, 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 interations=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_lr_it10 = LogisticRegressionWithLBFGS.train(train, iterations=10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.802557057141255\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it10 = test.map(lambda p: (p.label, 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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic with intercept and interactions=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_lr_it10_int = LogisticRegressionWithLBFGS.train(train, iterations=10, intercept=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.8009588964279706\n"
     ]
    }
   ],
   "source": [
    "# Evaluating the model on test data\n",
    "labelsAndPreds_te_it10_int = test.map(lambda p: (p.label, 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": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[20793.  5024.]\n",
      " [ 1653.  8196.]]\n",
      "False negative rate 16.78%\n",
      "False positive rate 19.46%\n",
      "Precision(TP/all positives) 62.00%\n",
      "Recall(TP/all positive ground truth) 83.22%\n",
      "Area under PR for Linear regression = 59.11%\n",
      "Area under ROC for Linear regression = 81.88%\n"
     ]
    }
   ],
   "source": [
    "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",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision1))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall1))\n",
    "\n",
    "\n",
    "metrics_tr1 = BinaryClassificationMetrics(labelsAndPreds_te)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr1.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr1.areaUnderROC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PythonRDD[662] at RDD at PythonRDD.scala:53"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labelsAndPreds_te"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "\n",
    "# Let's use the run-of-the-mill evaluator\n",
    "evaluator = BinaryClassificationEvaluator(labelCol='Survived')\n",
    "\n",
    "# We have only two choices: area under ROC and PR curves :-(\n",
    "auroc = evaluator.evaluate(labelsAndPreds_te, {evaluator.metricName: \"areaUnderROC\"})\n",
    "auprc = evaluator.evaluate(labelsAndPreds_te, {evaluator.metricName: \"areaUnderPR\"})\n",
    "print(\"Area under ROC Curve: {:.4f}\".format(auroc))\n",
    "print(\"Area under PR Curve: {:.4f}\".format(auprc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area under ROC Curve: 0.8188\n",
      "Area under PR Curve: 0.5911\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fdd66157908>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import findspark\n",
    "from pyspark.sql import SparkSession\n",
    "from handyspark import *\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Creates instance of extended version of BinaryClassificationMetrics\n",
    "# using a DataFrame and its probability and label columns, as the output\n",
    "# from the classifier\n",
    "bcm = BinaryClassificationMetrics(labelsAndPreds_te)\n",
    "\n",
    "# We still can get the same metrics as the evaluator...\n",
    "print(\"Area under ROC Curve: {:.4f}\".format(bcm.areaUnderROC))\n",
    "print(\"Area under PR Curve: {:.4f}\".format(bcm.areaUnderPR))\n",
    "\n",
    "# But now we can PLOT both ROC and PR curves!\n",
    "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n",
    "bcm.plot_roc_curve(ax=axs[0])\n",
    "bcm.plot_pr_curve(ax=axs[1])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.util import MLUtils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# converting to LibSVM file\n",
    "MLUtils.saveAsLibSVMFile(lp, \"libsvm.txt\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LabeledPoint(0.0, (79,[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78],[77.0,20.0,2.0,5.0,2.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,169.0,0.0,2.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]))]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "data = MLUtils.loadLibSVMFile(sc, 'libsvm.txt')\n",
    "data.take(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.tree import RandomForest, RandomForestModel\n",
    "\n",
    "# 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=3, featureSubsetStrategy=\"auto\",\n",
    "                                     impurity='gini', maxDepth=5, maxBins=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.7532383782874447\n"
     ]
    }
   ],
   "source": [
    "# Evaluate model on test instances and compute test error\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",
    "\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": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[2.2385e+04 8.8890e+03]\n",
      " [1.6000e+01 4.4800e+03]]\n",
      "False negative rate 16.78%\n",
      "False positive rate 19.46%\n",
      "Precision(TP/all positives) 33.51%\n",
      "Recall(TP/all positive ground truth) 99.64%\n",
      "Area under PR for Linear regression = 33.47%\n",
      "Area under ROC for Linear regression = 85.61%\n"
     ]
    }
   ],
   "source": [
    "metrix2 = MulticlassMetrics(labelsAndPreds_te2)\n",
    "con_metrix2=metrix2.confusionMatrix().toArray()\n",
    "\n",
    "print('Confusion matrix')\n",
    "print(con_metrix2)\n",
    "\n",
    "FN2=metrix1.falsePositiveRate(0.0)\n",
    "FP2=metrix1.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",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision2))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall2))\n",
    "\n",
    "\n",
    "metrics_tr2 = BinaryClassificationMetrics(labelsAndPreds_te2)\n",
    "\n",
    "print(\"Area under PR for Linear regression = {:2.2%}\".format(metrics_tr2.areaUnderPR))\n",
    "\n",
    "# Area under ROC curve for training data\n",
    "print(\"Area under ROC for Linear regression = {:2.2%}\".format(metrics_tr2.areaUnderROC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area under ROC Curve: 0.8561\n",
      "Area under PR Curve: 0.3347\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fdd7b07d7f0>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import findspark\n",
    "from pyspark.sql import SparkSession\n",
    "from handyspark import *\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Creates instance of extended version of BinaryClassificationMetrics\n",
    "# using a DataFrame and its probability and label columns, as the output\n",
    "# from the classifier\n",
    "bcm1 = BinaryClassificationMetrics(labelsAndPreds_te2)\n",
    "\n",
    "# We still can get the same metrics as the evaluator...\n",
    "print(\"Area under ROC Curve: {:.4f}\".format(bcm1.areaUnderROC))\n",
    "print(\"Area under PR Curve: {:.4f}\".format(bcm1.areaUnderPR))\n",
    "\n",
    "# But now we can PLOT both ROC and PR curves!\n",
    "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n",
    "bcm1.plot_roc_curve(ax=axs[0])\n",
    "bcm1.plot_pr_curve(ax=axs[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model accuracy (test): 0.5877586496943868\n"
     ]
    }
   ],
   "source": [
    "from pyspark.mllib.classification import SVMWithSGD\n",
    "\n",
    "model_svm = SVMWithSGD.train(train,iterations=10)\n",
    "\n",
    "labelsAndPreds_te3 = test.map(lambda p: (p.label, float(model_svm.predict(p.features))))\n",
    "accuracy_te3 = 1.0 * labelsAndPreds_te3.filter(lambda pl: pl[0] == pl[1]).count() / test_count\n",
    "print('model accuracy (test): {}'.format(accuracy_te3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[11345.  3602.]\n",
      " [11101.  9618.]]\n",
      "False negative rate 53.58%\n",
      "False positive rate 24.10%\n",
      "Precision(TP/all positives) 72.75%\n",
      "Recall(TP/all positive ground truth) 46.42%\n",
      "Area under PR for Linear regression = 68.83%\n",
      "Area under ROC for Linear regression = 61.16%\n"
     ]
    }
   ],
   "source": [
    "metrix3 = MulticlassMetrics(labelsAndPreds_te3)\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",
    "\n",
    "print('Precision(TP/all positives) {:2.2%}'.format(precision3))\n",
    "print('Recall(TP/all positive ground truth) {:0.2%}'.format(recall3))\n",
    "\n",
    "metrics_tr3 = BinaryClassificationMetrics(labelsAndPreds_te3)\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": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area under ROC Curve: 0.6116\n",
      "Area under PR Curve: 0.6883\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fdd66661e48>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import findspark\n",
    "from pyspark.sql import SparkSession\n",
    "from handyspark import *\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "\n",
    "\n",
    "from pyspark.sql import SparkSession\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Creates instance of extended version of BinaryClassificationMetrics\n",
    "# using a DataFrame and its probability and label columns, as the output\n",
    "# from the classifier\n",
    "bcm2 = BinaryClassificationMetrics(labelsAndPreds_te3)\n",
    "\n",
    "# We still can get the same metrics as the evaluator...\n",
    "print(\"Area under ROC Curve: {:.4f}\".format(bcm2.areaUnderROC))\n",
    "print(\"Area under PR Curve: {:.4f}\".format(bcm2.areaUnderPR))\n",
    "\n",
    "# But now we can PLOT both ROC and PR curves!\n",
    "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n",
    "bcm2.plot_roc_curve(ax=axs[0])\n",
    "bcm2.plot_pr_curve(ax=axs[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}