Do Taxi Drivers Take the Fastest Route?

1# First we import a bunch of libraries
2import pandas as pd
3import numpy as np
4import folium # map visualisation package
5import requests # this we use for API calls
6import json
7import matplotlib.pyplot as plt
8import branca.colormap as cm
9from dateutil import tz
10import datetime
11import time
12from tqdm import tqdm
13
14# Then we load the data
15df = pd.read_csv("/set/path/to/train.csv")
16df.head()

df.shape
(1710670, 9)

api_key = "insert your own API key here"

1# Initiate the map with the TomTom maps API
2def initialise_map(api_key=api_key, location=[41.161178, -8.648490], zoom=14, style = "main"):
3    """
4    The initialise_map function initialises a clean TomTom map
5    """
6    maps_url = "http://{s}.api.tomtom.com/map/1/tile/basic/"+style+"/{z}/{x}/{y}.png?tileSize=512&key="
7    TomTom_map = folium.Map(
8    location = location, # on what coordinates [lat, lon] we want to initialise our map
9    zoom_start = zoom, # with what zoom level we want to initialise our map, from 0 to 22
10    tiles = str(maps_url + api_key),
11    attr = 'TomTom')
12    return TomTom_map
13
14# Save map as TomTom_map
15TomTom_map = initialise_map()
16TomTom_map

1def polyline_to_list(polyline):
2    """
3    The polyline_to_list_lists function transforms the raw polyline to a list of tuples
4    input: '[[-8.639847,41.159826],[-8.640351,41.159871]'
5    output: [[41.159826, -8.639847],[41.159871, -8.640351]]
6    """
7    trip = json.loads(polyline) # json.loads converts the string to a list
8    coordinates_list = [list(reversed(coordinates)) for coordinates in trip]
9    # transform list (reverse values and put it in a list of lists)
10    return coordinates_list
11
12# Plot polyline on the map
13polyline = polyline_to_list(df['POLYLINE'][1])
14folium.PolyLine(polyline).add_to(TomTom_map)
15TomTom_map

1def convertUnixTimeToDate(timestamp):
2    """
3    The convertUnixTimeToDate function transforms a UNIX timestamp to a ISO861 dateTime format
4    for a date in the future
5    input: 1372636858
6    output: '2024-05-3T00:00:58Z'
7    """
8
9    # Portugal is in UTC+0 time zone, first get the right time zone:
10    UTC = tz.gettz('UTC')
11
12    # Then convert our timestamp to the right format:
13    timeTrip = datetime.datetime.fromtimestamp(timestamp,tz=UTC)
14    weekday = timeTrip.strftime("%A") # get day of the week
15    timeofday = timeTrip.strftime("%H:%M:%SZ") # get time of the day
16
17    # Some hardcoded weekday dates in the future. Not the most elegant solution but fast:
18    convertWeekdays = {
19        "Monday":"2024-05-3T",
20        "Tuesday":"2024-05-4T",
21        "Wednesday":"2024-05-5T",
22        "Thursday":"2024-05-6T",
23        "Friday":"2024-05-7T",
24        "Saturday":"2024-05-8T",
25        "Sunday":"2024-05-9T"}
26
27    routingTime = convertWeekdays[weekday] + timeofday
28
29    return routingTime

