appendix/Data_Cleaning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation\n",
    "\n",
    "Since we are looking at contributing factors to a car crash, information that occurs after the crash event is not utilizable. \n",
    "So, we drop unncessary columns and transform the 'object' data types in the dataframe into a 'int' data type in order for us to pass it into a model.\n",
    "\n",
    "For missing values, if there was a way to fill those in with a reasonable explaination, we did so. Luckily, missing values mostly fell under the columns which we determined not relevant to the crash.\n",
    "\n",
    "First we dropped all unnecessary columns such as injury severity and street direction. After dropping missing values we could not reasonably populate ourselves, we were left with a dataset of ~950,000 entries. Then, we mapped all the object data types into an int or float 64 to pass into our model. Finally, we created a Target column to label the crashes as Preventable or Less Preventable.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read the csv files using pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_crash = pd.read_csv('../data/raw_data/Traffic_Crashes_Crashes.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vehicle = pd.read_csv('../data/raw_data/Traffic_Crashes_Vehicle.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people = pd.read_csv('../data/raw_data/Traffic_Crashes_People.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# Cleaning Crashes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dropping Columns\n",
    "\n",
    "\n",
    "Within the Crashes dataset, our team determined that there were a lot of columns that did not contribute any value to the \n",
    "stakeholder's business problem, which is identifying causes of a car crash. Information such as injuries may tell us the severity of the crash, but not a clue on to how the crash occured. Same applies to when the police were notified and time it took place.\n",
    "\n",
    "Columns such as 'INTERSECTION_RELATED_I', 'NOT_RIGHT_OF_WAY_I' may contain relevant information, however they hold too many null values for us to fill, so we decided to drop them.\n",
    "\n",
    "Columns such 'STREET_DIRECTION' and 'ALIGNMENT' tells us the road shape, but since it is not feasible to change any of these roads - meaning they will always have turns and a direction - so we also left these columns from our final dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Drop columns that are not relevant to \"Car Crash Contributors\". For example, information about the injury severity does not \n",
    "# tell us a contributing factor to a crash.\n",
    "\n",
    "not_relevant_info = ['RD_NO', 'CRASH_DATE', 'CRASH_DATE_EST_I', 'LANE_CNT', 'REPORT_TYPE', 'CRASH_TYPE', \\\n",
    "                     'INTERSECTION_RELATED_I', 'NOT_RIGHT_OF_WAY_I', 'DATE_POLICE_NOTIFIED', 'DAMAGE', 'NUM_UNITS', \\\n",
    "                     'HIT_AND_RUN_I', 'PHOTOS_TAKEN_I', 'STATEMENTS_TAKEN_I', 'FIRST_CRASH_TYPE', \\\n",
    "                     'DOORING_I', 'WORK_ZONE_I', 'WORK_ZONE_TYPE', 'WORKERS_PRESENT_I', 'ALIGNMENT', \\\n",
    "                     'MOST_SEVERE_INJURY', 'INJURIES_TOTAL', 'INJURIES_FATAL', 'INJURIES_INCAPACITATING', \\\n",
    "                     'INJURIES_NON_INCAPACITATING', 'INJURIES_REPORTED_NOT_EVIDENT', 'INJURIES_NO_INDICATION', \\\n",
    "                     'INJURIES_REPORTED_NOT_EVIDENT', 'INJURIES_NO_INDICATION', 'INJURIES_UNKNOWN', \\\n",
    "                     'STREET_NO', 'STREET_DIRECTION', 'STREET_NAME', 'BEAT_OF_OCCURRENCE', \\\n",
    "                     'LOCATION', 'CRASH_HOUR', 'CRASH_DAY_OF_WEEK', 'CRASH_MONTH', 'POSTED_SPEED_LIMIT']\n",
    "\n",
    "df_crash.drop((not_relevant_info), axis = 1, inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the helper functions, if the value in the column contains any of these values, return a '1', otherwise, return '0'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define different functions to categorize columns into numarical columns for our models. \n",
    "def traffic_control_transfomer(val):\n",
    "    if val in relevant_device_present:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "def device_working(val):\n",
    "    if val in working_devices:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def device_present(val):\n",
    "    if val == True:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def weather_condition(val):\n",
    "    if val in bad_weather_cond:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def visibility(val):\n",
    "    if val in bad_visibility:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "# List would contain just one variable so we just spelled it out here\n",
    "def trafficway_danger(val):\n",
    "    if val == 'NOT DIVIDED':\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def road_cond(val):\n",
    "    if val in bad_road_cond:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def defect_road(val):\n",
    "    if val in road_defect:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def boolean(val):\n",
    "    if val == False:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Helper functions to correctly categorize different primary causes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crash_cause(val):\n",
    "    if val in driving:\n",
    "        return 1\n",
    "    elif val in behavior:\n",
    "        return 2\n",
    "    elif val in road:\n",
    "        return 3\n",
    "    else:\n",
    "        return 4\n",
    "\n",
    "def one(val):\n",
    "    if val == 5:\n",
    "        return 1\n",
    "    else:\n",
    "        return val\n",
    "\n",
    "def two(val):\n",
    "    if val == 5:\n",
    "        return 2\n",
    "    else:\n",
    "        return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# List containing whether a traffic control or warning sign was present in the area.\n",
    "relevant_device_present = ['TRAFFIC SIGNAL', 'STOP SIGN/FLASHER', 'OTHER', 'LANE USE MARKING', 'YIELD', 'OTHER REG. SIGN', \\\n",
    "                 'OTHER WARNING SIGN', 'RAILROAD CROSSING GATE', 'PEDESTRIAN CROSSING SIGN', 'POLICE/FLAGMAN', 'SCHOOL ZONE', \\\n",
    "                 'DELINEATORS', 'FLASHING CONTROL SIGNAL', 'BICYCLE CROSSING SIGN', 'NO PASSING', 'RR CROSSING SIGN']\n",
    "# List containing if the Device was functioning\n",
    "working_devices = ['FUNCTIONING PROPERLY', 'WORN REFLECTIVE MATERIAL']\n",
    "# List containing bad weather elements\n",
    "bad_weather_cond = ['RAIN', 'SNOW', 'FOG/SMOKE/HAZE', 'SLEET/HAIL', 'FREEZING RAIN/DRIZZLE', 'BLOWING SNOW', \\\n",
    "                   'SEVERE CROSS WIND GATE', 'BLOWING SAND, SOIL, DIRT']\n",
    "# List containing bad visibility environment\n",
    "bad_visibility = ['DARKNESS', 'DUSK', 'DAWN']\n",
    "# Lists containing bad road conditions\n",
    "bad_road_cond = ['WET', 'SNOW OR SLUSH', 'ICE', 'SAND, MUD, DIRT']\n",
    "road_defect = ['RUT, HOLES', 'WORN_SURFACE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map all columns to int64 to model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_crash['BAD_WEATHER'] = df_crash['WEATHER_CONDITION'].map(weather_condition)\n",
    "df_crash['BAD_VISIBILITY'] = df_crash['LIGHTING_CONDITION'].map(visibility)\n",
    "df_crash['BAD_TRAFFIC'] = df_crash['TRAFFICWAY_TYPE'].map(trafficway_danger)\n",
    "df_crash['BAD_ROAD_CONDITION'] = df_crash['ROADWAY_SURFACE_COND'].map(road_cond)\n",
    "df_crash['DEFECT_ROAD'] = df_crash['ROAD_DEFECT'].map(defect_road)\n",
    "\n",
    "df_crash['TRAFFIC_DEVICE_PRESENT'] = df_crash['TRAFFIC_CONTROL_DEVICE'].map(traffic_control_transfomer)\n",
    "df_crash['DEVICE_WORKING'] = df_crash['DEVICE_CONDITION'].map(device_working)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final 'Device' column that returns \"1\" when the traffice device is both present, AND working."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "device_list = (df_crash['TRAFFIC_DEVICE_PRESENT'] == 1) & (df_crash['DEVICE_WORKING'] == 1)\n",
    "device_dataframe = pd.DataFrame(device_list, columns = ['TRAFFIC_DEVICE'], index = df_crash.index)\n",
    "frames = [df_crash, device_dataframe]\n",
    "df_crash = pd.concat(frames, axis = 1)\n",
    "df_crash['WORKING_TRAFFIC_DEVICE'] = df_crash['TRAFFIC_DEVICE'].map(device_present)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List for mapping \"PRIMARY CONTRIBUTORY CAUSE\" as recorded by officer at scene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "driving = ['FAILING TO YIELD RIGHT-OF-WAY', 'FOLLOWING TOO CLOSELY', 'IMPROPER OVERTAKING/PASSING', 'FAILING TO REDUCE SPEED TO AVOID CRASH', \\\n",
    "          'IMPROPER BACKING', 'IMPROPER LANE USAGE', 'IMPROPER TURNING/NO SIGNAL', 'DRIVING SKILLS/KNOWLEDGE/EXPERIENCE', \\\n",
    "          'DISREGARDING TRAFFIC SIGNALS', 'DISREGARDING STOP SIGN', 'DISTRACTION - FROM INSIDE VEHICLE', 'DRIVING ON WRONG SIDE/WRONG WAY', \\\n",
    "          'DISTRACTION - FROM OUTSIDE VEHICLE', 'EXCEEDING AUTHORIZED SPEED LIMIT', 'EXCEEDING SAFE SPEED FOR CONDITIONS', \\\n",
    "          'DISREGARDING OTHER TRAFFIC SIGNS', 'DISREGARDING ROAD MARKINGS', 'TURNING RIGHT ON RED', 'RELATED TO BUS STOP', 'DISREGARDING YIELD SIGN', \\\n",
    "           'PASSING STOPPED SCHOOL BUS']\n",
    "behavior = ['PHYSICAL CONDITION OF DRIVER', 'OPERATING VEHICLE IN ERRATIC, RECKLESS, CARELESS, NEGLIGENT OR AGGRESSIVE MANNER' \\\n",
    "           'UNDER THE INFLUENCE OF ALCOHOL/DRUGS (USE WHEN ARREST IS EFFECTED)', 'CELL PHONE USE OTHER THAN TEXTING', \\\n",
    "           'HAD BEEN DRINKING (USE WHEN ARREST IS NOT MADE)', 'TEXTING', 'DISTRACTION - OTHER ELECTRONIC DEVICE (NAVIGATION DEVICE, DVD PLAYER, ETC.)']\n",
    "road = ['WEATHER', 'VISION OBSCURED (SIGNS, TREE LIMBS, BUILDINGS, ETC.)', 'ROAD ENGINEERING/SURFACE/MARKING DEFECTS', \\\n",
    "       'ROAD CONSTRUCTION/MAINTENANCE']\n",
    "other = ['EQUIPMENT - VEHICLE CONDITION', 'EVASIVE ACTION DUE TO ANIMAL, OBJECT, NONMOTORIST', 'ANIMAL', \\\n",
    "         'BICYCLE ADVANCING LEGALLY ON RED LIGHT', 'OBSTRUCTED CROSSWALKS', 'MOTORCYCLE ADVANCING LEGALLY ON RED LIGHT']\n",
    "\n",
    "df_crash['Target1'] = df_crash['PRIM_CONTRIBUTORY_CAUSE'].map(crash_cause)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Because our primary target variable is 'contributory causes to a crash' using the informating recorded by the police report would make the most sense. Who else would know better on the primary cause of the accident than the driver or officer that arrived at the scene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Update any rows where 'PRIM_CONTRIBUTORY_CAUSE' is \"not determined\" and 'SEC_CONTRIBUTORY_CAUSE' have a value, then update\n",
    "# 'PRIM_CONTRIBUTORY_CAUSE' to the value entered in'SEC_CONTRIBUTORY_CAUSE'\n",
    "for index, row in df_crash.iterrows(): \n",
    "    if df_crash.loc[index,'PRIM_CONTRIBUTORY_CAUSE'] == 'UNABLE TO DETERMINE':\n",
    "        if (df_crash.loc[index,'SEC_CONTRIBUTORY_CAUSE'] != 'UNABLE TO DETERMINE') & (df_crash.loc[index,'SEC_CONTRIBUTORY_CAUSE'] != 'NOT APPLICABLE'):\n",
    "            df_crash.loc[index,'PRIM_CONTRIBUTORY_CAUSE'] = df_crash.loc[index,'SEC_CONTRIBUTORY_CAUSE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting 'UNABLE TO DETERMINE' columns to be recorded as \"road\" when 'BAD ROAD CONDITION' is also true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_crash['is_two'] = (df_crash['Target1'] == 4) & (df_crash['BAD_ROAD_CONDITION'] == 1)\n",
    "df_crash['Target'] = df_crash['Target1'] + df_crash['is_two']\n",
    "df_crash['is_two'] = df_crash['is_two'].map(two)\n",
    "df_crash['Target'] = df_crash['Target1'] + df_crash['is_two']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Had to separate this helper function due to Python errors\n",
    "def road(val):\n",
    "    if val == 5:\n",
    "        return 3\n",
    "    else:\n",
    "        return val\n",
    "df_crash['Target'] = df_crash['Target'].map(road)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we can drop the columns we transformed as they are unusable in our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "unnecessary_traffic_columns = ['TRAFFIC_CONTROL_DEVICE', 'DEVICE_CONDITION', 'TRAFFIC_DEVICE_PRESENT', 'DEVICE_WORKING', \\\n",
    "                              'WEATHER_CONDITION', 'LIGHTING_CONDITION', 'TRAFFICWAY_TYPE', 'ROADWAY_SURFACE_COND', 'ROAD_DEFECT', \\\n",
    "                              'PRIM_CONTRIBUTORY_CAUSE', 'SEC_CONTRIBUTORY_CAUSE', 'TRAFFIC_DEVICE', 'Target1', 'is_two']\n",
    "df_crash.drop(unnecessary_traffic_columns, axis = 1, inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save file to a csv folder so we do not have to run all the data cleaning steps again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_crash.to_csv('../data/cleaned_data/cleaned_crash_data.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# Cleaning People"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop columns that do not have any predictive or inferential value in determining the cause of a car crash"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people.drop(['PERSON_ID', 'PERSON_TYPE', 'RD_NO', 'VEHICLE_ID', 'SEAT_NO', 'CITY', 'STATE', 'ZIPCODE', 'SEX', \n",
    "         'DRIVERS_LICENSE_STATE', 'DRIVERS_LICENSE_CLASS', 'SAFETY_EQUIPMENT', 'AIRBAG_DEPLOYED', 'EJECTION', \n",
    "         'INJURY_CLASSIFICATION', 'HOSPITAL', 'EMS_AGENCY', 'EMS_RUN_NO', 'PEDPEDAL_ACTION', 'PEDPEDAL_VISIBILITY', \n",
    "         'PEDPEDAL_LOCATION', 'BAC_RESULT', 'BAC_RESULT VALUE', 'CELL_PHONE_USE'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop missing and null values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people.dropna(subset=['AGE'], inplace=True)\n",
    "df_people.dropna(subset=['DRIVER_ACTION'], inplace=True)\n",
    "df_people.dropna(subset=['DRIVER_VISION'], inplace=True)\n",
    "df_people.dropna(subset=['PHYSICAL_CONDITION'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cleaning the 3 columns with many unknown values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people = df_people[df_people['DRIVER_VISION']!='UNKNOWN']\n",
    "df_people = df_people[df_people['DRIVER_ACTION']!='UNKNOWN']\n",
    "df_people = df_people[df_people['PHYSICAL_CONDITION']!='UNKNOWN']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Formatting, cleaning, and binning the AGE column. 15 is the youngest age to legally drive in the state of Illinois\n",
    "with a learner's permit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people = df_people[df_people['AGE']>=15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define Lists for helper functions in order to map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "dangerous_beh = ['IMPAIRED - ALCOHOL', 'FATIGUED/ASLEEP', 'EMOTIONAL', 'ILLNESS/FAINTED', 'HAD BEEN DRINKING', \n",
    "                 'IMPAIRED - DRUGS', 'IMPAIRED - ALCOHOL AND DRUGS', 'MEDICATED']\n",
    "bad_vision = ['OTHER', 'MOVING VEHICLES', 'PARKED VEHICLES', 'WINDSHIELD (WATER/ICE)', 'BLINDED - SUNLIGHT', 'HILLCREST',\n",
    "             'EMBANKMENT', 'BLOWING MATERIALS', 'SIGNBOARD']\n",
    "bad_action = ['OTHER', 'FAILED TO YIELD', 'FOLLOWED TOO CLOSELY', 'IMPROPER TURN', 'IMPROPER BACKING', 'IMPROPER LANE CHANGE',\n",
    "             'IMPROPER PASSING', 'TOO FAST FOR CONDITIONS', 'DISREGARDED CONTROL DEVICES', 'IMPROPER PARKING',\n",
    "             'WRONG WAY/SIDE', 'CELL PHONE USE OTHER THAN TEXTING', 'OVERCORRECTED', 'EMERGENCY VEHICLE ON CALL',\n",
    "             'EVADING POLICE VEHICLE', 'TEXTING', 'STOPPED SCHOOL BUS', 'LICENSE RESTRICTIONS']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transform more categorical columns into numerical format. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def physical_condition(val):\n",
    "    if val in dangerous_beh:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "def obscured_vision(val):\n",
    "    if val in bad_vision:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def driver_error(val):\n",
    "    if val in bad_action:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "def ages(val):\n",
    "    if val in highrisk_ages:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map and drop object columns as they were tranformed into a data format we can pass into a model columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people['DANGEROUS_BEH'] = df_people['PHYSICAL_CONDITION'].map(physical_condition)\n",
    "df_people['OBSCURED_VIZ'] = df_people['DRIVER_VISION'].map(obscured_vision)\n",
    "df_people['DRIVER_ERROR'] = df_people['DRIVER_ACTION'].map(driver_error)\n",
    "unnecessary_columns = ['AGE', 'DRIVER_ACTION', 'DRIVER_VISION', 'PHYSICAL_CONDITION']\n",
    "df_people.drop(unnecessary_columns, axis = 1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save file to a csv folder so we do not have to run all the data cleaning steps again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_people.to_csv('../data/cleaned_data/cleaned_people_data.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# Cleaning Vehicles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instantiate pandas DataFrame with only relevant columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vehicle = df_vehicle[['CRASH_RECORD_ID', 'NUM_PASSENGERS', 'VEHICLE_DEFECT']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transform the last categorical columns into numerical format and clean up for our models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "No_def = ['NONE', 'UNKNOWN']\n",
    "\n",
    "def veh_defect(val):\n",
    "    if val in No_def:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1\n",
    "\n",
    "def passengers(val):\n",
    "    if val >= 1:\n",
    "        return 1\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vehicle['VEHICLE_DEFECT'] = df_vehicle['VEHICLE_DEFECT'].map(veh_defect)\n",
    "df_vehicle['NUM_PASSENGERS'] = df_vehicle['NUM_PASSENGERS'].map(passengers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If missing values for passengers, update to just driver in car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vehicle.NUM_PASSENGERS = df_vehicle.NUM_PASSENGERS.fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save file to a csv folder so we do not have to run all the data cleaning steps again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_vehicle.to_csv('../data/cleaned_data/cleaned_vehicle_data.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Main Dataframe, \"main_df\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merge the the DataFrames into one using 'CRASH_RECORD_ID' column to join\n",
    "main_df = df_crash.merge(df_vehicle, left_on='CRASH_RECORD_ID', right_on = 'CRASH_RECORD_ID', how='inner')\n",
    "main_df = main_df.merge(df_people, left_on='CRASH_RECORD_ID', right_on = 'CRASH_RECORD_ID', how='inner')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we merged the dataframes, we noticed that the number of rows in our dataset increased drastically, but not exactly 2x. \n",
    "\n",
    "After examining the data, we found that some rows had split into two entries due to a crash normally involving two parties (but not always, so hence the ALMOST 2x). \n",
    "\n",
    "We decided to keep the duplicated entries as no matter how many parties were involved, a cause that determined the crash affected all parties.\n",
    "\n",
    "Then, we fixed the Target columns to accurately reflect the 'DANGEROUS_BEH' column as the Target column was created before the \n",
    "'DANGEROUS_BEH' merge. Same logic applies to the 'DRIVER_ERROR' column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting 'UNABLE TO DETERMINE' columns to be recorded as \"behavior\" when 'DANGEROUS_BEH' is also true\n",
    "main_df['is_two'] = (main_df['Target'] == 4) & (main_df['DANGEROUS_BEH'] == 1)\n",
    "main_df['is_two'] = main_df['is_two'].map(boolean)\n",
    "main_df['Target'] = main_df['Target'] + main_df['is_two']\n",
    "main_df['Target'] = main_df['Target'].map(two)\n",
    "main_df.drop(['is_two'], axis = 1, inplace = True)\n",
    "\n",
    "# Converting 'UNABLE TO DETERMINE' columns to be recorded as \"driver\" when 'DRIVER_ERROR' is also true\n",
    "main_df['is_one'] = (main_df['Target'] == 4) & (main_df['DRIVER_ERROR'] == 1)\n",
    "main_df['is_one'] = main_df['is_one'].map(boolean)\n",
    "main_df['Target'] = main_df['Target'] + main_df['is_one']\n",
    "main_df['Target'] = main_df['Target'].map(one)\n",
    "main_df.drop(['is_one'], axis = 1, inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Originally we wanted to do a 4 target classifer - driver error, behavioral error, road conditions, and other factors.\n",
    "\n",
    "However, due to the class imbalance, we grouped driver action (driver error, behavioral error) and road / external factors in order to fix the class imbalance problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    718270\n",
       "1    233870\n",
       "Name: Target, dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def target_map(val):\n",
    "    if ((val == 1) | (val == 2)):\n",
    "        return 0\n",
    "    elif ((val == 3) | (val == 4)):\n",
    "        return 1\n",
    "    \n",
    "main_df['Target'] = main_df['Target'].map(target_map)\n",
    "main_df['Target'].value_counts()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before saving our final modeling data to a csv, we ran a heatmap to see if there are any concerning correlations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(rc={'figure.figsize':(20, 20)})\n",
    "sns.heatmap(main_df.corr().abs(),annot=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because BAD_WEATHER and BAD_ROAD_CONDITIONS are highly correlated with each other. To not overfit to our data, we dropped BAD_WEATHER from our dataset.\n",
    "\n",
    "Longitude and Latitude will be dropped in our modeling notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df.drop('BAD_WEATHER', axis = 1, inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save final file to a csv folder for our main cleaned csv file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_df.to_csv('../data/cleaned_data/cleaned_modeling_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>CRASH_RECORD_ID</th>\n",
       "      <th>LATITUDE</th>\n",
       "      <th>LONGITUDE</th>\n",
       "      <th>BAD_VISIBILITY</th>\n",
       "      <th>BAD_TRAFFIC</th>\n",
       "      <th>BAD_ROAD_CONDITION</th>\n",
       "      <th>DEFECT_ROAD</th>\n",
       "      <th>WORKING_TRAFFIC_DEVICE</th>\n",
       "      <th>Target</th>\n",
       "      <th>NUM_PASSENGERS</th>\n",
       "      <th>VEHICLE_DEFECT</th>\n",
       "      <th>CRASH_DATE</th>\n",
       "      <th>DANGEROUS_BEH</th>\n",
       "      <th>OBSCURED_VIZ</th>\n",
       "      <th>DRIVER_ERROR</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4fd0a3e0897b3335b94cd8d5b2d2b350eb691add56c62d...</td>\n",
       "      <td>41.919664</td>\n",
       "      <td>-87.773288</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>07/10/2019 05:56:00 PM</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4fd0a3e0897b3335b94cd8d5b2d2b350eb691add56c62d...</td>\n",
       "      <td>41.919664</td>\n",
       "      <td>-87.773288</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>07/10/2019 05:56:00 PM</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>009e9e67203442370272e1a13d6ee51a4155dac65e583d...</td>\n",
       "      <td>41.741804</td>\n",
       "      <td>-87.740954</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>06/30/2017 04:00:00 PM</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>009e9e67203442370272e1a13d6ee51a4155dac65e583d...</td>\n",
       "      <td>41.741804</td>\n",
       "      <td>-87.740954</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>06/30/2017 04:00:00 PM</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ee9283eff3a55ac50ee58f3d9528ce1d689b1c4180b4c4...</td>\n",
       "      <td>41.773456</td>\n",
       "      <td>-87.585022</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>07/10/2020 10:25:00 AM</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                     CRASH_RECORD_ID   LATITUDE  LONGITUDE  \\\n",
       "0  4fd0a3e0897b3335b94cd8d5b2d2b350eb691add56c62d...  41.919664 -87.773288   \n",
       "1  4fd0a3e0897b3335b94cd8d5b2d2b350eb691add56c62d...  41.919664 -87.773288   \n",
       "2  009e9e67203442370272e1a13d6ee51a4155dac65e583d...  41.741804 -87.740954   \n",
       "3  009e9e67203442370272e1a13d6ee51a4155dac65e583d...  41.741804 -87.740954   \n",
       "4  ee9283eff3a55ac50ee58f3d9528ce1d689b1c4180b4c4...  41.773456 -87.585022   \n",
       "\n",
       "   BAD_VISIBILITY  BAD_TRAFFIC  BAD_ROAD_CONDITION  DEFECT_ROAD  \\\n",
       "0               0            0                   0            0   \n",
       "1               0            0                   0            0   \n",
       "2               0            1                   0            0   \n",
       "3               0            1                   0            0   \n",
       "4               0            0                   0            0   \n",
       "\n",
       "   WORKING_TRAFFIC_DEVICE  Target  NUM_PASSENGERS  VEHICLE_DEFECT  \\\n",
       "0                       0       0             0.0               0   \n",
       "1                       0       0             1.0               0   \n",
       "2                       1       0             0.0               0   \n",
       "3                       1       0             1.0               0   \n",
       "4                       1       0             0.0               0   \n",
       "\n",
       "               CRASH_DATE  DANGEROUS_BEH  OBSCURED_VIZ  DRIVER_ERROR  \n",
       "0  07/10/2019 05:56:00 PM              0             0             0  \n",
       "1  07/10/2019 05:56:00 PM              0             0             0  \n",
       "2  06/30/2017 04:00:00 PM              0             0             0  \n",
       "3  06/30/2017 04:00:00 PM              0             0             0  \n",
       "4  07/10/2020 10:25:00 AM              0             0             1  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A preview, if you wanted to load the data to explore\n",
    "main_df = pd.read_csv('../data/cleaned_data/cleaned_modeling_data.csv')\n",
    "main_df.drop('Unnamed: 0', axis = 1, inplace = True)\n",
    "main_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}