def __init__(self, config_, year, month, weekday):
"""
Constructor
:param config_:
:return:
"""
self.config = config_
self.year = year
self.month = month
self.weekday = weekday
self.logger = logging.getLogger("cuda_logger")
data_provider = DataProvider(self.config)
hex_attr_df = data_provider.read_hex_bin_attributes()
hex_attr_df['center'] = hex_attr_df.apply(self.calculate_bin_center,
axis=1)
self.hex_attr_df = hex_attr_df
def __init__(self, config_):
"""
Constructor
:param config_:
:returns:
"""
self.config = config_
self.logger = logging.getLogger("cuda_logger")
self.start_time = self.config["city_state_creator"]["start_time"]
self.end_time = self.config["city_state_creator"]["end_time"]
self.time_slice_duration = self.config["city_state_creator"][
"time_slice_duration"]
self.time_unit_duration = self.config["city_state_creator"][
"time_unit_duration"]
data_provider = DataProvider(self.config)
hex_attr_df = data_provider.read_hex_bin_attributes()
hex_dist_df = data_provider.read_hex_bin_distances()
self.hex_bins = hex_attr_df['hex_id'].values
self.hex_dist = hex_dist_df[[
'pickup_bin', 'dropoff_bin', 'straight_line_distance'
]]
def __init__(self, config_):
"""
Constructor
:param config_:
:return:
"""
self.config = config_
self.logger = logging.getLogger("gym_logger")
data_provider = DataProvider(self.config)
# City state parameters
self.city_states = data_provider.read_city_states()
self.hex_attr_df = data_provider.read_hex_bin_attributes()
self.hex_bins = self.hex_attr_df['hex_id']
self.T = len(self.city_states) # Number of time steps
self.S = len(self.hex_bins) # Number of hex bins
# Environment parameters
self.num_drivers = self.config['env_parameters']['num_drivers']
self.distribution = self.config['env_parameters'][
'driver_distribution']
self.next_free_timestep = np.zeros(
self.num_drivers) # Next free timestep for each driver
self.total_driver_earnings = np.zeros(
self.num_drivers) # Total earnings for each driver
# Environment action and observation space
actions = [7 for i in range(self.S)]
drivers = [self.num_drivers for i in range(self.S)]
self.action_space = spaces.MultiDiscrete(actions)
# self.observation_space = spaces.Tuple((
# # spaces.Discrete(self.T), # Time step
# spaces.MultiDiscrete(drivers) # Driver distribution
# ))
self.observation_space = spaces.MultiDiscrete(drivers)
self.reset()
def run(self):
"""
This method executes the job
:param:
:return:
"""
self.logger.info("Starting job: NeighborhoodDataExportJob\n")
data_provider = DataProvider(self.config)
data_exporter = DataExporter(self.config)
hex_attr_df = data_provider.read_hex_bin_attributes()
hex_bins = hex_attr_df['hex_id'].values
data = {}
for r in xrange(self.radius + 1):
data[r] = {}
for hex_bin in hex_bins:
neighbors = hex_neighborhood(hex_bin, hex_attr_df, r)
zero_vector = np.zeros(len(hex_bins))
np.put(zero_vector, neighbors, 1)
one_hot_encoding_vector = zero_vector
data[r][hex_bin] = one_hot_encoding_vector
data_exporter.export_neighborhood_data(data)
self.logger.info("Finished job: NeighborhoodDataExportJob")
def run(self):
"""
Creates and runs training episode
:param:
:return:
"""
data_provider = DataProvider(self.config)
hex_attr_df = data_provider.read_hex_bin_attributes()
hex_distance_df = data_provider.read_hex_bin_distances()
city_states = data_provider.read_city_states(self.city_states_filename)
neighborhood = data_provider.read_neighborhood_data()
popular_bins = data_provider.read_popular_hex_bins()
num_episodes = self.config['RL_parameters']['num_episodes']
ind_episodes = self.config['RL_parameters']['ind_episodes']
exp_decay_multiplier = self.config['RL_parameters']['exp_decay_multiplier']
q_ind = None
r_table = None
xi_matrix = None
best_episode = None
best_model = {}
progress_bar = tqdm(xrange(num_episodes))
for episode_id in progress_bar:
progress_bar.set_description("Episode: {}".format(episode_id))
current_best = -1000000
# Create episode
ind_exploration_factor = np.e ** (-1 * episode_id * exp_decay_multiplier / ind_episodes)
episode = Episode(self.config,
episode_id,
ind_exploration_factor,
hex_attr_df,
hex_distance_df,
city_states,
neighborhood,
popular_bins,
q_ind,
r_table,
xi_matrix)
# Run episode
tables = episode.run()
q_ind = tables['q_ind']
r_table = tables['r_table']
xi_matrix = tables['xi_matrix']
episode_tracker = tables['episode_tracker']
# Uncomment for logging if running a job, comment during experiments
# otherwise it leads to insanely huge logging output which is useless
# self.logger.info("""
# Expt: {} Episode: {} Earnings: {}
# Pax rides: {} Relocation rides: {} Unmet demand: {}
# """.format(self.expt_name, episode_id,
# episode_tracker.gross_earnings,
# episode_tracker.successful_waits,
# episode_tracker.relocation_rides,
# episode_tracker.unmet_demand))
# self.logger.info("----------------------------------")
self.training_tracker.update_RL_tracker(
episode_id, episode_tracker.gross_earnings,
episode_tracker.successful_waits, episode_tracker.unsuccessful_waits,
episode_tracker.unmet_demand, episode_tracker.relocation_rides,
episode_tracker.DET, episode_tracker.DPRT, episode_tracker.DWT,
episode_tracker.DRT, episode_tracker.DCT)
# Keep track of the best episode
if self.objective == 'revenue':
if episode_tracker.gross_earnings >= current_best:
best_episode = episode_tracker
current_best = best_episode.gross_earnings
else: # self.objective == 'pickups':
if episode_tracker.successful_waits >= current_best:
best_episode = episode_tracker
current_best = episode_tracker.successful_waits
# Keep track of the best model
best_model['ind_exploration_factor'] = ind_exploration_factor
best_model['config'] = self.config
best_model['q_ind'] = q_ind
best_model['r_table'] = r_table
best_model['xi_matrix'] = xi_matrix
best_model['training_tracker'] = self.training_tracker
# After finishing training
self.logger.info("Expt: {} Earnings: {} Met Demand: {} Unmet Demand: {}".format(self.expt_name,
best_episode.gross_earnings,
best_episode.successful_waits,
best_episode.unmet_demand))
return best_episode, best_model, self.training_tracker
def run(self):
"""
Creates and runs training episode
:param:
:return:
"""
data_provider = DataProvider(self.config)
hex_attr_df = data_provider.read_hex_bin_attributes()
hex_distance_df = data_provider.read_hex_bin_distances()
city_states = data_provider.read_city_states(
self.test_parameters['city_states_filename'])
model = data_provider.read_model(
self.test_parameters['model_filename'])
neighborhood = data_provider.read_neighborhood_data()
popular_bins = data_provider.read_popular_hex_bins()
q_ind = model['q_ind']
r_table = model['r_table']
xi_matrix = model['xi_matrix']
episode_id = 0
# Create episode
ind_exploration_factor = 0.0
episode = Episode(self.config, episode_id, ind_exploration_factor,
hex_attr_df, hex_distance_df, city_states,
neighborhood, popular_bins, q_ind, r_table,
xi_matrix, True)
# Run episode
tables = episode.run()
q_ind = tables['q_ind']
r_table = tables['r_table']
xi_matrix = tables['xi_matrix']
episode_tracker = tables['episode_tracker']
self.testing_tracker.update_RL_tracker(
0, episode_tracker.gross_earnings,
episode_tracker.successful_waits,
episode_tracker.unsuccessful_waits, episode_tracker.unmet_demand,
episode_tracker.relocation_rides, episode_tracker.DET,
episode_tracker.DPRT, episode_tracker.DWT, episode_tracker.DRT,
episode_tracker.DCT)
self.logger.info("""
Expt: {} Earnings: {}
Model: {}
Test day: {}
Num drivers: {}
Pax rides: {} Relocation rides: {} Unmet demand: {}
""".format(
self.expt_name, episode_tracker.gross_earnings,
self.test_parameters['model_filename'],
self.test_parameters['city_states_filename'],
self.config['RL_parameters']['num_drivers'],
episode_tracker.successful_waits, episode_tracker.relocation_rides,
episode_tracker.unmet_demand))
self.logger.info("----------------------------------")
return self.testing_tracker
