Ride Aggregation Efficiency

I propose a ride aggregation efficiency metric that yields a nonnegative number whose magnitude summarizes how many times a trip can be grouped with other trips, accounting for trip duration. For example,

• a trip whose aggregation efficiency is 0 is unaggregable, whereas
• a trip whose aggregation efficiency is 4 can group its trajectory with nearby trips four times over.

For zones, aggregation efficiency in a given time window is the average of the aggregation efficiencies of the trips within the zone and time window.

I measure ride aggregation efficiency by considering fields of aggregation compatibility around the trajectories of past taxi trips and by quantifying the amount of overlap in those fields. The core idea is that if there is a large amount of overlap between the aggregation compatibility fields of two taxi trips, then the trips can be easily aggregated.

I make the following assumptions:

• Vehicles travel at constant velocity in straight-line trajectories from their origins to their destinations.
• Aggregation compatibility is a decreasing function of straight-line distance between two vehicles.

Based on these assumptions, I posit the following model and efficiency metrics:

1. A vehicle's aggregation compatibility field at each point in time can be represented by a bivariate Gaussian distribution.
2. Over the course of their trajectories, the amount of overlap between the fields of two vehicles measures their mutual aggregation compatibility.
3. I calculate the aggregation compatibility of two vehicle trajectories (i.e., trips) by integrating the overlap of their aggregation compatibility fields across space and time.
4. I calculate the trip aggregation efficiency by (1) summing the pairwise aggregation compatibilities of that trip with all other trips in a given time window and zone and (2) dividing by the duration of the trip.
5. I calculate the zone aggregation efficiency by taking the mean of the zone's trip aggregation efficiencies in a given time window.

The core calculation is the integration of aggregation compatibility overlap across space and time:

where \( t \) is time, \( x \) is longitude, \( y \) is latitude, \( μ_i(t) \) is the coordinates of the vehicle \( i \) at time \( t \), \( \Sigma \) is the covariance matrix for aggregation compatibility, \( n \) is the number of standard deviations the limit of truncation is away from the mean, and \( c \) is the normalizing constant for the truncated bivariate normal distribution.

In order to operationalize this model, I implement the following features:

• Truncated bivariate normal distribution to represent aggregation compatibility (see class TruncBiNorm and TruncBiNormOverlap in taxi.py)
• Use a trip's pick-up time, origin, and destination to instantiate an trip object with corresponding trajectory and aggregation compatibility field (see class Trip in taxi.py)

This model has three parameters that impact the efficiency calculation for a given set of taxi trip data:

• Vehicle velocity. Assume 15 km/h (about 9.3 mph), or 250 m/min.
  • 0.00225 lat/min
  • 0.00296 lon/min
• Standard deviation of aggregation compatibility. Assume 300 m (just over 1 Manhattan avenue).
  • 0.00270 lat
  • 0.00355 lon
• Limits of bivariate Gaussian truncation. Assume 3 standard deviations.

I calculate aggregation efficiencies for individual trips with various zones and time windows. I take Midtown to represent Manhattan and examine the following zone combinations:

• Astoria
• Astoria–Midtown
• Astoria–Midtown–LGA
• UES
• UES–Midtown

I perform the calculation over six different times of the week:

• Weekday morning (Wednesday starting at 08:00)
• Weekday afternoon (Wednesday starting at 12:00)
• Weekday evening (Wednesday starting at 18:00)
• Weekend morning (Saturday starting at 08:00)
• Weekend afternoon (Saturday starting at 12:00)
• Weekend evening (Saturday starting at 18:00)

Because the aggregation efficiency calculation is computationally intensive, I use various windows of time ranging from 1–120 minutes to limit the number of trips to a reasonable level. For each time window with more than 30 trips, I randomly sample just 30 trips to perform the aggregation efficiency calculation. The table below shows the zone‐level aggregation efficiencies.

# Load aggregation efficiency calculation layout
ae_layout = pd.read_csv('aggeff_layout.csv')

# Load trip data and aggregation efficiency results
trips, zae = [], []
for i in ae_layout.index:
    with open('results/trips_{}.pkd'.format(i), 'rb') as f:
	trips.append(pickle.load(f))
    with open('results/zae_{}.pkd'.format(i), 'rb') as f:
	zae.append(pickle.load(f))

pd.concat(
    [
	ae_layout[['zone_label', 'time_label', 'start_time', 'duration']],
	pd.DataFrame(
	    [(len(td), np.mean(ae)) for td, ae in zip(trips, zae)],
	    columns=['n_trips', 'efficiency'],
	),
    ],
    axis=1,
).sort_values(['zone_label', 'start_time'])