1def call_routing_api(polyline, departure_time, api_key=api_key, taxi_route=True):
2    """
3    Input is a polyline of a taxi route, a UNIX departure time, and whether to get the results for the taxi
4    route or fastest route
5    Output is the traffic delay in seconds, travel time of the route, route points from the Routing API and
6    the full response from the API
7    """
8
9    coordinates_list = polyline_to_list(polyline) # transform polyline to list of tuples
10
11    lat1, lon1 = coordinates_list[0] # origin coordinates of the trip
12    lat2, lon2 = coordinates_list[-1] # destination coordinates of the trip
13
14    # Set the URL for the Routing API
15    routing_url = "https://api.tomtom.com/routing/1/calculateRoute/"
16    url = str(routing_url + str(lat1) + ',' + str(lon1) + ':' + str(lat2) + ',' + str(lon2) +
17    "/json?maxAlternatives=0&departAt=" + convertUnixTimeToDate(departure_time) +
18    "&traffic=true&key=" + api_key)
19
20    # Add support points for the route reconstruction:
21    body = {"supportingPoints": []}
22
23    if taxi_route == True:
24        support_points = polyline_to_list(polyline) # use the whole polyline
25        for point in support_points:
26            body["supportingPoints"].append({"latitude": point[0],"longitude": point[1]})
27    else:
28        support_points = polyline_to_list(polyline)[-1] # use only the final coordinate
29        body["supportingPoints"].append({"latitude": support_points[0],"longitude": support_points[1]})
30
31    # Send the API call to TomTom:
32    n = 0
33    while True:
34        n+=1
35        try:
36            response = requests.post(url,json=body)
37
38            # Call was succesful"
39            if response.status_code == 200:
40                break
41
42            # Call broke QPS limit, sleep for one second:
43            elif response.status_code == 403:
44                time.sleep(1)
45        except:
46            print("error", str(response.status_code))
47
48        # Stop after 4 attempts:
49        if n > 4:
50            break
51    # Return None if the call was not succesful
52    if response.status_code == 200:
53        response = response.json()
54
55        delay = response['routes'][0]["summary"]['trafficDelayInSeconds']
56        travel_time = response['routes'][0]["summary"]['travelTimeInSeconds']
57        points = response['routes'][0]['legs'][0]['points']
58        route_points = [[point['latitude'], point['longitude']] for point in points]
59
60        return delay, travel_time, route_points, response
61    else:
62        return None, None, None, None

1# First we calculate the travel time and route for the original taxi trip:
2delay_taxi, travel_time_taxi, route_points_taxi, response_taxi = call_routing_api(df['POLYLINE'][1], df['TIMESTAMP'][1], taxi_route=True)
3
4print("The taxi route will take you:", travel_time_taxi, 'seconds')
5
6# Next we calculate the travel time and route for the fastest route:
7delay_fastest, travel_time_fastest, route_points_fastest, response_fastest = call_routing_api(df['POLYLINE'][1], df['TIMESTAMP'][1], taxi_route=False)
8
9print("The fastest route will take you:", travel_time_fastest, 'seconds')
10
11The taxi route will take you: 657 seconds
12The fastest route will take you: 657 seconds

1# Initialise TomTom map
2TomTom_map = initialise_map(location=[41.164962,-8.656301], zoom=15)
3
4# Plot the points of the original route on the map
5polyline = polyline_to_list(df['POLYLINE'][1])
6folium.PolyLine(polyline, color="blue", weight=2, opacity=1).add_to(TomTom_map)
7
8# Plot the points of the original reconstructed route on the map
9folium.PolyLine(route_points_taxi, color="black", weight=2, opacity=1).add_to(TomTom_map)
10
11# Plot fastest route on the map
12folium.PolyLine(route_points_fastest, color="red", weight=2, opacity=1).add_to(TomTom_map)
13
14TomTom_map

1# retrieve 1200 random samples
2random_sample = df.sample(1200, random_state=123)
3random_sample = random_sample.reset_index().drop('index', axis=1) # reset index so we can iterate
4
5# initialise dictionary in which we will store our results
6results = {"Fastest_traveltime": [], "Taxi_traveltime": [],"Polyline" :[]}
7# For each polyline in random_sample, call the call_routing_api function twice, once to retrieve the travel time
8# for the fastest route and once for the travel time of the taxi route
9
10for i in tqdm( range(len(random_sample)) ):
11    if random_sample['POLYLINE'][i] != '[]': # check if polyline is not empty
12
13    # travel time fastest route
14    results['Fastest_traveltime'].append(
15        call_routing_api(random_sample['POLYLINE'][i], random_sample['TIMESTAMP'][i], taxi_route=False)[1])
16
17    # travel time taxi route
18    results['Taxi_traveltime'].append(
19        call_routing_api(random_sample['POLYLINE'][i], random_sample['TIMESTAMP'][i], taxi_route=True)[1])
20
21    # add departurePoint to results:
22    polyline = polyline_to_list(random_sample['POLYLINE'][i])
23    results['Polyline'].append(polyline)
24100.|██████████| 1200/1200 [13:34<00:00, 1.58it/s]

