mp3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mini Project 3\n",
    "## Bike paths and accidents\n",
    "\n",
    "**Names:** Enrique Sanchez, Parker Addison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> My favorite section is titled as such below!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are you more or less likely to face injurity in a bike-related accident if that accident occurs on a bike path or not?  What if you look at this dependent on severity, zipcode, or type of parties involved?  Where in the city of San Diego are you more likely to get into an accident involving alcohol?  Can this be explained by additional statistics by zipcode, such as the number of bars in a zipcode?\n",
    "\n",
    "We can answer all of these questions, and more, by using the ArcGIS API for Python.\n",
    "\n",
    "Remember that in the first lecture we found a layer containing collisions and bike routes.  This file showed bike and pedestrian TIMS-geocoded (Transpotation Injury Mapping System) collisions in San Diego county.  You can view the relevant metadata at https://tims.berkeley.edu/help/SWITRS.php (Statewide Integrated Traffic Records System from CA Highway Patrol)\n",
    "\n",
    "\n",
    "Your tasks include:\n",
    "1. At the site above, go to SWITRS Query and Map, then request bike collision data between 1/1/2014 and 12/31/2018 for San Diego city.\n",
    "1. Download and explore the collision data.  Also download and explore party and victim data.\n",
    "1. Explor and understand the fields you need to work with. See SWITRS FAQ page at https://tims.berkeley.edu/help/Query_and_Map.php#FAQs and the codebook at https://tims.berkeley.edu/help/SWITRS.php#Codebook. SWITRS is relatively well documented.\n",
    "1. Find a way to join all three tables (collisions, parties, victims). Note that there are similarly-named fields in the three tables, but they can mean different things or be applied to different groups.\n",
    "1. Create point map of collisions.\n",
    "1. Save the joined table as a feature service on ArcGIS Online.\n",
    "1. Identify collisions that happened on versus off of a bike path. This can be tricky. Geometrically, what does it mean to \"be on a bike path\"?  Also, which ArcGIS techniques can you use to connect Collisions to Bike Routes?\n",
    "1. Summarize collision trends by zipcode, and use geoenrichment to add additional data to the zipcodes table.\n",
    "1. Analyze the collisions and zipcode layers, answering the questions above.  Use a technique such as regression to build a model and/or further your analysis.\n",
    "\n",
    "Deliverables:\n",
    "1. Maps of bicycle accidents and bike paths, dependent on a) alcohol involvement, b) whether the ciclist was at fault due to impairment, and c) type of parties involved.\n",
    "2. By zipcode, display accidents with alcohol involved as well as one other variable that may explain it based on your exploration.\n",
    "3. A brief description of findings (300 words or more)\n",
    "4. URLs for all resources you've added to ArcGIS Online\n",
    "5. For extra credit: a) interesting exploration involving the victims table and b) insights that can be presented to a local planning commission to reduce the risk or severity of bike collisions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import arcgis\n",
    "from arcgis.gis import GIS\n",
    "from arcgis.features.find_locations import find_existing_locations\n",
    "from arcgis.geoenrichment import standard_geography_query, enrich\n",
    "\n",
    "import scipy\n",
    "import sklearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter password: ········\n"
     ]
    }
   ],
   "source": [
    "gis = GIS(username='pgaddiso_UCSDOnline8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 1. Loading the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Lets go ahead and read in the data.\n",
    "\n",
    "# This is data from San Diego City.\n",
    "collisions = pd.read_csv(\"data/Collisions.csv\")\n",
    "parties = pd.read_csv(\"data/Parties.csv\")\n",
    "victims = pd.read_csv(\"data/Victims.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 2. Joining party (and victims for extra credit) to the collisions data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# In order to join these data frames together, we must find the columns they share\n",
    "shared_collisions_parties = list(set(collisions.columns) & set(parties.columns))\n",
    "\n",
    "# We can see that they all share two columns names: ACCIDENT_YEAR and CASE_ID\n",
    "# We should note that when we join collisions and parties, CASE_ID will no longer be\n",
    "# unique. We will have n similar CASE_IDs where n is the party size involved in collision.\n",
    "collisions_parties = collisions.merge(parties, on=shared_collisions_parties)\n",
    "\n",
    "# Since we now have party information and collision data together, we must merge it with\n",
    "# victim data. However, we cannot merge only on CASE_ID since this will lead to \n",
    "# unwanted repetition. Instead, we should merge on CASE_ID and PARTY_NUMBER so we merge\n",
    "# the correct victim information to the corresponding victim in the joint collisions above.\n",
    "#\n",
    "# Note that we're using a left join here because we have data for only a subset (~2700) of\n",
    "# victims.  We don't want this to affect our analysis of the collisions, so we want to keep\n",
    "# all of our collision entries!\n",
    "shared_with_victims = list(set(collisions_parties.columns) & set(victims.columns))\n",
    "all_data = collisions_parties.merge(victims, on=shared_with_victims, how=\"left\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 3. Cleaning spatial data and creating a point map of collisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Our data has LONGITUDE and LATITUDE which are generated by GPS, as well as POINT_X and POINT_Y\n",
    "# which have been geocoded already.\n",
    "#\n",
    "# We should fill in any missing lat-long with their point_x and point_y, since the lat-long are\n",
    "# likely more accurate since they were generated at the scene.\n",
    "\n",
    "# If we attempt to create a point layer for collisions as is, we will be unable \n",
    "# to plot as it is missing 355 coordinate pairs. Therefore, we should remove\n",
    "# the rows that have the coordinates missing.\n",
    "\n",
    "# Additionally, let's not confuse ourselves!  We'll drop the POINT_X, POINT_Y, LONGITUDE, and\n",
    "# LATITUDE columns once we create the new columns.\n",
    "\n",
    "def clean_coords(df):\n",
    "    df_xy = (\n",
    "        df\n",
    "        .assign(\n",
    "            x=all_data.LONGITUDE.combine_first(all_data.POINT_X),\n",
    "            y=all_data.LATITUDE.combine_first(all_data.POINT_Y)\n",
    "        )\n",
    "        .drop([\"POINT_X\", \"POINT_Y\", \"LONGITUDE\", \"LATITUDE\"], axis=1)\n",
    "        .dropna(subset=['x', 'y'])\n",
    "    )\n",
    "    \n",
    "    return df_xy\n",
    "\n",
    "collisions = clean_coords(collisions)\n",
    "\n",
    "# Now that we have the coordinates in the right place, we will create a\n",
    "# spatial data frame.\n",
    "#\n",
    "# For whatever reason, we won't be able to fully plot our sdf unless we drop\n",
    "# additional columns.\n",
    "#\n",
    "# Note: This is an sdf of just the collisions.\n",
    "sdf = (\n",
    "    pd.DataFrame.spatial.from_xy(collisions, x_column = 'x', y_column='y')\n",
    "    .replace(np.NaN, '', regex=True)\n",
    "    .drop([\"PCF_VIOLATION\"], axis=1)\n",
    ")\n",
    "sdf = sdf.replace(np.nan, '', regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we can plot all collisions!\n",
    "map1 = gis.map(\"San Diego\", zoomlevel=10)\n",
    "sdf.spatial.plot(map_widget=map1, alpha=.3)\n",
    "map1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 4. Classifying on-path and off-path collisions and summarizing different collision types by zipcode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# First we should get a hold of San Diego bike routes.\n",
    "#\n",
    "# Data description:\n",
    "# \"\"\"\n",
    "# This dataset uses the SanGIS Roads_All layer as the basis for the linear\n",
    "# features. SANDAG obtained input on bike network data from local jurisdictions\n",
    "# in 2017 and 2018 and used this information to update the regional bikeways\n",
    "# dataset. For specific information regarding the status of bike facilities\n",
    "# represented in the data, please contact bike planning staff for the respective\n",
    "# local jurisdictions.\n",
    "#\n",
    "# This data has been reprojected for purposes of the San Diego Ocean Planning\n",
    "# Partnership, a collaborative pilot project between the California State Lands\n",
    "# Commission and the Port of San Diego. For more information about the\n",
    "# Partnership, please visit: https://www.sdoceanplanning.org/ These routes,\n",
    "# while being well outside of the planning boundary, show conduits for coastal\n",
    "# access from communities across San Diego. As with all data shown outside of\n",
    "# the preliminary planning boundary, this data is included for reference only.\n",
    "#\n",
    "# This dataset is available for viewing in an interactive web map. Visit\n",
    "# 511sd.com/bikemap to view the interactive map. \n",
    "# \"\"\"\n",
    "#\n",
    "# Source:\n",
    "# https://ucsdonline.maps.arcgis.com/home/item.html?id=086106add0a645ba864db08f45c795ea\n",
    "\n",
    "bike_routes_fl = gis.content.get(\"086106add0a645ba864db08f45c795ea\")\n",
    "\n",
    "# Let's also read in our collision data from ArcGIS Online\n",
    "\n",
    "# ---------------------------------------------------------------------------- #\n",
    "# Exporting our collisions sdf to a feature layer.\n",
    "#\n",
    "# Note: This only needs to be run once.  It should be shared and accessible now!\n",
    "\n",
    "# collisions_fl = sdf.spatial.to_featurelayer(\"MP3-BikeCollisions\", gis, [\"bike\", \"collisions\"])\n",
    "# collisions_fl.share(org=True)\n",
    "# ---------------------------------------------------------------------------- #\n",
    "\n",
    "collisions_fl = gis.content.get(\"17010ad85a8d43159bd786b34144b96e\")\n",
    "\n",
    "\n",
    "# After a bit of analysis, we determined that 40 feet is a pretty\n",
    "# good estimate for the error between a true bike path and \n",
    "# bike collision.\n",
    "#\n",
    "# Many bike paths are drawn through the center of large roads such as Gilman or\n",
    "# Genesee, as opposed to having a bike path for each direction.  These roads are\n",
    "# often two to three lanes each direction, and thus there's an expected error of\n",
    "# about ~24–36 feet between the median strip and a bike lane (side of road).\n",
    "#\n",
    "# It is also likely that locations are reported from the sidewalk, as opposed to\n",
    "# the center of the road, so there may be additional error between the bike lane\n",
    "# and the sidewalk where the incident was reported.\n",
    "#\n",
    "# Unfortunately, for narrower bike paths or roads, this buffer may be too large;\n",
    "# perhaps we are capturing collisions that took place across the street...\n",
    "#\n",
    "# This is an issue that probably requires the use of different sized buffers\n",
    "# around the different types of bike routes listed in our data source.  However,\n",
    "# we don't quite have enough domain expertise in the field of bike paths to know\n",
    "# what sort of bike routes there are, and what sort of buffers make sense.\n",
    "#\n",
    "# For the purpose of our analysis, what we currently have works fine!\n",
    "\n",
    "# ---------------------------------------------------------------------------- #\n",
    "# It should be noted that using `find_existing_locations` resulted in some bugs,\n",
    "# in which some collisions would be selected when they shouldn't have, and vice\n",
    "# versa.\n",
    "#\n",
    "# Additionally, `join_features` is preferred here so that we have access to the\n",
    "# type of route that the collision took place on, which may be interesting for\n",
    "# future analysis.\n",
    "\n",
    "# Note: This only needs to be run once.  It should be shared and accessible now!\n",
    "\n",
    "# path_collisions_fl = arcgis.join_features(\n",
    "#     collisions_fl.layers[0], bike_routes_fl.layers[0], \"withindistance\", 40, \"Feet\",\n",
    "#     output_name=\"MP3-PathCollisions\"\n",
    "# )\n",
    "# path_collisions_fl.share(org=True)\n",
    "# ---------------------------------------------------------------------------- #\n",
    "\n",
    "path_collisions_fl = gis.content.get(\"199dffb82ba44d499e00a728a40403df\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's plot the data to verify the accuracy of on-path collisions.\n",
    "\n",
    "# Multi colored lines: Bike paths\n",
    "# Orange dots: Collision\n",
    "# Blue dots: Collision on a bike path\n",
    "map2 = gis.map(\"San Diego\", zoomlevel=10)\n",
    "map2.add_layer(path_collisions_fl)\n",
    "map2.add_layer(bike_routes_fl, {'opacity':.6})\n",
    "map2.add_layer(collisions_fl)\n",
    "map2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Let's convert the bike path collisions into a spatial data frame so that we can\n",
    "# add a boolean to our collisions feature layer.\n",
    "path_collisions_df = path_collisions_fl.layers[0].query().sdf\n",
    "\n",
    "# Since path_collisions_df contains CASE_ID, we can add a boolean column to our\n",
    "# original sdf that signifies whether or not the collision was on a bike path\n",
    "on_path_bools = sdf.CASE_ID.isin(path_collisions_df.CASE_ID)\n",
    "\n",
    "\n",
    "# Adding zip codes to our original sdf will be helpful for future analysis\n",
    "# in determining exactly where these collisions are occurring.\n",
    "#\n",
    "# We decided to use a spatial join here, as reverse geocoding would have involved\n",
    "# additional cleanup to extract the zipcode from the addresses, and could result\n",
    "# in incorrect zipcodes if the bike path has no nearby addresses.\n",
    "\n",
    "# Reading in zip code data\n",
    "sd_zip_codes = gis.content.search('title: San Diego Zip Codes', outside_org=True)[0]\n",
    "zip_codes = sd_zip_codes.layers[0]\n",
    "\n",
    "# ---------------------------------------------------------------------------- #\n",
    "# Spatial join between collision layer and this new layer\n",
    "# join = arcgis.join_features(\n",
    "#     collisions_fl, zip_codes, spatial_relationship='within',\n",
    "#     output_name=\"MP3-CollisionsWithZipcodes\"\n",
    "# )\n",
    "# join.share(org=True)\n",
    "# ---------------------------------------------------------------------------- #\n",
    "\n",
    "join = gis.content.get(\"0ca2a0a2ed054133a39271590ae90381\")\n",
    "collisions_zipcodes = join.layers[0].query().sdf\n",
    "\n",
    "\n",
    "# Now we can add the zip codes and path booleans to sdf\n",
    "collisions_sdf = (\n",
    "    sdf.assign(\n",
    "        ON_PATH=on_path_bools,\n",
    "        ZIPCODE=collisions_zipcodes.ZIP,\n",
    "    )\n",
    "    .merge(path_collisions_df[[\"CASE_ID\", \"ROUTE\"]], on=\"CASE_ID\", how=\"left\")\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 5. Generating maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some setup for the maps:\n",
    "\n",
    "map_sdf = collisions_sdf.copy()\n",
    "\n",
    "### For the alcohol question ###\n",
    "\n",
    "# Let's clean the alcohol column in the sdf\n",
    "map_sdf[\"ALCOHOL_INVOLVED\"] = map_sdf[\"ALCOHOL_INVOLVED\"].replace({'':\"False\", 'Y': \"True\"})\n",
    "\n",
    "\n",
    "### For the impairment question ###\n",
    "\n",
    "# Let's determine which cases involved bikers that were at fault and impaired\n",
    "\n",
    "# NOTE: The PARTY_SOBRIETY column has many vlaues where the impairment in unknown.\n",
    "# In order to not make false assumptions, we will only count impaired as those\n",
    "# with the value 'B': Had been drinking, under influence\n",
    "# Also, those who are under drug influence or physical impairment in PARTY_DRUG_PHYSICAL\n",
    "impaired = collisions_parties[(collisions_parties['PARTY_TYPE'] == '4') & \n",
    "                              (collisions_parties['AT_FAULT'] == 'Y') &\n",
    "                              ((collisions_parties['PARTY_SOBRIETY'].isin(['B'])) |\n",
    "                               (collisions_parties['PARTY_DRUG_PHYSICAL'] == 'E') | \n",
    "                               (collisions_parties['PARTY_DRUG_PHYSICAL'] == 'F'))]\n",
    "\n",
    "impaired_cases = impaired['CASE_ID'].unique()\n",
    "\n",
    "# Lets now create a column in our sdf signifying whether the bicylcist\n",
    "# was at fault and impaired\n",
    "map_sdf['BIKE_IMPAIRED'] = map_sdf['CASE_ID'].isin(impaired_cases).astype(str)\n",
    "\n",
    "\n",
    "### For the party question ###\n",
    "\n",
    "# Let's figure out the different party combinations that we have\n",
    "party_types = {\n",
    "    '1': \"Driver\",\n",
    "    '2': \"Pedestrian\",\n",
    "    '3': \"Parked Vehicle\",\n",
    "    '4': \"Bicyclist\",\n",
    "    '5': \"Other\",\n",
    "    '-': \"Unknown\"\n",
    "}\n",
    "\n",
    "party_combos = (\n",
    "    collisions_parties\n",
    "    .assign(PARTY_TYPE=collisions_parties.PARTY_TYPE.replace(party_types))\n",
    "    .groupby('CASE_ID')\n",
    "    .PARTY_TYPE\n",
    "    .apply(lambda x: tuple(np.sort(x.tolist())))\n",
    ")\n",
    "\n",
    "combos_less_than_three = party_combos.value_counts().loc[lambda ser: ser < 3].index\n",
    "\n",
    "party_combos[party_combos.isin(combos_less_than_three)] = \"Other Combination\"\n",
    "\n",
    "map_sdf = map_sdf.merge(party_combos.astype(str).to_frame(), left_on=\"CASE_ID\", right_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1a.**\n",
    "Let's begin by generating a map of bike collisions dependent on whether or not alcohol was involved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of collisions where alcohol was involved: 183\n"
     ]
    }
   ],
   "source": [
    "print('Number of collisions where alcohol was involved: %d' %sum(map_sdf['ALCOHOL_INVOLVED'] == \"True\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map3 = gis.map(\"San Diego\", zoomlevel=10)\n",
    "map3.add_layer(bike_routes_fl, {'opacity':0.3})\n",
    "# Note that the color map is not fully deterministic...\n",
    "# If the colors are too similar, running this cell again will likely fix the issue.\n",
    "map_sdf.spatial.plot(map_widget=map3, renderer_type= 'u', col='ALCOHOL_INVOLVED', cmap='plasma')\n",
    "map3.legend=True\n",
    "map3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1b.** \n",
    "Now we want a map dependent on whether the bicyclist was at fault due to impairment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of collisions where bicyclist was at fault due to impairment: 31\n"
     ]
    }
   ],
   "source": [
    "print('Number of collisions where bicyclist was at fault due to impairment: %d' %sum(map_sdf[\"BIKE_IMPAIRED\"] == \"True\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map4 = gis.map(\"San Diego\", zoomlevel=10)\n",
    "# Note that the color map is not fully deterministic...\n",
    "# If the colors are too similar, running this cell again will likely fix the issue.\n",
    "map_sdf.spatial.plot(map_widget=map4, renderer_type='u', col='BIKE_IMPAIRED', cmap='plasma')\n",
    "map4.add_layer(bike_routes_fl, {'opacity':.5})\n",
    "map4.legend=True\n",
    "map4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1c.**\n",
    "Lastly, we want a map of collisions dependent on the types of the other party."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we can plot!\n",
    "map5 = gis.map(\"San Diego\", zoomlevel=10)\n",
    "# Note that the color map is not fully deterministic...\n",
    "# If the colors are too similar, running this cell again will likely fix the issue.\n",
    "map_sdf.spatial.plot(map_widget=map5, renderer_type='u', col=\"PARTY_TYPE\", cmap=\"plasma\")\n",
    "map5.add_layer(bike_routes_fl, {'opacity':.5})\n",
    "map5.legend=True\n",
    "map5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 6. Analyze the data and respond to the above questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "44ae55a75f5de20170f9b6909ddb8245",
     "grade": true,
     "grade_id": "cell-1eddfee53360f3fb",
     "locked": false,
     "points": 10,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "**Are you more likely to be injured in a bike-related accident if it occurs on or off of a bike path?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First and foremost, we should determine the proportion of bike collisions that occurred on bike paths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of bike collisions on bike path: 0.627083\n"
     ]
    }
   ],
   "source": [
    "prop_path = collisions_sdf.ON_PATH.mean()\n",
    "print('Proportion of bike collisions on bike path: %f' %prop_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average proportion of on-path bike collisions when grouping by zipcode: 0.6125254458867019\n"
     ]
    }
   ],
   "source": [
    "# Let's make sure we're not looking at a case of Simpson's Paradox!\n",
    "#\n",
    "# If we group by zipcode, do we still see roughly the same proportion?\n",
    "print(\n",
    "    \"Average proportion of on-path bike collisions when grouping by zipcode:\",\n",
    "    collisions_sdf.groupby(\"ZIPCODE\").ON_PATH.mean().mean()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Over 60% of collisions occur on a path!  While this may sounds like being on a path is more dangerous than being off a path, it is actually inconclusive in either direction, since we don't have any idea how many cyclists ride on bike paths versus off of bike paths.  Thus, we have no way to find collisions *rates* for on-versus-off path.  We'll need to find another way to investigate this.\n",
    "\n",
    "We can compare the the injury rates on and off bike paths.\n",
    "\n",
    "TIMS provides some meta data on the collision severity column:\n",
    "\n",
    "- 1 - Fatal\n",
    "- 2 - Injury (Severe)\n",
    "- 3 - Injury (Other Visible)\n",
    "- 4 - Injury (Complaint of Pain)\n",
    "- 0 – Property Damage Only (PDO)\n",
    "\n",
    "We can consider any value between 1–4 as an injury."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ON_PATH\n",
       "False    1.0\n",
       "True     1.0\n",
       "Name: COLLISION_SEVERITY, dtype: float64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's compute the proportion of injuries for the collisions\n",
    "# on and off the bike paths\n",
    "collisions_sdf.groupby(\"ON_PATH\")['COLLISION_SEVERITY'].apply(lambda x: sum(x > 0) / len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, it appears that every collision (on or off a bike path) has resulted in some sort of injury. Therefore, based on the data, you are just as likely to be injured if you are on a bike path as off a bike path.\n",
    "\n",
    "Of course, this is not interesting so we will compare the severity of the injuries on and off bike paths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "# We find the rate of each type of severity level.\n",
    "injury_rates = collisions_sdf.groupby(\"ON_PATH\")['COLLISION_SEVERITY'].value_counts(normalize=True).rename('INJURY_RATE')\n",
    "\n",
    "sns.barplot(x='COLLISION_SEVERITY', y='INJURY_RATE', hue='ON_PATH', data = injury_rates.reset_index())\n",
    "plt.title('Injury Rates On and Off Bike Paths');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The distributions of collision severities on and off bike paths appear identical. Although there are some differences, they are not extreme enough to convince us that the severity of injuries differ on and off bike paths."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How would the results differ for injuries of different severity, by zipcodes, and by the type of other party in the accident?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous question, we analyzed the differences in severity between collisions on and off bike paths so we will now focus on zip codes and the types of the other party."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zip codes can be quite interesting as some areas can have more people, more bike paths, etc. Let's quickly analyze the severity of the injuries within each zip code regardless of where the collision occurred. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Average severity of every zip code\n",
    "(\n",
    "    collisions_sdf\n",
    "    .groupby('ZIPCODE')['COLLISION_SEVERITY'].mean().sort_values()\n",
    "    .plot(kind='Barh', figsize=(15, 9), color='gray')\n",
    ")\n",
    "\n",
    "plt.xlabel('Severity')\n",
    "plt.ylabel('Zip Code')\n",
    "plt.title('Average Collision Severity by Zip Code');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly we can see that some zip codes have greater average severities than other. However, it must be noted that some zip codes have very view collisions so one collision can heavily skew its overall average.  Also, the fact that this data comes from San Diego City may bring higher counts to the zip codes exclusively within it.\n",
    "\n",
    "Let's instead plot the averages for those with at least 20 collisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sizes = collisions_sdf.groupby('ZIPCODE')['COLLISION_SEVERITY'].size()\n",
    "greater_20_index = sizes[sizes > 20].index\n",
    "greater_20_df = collisions_sdf[collisions_sdf['ZIPCODE'].isin(greater_20_index)]\n",
    "greater_20_df.groupby('ZIPCODE')['COLLISION_SEVERITY'].mean().sort_values().plot(kind='Barh', figsize=(12, 6), color='gray')\n",
    "\n",
    "plt.xlabel('Severity')\n",
    "plt.ylabel('Zip Code')\n",
    "plt.title('Average Collision Severity by Zip Code with 20 or More Collisions');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have a more accurate representation of how the severity of collisions differs among zip codes. Overall, we can see that they all fall in the lower 3's which represents a visible injury.\n",
    "\n",
    "Let's now break it down based on whether or not they are on bike paths. We will continue focusing on zip codes with at least 20 collisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "zip_path_rates = greater_20_df.groupby(['ON_PATH', 'ZIPCODE'])['COLLISION_SEVERITY'].mean()\n",
    "\n",
    "plt.figure(figsize=(15,8))\n",
    "sns.barplot(x='ZIPCODE', y='COLLISION_SEVERITY', hue='ON_PATH', data = zip_path_rates.reset_index())\n",
    "plt.title('Average Collision Severity by Zip Codes On and Off Bike Paths')\n",
    "plt.xticks(rotation=60);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is quite difficult to tell visually if the differences are significant. In order to determine whether these distributions are different, we will be conducting a hypothesis test.  A paired, two-sample t-test will be used here, comparing the average collision severity of off-path versus on-path collisions, paired by zipcode.\n",
    "\n",
    "$H_0: \\mu_\\text{off path} = \\mu_\\text{on path},\\quad H_1: \\mu_\\text{off path} \\neq \\mu_\\text{on path},\\quad \\alpha=0.05$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3735379378808439\n"
     ]
    }
   ],
   "source": [
    "t_stat, p_value = scipy.stats.ttest_rel(zip_path_rates[True], zip_path_rates[False])\n",
    "print(p_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p=0.37 \\not< \\alpha=0.05$, thus we fail to reject $H_0$.  We don't believe there is any significant difference in average collision severity between on-path versus off-path collisions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we look at any difference by collision party combinations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,5))\n",
    "path_combos = map_sdf.groupby(['ON_PATH'])['PARTY_TYPE'].value_counts(normalize=True).rename(0)\n",
    "sns.barplot(x='PARTY_TYPE', y=0, hue='ON_PATH', data = path_combos.reset_index())\n",
    "\n",
    "plt.xlabel('Party Combination')\n",
    "plt.ylabel('Proportion of Collisions')\n",
    "plt.title('Proportion of Collisions by Party Combination On/Off Bike Path')\n",
    "plt.xticks(rotation=60);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the distributions of the other party on/off bike paths are very similar! The most common collision on/off a bike path occurs between the bicyclist and driver.\n",
    "\n",
    "Although they are similar in this sense, let's see if there is a difference in the severities by each party category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PARTY_TYPE\n",
       "('Bicyclist', 'Bicyclist')                   3.000000\n",
       "('Bicyclist', 'Bicyclist', 'Driver')         3.000000\n",
       "('Bicyclist', 'Driver')                      3.304589\n",
       "('Bicyclist', 'Driver', 'Driver')            3.235294\n",
       "('Bicyclist', 'Driver', 'Parked Vehicle')    3.000000\n",
       "('Bicyclist', 'Other')                       3.333333\n",
       "('Bicyclist', 'Parked Vehicle')              3.171875\n",
       "('Bicyclist', 'Pedestrian')                  3.312500\n",
       "('Bicyclist',)                               3.096360\n",
       "Other Combination                            3.083333\n",
       "Name: COLLISION_SEVERITY, dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map_sdf.groupby(\"PARTY_TYPE\")[\"COLLISION_SEVERITY\"].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the above, collisions involving more than one bicyclist seem associated with very slightly more severe injuries.  This could possibly be explained by there being twice as many people who are likely to be injured!  Overall, the differences in average severity are very slight, and not too much inference can be reliably ascertained.\n",
    "\n",
    "Let's check if things change when we split up the data on whether or not they are on bike paths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Comparing average severity for different party types between off path and on path collisions.\n",
    "grouped = map_sdf.groupby(['ON_PATH','PARTY_TYPE'])['COLLISION_SEVERITY'].mean().sort_values().rename(0)\n",
    "sns.barplot(x=\"PARTY_TYPE\", y=0, hue=\"ON_PATH\", data=grouped.reset_index())\n",
    "\n",
    "plt.xlabel('Party Combination')\n",
    "plt.ylabel('Average Severity Number')\n",
    "plt.title('Average Severity Number of Collisions by Party Combination On/Off Bike Path')\n",
    "plt.xticks(rotation=60);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"favorite-section\"></a>",
    "\n",
    "### This is my favorite section!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The average severity for every party combination dependent on bike paths don't show too much difference.\n",
    "\n",
    "However, a large amount of the \"bike paths\" are really just large roads with bike lanes!\n",
    "\n",
    "What are the differences in severity by route type?  If this is looks promising, then perhaps we can build a classifier for injury based on alcohol involved, route type, and party combination.  Route types are encoded as following:\n",
    "\n",
    "* 0 - Off Path\n",
    "* 1 - Multi-use Path\n",
    "* 2 - Bike Lane\n",
    "* 3 - Bike Route\n",
    "* 6 - Freeway Shoulder Bike Access\n",
    "* 8 - Other Suggested Route"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ROUTE\n",
       "0.0    3.250000\n",
       "1.0    3.400000\n",
       "2.0    3.233591\n",
       "3.0    3.227397\n",
       "6.0    3.250000\n",
       "8.0    3.229452\n",
       "Name: COLLISION_SEVERITY, dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collisions_sdf.assign(ROUTE=collisions_sdf.ROUTE.fillna(0)).groupby(\"ROUTE\").COLLISION_SEVERITY.mean().sort_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's not a large difference between average severity for different routes either... but perhaps there is yet one more interesting calculation we can perform to try to answer whether you are more likely to be injured on versus off of a path.\n",
    "\n",
    "What if we look at a frequentist likelihood of being injured on the different types of routes?\n",
    "\n",
    "We can find a collision rate normalized by route as *\"# of collisions per km of route infrastructure\"*, and then we can compare these values for the different route type!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ROUTE\n",
       "0.0    0.311415\n",
       "1.0    0.071986\n",
       "2.0    0.254515\n",
       "3.0    0.561342\n",
       "6.0    0.054508\n",
       "8.0    0.495004\n",
       "dtype: float64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NOTE: This cell will take ~1 minute to run, since we need to create study areas and enrich.\n",
    "\n",
    "# Curious how many collisions happened on each route type.  Maybe we can also normalize by total length\n",
    "# of each route type.\n",
    "\n",
    "# Our bike routes feature layer will calculate a Shape__Length feature for us when we convert to a sdf.\n",
    "# Note that this will be in epsg=3857, which is in meters!  Let's just convert to km.\n",
    "meters_to_km = 1 / 1000\n",
    "routes_sdf = bike_routes_fl.layers[0].query().sdf\n",
    "route_lengths = routes_sdf.groupby(\"ROUTE\").Shape__Length.sum() * meters_to_km\n",
    "\n",
    "# But, we don't have any lengths for non-bike routes... sounds like the time for enrich!\n",
    "#\n",
    "# To find the \"length\" of off-path routes, we will:\n",
    "# 1. Create a study area which encompasses all of our collisions.\n",
    "# 2. Enrich the study area with road density\n",
    "# 3. Subtract total bike route length from total road length.\n",
    "\n",
    "# Let's enrich by zipcode, since we have a plan to use zipcode road density in the future.\n",
    "#\n",
    "# In order to enrich areas based on their zipcode, we must get the study area\n",
    "# associated with each zipcode, then pass these in to be enriched.\n",
    "zipcodes = collisions_sdf.ZIPCODE.unique().astype(int).astype(str).tolist()\n",
    "\n",
    "# For some reason the geoquery field is incapable of handling a list!\n",
    "# Thus, the following workaround is born.\n",
    "zipstudies = pd.concat(map(\n",
    "    lambda zipcode: standard_geography_query(\n",
    "        source_country=\"US\", layers=[\"US.ZIP5\"], geoquery=zipcode, return_geometry=True\n",
    "    ).iloc[[0]],\n",
    "    zipcodes\n",
    "))\n",
    "\n",
    "# Can't convince arcgis to run enrich on the sdf either...\n",
    "# So we need to run each one separately.\n",
    "infrastructures = pd.concat(map(\n",
    "    lambda studyrow: enrich(studyrow[1].to_frame().T, [\"Infrastructure\"]),\n",
    "    zipstudies.iterrows()\n",
    "))\n",
    "\n",
    "# The roadsums are in km, just like our route lengths.\n",
    "total_off_path_length = infrastructures.RoadSum.sum() - route_lengths.sum()\n",
    "\n",
    "route_lengths[0] = total_off_path_length\n",
    "\n",
    "# We are essentially calculating number of collisions per kilometer of route infrastructure, for each route type.\n",
    "(\n",
    "    collisions_sdf\n",
    "    .assign(ROUTE=collisions_sdf.ROUTE.fillna(0))\n",
    "    .groupby(\"ROUTE\").CASE_ID.count().sort_index()\n",
    "    / route_lengths\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If in fact you were more likely to be injured off of a bike path, then we would expect to see the number of injuries per roadway that is *not* a bike route to be the largest.  We didn't see any result that simple... but if we go a bit deeper, we did uncover some insights.\n",
    "\n",
    "Here's what we uncovered:\n",
    "- Being on a traditional bike path or other walking path without cars (labelled as 1 - Multi-use path) is likely the safest in terms of avoiding collisions (and thus—by our data—injuries, since all collisions resulted in an injury of some kind).\n",
    "- Although the collision rate for 6 - Freeway Shoulder Bike Access is actually lower than Multi-use paths, this is likely because a) There are very few routes in this classification, and b) There are probably very few cyclists who would want to bike on the side of a freeway.  So, we are deciding to mostly ignore this type of route.\n",
    "- The most dangerous routes are \"3 - Bike Route\" and \"8 - Other Suggested Route\".  This also makes sense because both of these classifications are used for roads that do not necessarily have a dedicated bike lane throughout (the road may be shared, or parking in the bike lane may be allowed).  Many streets in the city that have no bike lane whatsoever are classified as \"Other Suggest Routes\", and an example of a \"Bike Route\" would be the stretch of Gilman Drive between Meyers and Scholars where drivers need to share the road with cyclists because the bike lane has disappeared.  In these cases, the cyclist needs to ride on the same part of the road as the cars, so it's more likely that there will be collisions.\n",
    "- While less safe than Multi-use paths, Bike Lanes have a relatively low collision rate.  Bike Lanes are indeed safer than cycling off of the paths entirely.\n",
    "- Main takeaway: Cyclists are safest when there is a path or part of a path that is dedicated specifically for cycling, and much more collision-prone when they need to share a path with cars."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In which parts of the city are you more likely to get into an accident with alcohol involved?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09b7976867f341648f9a19375a513448",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "MapView(layout=Layout(height='400px', width='100%'), zoom=12.0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"map-static-img-preview-05e27bd9-4b5d-4e42-89eb-604e424c5700\"><img src=\"\"></img></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's create a heat map to get a feel for where alcohol-related accidents occur\n",
    "map6 = gis.map(\"San Diego\", zoomlevel=12)\n",
    "map6.add_layer(collisions_fl, {\"renderer\":\"HeatmapRenderer\", \"field_name\":'ALCOHOL_INVOLVED'})\n",
    "map6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we inspect the heat map carefully, we can see that these accidents occur predominently around famous attractions.\n",
    "\n",
    "For example, at the zoom level specified, we see four main clusters. The densist being at the coast of the San Diego Harbor. This is the location where many of San Diego's biggest events occur such as Padres games at Petco Park, Comic-Con at the San Diego Convention Center, and even the Gas Lamp District.\n",
    "\n",
    "We see the next cluster right around the North Park/Balboa Park Area. Through this area the San Diego Pride Festival happens every year. Also, this area is filled with housing and busy streets so we would expect a lot of bike use here and subsequently bike collisions.\n",
    "\n",
    "We see the next two clusters surround the Mission Bay/Pacific Beach area and Old Town. These areas are popular tourist destinations.\n",
    "\n",
    "Clearly we can see that alcohol related bike incidents occur in areas where people are likely to find amusement and consume alcohol in San Diego. This comes at no surprise!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": [
    "# Now we know the general areas of the collisions, lets figure out the zip codes!\n",
    "top_5 = (\n",
    "    collisions_sdf\n",
    "    .assign(ALCOHOL_INVOLVED=collisions_sdf.ALCOHOL_INVOLVED.replace({'':False,'Y':True}))\n",
    "    .groupby('ZIPCODE')['ALCOHOL_INVOLVED']\n",
    "    .sum().sort_values(ascending=False)\n",
    "    .iloc[:5]\n",
    ")\n",
    "top_5.plot(kind='bar', color='gray')\n",
    "\n",
    "plt.title('Top 5 Zip Codes with Alcohol-Related Incidents')\n",
    "plt.ylabel('Number of Alcohol-Related Incident');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e3e79193e3ef471caaece7522f4b76ff",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "MapView(layout=Layout(height='400px', width='100%'), zoom=10.0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class=\"map-static-img-preview-abdc4327-a5db-434c-8c3d-928c5fd6d98c\"><img src=\"\"></img></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Lets plot these zip codes on a map!\n",
    "map7 = gis.map('San Diego', zoomlevel=10)\n",
    "\n",
    "zips = zip_codes.query().sdf\n",
    "zips = zips[zips['ZIP'].isin(top_5.index)]\n",
    "zips.spatial.plot(map_widget=map7)\n",
    "\n",
    "map7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The top 5 zip codes make up over a third of all alcohol-related incidents! Based on what's above, the greatest number of incidents occur within the 92101 zip code, more than one tenth of all incidents in San Diego City occur here (there are 39 zipcodes in our dataset).  This is the zipcode which we previously believed to be the most dangerous based on the heat map.\n",
    "\n",
    "It appears that one is more likely to get into a bike-related accident in the 92109, 92101, 92154, 92104, and 92037 zip codes. Please note that we are making this conclusion based on the sheer number of incidents. We do not know how many bikers were going through the area so we are unable to calculate a rate for each zip code.\n",
    "\n",
    "However, just as before, perhaps we can get a better idea of the danger level in different zipcodes by enriching.\n",
    "\n",
    "If we enrich each zipcode to find the number of commuters that ride a bike to work, then we can control for this when counting collisions.\n",
    "\n",
    "Note that this isn't a perfect estimate for the number of cyclists that pass through each zipcode, because cyclists could be commuting from one zipcode to another zipcode (or not even commuting at all), however it will be interesting to see how/if our results change when we normalize using this estimate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92114.0    0.300000\n",
       "92108.0    0.285714\n",
       "92154.0    0.147541\n",
       "92111.0    0.142857\n",
       "92131.0    0.111111\n",
       "dtype: float64"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Just as before, let's enrich our zipcodes.\n",
    "commutes = pd.concat(map(\n",
    "    lambda studyrow: enrich(studyrow[1].to_frame().T, [\"Commute\"]),\n",
    "    zipstudies.iterrows()\n",
    "))\n",
    "\n",
    "# We can find the number of bicycle commuters in each zip as the ACSBICYCLE field.\n",
    "# And we can normalize the number of alcohol-related collisions in each zipcode by\n",
    "# that number of commuters.\n",
    "commutes = commutes.assign(AreaID = commutes.AreaID.astype(float))\n",
    "\n",
    "(\n",
    "    collisions_sdf\n",
    "    .assign(ALCOHOL_INVOLVED=collisions_sdf.ALCOHOL_INVOLVED.replace({'':False,'Y':True}))\n",
    "    .groupby('ZIPCODE')['ALCOHOL_INVOLVED'].sum()\n",
    "    / commutes.groupby(\"AreaID\").ACSBICYCLE.sum()\n",
    ").sort_values(ascending=False).loc[lambda ser: (ser > 0) & (ser < np.inf)].iloc[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This estimate is not a good idea after all. (Although zipcode 92154 does show up again...)\n",
    "\n",
    "For the reasons mentioned above—there are cyclists other than commuters and commuters don't remain in the same zipcode as they live—the rankings of the alcohol-related collision rates are determined almost entirely by the estimate for bicycle commuters.  All of the top 5 alcohol-related collision rates show above come from zipcodes with very few bicycle commuters.\n",
    "\n",
    "If we try normalizing the total number of collisions instead of just alcohol-related collisions, we find in many of the top 5 zipcodes there are actually more collisions than commuters!  So, although this attempt was fun, the estimate is not good enough to produce worthwhile insights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92114.0    2.200000\n",
       "92108.0    1.857143\n",
       "92154.0    1.196721\n",
       "92111.0    1.040816\n",
       "92110.0    0.820000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\n",
    "    collisions_sdf\n",
    "    .groupby('ZIPCODE').CASE_ID.count()\n",
    "    / commutes.groupby(\"AreaID\").ACSBICYCLE.sum()\n",
    ").sort_values(ascending=False).loc[lambda ser: (ser > 0) & (ser < np.inf)].iloc[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a predictor for collision severity using collision features and victim features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to train a model to predict collision severity, using fields that might be easily reported via an initial report of the collision.  This includes:\n",
    "- Route, Party Combination, Number of Victims, Min and Max Age of Victims, and (possibly, though in reality unlikely) Alcohol Involved and Bike Impaired"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>COLLISION_SEVERITY</th>\n",
       "      <th>ROUTE</th>\n",
       "      <th>PARTY_TYPE</th>\n",
       "      <th>ALCOHOL_INVOLVED</th>\n",
       "      <th>BIKE_IMPAIRED</th>\n",
       "      <th>NUM_VICTIMS</th>\n",
       "      <th>MIN_AGE</th>\n",
       "      <th>MAX_AGE</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CASE_ID</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>90581634</th>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>('Bicyclist',)</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>65</td>\n",
       "      <td>65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90410428</th>\n",
       "      <td>4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>('Bicyclist', 'Driver')</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>49</td>\n",
       "      <td>49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90027314</th>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>('Bicyclist',)</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>53</td>\n",
       "      <td>53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90196205</th>\n",
       "      <td>4</td>\n",
       "      <td>2.0</td>\n",
       "      <td>('Bicyclist', 'Driver')</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90124838</th>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>('Bicyclist', 'Driver')</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>1</td>\n",
       "      <td>28</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          COLLISION_SEVERITY  ROUTE               PARTY_TYPE ALCOHOL_INVOLVED  \\\n",
       "CASE_ID                                                                         \n",
       "90581634                   3    0.0           ('Bicyclist',)            False   \n",
       "90410428                   4    0.0  ('Bicyclist', 'Driver')            False   \n",
       "90027314                   3    0.0           ('Bicyclist',)            False   \n",
       "90196205                   4    2.0  ('Bicyclist', 'Driver')            False   \n",
       "90124838                   2    0.0  ('Bicyclist', 'Driver')             True   \n",
       "\n",
       "         BIKE_IMPAIRED  NUM_VICTIMS  MIN_AGE  MAX_AGE  \n",
       "CASE_ID                                                \n",
       "90581634         False            1       65       65  \n",
       "90410428         False            1       49       49  \n",
       "90027314         False            1       53       53  \n",
       "90196205         False            3        9       12  \n",
       "90124838         False            1       28       28  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = (\n",
    "    pd.merge(\n",
    "        collisions[[\"CASE_ID\"]], map_sdf[[\"CASE_ID\", \"COLLISION_SEVERITY\", \"ROUTE\", \"PARTY_TYPE\", \"ALCOHOL_INVOLVED\", \"BIKE_IMPAIRED\"]],\n",
    "        on=\"CASE_ID\", how=\"inner\"\n",
    "    )\n",
    "    # The only column with nulls so far is \"ROUTE\", which occurs when a collision was off-path.\n",
    "    .fillna(0.0)\n",
    "    # We need to get the number of victims and min/max age using the victim data grouped by case_id\n",
    "    .set_index(\"CASE_ID\")\n",
    "    .assign(\n",
    "        NUM_VICTIMS=victims.groupby(\"CASE_ID\").PARTY_NUMBER.size(),\n",
    "        MIN_AGE=victims.groupby(\"CASE_ID\").VICTIM_AGE.min(),\n",
    "        MAX_AGE=victims.groupby(\"CASE_ID\").VICTIM_AGE.max(),\n",
    "    )\n",
    ")\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('pre', ColumnTransformer(n_jobs=None, remainder='passthrough', sparse_threshold=0.3,\n",
       "         transformer_weights=None,\n",
       "         transformers=[('party_type', OrdinalEncoder(categories=[array([\"('Bicyclist',)\", \"('Bicyclist', 'Driver')\",\n",
       "       \"('Bicyclist', 'Parked Vehicle')\", 'Other Combin...obs=None,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False))])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = df.drop(\"COLLISION_SEVERITY\", axis=1)\n",
    "y = df.COLLISION_SEVERITY\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "\n",
    "pl = Pipeline([\n",
    "    (\"pre\", ColumnTransformer([\n",
    "        (\"party_type\", OrdinalEncoder(categories=[X.PARTY_TYPE.unique()]), [\"PARTY_TYPE\"]),\n",
    "        (\"boolean-string\", OrdinalEncoder(categories=[X.ALCOHOL_INVOLVED.unique(), X.BIKE_IMPAIRED.unique()]), [\"ALCOHOL_INVOLVED\", \"BIKE_IMPAIRED\"])\n",
    "    ], remainder=\"passthrough\")),\n",
    "    (\"clf\", RandomForestClassifier(100))\n",
    "])\n",
    "\n",
    "\n",
    "pl.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5604166666666667"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first, seeing an accuracy of ~56% seemed good since there are four labels that appear!  However, we then realized that the classifier would have performed better by just guessing '3' every time.  Comparing the predictions to the true values, we saw no evidence that the random forest was able to uncover what makes a very severe collision so severe, or a non-serious collision non-serious—our classifier was likely overwhelmed by the number of '3's in the dataset.\n",
    "\n",
    "Because the more severe collisions are so rare, we should likely use a regression model that is built to handle rare events.  We do not know of such models yet.  Additionally, when all is said and done joining our ~2700 victim rows to their collisions and making sure we have a location so that we can say whether or not the collision was on a path, we only have 1920 collisions to train on.  Perhaps we might see our predictions improve if we were to run this project on the larger dataset.  However, we noticed that in some cases there are two parties involved, but there is only data present for one of them, and in many cases there is no victim data available—this is a large reason for our small data size!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}