04_Balanced Data- Pyspark Randomforest  Gradient-Boosted Tree.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml import Pipeline\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import col, explode, array, lit\n",
    "from pyspark.ml.feature import StringIndexer\n",
    "from pyspark.ml.feature import VectorAssembler, StandardScaler\n",
    "from pyspark.sql.types import IntegerType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder \\\n",
    "        .master('local[*]') \\\n",
    "        .appName('first_spark_application') \\\n",
    "        .getOrCreate() #if there is a active session it will get or create one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading data \n",
    "\n",
    "health = spark.read.csv('train.csv', header=True, inferSchema=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indexing categorical data\n",
    "from pyspark.sql.functions import lit ,when\n",
    "health = health.withColumn('Vehicle_Age', when(health.Vehicle_Age == '< 1 Year', lit(1)).otherwise(health.Vehicle_Age))\n",
    "health = health.withColumn('Vehicle_Age', when(health.Vehicle_Age == '1-2 Year', lit(2)).otherwise(health.Vehicle_Age))\n",
    "health = health.withColumn('Vehicle_Age', when(health.Vehicle_Age == '> 2 Years', lit(3)).otherwise(health.Vehicle_Age))\n",
    "health = health.withColumn('Vehicle_Age', health['Vehicle_Age'].cast(IntegerType()))\n",
    "\n",
    "\n",
    "\n",
    "#indexer1 = StringIndexer(inputCol='Vehicle_Age',\n",
    "#outputCol='Vehicle_Age_idx')\n",
    "\n",
    "indexer2 = StringIndexer(inputCol='Gender',\n",
    "outputCol='Gender_idx')\n",
    "\n",
    "indexer3 = StringIndexer(inputCol='Vehicle_Damage',\n",
    "outputCol='Vehicle_Damage_idx')\n",
    "\n",
    "\n",
    "# now we need to combine all the features in a single list\n",
    "# we are doing this because pyspark.ml what all the features in a list\n",
    "\n",
    "assembler = VectorAssembler(inputCols=['Age', 'Driving_License', \n",
    "                                       'Region_Code', 'Previously_Insured', \n",
    "                                       'Annual_Premium', \n",
    "                                       'Policy_Sales_Channel', 'Vintage', \n",
    "                                        'Gender_idx','Vehicle_Damage_idx'],\n",
    "                            outputCol='features')\n",
    "\n",
    "pipeline = Pipeline(stages=[indexer2, indexer3, assembler])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using pipeline to prepare data for models \n",
    "healthe = pipeline.fit(health).transform(health)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "| id|Gender|Age|Driving_License|Region_Code|Previously_Insured|Vehicle_Age|Vehicle_Damage|Annual_Premium|Policy_Sales_Channel|Vintage|Response|Gender_idx|Vehicle_Damage_idx|            features|\n",
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "|  1|  Male| 44|              1|       28.0|                 0|          3|           Yes|       40454.0|                26.0|    217|       1|       0.0|               0.0|[44.0,1.0,28.0,0....|\n",
      "|  2|  Male| 76|              1|        3.0|                 0|          2|            No|       33536.0|                26.0|    183|       0|       0.0|               1.0|[76.0,1.0,3.0,0.0...|\n",
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "healthe.show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# over sampling data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ratio: 7\n"
     ]
    }
   ],
   "source": [
    "major_df = healthe.filter(col(\"Response\") == 0)\n",
    "minor_df = healthe.filter(col(\"Response\") == 1)\n",
    "ratio = int(major_df.count()/minor_df.count())\n",
    "print(\"ratio: {}\".format(ratio))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# duplicate the minority rows\n",
    "a = range(ratio)\n",
    "oversampled_df = minor_df.withColumn(\"dummy\", explode(array([lit(x) for x in a]))).drop('dummy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "| id|Gender|Age|Driving_License|Region_Code|Previously_Insured|Vehicle_Age|Vehicle_Damage|Annual_Premium|Policy_Sales_Channel|Vintage|Response|Gender_idx|Vehicle_Damage_idx|            features|\n",
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "|  2|  Male| 76|              1|        3.0|                 0|          2|            No|       33536.0|                26.0|    183|       0|       0.0|               1.0|[76.0,1.0,3.0,0.0...|\n",
      "|  4|  Male| 21|              1|       11.0|                 1|          1|            No|       28619.0|               152.0|    203|       0|       0.0|               1.0|[21.0,1.0,11.0,1....|\n",
      "|  5|Female| 29|              1|       41.0|                 1|          1|            No|       27496.0|               152.0|     39|       0|       1.0|               1.0|[29.0,1.0,41.0,1....|\n",
      "|  6|Female| 24|              1|       33.0|                 0|          1|           Yes|        2630.0|               160.0|    176|       0|       1.0|               0.0|[24.0,1.0,33.0,0....|\n",
      "|  7|  Male| 23|              1|       11.0|                 0|          1|           Yes|       23367.0|               152.0|    249|       0|       0.0|               0.0|[23.0,1.0,11.0,0....|\n",
      "|  9|Female| 24|              1|        3.0|                 1|          1|            No|       27619.0|               152.0|     28|       0|       1.0|               1.0|[24.0,1.0,3.0,1.0...|\n",
      "| 10|Female| 32|              1|        6.0|                 1|          1|            No|       28771.0|               152.0|     80|       0|       1.0|               1.0|[32.0,1.0,6.0,1.0...|\n",
      "| 12|Female| 24|              1|       50.0|                 1|          1|            No|       48699.0|               152.0|    289|       0|       1.0|               1.0|[24.0,1.0,50.0,1....|\n",
      "| 13|Female| 41|              1|       15.0|                 1|          2|            No|       31409.0|                14.0|    221|       0|       1.0|               1.0|[41.0,1.0,15.0,1....|\n",
      "| 14|  Male| 76|              1|       28.0|                 0|          2|           Yes|       36770.0|                13.0|     15|       0|       0.0|               0.0|[76.0,1.0,28.0,0....|\n",
      "| 15|  Male| 71|              1|       28.0|                 1|          2|            No|       46818.0|                30.0|     58|       0|       0.0|               1.0|[71.0,1.0,28.0,1....|\n",
      "| 17|Female| 25|              1|       45.0|                 0|          1|           Yes|       26218.0|               160.0|    256|       0|       1.0|               0.0|[25.0,1.0,45.0,0....|\n",
      "| 18|Female| 25|              1|       35.0|                 1|          1|            No|       46622.0|               152.0|    299|       0|       1.0|               1.0|[25.0,1.0,35.0,1....|\n",
      "| 19|  Male| 42|              1|       28.0|                 0|          2|           Yes|       33667.0|               124.0|    158|       0|       0.0|               0.0|[42.0,1.0,28.0,0....|\n",
      "| 21|  Male| 65|              1|       28.0|                 0|          2|           Yes|       41184.0|               124.0|    116|       0|       0.0|               0.0|[65.0,1.0,28.0,0....|\n",
      "| 22|  Male| 49|              1|       28.0|                 0|          2|           Yes|       50791.0|               124.0|    177|       0|       0.0|               0.0|[49.0,1.0,28.0,0....|\n",
      "| 23|  Male| 23|              1|       50.0|                 1|          1|            No|       45283.0|               152.0|    232|       0|       0.0|               1.0|[23.0,1.0,50.0,1....|\n",
      "| 24|  Male| 44|              1|       28.0|                 0|          2|           Yes|       41852.0|               163.0|     60|       0|       0.0|               0.0|[44.0,1.0,28.0,0....|\n",
      "| 25|  Male| 34|              1|       15.0|                 1|          2|            No|       38111.0|               152.0|    180|       0|       0.0|               1.0|[34.0,1.0,15.0,1....|\n",
      "| 26|Female| 21|              1|       28.0|                 1|          1|            No|       61964.0|               152.0|     72|       0|       1.0|               1.0|[21.0,1.0,28.0,1....|\n",
      "+---+------+---+---------------+-----------+------------------+-----------+--------------+--------------+--------------------+-------+--------+----------+------------------+--------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# combine both oversampled minority rows and previous majority rows \n",
    "combined_df = major_df.unionAll(oversampled_df)\n",
    "combined_df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# rechecking if the ratio is now equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ratio: 1\n"
     ]
    }
   ],
   "source": [
    "major_df = combined_df.filter(col(\"Response\") == 0)\n",
    "minor_df = combined_df.filter(col(\"Response\") == 1)\n",
    "ratio = int(major_df.count()/minor_df.count())\n",
    "print(\"ratio: {}\".format(ratio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# setting the new balaced data as the main data \n",
    "so that there is no need to edit the file below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "healthe = combined_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# preparing data for model fitting\n",
    "\n",
    "- We are selecting the features column and response column to get that data needed for predictions\n",
    "\n",
    "- we need to change the output column name to label for the models to work right in spark\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# making the column names as pyspark wants\n",
    "health_ml = healthe.select(['features','Response']).withColumnRenamed('Response', 'label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-----+\n",
      "|            features|label|\n",
      "+--------------------+-----+\n",
      "|[76.0,1.0,3.0,0.0...|    0|\n",
      "|[21.0,1.0,11.0,1....|    0|\n",
      "+--------------------+-----+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "health_ml.show(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+------+\n",
      "|label| count|\n",
      "+-----+------+\n",
      "|    1|326970|\n",
      "|    0|334399|\n",
      "+-----+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "health_ml.groupby('label').count().show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see we now we have a some what balanced dataset now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initiating a standard scaler\n",
    "sScaler = StandardScaler(\n",
    "    withMean=True, withStd=True, inputCol=\"features\", outputCol=\"features_scc\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using standard scaler to scale data \n",
    "health_ml = sScaler.fit(health_ml).transform(health_ml)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-----+--------------------+\n",
      "|            features|label|        features_scc|\n",
      "+--------------------+-----+--------------------+\n",
      "|[76.0,1.0,3.0,0.0...|    0|[2.45053644812442...|\n",
      "|[21.0,1.0,11.0,1....|    0|[-1.3759663044552...|\n",
      "|[29.0,1.0,41.0,1....|    0|[-0.8193840858982...|\n",
      "|[24.0,1.0,33.0,0....|    0|[-1.1672479724963...|\n",
      "|[23.0,1.0,11.0,0....|    0|[-1.2368207498159...|\n",
      "+--------------------+-----+--------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# checking top 5 rows to see how standard scaler is working\n",
    "health_ml.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------------------+\n",
      "|label|            features|\n",
      "+-----+--------------------+\n",
      "|    0|[2.45053644812442...|\n",
      "|    0|[-1.3759663044552...|\n",
      "|    0|[-0.8193840858982...|\n",
      "|    0|[-1.1672479724963...|\n",
      "|    0|[-1.2368207498159...|\n",
      "+-----+--------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# we are switching feature column with new scaled column\n",
    "health_ml = health_ml.drop('features').withColumnRenamed('features_scc', 'features')\n",
    "health_ml.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify a seed for reproducibility\n",
    "# we are spliting the data in test train\n",
    "\n",
    "health_train, health_test = health_ml.randomSplit([0.8, 0.2], seed= 23 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "529415 131954\n"
     ]
    }
   ],
   "source": [
    "print(health_train.count(), health_test.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml.classification import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LogisticRegression(featuresCol='features', labelCol='label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initiating logistics model\n",
    "logistic = model.fit(health_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make predictions on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "predection = logistic.transform(health_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------------------+--------------------+--------------------+----------+\n",
      "|label|            features|       rawPrediction|         probability|prediction|\n",
      "+-----+--------------------+--------------------+--------------------+----------+\n",
      "|    0|[-1.4455390817748...|[-0.6242104464358...|[0.34882445781919...|       1.0|\n",
      "|    0|[-1.4455390817748...|[-0.6266998641658...|[0.34825920966727...|       1.0|\n",
      "+-----+--------------------+--------------------+--------------------+----------+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "predection.show(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+-----+\n",
      "|label|prediction|count|\n",
      "+-----+----------+-----+\n",
      "|    1|       0.0| 1588|\n",
      "|    0|       0.0|39705|\n",
      "|    1|       1.0|63770|\n",
      "|    0|       1.0|26891|\n",
      "+-----+----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "predection.groupBy(\"label\", \"prediction\").count().show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above is the confusion metrics for the results got from logistic regression\n",
    "##### 1 : Customer is interested, \n",
    "##### 0 : Customer is not interested"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Logistic Regression model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Area Under ROC 0.8179237531717645\n"
     ]
    }
   ],
   "source": [
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "evaluator = BinaryClassificationEvaluator()\n",
    "print('Test Area Under ROC', evaluator.evaluate(predection))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We can obtain the coefficients by using LogisticRegressionModel’s attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "beta = np.sort(logistic.coefficients)\n",
    "plt.plot(beta)\n",
    "plt.ylabel('Beta Coefficients')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summarize the model over the training set, we can also obtain the receiver-operating characteristic and areaUnderROC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set areaUnderROC: 0.8157594923678491\n"
     ]
    }
   ],
   "source": [
    "trainingSummary = logistic.summary\n",
    "roc = trainingSummary.roc.toPandas()\n",
    "plt.plot(roc['FPR'],roc['TPR'])\n",
    "plt.ylabel('False Positive Rate')\n",
    "plt.xlabel('True Positive Rate')\n",
    "plt.title('ROC Curve')\n",
    "plt.show()\n",
    "print('Training set areaUnderROC: ' + str(trainingSummary.areaUnderROC))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precision and recall.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": [
    "pr = trainingSummary.pr.toPandas()\n",
    "plt.plot(pr['recall'],pr['precision'])\n",
    "plt.ylabel('Precision')\n",
    "plt.xlabel('Recall')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decision Tree "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+----------------------------------------+\n",
      "|label|prediction|probability                             |\n",
      "+-----+----------+----------------------------------------+\n",
      "|0    |0.0       |[0.744565951127312,0.255434048872688]   |\n",
      "|0    |0.0       |[0.744565951127312,0.255434048872688]   |\n",
      "|0    |0.0       |[0.744565951127312,0.255434048872688]   |\n",
      "|0    |0.0       |[0.8461070559610706,0.15389294403892945]|\n",
      "|0    |1.0       |[0.3441798941798942,0.6558201058201059] |\n",
      "+-----+----------+----------------------------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Import the Decision Tree Classifier class\n",
    "from pyspark.ml.classification import DecisionTreeClassifier\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "# Create a classifier object and fit to the training data\n",
    "tree = DecisionTreeClassifier()\n",
    "tree_model = tree.fit(health_train)\n",
    "\n",
    "# Create predictions for the testing data and take a look at the predictions\n",
    "prediction = tree_model.transform(health_test)\n",
    "prediction.select('label', 'prediction', 'probability').show(5, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+-----+\n",
      "|label|prediction|count|\n",
      "+-----+----------+-----+\n",
      "|    1|       0.0| 5947|\n",
      "|    0|       0.0|45169|\n",
      "|    1|       1.0|59411|\n",
      "|    0|       1.0|21427|\n",
      "+-----+----------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "prediction.groupBy(\"label\", \"prediction\").count().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Params.explainParam of DecisionTreeClassificationModel (uid=DecisionTreeClassifier_0ad67aca1531) of depth 5 with 29 nodes>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_model.explainParam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Decision Tree model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Area Under ROC: 0.817624261470211\n"
     ]
    }
   ],
   "source": [
    "evaluator = BinaryClassificationEvaluator()\n",
    "print(\"Test Area Under ROC: \" + str(evaluator.evaluate(prediction, {evaluator.metricName: \"areaUnderROC\"})))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+--------------------+\n",
      "|label|prediction|         probability|\n",
      "+-----+----------+--------------------+\n",
      "|    0|       0.0|[0.61061866773522...|\n",
      "|    0|       0.0|[0.61061866773522...|\n",
      "|    0|       0.0|[0.61906168771200...|\n",
      "|    0|       0.0|[0.86070827361802...|\n",
      "|    0|       1.0|[0.35002260137764...|\n",
      "|    0|       0.0|[0.61061866773522...|\n",
      "|    0|       0.0|[0.61906168771200...|\n",
      "|    0|       0.0|[0.61061866773522...|\n",
      "|    0|       0.0|[0.95990260997920...|\n",
      "|    0|       0.0|[0.96066593220628...|\n",
      "+-----+----------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from pyspark.ml.classification import RandomForestClassifier\n",
    "rf = RandomForestClassifier(featuresCol = 'features', labelCol = 'label')\n",
    "rfModel = rf.fit(health_train)\n",
    "predictions = rfModel.transform(health_test)\n",
    "predictions.select('label', 'prediction', 'probability').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Area Under ROC: 0.8432938491363777\n"
     ]
    }
   ],
   "source": [
    "evaluator = BinaryClassificationEvaluator()\n",
    "print(\"Test Area Under ROC: \" + str(evaluator.evaluate(predictions, {evaluator.metricName: \"areaUnderROC\"})))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient-Boosted Tree "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+--------------------+\n",
      "|label|prediction|         probability|\n",
      "+-----+----------+--------------------+\n",
      "|    0|       0.0|[0.78722752019038...|\n",
      "|    0|       0.0|[0.78722752019038...|\n",
      "|    0|       0.0|[0.76898842252375...|\n",
      "|    0|       0.0|[0.84741365236653...|\n",
      "|    0|       1.0|[0.40190920101951...|\n",
      "|    0|       0.0|[0.78722752019038...|\n",
      "|    0|       0.0|[0.78213834257413...|\n",
      "|    0|       0.0|[0.79960976349719...|\n",
      "|    0|       0.0|[0.93271593904077...|\n",
      "|    0|       0.0|[0.93292447768035...|\n",
      "+-----+----------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from pyspark.ml.classification import GBTClassifier\n",
    "gbt = GBTClassifier(maxIter=10)\n",
    "gbtModel = gbt.fit(health_train)\n",
    "predictions = gbtModel.transform(health_test)\n",
    "predictions.select('label', 'prediction', 'probability').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Gradient-Boosted Tree Classifier（It is the best classifier）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Area Under ROC: 0.8546554939441174\n"
     ]
    }
   ],
   "source": [
    "evaluator = BinaryClassificationEvaluator()\n",
    "print(\"Test Area Under ROC: \" + str(evaluator.evaluate(predictions, {evaluator.metricName: \"areaUnderROC\"})))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use explainParams() to print a list of all params and their definitions to understand what params available for tuning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cacheNodeIds: If false, the algorithm will pass trees to executors to match instances with nodes. If true, the algorithm will cache node IDs for each instance. Caching can speed up training of deeper trees. Users can set how often should the cache be checkpointed or disable it by setting checkpointInterval. (default: False)\n",
      "checkpointInterval: set checkpoint interval (>= 1) or disable checkpoint (-1). E.g. 10 means that the cache will get checkpointed every 10 iterations. Note: this setting will be ignored if the checkpoint directory is not set in the SparkContext. (default: 10)\n",
      "featureSubsetStrategy: The number of features to consider for splits at each tree node. Supported options: 'auto' (choose automatically for task: If numTrees == 1, set to 'all'. If numTrees > 1 (forest), set to 'sqrt' for classification and to 'onethird' for regression), 'all' (use all features), 'onethird' (use 1/3 of the features), 'sqrt' (use sqrt(number of features)), 'log2' (use log2(number of features)), 'n' (when n is in the range (0, 1.0], use n * number of features. When n is in the range (1, number of features), use n features). default = 'auto' (default: all)\n",
      "featuresCol: features column name. (default: features)\n",
      "labelCol: label column name. (default: label)\n",
      "lossType: Loss function which GBT tries to minimize (case-insensitive). Supported options: logistic (default: logistic)\n",
      "maxBins: Max number of bins for discretizing continuous features.  Must be >=2 and >= number of categories for any categorical feature. (default: 32)\n",
      "maxDepth: Maximum depth of the tree. (>= 0) E.g., depth 0 means 1 leaf node; depth 1 means 1 internal node + 2 leaf nodes. (default: 5)\n",
      "maxIter: max number of iterations (>= 0). (default: 20, current: 10)\n",
      "maxMemoryInMB: Maximum memory in MB allocated to histogram aggregation. If too small, then 1 node will be split per iteration, and its aggregates may exceed this size. (default: 256)\n",
      "minInfoGain: Minimum information gain for a split to be considered at a tree node. (default: 0.0)\n",
      "minInstancesPerNode: Minimum number of instances each child must have after split. If a split causes the left or right child to have fewer than minInstancesPerNode, the split will be discarded as invalid. Should be >= 1. (default: 1)\n",
      "predictionCol: prediction column name. (default: prediction)\n",
      "seed: random seed. (default: -9200881723176468012)\n",
      "stepSize: Step size (a.k.a. learning rate) in interval (0, 1] for shrinking the contribution of each estimator. (default: 0.1)\n",
      "subsamplingRate: Fraction of the training data used for learning each decision tree, in range (0, 1]. (default: 1.0)\n"
     ]
    }
   ],
   "source": [
    "print(gbt.explainParams())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5 Folds CorssValidation with ParamGrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8580130196890567"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pyspark.ml.tuning import ParamGridBuilder, CrossValidator\n",
    "paramGrid = (ParamGridBuilder()\n",
    "             .addGrid(gbt.maxDepth, [2, 4, 6])\n",
    "             .addGrid(gbt.maxBins, [20, 60])\n",
    "             .addGrid(gbt.maxIter, [10, 20])\n",
    "             .build())\n",
    "cv = CrossValidator(estimator=gbt, estimatorParamMaps=paramGrid, evaluator=evaluator, numFolds=5)\n",
    "# Run cross validations.  This can take about 6 minutes since it is training over 20 trees!\n",
    "cvModel = cv.fit(health_train)\n",
    "predictions = cvModel.transform(health_test)\n",
    "evaluator.evaluate(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}