1# save results as pandas dataframe
2results = pd.DataFrame(results)
3
4# calculate the difference in minutes between the two routes
5results['Difference_min'] = (results['Taxi_traveltime'] - results['Fastest_traveltime']) / 60
6
7# calculate the relative difference between the two routes
8results['Relative_diff'] = (results['Taxi_traveltime'] - results['Fastest_traveltime']) / results['Fastest_traveltime']
9
10# keep only the trips that are long enough to make a proper comparison
11results = results[results['Fastest_traveltime'] > 60] # trips should take at least 1 minute
12
13# display dataframe
14results.head()

print("Maximum relative difference is", round(max(results['Relative_diff']), 2))
Maximum relative difference is 11.74

# filter out outliers
results = results[results['Relative_diff'] < 2]

1print("Mean:", np.mean(results['Difference_min']))
2print("Standard deviation:", np.std(results['Difference_min']))
3Mean: 2.5056110102843316
4Standard deviation: 3.538457376554713

1# Plot histogram
2difference_min = sorted(np.array(results['Difference_min']))
3fig = plt.figure(figsize=(15,8))
4plt.hist(difference_min, bins=15)
5plt.title("Difference in minutes with the fastest route")
6plt.xlabel("Minutes")
7plt.ylabel('Counts')

1# Plot histogram
2difference_min = sorted(np.array(results['Relative_diff']))
3fig = plt.figure(figsize=(15,8))
4plt.hist(difference_min, bins=15)
5plt.title("Relative difference with fastest route")
6plt.xlabel("Relative difference")
7plt.ylabel('Counts')

1# Get some percentiles of the relative difference
2results['Relative_diff'].quantile([0.1, 0.23, 0.24, 0.5, 0.6, 0.75, 0.835, 0.9, 0.95, 0.98, 1])
30.100 0.000000
40.230 0.001009
50.240 0.004345
60.500 0.138331
70.600 0.199668
80.750 0.351191
90.835 0.491842
100.900 0.703618
110.950 0.941956
120.980 1.344909
131.000 1.970732
14Name: Relative_diff, dtype: float64

1# Create a linear color scale
2linear_color = cm.LinearColormap(['green', 'yellow', 'red'], vmin=0, vmax=0.5)
3linear_color

1# Plot the starting point on the map
2TomTom_map_bubble = initialise_map(api_key=api_key, location=[41.161178, -8.648490], zoom=13, style = "night")
3
4for index, row in results[:1000].iterrows(): # limit number of data points plotted to 1000
5
6    popup_string = "Relative delay = " + str(round(100* row["Relative_diff"], 1)) + "%"
7
8    folium.Circle(
9      location = row["Polyline"][0],
10      popup= popup_string,
11      radius=30,
12      color=linear_color(row["Relative_diff"]), #get_color(row["Relative_diff"]),
13      fill=True,
14      ).add_to(TomTom_map_bubble)
15
16TomTom_map_bubble

1# On this map we visualize all the polylines of the taxi trips using the same color scheme
2TomTom_map_lines = initialise_map(api_key=api_key, location=[41.161178, -8.648490], zoom=13, style = "night")
3for index, row in results[:500].iterrows(): # limit number of polylines plotted to 500
4
5    folium.PolyLine(row["Polyline"],
6        color=linear_color(row["Relative_diff"]),
7        weight=1.0,
8        opacity=1.5
9        ).add_to(TomTom_map_lines)
10
11TomTom_map_lines