tech-summary/navigation/eta/making_predictions_sample.ipynb

{
 "cells": [
  {
   "attachments": {
    "ads2_0701.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input Data\n",
    "\n",
    "\n",
    "\n",
    "- [Specification of flight data](https://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236&DB_Short_Name=On-Time)\n",
    "- [S3 Location for 2015 data](https://s3.amazonaws.com/agile_data_science/On_Time_On_Time_Performance_2015.csv.bz2)\n",
    "- The fileds in CSV\n",
    "```\n",
    "  \"Year\",\"Quarter\",\"Month\",\n",
    "     \"DayofMonth\",\"DayOfWeek\",\"FlightDate\",\"UniqueCarrier\",\n",
    "     \"AirlineID\",\"Carrier\",\"TailNum\",\"FlightNum\",\n",
    "    \"OriginAirportID\",\"OriginAirportSeqID\",\"OriginCityMarketID\",\n",
    "    \"Origin\",\"OriginCityName\",\"OriginState\",\"OriginStateFips\",\n",
    "    \"OriginStateName\",\"OriginWac\",\"DestAirportID\",\"DestAirportSeqID\",\n",
    "    \"DestCityMarketID\",\"Dest\",\"DestCityName\",\"DestState\",\n",
    "    \"DestStateFips\",\"DestStateName\",\"DestWac\",\"CRSDepTime\",\"DepTime\",\n",
    "    \"DepDelay\",\"DepDelayMinutes\",\"DepDel15\",\"DepartureDelayGroups\",\n",
    "    \"DepTimeBlk\",\"TaxiOut\",\"WheelsOff\",\"WheelsOn\",\"TaxiIn\",\n",
    "    \"CRSArrTime\",\"ArrTime\",\"ArrDelay\",\"ArrDelayMinutes\",\n",
    "    \"ArrDel15\",\"ArrivalDelayGroups\",\"ArrTimeBlk\",\"Cancelled\",\n",
    "    \"CancellationCode\",\"Diverted\",\"CRSElapsedTime\",\n",
    "    \"ActualElapsedTime\",\"AirTime\",\"Flights\",\"Distance\",\n",
    "    \"DistanceGroup\",\"CarrierDelay\",\"WeatherDelay\",\"NASDelay\",\"Security\n",
    "    Delay\",\"LateAircraftDelay\",\"FirstDepTime\",\"TotalAddGTime\",\n",
    "    \"LongestAddGTime\",\"DivAirportLandings\",\"DivReachedDest\",\n",
    "    \"DivActualElapsedTime\",\"DivArrDelay\",\"DivDistance\",\"Div1Airport\",\n",
    "    \"Div1AirportID\",\"Div1AirportSeqID\",\"Div1WheelsOn\",\n",
    "    \"Div1TotalGTime\",\"Div1LongestGTime\",\"Div1WheelsOff\",\n",
    "    \"Div1TailNum\",\"Div2Airport\",\"Div2AirportID\",\n",
    "    \"Div2AirportSeqID\",\"Div2WheelsOn\",\"Div2TotalGTime\",\n",
    "    \"Div2LongestGTime\",\"Div2WheelsOff\",\"Div2TailNum\",\"Div3Airport\",\n",
    "    \"Div3AirportID\",\"Div3AirportSeqID\",\"Div3WheelsOn\",\n",
    "    \"Div3TotalGTime\",\"Div3LongestGTime\",\"Div3WheelsOff\",\"Div3TailNum\",\n",
    "    \"Div4Airport\",\"Div4AirportID\",\"Div4AirportSeqID\",\n",
    "    \"Div4WheelsOn\",\"Div4TotalGTime\",\"Div4LongestGTime\",\n",
    "    \"Div4WheelsOff\",\"Div4TailNum\",\"Div5Airport\",\"Div5AirportID\",\n",
    "    \"Div5AirportSeqID\",\"Div5WheelsOn\",\"Div5TotalGTime\",\n",
    "    \"Div5LongestGTime\",\"Div5WheelsOff\",\"Div5TailNum\"\n",
    "```\n",
    "- Data sample\n",
    "```\n",
    "2015,1,1,1,4,2015-01-01,\"AA\",19805,\"AA\",\"N787AA\",\"1\",12478,1247802,...,\"JFK\", ... \n",
    "2015,1,1,2,5,2015-01-02,\"AA\",19805,\"AA\",\"N795AA\",\"1\",12478,...,31703,\"JFK\", ... \n",
    "2015,1,1,3,6,2015-01-03,\"AA\",19805,\"AA\",\"N788AA\",\"1\",12478,...,31703,\"JFK\", ...\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "### Target\n",
    "We want predict whether we will be delaied for our destination\n",
    "\n",
    "We might formulate categories similar to the buckets we will use for the weather delay distribution (0–15, 15–60, and 60+), and then classify into these three categories.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize PySpark\n",
    "APP_NAME = \"Introducing PySpark\"\n",
    "\n",
    "# If there is no SparkSession, create the environment\n",
    "try:\n",
    "  sc and spark\n",
    "except NameError as e:\n",
    "  import findspark\n",
    "  findspark.init()\n",
    "  import pyspark\n",
    "  import pyspark.sql\n",
    "\n",
    "  sc = pyspark.SparkContext()\n",
    "  spark = pyspark.sql.SparkSession(sc).builder.appName(APP_NAME).getOrCreate()\n",
    "\n",
    "print(\"PySpark initialized...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading data\n",
    "1. `csv` files always be converted to row based compressed file format such as Parquet\n",
    "\n",
    "2. Use spark `dataframe` not `rdd` to do operations, expecially for `python`\n",
    "   \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the on-time Parquet file\n",
    "on_time_dataframe = spark.read.parquet('../data/on_time_performance.parquet')\n",
    "on_time_dataframe.registerTempTable(\"on_time_performance\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting Features with PySpark\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "on_time_dataframe = on_time_dataframe.filter(on_time_dataframe.Month == '1')\n",
    "\n",
    "# Select a few features of interest\n",
    "simple_on_time_features = spark.sql(\"\"\"\n",
    "SELECT\n",
    "  FlightNum,\n",
    "  FlightDate,\n",
    "  DayOfWeek,\n",
    "  DayofMonth AS DayOfMonth,\n",
    "  CONCAT(Month, '-',  DayofMonth) AS DayOfYear,\n",
    "  Carrier,\n",
    "  Origin,\n",
    "  Dest,\n",
    "  Distance,\n",
    "  DepDelay,\n",
    "  ArrDelay,\n",
    "  CRSDepTime,\n",
    "  CRSArrTime\n",
    "FROM on_time_performance\n",
    "  WHERE FlightDate < '2015-02-01'\n",
    "\"\"\")\n",
    "simple_on_time_features.show(5)\n",
    "\n",
    "# Sample 10% to make executable inside the notebook\n",
    "simple_on_time_features = simple_on_time_features.sample(False, 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+---------+----------+---------+----------+---------+-------+------+----+--------+--------+--------+----------+----------+\n",
    "|FlightNum|FlightDate|DayOfWeek|DayOfMonth|DayOfYear|Carrier|Origin|Dest|Distance|DepDelay|ArrDelay|CRSDepTime|CRSArrTime|\n",
    "+---------+----------+---------+----------+---------+-------+------+----+--------+--------+--------+----------+----------+\n",
    "|     1519|2015-01-01|        4|         1|      1-1|     AA|   DFW| MEM|   432.0|    -3.0|    -6.0|      1345|      1510|\n",
    "|     1519|2015-01-01|        4|         1|      1-1|     AA|   MEM| DFW|   432.0|    -4.0|    -9.0|      1550|      1730|\n",
    "|     2349|2015-01-01|        4|         1|      1-1|     AA|   ORD| DFW|   802.0|     0.0|    26.0|      1845|      2115|\n",
    "|     1298|2015-01-01|        4|         1|      1-1|     AA|   DFW| ATL|   731.0|   100.0|   112.0|      1820|      2120|\n",
    "|     1422|2015-01-01|        4|         1|      1-1|     AA|   DFW| HDN|   769.0|    78.0|    78.0|      0800|      0925|\n",
    "+---------+----------+---------+----------+---------+-------+------+----+--------+--------+--------+----------+----------+\n",
    "```\n",
    "\n",
    "\n",
    "Looks like a few flights don’t have delay information. Let’s filter those, and sort the data before saving it as a single JSON file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter nulls, they can't help us\n",
    "filled_on_time_features = simple_on_time_features.filter(\n",
    "  simple_on_time_features.ArrDelay.isNotNull()\n",
    "  &\n",
    "  simple_on_time_features.DepDelay.isNotNull()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DateTime Conversion\n",
    "\n",
    "Now we need to convert all our dates and times (datetimes) from a string representation to a mathematical one—otherwise, our predictive algorithms can’t understand them in their proper and most useful contexts. To do so, we need some utility functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to turn timestamps into timestamps, and not strings or numbers\n",
    "def convert_hours(hours_minutes):\n",
    "  hours = hours_minutes[:-2]\n",
    "  minutes = hours_minutes[-2:]\n",
    "  \n",
    "  if hours == '24':\n",
    "    hours = '23'\n",
    "    minutes = '59'\n",
    "  \n",
    "  time_string = \"{}:{}:00Z\".format(hours, minutes)\n",
    "  return time_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compose_datetime(iso_date, time_string):\n",
    "  return \"{} {}\".format(iso_date, time_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_iso_string(iso_date, hours_minutes):\n",
    "  time_string = convert_hours(hours_minutes)\n",
    "  full_datetime = compose_datetime(iso_date, time_string)\n",
    "  return full_datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_datetime(iso_string):\n",
    "  return iso8601.parse_date(iso_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_datetime(iso_date, hours_minutes):\n",
    "  iso_string = create_iso_string(iso_date, hours_minutes)\n",
    "  dt = create_datetime(iso_string)\n",
    "  return dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def day_of_year(iso_date_string):\n",
    "  dt = iso8601.parse_date(iso_date_string)\n",
    "  doy = dt.timetuple().tm_yday\n",
    "  return doy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alter_feature_datetimes(row):\n",
    "  flight_date = iso8601.parse_date(row['FlightDate'])\n",
    "  scheduled_dep_time = convert_datetime(row['FlightDate'], row['CRSDepTime'])\n",
    "  scheduled_arr_time = convert_datetime(row['FlightDate'], row['CRSArrTime'])\n",
    "\n",
    "  # Handle overnight flights\n",
    "  if scheduled_arr_time < scheduled_dep_time:\n",
    "    scheduled_arr_time += datetime.timedelta(days=1)\n",
    "\n",
    "  doy = day_of_year(row['FlightDate'])\n",
    "  \n",
    "  return {\n",
    "    'FlightNum': row['FlightNum'],\n",
    "    'FlightDate': flight_date,\n",
    "    'DayOfWeek': int(row['DayOfWeek']),\n",
    "    'DayOfMonth': int(row['DayOfMonth']),\n",
    "    'DayOfYear': doy,\n",
    "    'Carrier': row['Carrier'],\n",
    "    'Origin': row['Origin'],\n",
    "    'Dest': row['Dest'],\n",
    "    'Distance': row['Distance'],\n",
    "    'DepDelay': row['DepDelay'],\n",
    "    'ArrDelay': row['ArrDelay'],\n",
    "    'CRSDepTime': scheduled_dep_time,\n",
    "    'CRSArrTime': scheduled_arr_time,\n",
    "  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+-------------------+---------+------+\n",
    "|ArrDelay|         CRSArrTime|         CRSDepTime|Carrier|DayOfMonth|DayOfWeek|DayOfYear|DepDelay|Dest|Distance|         FlightDate|FlightNum|Origin|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+-------------------+---------+------+\n",
    "|     1.0|2015-01-01 10:06:00|2015-01-01 07:20:00|     AA|         1|        4|        1|    -6.0| MIA|   921.0|2015-01-01 00:00:00|     1173|   IAD|\n",
    "|    13.0|2015-01-01 16:50:00|2015-01-01 15:25:00|     AA|         1|        4|        1|     9.0| DFW|   731.0|2015-01-01 00:00:00|      194|   ATL|\n",
    "|    58.0|2015-01-01 18:50:00|2015-01-01 17:40:00|     AA|         1|        4|        1|    60.0| ONT|  1188.0|2015-01-01 00:00:00|     1605|   DFW|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+-------------------+---------+------+\n",
    "```\n",
    "only showing top 5 rows\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import Row\n",
    "timestamp_features = filled_on_time_features.rdd.map(alter_feature_datetimes)\n",
    "timestamp_df = timestamp_features.map(lambda x: Row(**x)).toDF()\n",
    "timestamp_df.show(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Always explicitly sort your data before vectorizing it. Don’t leave the sort up to the system. If you do so, a software version change or some other unknown cause might ultimately change the sort order of your training data as compared with your result data. This would be catastrophic and confusing and should be avoided at all costs. Explicitly sorting training data in a way that avoids arbitrary sorting is essential:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Explicitly sort the data and keep it sorted throughout. \n",
    "# Leave nothing to chance.\n",
    "sorted_features = timestamp_df.sort(\n",
    "  timestamp_df.DayOfYear,\n",
    "  timestamp_df.Carrier,\n",
    "  timestamp_df.Origin,\n",
    "  timestamp_df.Dest,\n",
    "  timestamp_df.FlightNum,\n",
    "  timestamp_df.CRSDepTime,\n",
    "  timestamp_df.CRSArrTime,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s copy the file into a JSON Lines file and check it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store as a single JSON file and bzip2 it\n",
    "sorted_features.write.mode(\"overwrite\").json(\"../data/simple_flight_delay_features.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now take a look at the result:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "14M\t../data/simple_flight_delay_features.json\n",
    "\n",
    "==> ../data/simple_flight_delay_features.json/part-00000-b22e4fa9-4bf4-4696-a8dd-01989f88482e-c000.json <==\n",
    "{\"ArrDelay\":13.0,\"CRSArrTime\":\"2015-01-01T16:50:00.000Z\",\"CRSDepTime\":\"2015-01-01T15:25:00.000Z\",\"Carrier\":\"AA\",\"DayOfMonth\":1,\"DayOfWeek\":4,\"DayOfYear\":1,\"DepDelay\":9.0,\"Dest\":\"DFW\",\"Distance\":731.0,\"FlightDate\":\"2015-01-01T00:00:00.000Z\",\"FlightNum\":\"194\",\"Origin\":\"ATL\"}\n",
    "{\"ArrDelay\":25.0,\"CRSArrTime\":\"2015-01-01T20:30:00.000Z\",\"CRSDepTime\":\"2015-01-01T19:00:00.000Z\",\"Carrier\":\"AA\",\"DayOfMonth\":1,\"DayOfWeek\":4,\"DayOfYear\":1,\"DepDelay\":-2.0,\"Dest\":\"DFW\",\"Distance\":731.0,\"FlightDate\":\"2015-01-01T00:00:00.000Z\",\"FlightNum\":\"232\",\"Origin\":\"ATL\"}\n",
    "{\"ArrDelay\":16.0,\"CRSArrTime\":\"2015-01-01T15:30:00.000Z\",\"CRSDepTime\":\"2015-01-01T14:25:00.000Z\",\"Carrier\":\"AA\",\"DayOfMonth\":1,\"DayOfWeek\":4,\"DayOfYear\":1,\"DepDelay\":24.0,\"Dest\":\"DFW\",\"Distance\":190.0,\"FlightDate\":\"2015-01-01T00:00:00.000Z\",\"FlightNum\":\"2297\",\"Origin\":\"AUS\"}\n",
    "{\"ArrDelay\":-31.0,\"CRSArrTime\":\"2015-01-01T13:30:00.000Z\",\"CRSDepTime\":\"2015-01-01T10:55:00.000Z\",\"Carrier\":\"AA\",\"DayOfMonth\":1,\"DayOfWeek\":4,\"DayOfYear\":1,\"DepDelay\":-4.0,\"Dest\":\"ORD\",\"Distance\":978.0,\"FlightDate\":\"2015-01-01T00:00:00.000Z\",\"FlightNum\":\"2279\",\"Origin\":\"AUS\"}\n",
    "{\"ArrDelay\":-30.0,\"CRSArrTime\":\"2015-01-01T20:20:00.000Z\",\"CRSDepTime\":\"2015-01-01T17:45:00.000Z\",\"Carrier\":\"AA\",\"DayOfMonth\":1,\"DayOfWeek\":4,\"DayOfYear\":1,\"DepDelay\":-8.0,\"Dest\":\"ORD\",\"Distance\":978.0,\"FlightDate\":\"2015-01-01T00:00:00.000Z\",\"FlightNum\":\"2408\",\"Origin\":\"AUS\"}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a Classifier with Spark ML\n",
    "\n",
    "\n",
    "Spark's goal is to make practical machine learning scalable and easy. At a high level, it provides tools such as:_\n",
    "\n",
    "* ML Algorithms: common learning algorithms such as classification, regression, clustering, and collaborative filtering\n",
    "\n",
    "* Featurization: feature extraction, transformation, dimensionality reduction, and selection\n",
    "\n",
    "* Pipelines: tools for constructing, evaluating, and tuning ML Pipelines\n",
    "\n",
    "* Persistence: saving and load algorithms, models, and Pipelines\n",
    "\n",
    "* Utilities: linear algebra, statistics, data handling, etc.\n",
    "\n",
    "MLlib uses Spark DataFrames as the foundation for tables and records. Although some RDD-based methods still remain, they are not under active development.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# {\n",
    "#   \"ArrDelay\":5.0,\"CRSArrTime\":\"2015-12-31T03:20:00.000-08:00\",\n",
    "#   \"CRSDepTime\":\"2015-12-31T03:05:00.000-08:00\",\n",
    "#   \"Carrier\":\"WN\",\"DayOfMonth\":31,\"DayOfWeek\":4,\n",
    "#   \"DayOfYear\":365,\"DepDelay\":14.0,\"Dest\":\"SAN\",\n",
    "#   \"Distance\":368.0, \"FlightDate\":\"2015-12-30T16:00:00.000-08:00\",\n",
    "#   \"FlightNum\":\"6109\",\"Origin\":\"TUS\"\n",
    "# }\n",
    "#\n",
    "\n",
    "from pyspark.sql.types import StringType, IntegerType, FloatType, DateType, TimestampType \n",
    "from pyspark.sql.types import StructType, StructField\n",
    "\n",
    "schema = StructType([\n",
    "  StructField(\"ArrDelay\", FloatType(), True),       # \"ArrDelay\":5.0\n",
    "  StructField(\"CRSArrTime\", TimestampType(), True), # \"CRSArrTime\":\"2015-12...\"\n",
    "  StructField(\"CRSDepTime\", TimestampType(), True), # \"CRSDepTime\":\"2015-12...\"\n",
    "  StructField(\"Carrier\", StringType(), True),       # \"Carrier\":\"WN\"\n",
    "  StructField(\"DayOfMonth\", IntegerType(), True),   # \"DayOfMonth\":31\n",
    "  StructField(\"DayOfWeek\", IntegerType(), True),    # \"DayOfWeek\":4\n",
    "  StructField(\"DayOfYear\", IntegerType(), True),    # \"DayOfYear\":365\n",
    "  StructField(\"DepDelay\", FloatType(), True),       # \"DepDelay\":14.0\n",
    "  StructField(\"Dest\", StringType(), True),          # \"Dest\":\"SAN\"\n",
    "  StructField(\"Distance\", FloatType(), True),       # \"Distance\":368.0\n",
    "  StructField(\"FlightDate\", DateType(), True),      # \"FlightDate\":\"2015-12...\"\n",
    "  StructField(\"FlightNum\", StringType(), True),     # \"FlightNum\":\"6109\"\n",
    "  StructField(\"Origin\", StringType(), True),        # \"Origin\":\"TUS\"\n",
    "])\n",
    "\n",
    "features = spark.read.json(\n",
    "  \"../data/simple_flight_delay_features.json\", \n",
    "  schema=schema\n",
    ")\n",
    "features.first()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Addressing Nulls\n",
    "\n",
    "Before we can use the tools that PySpark’s MLlib provides us, we must eliminate null values from fields in rows of our DataFrames. Otherwise our code will crash as we start to employ tools from `pyspark.ml.features`.\n",
    "\n",
    "To detect null values in columns, we need only loop through our columns and inspect them with `pyspark.sql.Column.isNull`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "null_counts = [(column, features.where(features[column].isNull()).count()) \\\n",
    "  for column in features.columns]\n",
    "cols_with_nulls = filter(lambda x: x[1] > 0, null_counts)\n",
    "print(list(cols_with_nulls))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If null values are found, we need only employ `DataFrame.na.fill` to fill them. Supply `fillna` with a dict with the column name as the key and the column’s fill value as the value, and it will fill in the column name with that value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filled_features = features.na.fill({'DepDelay': 0})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our dataset, no nulls are found, but there usually are some, so take note of this step for the future. It will save you trouble as you start engineering and vectorizing your features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Replacing FlightNum with Route\n",
    "\n",
    "At this point it occurs to us that `FlightNums` will change, but routes do not… so long as we define a route as a pair of cities. So, let’s add a column Route, which is defined as the concatenation of `Origin`, -, and `Dest`, such as `ATL-SFO`. This will very simply inform our model whether certain routes are frequently delayed, separately from whether certain airports tend to have delays for inbound or outbound flights.\n",
    "\n",
    "To add Route, we need to use two utilities from the pyspark.sql.functions package. The concat function concatenates multiple strings together, and the lit function is needed to specify a literal string to concatenate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Add a Route variable to replace FlightNum\n",
    "#\n",
    "from pyspark.sql.functions import lit, concat\n",
    "features_with_route = features.withColumn(\n",
    "  'Route',\n",
    "  concat(\n",
    "    features.Origin,\n",
    "    lit('-'),\n",
    "    features.Dest\n",
    "  )\n",
    ")\n",
    "features_with_route.select(\"Origin\", \"Dest\", \"Route\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RDD Alternative RouteNum\n",
    "\n",
    "Note that if we wanted to, we could convert the record to an RDD, where we could run something like the following:\n",
    "\n",
    "```python\n",
    "def add_route(record):\n",
    "  record = record.asDict()\n",
    "  record['Route'] = record['Origin'] + \"-\" + record['Dest']\n",
    "  return record\n",
    "\n",
    "features_with_route_rdd = features.rdd.map(add_route)\n",
    "```\n",
    "\n",
    "The reason to use DataFrames is that they are much, much faster than RDDs, even if the API is slightly more complex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bucketizing a Continuous Variable for Classification\n",
    "\n",
    "Classification does not work to predict a continuous variable like flight delays (in minutes); classifications predict two or more categories. Therefore, in order to build a classifier for flight delays, we have to create categories our of delays in minutes.  How to select proper bucket?\n",
    "\n",
    "#### Determining Arrival Delay Buckets\n",
    "\n",
    "In the first run-through writing the book, we used the same buckets as Bay Area startup FlightCaster (founded in 2009 and acquired in 2011 by Next Jump): on time, slightly late, and very late. The values corresponding to these bins come from a natural split in how people think about time in terms of minutes, hours, and days. One hour is an intuitive value for the high end of slightly late. Over one hour would then be very late. “On time” would be within 15 minutes of the scheduled arrival time. If such natural bins weren’t available, you would want to closely analyze the distribution of your continuous variable to determine what buckets to use.\n",
    "\n",
    "As it turned out, this analysis was necessary in our case too. When writing the book, while debugging an issue with our Spark ML classifier model, we did an analysis where we found that a different set of categories were needed. Check out the Jupyter notebook at ch09/Debugging Prediction Problems.ipynb for details. Note that GitHub supports the display of Jupyter notebooks, which makes them a really powerful way to share data analyses—just commit and push to a GitHub repository and you’ve got a shared report. When you are doing iterative visualization, notebooks are very handy.\n",
    "\n",
    "#### Iterative Visualization with Histograms\n",
    "\n",
    "To begin, check out the overall distribution of flight delays, which we compute by converting the features `DataFrame` to an `RDD` and then employing `RDD.histogram`. `RDD.histogram` returns two lists: a set of buckets, and the count for each bucket. We then use `matplotlib.pyplot` to create a histogram. Note that because our buckets are already counted, we can’t use `pyplot.hist`. Instead, we employ `pyplot.bar` to create a histogram from our precomputed buckets and their corresponding counts.\n",
    "\n",
    "To gather our data, we select the `ArrDelay` column, convert the DataFrame to an `RDD`, and call `RDD.flatMap` to convert our records into an `RDD` containing a single list of floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.mlab as mlab\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Look at overall histogram\n",
    "data_tuple = features\\\n",
    "  .select(\"ArrDelay\")\\\n",
    "  .rdd\\\n",
    "  .flatMap(lambda x: x)\\\n",
    "  .histogram([-87.0, -60, -30, -15, 0, 15, 30, 60, 120])\n",
    "data_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_delay = features.select(\"ArrDelay\")\n",
    "\n",
    "sample = arr_delay.filter(arr_delay.ArrDelay < 120).sample(False, 0.10)\n",
    "sample.toPandas().hist('ArrDelay', bins=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "([-87.0, -60, -30, -15, 0, 15, 30, 60, 120],\n",
    " [5, 1031, 7441, 18039, 9589, 3712, 2951, 1958])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85077501-4ed49280-b177-11ea-8229-f6a7e229e1fd.png)\n",
    "\n",
    "Next, we extract the heights of the bars and the bin definitions from the tuple returned by histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = np.array(data_tuple[1])\n",
    "\n",
    "# The bins are 1 > length than the values\n",
    "full_bins = data_tuple[0]\n",
    "full_bins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "[-87.0, -60, -30, -15, 0, 15, 30, 60, 120]\n",
    "```\n",
    "Since bars are drawn from the left, we remove the rightmost item in the bins list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bars are drawn from the left\n",
    "mid_point_bins = full_bins[:-1]\n",
    "mid_point_bins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "[-87.0, -60, -30, -15, 0, 15, 30, 60]\n",
    "```\n",
    "Next, we use a list comprehension to determine the range between the values defining the buckets, which gives us the width of the bars. We’ve decided that the bars should be as wide as the data they measure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The width of a bar should be the range it maps in the data\n",
    "widths = [abs(i - j) for i, j in zip(full_bins[:-1], full_bins[1:])]\n",
    "widths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "[27.0, 30, 15, 15, 15, 15, 30, 60]\n",
    "```\n",
    "Finally, we plot the bar chart, specifying our bar widths (they draw from the left) and coloring our bars blue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# And now the bars should plot nicely\n",
    "bar = plt.bar(mid_point_bins, heights, width=widths, color='b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85078936-72e5a300-b17a-11ea-9d5c-d2fa97a0a6fc.png)\n",
    "\n",
    "We can summarize the previous operations in a function called create_hist, which we will reuse to draw other histograms like this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_hist(rdd_histogram_data):\n",
    "  \"\"\"Given an RDD.histogram, plot a pyplot histogram\"\"\"\n",
    "  heights = np.array(rdd_histogram_data[1])\n",
    "  full_bins = rdd_histogram_data[0]\n",
    "  mid_point_bins = full_bins[:-1]\n",
    "  widths = [abs(i - j) for i, j in zip(full_bins[:-1], full_bins[1:])]\n",
    "  bar = plt.bar(mid_point_bins, heights, width=widths, color='b')\n",
    "  return bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start, let’s visualize the first set of buckets we considered: –87 to 15, 15 to 60, and 60 to 200. Note that the first item in the bucket definition, –87, comes from the minimum delay in the dataset. We use 200 to keep from distorting the chart, although the maximum delay is actually 1,971 minutes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "buckets = [-87.0, 15, 60, 200]\n",
    "rdd_histogram_data = features\\\n",
    "  .select(\"ArrDelay\")\\\n",
    "  .rdd\\\n",
    "  .flatMap(lambda x: x)\\\n",
    "  .histogram(buckets)\n",
    "\n",
    "create_hist(rdd_histogram_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85078961-842eaf80-b17a-11ea-8590-345fc3c91daf.png)\n",
    "\n",
    "Wow. This is a very distorted distribution. We have created an imbalanced class set from one that should ideally be balanced. This is a problem, because imbalanced classes can produce classifiers that only predict the most common value, and yet still seem fairly accurate. At best, this label set would have made things hard for our classifier when there is no benefit to doing so. We need to rethink our labels.\n",
    "\n",
    "Let’s try something a little more granular and check the distribution using the set of buckets: [-87.0, -30, -15, 0, 15, 30, 120]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "buckets = [-87.0, -30, -15, 0, 15, 30, 120]\n",
    "rdd_histogram_data = features\\\n",
    "  .select(\"ArrDelay\")\\\n",
    "  .rdd\\\n",
    "  .flatMap(lambda x: x)\\\n",
    "  .histogram(buckets)\n",
    "\n",
    "create_hist(rdd_histogram_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85078984-8d1f8100-b17a-11ea-8750-b0bdc7d8326e.png)\n",
    "\n",
    "Hmm... this looks better, but the leftmost and rightmost buckets look too small. Let’s combine the –87 to –30 and –30 to –15 buckets, and try again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "buckets = [-87.0, -15, 0, 15, 30, 120]\n",
    "rdd_histogram_data = features\\\n",
    "  .select(\"ArrDelay\")\\\n",
    "  .rdd\\\n",
    "  .flatMap(lambda x: x)\\\n",
    "  .histogram(buckets)\n",
    "\n",
    "create_hist(rdd_histogram_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85079027-ac1e1300-b17a-11ea-9f12-c3282e02af76.png)\n",
    "\n",
    "This looks better! However, the 15–30 bucket seems too small. Let’s merge this bucket with the 0–15 bucket and try again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "buckets = [-87.0, -15, 0, 30, 120]\n",
    "rdd_histogram_data = features\\\n",
    "  .select(\"ArrDelay\")\\\n",
    "  .rdd\\\n",
    "  .flatMap(lambda x: x)\\\n",
    "  .histogram(buckets)\n",
    "\n",
    "create_hist(rdd_histogram_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](https://user-images.githubusercontent.com/16873751/85079035-b3452100-b17a-11ea-8a0f-1bcfee777c6f.png)\n",
    "\n",
    "he buckets end up being “very early” (> 15 minutes early), “early” (0–15 minutes early), “late” (0–30 minutes late), and “very late” (30+ minutes late). These aren’t perfect in terms of usability, but I think they can work. Ideally the distribution in the buckets would be equal, but they are close enough.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Bucketizing with `pyspark.ml.feature.Bucketizer`\n",
    "\n",
    "Creating buckets for classification is simpler using Bucketizer. We simply define our splits in a list, instantiate our Bucketizer, and then apply a transformation on our features DataFrame. We’ll do this transformation for the ArrDelay field:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Use pysmark.ml.feature.Bucketizer to bucketize ArrDelay\n",
    "#\n",
    "from pyspark.ml.feature import Bucketizer\n",
    "\n",
    "splits = [-float(\"inf\"), -15.0, 0, 15.0, 30.0, float(\"inf\")]\n",
    "bucketizer = Bucketizer(\n",
    "  splits=splits,\n",
    "  inputCol=\"ArrDelay\",\n",
    "  outputCol=\"ArrDelayBucket\"\n",
    ")\n",
    "ml_bucketized_features = bucketizer.transform(features_with_route)\n",
    "\n",
    "# Check the buckets out\n",
    "ml_bucketized_features.select(\"ArrDelay\", \"ArrDelayBucket\").show(10)"
   ]
  },
  {
   "attachments": {
    "ads2_0702.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+--------+--------------+\n",
    "|ArrDelay|ArrDelayBucket|\n",
    "+--------+--------------+\n",
    "|     9.0|           2.0|\n",
    "|   -12.0|           1.0|\n",
    "|   -17.0|           0.0|\n",
    "|    -9.0|           1.0|\n",
    "|   -27.0|           0.0|\n",
    "|   -29.0|           0.0|\n",
    "|     9.0|           2.0|\n",
    "|    -9.0|           1.0|\n",
    "|   -36.0|           0.0|\n",
    "|    12.0|           2.0|\n",
    "+--------+--------------+\n",
    "```\n",
    "\n",
    "\n",
    "## Feature Vectorization with `pyspark.ml.feature`\n",
    "\n",
    "Spark MLlib has an extremely rich library of functions for various machine learning tasks, so it is helpful when using MLlib to have the API documentation open in a browser tab, along with the DataFrame API documentation. While an RDD-based API does exist, we’ll be using the DataFrame-based MLlib routines.\n",
    "\n",
    "### Vectorizing Categorical Columns with Spark ML\n",
    "\n",
    "\n",
    "To follow along with this section, open the pyspark.ml.feature documentation. First we need to import our tools from pyspark.ml.feature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml.feature import StringIndexer, VectorAssembler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we need to index our nominal or categorical string columns into sets of vectors made up of binary variables for every unique value found in a given column. To achieve this, for each categorical column (be it a string or number), we need to:\n",
    "\n",
    "1. Configure and create a StringIndexer to index the column into one number per unique value.\n",
    "\n",
    "2. Execute fit on the StringIndexer to get a StringIndexerModel.\n",
    "\n",
    "3. Run the training data through StringIndexerModel.transform to index the strings into a new column.\n",
    "\n",
    "The code to implement these steps for each categorical variable column looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn category fields into categoric feature vectors, then drop \n",
    "# intermediate fields\n",
    "for column in [\"Carrier\", \"DayOfMonth\", \"DayOfWeek\", \"DayOfYear\",\n",
    "               \"Origin\", \"Dest\", \"Route\"]:\n",
    "  string_indexer = StringIndexer(\n",
    "    inputCol=column,\n",
    "    outputCol=column + \"_index\"\n",
    "  )\n",
    "  ml_bucketized_features = string_indexer.fit(ml_bucketized_features)\\\n",
    "                                         .transform(ml_bucketized_features)\n",
    "\n",
    "# Check out the indexes\n",
    "ml_bucketized_features.show(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+-------------+----------------+---------------+---------------+------------+----------+-----------+\n",
    "|ArrDelay|         CRSArrTime|         CRSDepTime|Carrier|DayOfMonth|DayOfWeek|DayOfYear|DepDelay|Dest|Distance|FlightDate|FlightNum|Origin|  Route|ArrDelayBucket|Carrier_index|DayOfMonth_index|DayOfWeek_index|DayOfYear_index|Origin_index|Dest_index|Route_index|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+-------------+----------------+---------------+---------------+------------+----------+-----------+\n",
    "|     9.0|2015-01-29 10:59:00|2015-01-29 09:30:00|     UA|        29|        4|       29|     0.0| EWR|   200.0|2015-01-29|      657|   BOS|BOS-EWR|           2.0|          5.0|             5.0|            1.0|            5.0|        17.0|      17.0|      274.0|\n",
    "|   -12.0|2015-01-29 08:37:00|2015-01-29 06:47:00|     UA|        29|        4|       29|     3.0| ORD|   867.0|2015-01-29|     1037|   BOS|BOS-ORD|           1.0|          5.0|             5.0|            1.0|            5.0|        17.0|       2.0|       94.0|\n",
    "|   -17.0|2015-01-29 19:19:00|2015-01-29 17:26:00|     UA|        29|        4|       29|     1.0| ORD|   867.0|2015-01-29|     1118|   BOS|BOS-ORD|           0.0|          5.0|             5.0|            1.0|            5.0|        17.0|       2.0|       94.0|\n",
    "|    -9.0|2015-01-29 09:45:00|2015-01-29 06:00:00|     UA|        29|        4|       29|    -6.0| SFO|  2704.0|2015-01-29|      433|   BOS|BOS-SFO|           1.0|          5.0|             5.0|            1.0|            5.0|        17.0|       6.0|      501.0|\n",
    "|   -27.0|2015-01-29 18:15:00|2015-01-29 16:42:00|     UA|        29|        4|       29|    -2.0| DEN|  1201.0|2015-01-29|      467|   CLE|CLE-DEN|           0.0|          5.0|             5.0|            1.0|            5.0|        41.0|       3.0|      569.0|\n",
    "|   -29.0|2015-01-29 10:59:00|2015-01-29 07:55:00|     UA|        29|        4|       29|     0.0| FLL|  1062.0|2015-01-29|     1026|   CLE|CLE-FLL|           0.0|          5.0|             5.0|            1.0|            5.0|        41.0|      19.0|     1528.0|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+-------------+----------------+---------------+---------------+------------+----------+-----------+\n",
    "```\n",
    "\n",
    "Having indexed our categorical features, now we combine them with our numeric features into a single feature vector for our classifier.\n",
    "\n",
    "### Vectorizing Continuous Variables and Indexes with Spark ML\n",
    "\n",
    "As they are already numeric, there isn’t much work required to vectorize our continuous numeric features. And now that we have indexes, we have a numeric representation of each string column. Now we simply employ VectorAssembler to combine the numeric and index columns into a single feature Vector. Then we drop the index columns, as they aren’t needed anymore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Handle continuous numeric fields by combining them into one feature vector\n",
    "numeric_columns = [\"DepDelay\", \"Distance\"]\n",
    "index_columns = [\"Carrier_index\", \"DayOfMonth_index\",\n",
    "                   \"DayOfWeek_index\", \"DayOfYear_index\", \"Origin_index\",\n",
    "                   \"Origin_index\", \"Dest_index\", \"Route_index\"]\n",
    "vector_assembler = VectorAssembler(\n",
    "  inputCols=numeric_columns + index_columns,\n",
    "  outputCol=\"Features_vec\"\n",
    ")\n",
    "final_vectorized_features = vector_assembler.transform(ml_bucketized_features)\n",
    "\n",
    "# Drop the index columns\n",
    "for column in index_columns:\n",
    "  final_vectorized_features = final_vectorized_features.drop(column)\n",
    "\n",
    "# Check out the features\n",
    "final_vectorized_features.show(10)\n",
    "\n",
    "final_vectorized_features = final_vectorized_features.filter(final_vectorized_features.FlightDate < '2015-02-01')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+\n",
    "|ArrDelay|         CRSArrTime|         CRSDepTime|Carrier|DayOfMonth|DayOfWeek|DayOfYear|DepDelay|Dest|Distance|FlightDate|FlightNum|Origin|  Route|ArrDelayBucket|        Features_vec|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+\n",
    "|     9.0|2015-01-29 10:59:00|2015-01-29 09:30:00|     UA|        29|        4|       29|     0.0| EWR|   200.0|2015-01-29|      657|   BOS|BOS-EWR|           2.0|[0.0,200.0,5.0,5....|\n",
    "|   -12.0|2015-01-29 08:37:00|2015-01-29 06:47:00|     UA|        29|        4|       29|     3.0| ORD|   867.0|2015-01-29|     1037|   BOS|BOS-ORD|           1.0|[3.0,867.0,5.0,5....|\n",
    "|   -17.0|2015-01-29 19:19:00|2015-01-29 17:26:00|     UA|        29|        4|       29|     1.0| ORD|   867.0|2015-01-29|     1118|   BOS|BOS-ORD|           0.0|[1.0,867.0,5.0,5....|\n",
    "|    -9.0|2015-01-29 09:45:00|2015-01-29 06:00:00|     UA|        29|        4|       29|    -6.0| SFO|  2704.0|2015-01-29|      433|   BOS|BOS-SFO|           1.0|[-6.0,2704.0,5.0,...|\n",
    "|   -27.0|2015-01-29 18:15:00|2015-01-29 16:42:00|     UA|        29|        4|       29|    -2.0| DEN|  1201.0|2015-01-29|      467|   CLE|CLE-DEN|           0.0|[-2.0,1201.0,5.0,...|\n",
    "|   -29.0|2015-01-29 10:59:00|2015-01-29 07:55:00|     UA|        29|        4|       29|     0.0| FLL|  1062.0|2015-01-29|     1026|   CLE|CLE-FLL|           0.0|[0.0,1062.0,5.0,5...|\n",
    "|     9.0|2015-01-29 08:16:00|2015-01-29 07:45:00|     UA|        29|        4|       29|    -4.0| ORD|   315.0|2015-01-29|     1715|   CLE|CLE-ORD|           2.0|[-4.0,315.0,5.0,5...|\n",
    "|    -9.0|2015-01-29 18:08:00|2015-01-29 16:56:00|     UA|        29|        4|       29|    -6.0| ORD|   599.0|2015-01-29|      411|   CLT|CLT-ORD|           1.0|[-6.0,599.0,5.0,5...|\n",
    "|   -36.0|2015-01-29 09:41:00|2015-01-29 07:00:00|     UA|        29|        4|       29|    -6.0| IAH|  1208.0|2015-01-29|     1657|   DCA|DCA-IAH|           0.0|[-6.0,1208.0,5.0,...|\n",
    "|    12.0|2015-01-29 12:39:00|2015-01-29 11:05:00|     UA|        29|        4|       29|    19.0| BIL|   455.0|2015-01-29|     1293|   DEN|DEN-BIL|           2.0|[19.0,455.0,5.0,5...|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+\n",
    "```\n",
    "\n",
    "\n",
    "Now we’re ready to train our classifier!\n",
    "\n",
    "### Classification with Spark ML\n",
    "\n",
    "Our features are prepared in a single field, Features_vec, and we’re ready to compose the experiment we’ll run as part of creating our classifier. To drive our experiment, we require a training dataset and a test dataset. As we discussed earlier, a training dataset is used to train the model and a test set is used to gauge its accuracy. Cross-validation ensures that the models we create in the lab perform well in the real world, and not just on paper.\n",
    "\n",
    "#### Test/Train Split with DataFrames\n",
    "\n",
    "As before with scikit-learn, we need to cross-validate. This means splitting our data between a training set and a test set.\n",
    "\n",
    "The DataFrame API makes this easy with `DataFrame.randomSplit`. This takes an array featuring the ratios of the splits, which should add up to 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test/train split\n",
    "training_data, test_data = final_vectorized_features.randomSplit([0.8, 0.2], seed=27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and Fitting a Model\n",
    "\n",
    "It takes three lines to import, instantiate, and fit a random forest classifier using our training dataset. Note that we’re using a random forest classifier because this is the most accurate decision tree model available in Spark MLlib that can classify into multiple categories. These classifiers also offer feature importances, which we will use in Chapter 9 to improve the model.\n",
    "\n",
    "Also note that we run the model once, and it throws an exception because we have more than 32 unique values for one feature, the default value for maxBins. We set maxBins to the value suggested by the exception, 4657, and the model fits successfully. Note that this can take a while, so grab some coffee:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate and fit random forest classifier\n",
    "from pyspark.ml.classification import RandomForestClassifier\n",
    "rfc = RandomForestClassifier(\n",
    "  featuresCol=\"Features_vec\",\n",
    "  labelCol=\"ArrDelayBucket\",\n",
    "  maxBins=4657,\n",
    "  maxMemoryInMB=1024,\n",
    "  seed=27\n",
    ")\n",
    "model = rfc.fit(training_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need to evaluate the classifier we’ve created.\n",
    "\n",
    "### EVALUATING A MODEL\n",
    "\n",
    "We can evaluate the performance of our classifier using the `MulticlassClassificationEvaluator`, which simply wraps the predictions we get from running `pyspark.ml.classification.RandomForestClassificationModel.transform` on the test dataset. Several metrics are available, but we’ll start with the raw accuracy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate model using test data\n",
    "predictions = model.transform(test_data)\n",
    "\n",
    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
    "evaluator = MulticlassClassificationEvaluator(\n",
    "  labelCol=\"ArrDelayBucket\", metricName=\"accuracy\"\n",
    ")\n",
    "accuracy = evaluator.evaluate(predictions)\n",
    "print(\"Accuracy = {}\".format(accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not great, but good enough for now. Don’t worry, we’ll work on making the model more accurate in Chapter 9.\n",
    "\n",
    "Let’s lay eyes on some of the predictions, to see that they’re sane. At one point we had a bug where all predictions were 0.0. Seeing a sample with different prediction values takes a bit of cleverness because of the way the transformation sorts the data, so we order the sample by the reservation system departure time before displaying it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sanity-check a sample\n",
    "predictions.sample(False, 0.001, 18).orderBy(\"CRSDepTime\").show(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+--------------------+--------------------+----------+\n",
    "|ArrDelay|         CRSArrTime|         CRSDepTime|Carrier|DayOfMonth|DayOfWeek|DayOfYear|DepDelay|Dest|Distance|FlightDate|FlightNum|Origin|  Route|ArrDelayBucket|        Features_vec|       rawPrediction|         probability|prediction|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+--------------------+--------------------+----------+\n",
    "|     9.0|2015-01-01 13:09:00|2015-01-01 11:20:00|     US|         1|        4|        1|    14.0| PBI|   590.0|2015-01-01|     1983|   CLT|CLT-PBI|           2.0|[14.0,590.0,6.0,2...|[1.51427525613448...|[0.07571376280672...|       2.0|\n",
    "|    17.0|2015-01-02 14:59:00|2015-01-02 10:15:00|     EV|         2|        5|        2|     2.0| CMH|  1154.0|2015-01-02|     4251|   DEN|DEN-CMH|           3.0|[2.0,1154.0,2.0,1...|[4.07963344542491...|[0.20398167227124...|       1.0|\n",
    "|   -21.0|2015-01-04 17:01:00|2015-01-04 15:36:00|     B6|         4|        7|        4|    -8.0| BOS|   399.0|2015-01-04|      690|   DCA|DCA-BOS|           0.0|[-8.0,399.0,8.0,1...|[4.379892488116,9...|[0.2189946244058,...|       1.0|\n",
    "|   205.0|2015-01-08 14:55:00|2015-01-08 08:45:00|     UA|         8|        4|        8|   102.0| ORD|  1744.0|2015-01-08|     1084|   LAX|LAX-ORD|           4.0|[102.0,1744.0,5.0...|[0.30996222720933...|[0.01549811136046...|       4.0|\n",
    "|   -18.0|2015-01-08 20:02:00|2015-01-08 18:20:00|     DL|         8|        4|        8|    -2.0| DCA|   547.0|2015-01-08|     1738|   ATL|ATL-DCA|           0.0|[-2.0,547.0,1.0,1...|[3.87135350468531...|[0.19356767523426...|       1.0|\n",
    "|    -4.0|2015-01-16 20:39:00|2015-01-16 19:00:00|     EV|        16|        5|       16|    -4.0| EWR|   445.0|2015-01-16|     4368|   GSO|GSO-EWR|           1.0|[-4.0,445.0,2.0,0...|[4.95868706175130...|[0.24793435308756...|       1.0|\n",
    "+--------+-------------------+-------------------+-------+----------+---------+---------+--------+----+--------+----------+---------+------+-------+--------------+--------------------+--------------------+--------------------+----------+\n",
    "```\n",
    "\n",
    "Now let’s see the distribution of the Prediction field, to verify we don’t have that same bug:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions.groupBy(\"Prediction\").count().orderBy('Prediction').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "+----------+-----+\n",
    "|Prediction|count|\n",
    "+----------+-----+\n",
    "|       0.0|   45|\n",
    "|       1.0| 6473|\n",
    "|       2.0| 1287|\n",
    "|       3.0|  167|\n",
    "|       4.0| 1191|\n",
    "+----------+-----+\n",
    "```\n",
    "\n",
    "This “sanity check” seems okay!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation Conclusion\n",
    "\n",
    "With Spark, we can create, train, and evaluate a classifier or regression in a few lines of code. Surprisingly, it is even more powerful than scikit-learn. But to be useful, we’ve got to deploy our prediction. We’ll do that in the next chapter.\n",
    "\n",
    "Now we have a problem—how do we deploy Spark ML models? Unlike scikit-learn models, we can’t simply place them inside our web application as an API, because they require the Spark platform to run. This is something we will address in the next chapter.\n",
    "\n",
    "\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "In this chapter we’ve taken what we know about the past to predict the future.\n",
    "\n",
    "In the next chapter, we’ll drill down into this prediction to drive a new action that can take advantage of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions.select(\"ArrDelayBucket\",\"prediction\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "\n",
    "+--------------+----------+\n",
    "|ArrDelayBucket|prediction|\n",
    "+--------------+----------+\n",
    "|           0.0|       1.0|\n",
    "|           0.0|       1.0|\n",
    "|           0.0|       1.0|\n",
    "|           0.0|       1.0|\n",
    "|           0.0|       1.0|\n",
    "+--------------+----------+\n",
    "```"
   ]
  }
 ],
 "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": 2
}