def load_experience_memory(self, path):
sd_path = os.path.join(path, "sd_history.pkl")
sars_path = os.path.join(path, "sars_history.pkl")
self.supply_demand_history = pickle.load(open(sd_path, "rb"))
self.experience_memory = pickle.load(open(sars_path, "rb"))
# print(len(self.experience_memory))
state_action, _, _ = self.experience_memory[0]
t_start, _, _ = state_action
state_action, _, _ = self.experience_memory[-1]
t_end, _, _ = state_action
print("period: {} ~ {}".format(get_local_datetime(t_start),
get_local_datetime(t_end)))
def load_OD_matrix(t, alpha=0.1):
localtime = get_local_datetime(t)
dayofweek, hour = localtime.weekday(), localtime.hour
hours_bin = int(hour / DESTINATION_PROFILE_TEMPORAL_AGGREGATION)
query = """
SELECT origin_x, origin_y, destination_x, destination_y, demand, trip_time
FROM od_profile
WHERE dayofweek = {dayofweek} and hours_bin = {hours_bin};
""".format(dayofweek=dayofweek, hours_bin=hours_bin)
df = pd.read_sql(query, engine, index_col=["origin_x", "origin_y", "destination_x", "destination_y"])
X_size = int(MAP_WIDTH / DESTINATION_PROFILE_SPATIAL_AGGREGATION) + 1
Y_size = int(MAP_HEIGHT / DESTINATION_PROFILE_SPATIAL_AGGREGATION) + 1
OD = np.full((X_size, Y_size, X_size, Y_size), alpha)
TT = np.zeros((X_size, Y_size, X_size, Y_size))
for od, row in df.iterrows():
OD[od] += row.demand
TT[od] = row.trip_time
for ox in range(X_size):
for oy in range(Y_size):
OD[ox, oy] /= OD[ox, oy].sum()
average_TT = np.zeros((X_size, Y_size))
for ox in range(X_size):
for oy in range(Y_size):
average_TT[ox, oy] = (TT[ox, oy] * OD[ox, oy]).sum()
# TT = np.tensordot(TT, OD, axes=[(2, 3), (2, 3)])
return OD, average_TT
def par_step_push(self):
t1 = time.time()
self.push_vehicles(self.__dt, self.__t)
# t_p_update = time.time() - t1
#after the push, call the vehicle to step for all vehicles in each zone
# t1 = time.time()
self.vehicle_step_update(
self.__dt,
self.__t) # interpolate routes and update vehicle status
# t_v_update=time.time()-t1
# update the demand for each matching zone
ray.get([
c.async_demand_gen.remote(self.__t)
for c in self.match_zone_collection
])
'''
todo: add a download and push function for charging stations.
'''
self.download_match_zone_metrics()
if self.__t % STORE_TRANSITION_CYCLE == 0: # STORE_TRANSITION_CYCLE = 60*60 sec
self.store_transitions_from_veh()
self.__update_time()
if self.__t % 3600 == 0:
self.logger.info("Elapsed : {}".format(get_local_datetime(
self.__t))) # added origin UNIX time inside func.
def get_customer_waiting_time(self, customer_df, bin_width=300):
""" Customer Waiting time (discretized time) """
customer_df["time_bin"] = self.add_time_bin(customer_df, bin_width)
df = customer_df[customer_df.status == 2].groupby(
"time_bin").waiting_time.mean()
df.index = [time_utils.get_local_datetime(x) for x in df.index]
return df
def step(self):
for customer in CustomerRepository.get_all():
customer.step(self.__dt)
if customer.is_arrived() or customer.is_disappeared():
CustomerRepository.delete(customer.get_id())
for vehicle in VehicleRepository.get_all():
vehicle.step(self.__dt)
# vehicle.print_vehicle()
if vehicle.exit_market():
score = ','.join(
map(str, [
self.get_current_time(),
vehicle.get_id(),
vehicle.get_total_dist(),
vehicle.compute_profit()
] + vehicle.get_score()))
if vehicle.agent_type == agent_codes.dqn_agent:
self.current_dqnV -= 1
else:
self.current_dummyV -= 1
sim_logger.log_score(score)
VehicleRepository.delete(vehicle.get_id())
self.__populate_new_customers()
self.__update_time()
if self.__t % 3600 == 0:
# print("Elapsed : {}".format(get_local_datetime(self.__t)))
self.logger.info("Elapsed : {}".format(get_local_datetime(
self.__t)))
def create_training_dataset(df, n_weeks):
t_start = df.request_datetime.min()
t_end = t_start + 3600 * 24 * 7 * n_weeks
df = df[(df.request_datetime >= t_start) & (df.request_datetime < t_end)]
df["datetime_obj"] = df.request_datetime.apply(
lambda x: get_local_datetime(x))
return df
def par_step(self): # we use parallel update to call the step function.
'''
Parallel run of the simulator that involves the following key steps:
1. conduct the matching for each matching zone
2. Update passenger status
3. Update vehicle status
4. Dispatch vehicles
5. Generate new passengers
:return:
'''
# conduct matching first
tick = self.__t - self.start_time # unit: sec
t_start = time.time()
[m.match() for m in self.match_zone_collection] # force this to complete
# dispatched vehicles which have been attached dispatch actions.
[m.dispatch(tick) for m in self.match_zone_collection]
#self.download_match_zone_metrics()
# update passenger status
[m.update_passengers() for m in self.match_zone_collection]
self.update_vehicles(self.__t) # push routes inside if needed
t1=time.time()
#update charging stations...
[cs.step(self.__dt, self.__t) for cs in self.charging_station_collections]
cs_time=time.time()-t1
self.enter_market()
#after the push, call the vehicle to step for all vehicles in each zone
# t1 = time.time()
self.vehicle_step_update(self.__dt,self.__t) # interpolate routes and update vehicle status
# t_v_update=time.time()-t1
# update the demand for each matching zone
[c.async_demand_gen(tick) for c in self.match_zone_collection]
'''
todo: add a download and push function for charging stations.
'''
self.download_match_zone_metrics()
STORE_TRANSITION_CYCLE=1 #store everytick
if self.__t % STORE_TRANSITION_CYCLE == 0: # STORE_TRANSITION_CYCLE = 60*60 sec
self.store_transitions_from_veh()
self.__update_time()
if self.__t % 3600 == 0:
self.logger.info("Elapsed : {}".format(get_local_datetime(self.__t)))
t_end = time.time() - t_start
print('Iteration {} completed, total cpu time={:.3f}'.format(tick / 60, t_end))
def update_hourly_demand(self, t, max_hours=4):
localtime = get_local_datetime(t - 60 * 30)
current_time = localtime.month, localtime.day, localtime.hour
if len(self.hourly_demand) == 0 or self.current_time != current_time:
self.current_time = current_time
self.hourly_demand = [self.load_demand_profile(t + 60 * (60 * i - 30)) for i in range(max_hours)]
x = (localtime.minute - 30) / 60.0
return x
def construct_time_features(self, timestamp):
t = get_local_datetime(timestamp)
hourofday = t.hour / 24.0 * 2 * np.pi
dayofweek = t.weekday() / 7.0 * 2 * np.pi
return [
np.sin(hourofday),
np.cos(hourofday),
np.sin(dayofweek),
np.cos(dayofweek)
]
def update(self):
# t_v_update=time.time()-t1
self.download_match_zone_metrics()
if self.__t % STORE_TRANSITION_CYCLE == 0: # STORE_TRANSITION_CYCLE = 60*60 sec
self.store_transitions_from_veh()
self.__update_time()
if self.__t % 3600 == 0:
self.logger.info("Elapsed : {}".format(get_local_datetime(
self.__t))) # added origin UNIX time inside func.
def get_customer_status(self, customer_df, bin_width=300):
customer_df["time_bin"] = self.add_time_bin(customer_df, bin_width)
df = customer_df.groupby(["time_bin",
"status"]).size().reset_index().pivot(
index="time_bin",
columns="status",
values=0).fillna(0)
df = df.rename(columns={2: "ride_on", 4: "rejected"})
df["total"] = sum([x for _, x in df.iteritems()])
df.index = [time_utils.get_local_datetime(x) for x in df.index]
return df
def load_demand_profile(t):
localtime = get_local_datetime(t)
dayofweek, hour = localtime.weekday(), localtime.hour
query = """
SELECT x, y, demand
FROM demand_profile
WHERE dayofweek = {dayofweek} and hour = {hour};
""".format(dayofweek=dayofweek, hour=hour)
demand = pd.read_sql(query, engine, index_col=["x", "y"]).demand
M = np.zeros((MAP_WIDTH, MAP_HEIGHT))
for (x, y), c in demand.iteritems():
M[x, y] += c
return M
def plot_summary(self, paths, labels, plt):
plt.figure(figsize=(12, 5))
plt.subplots_adjust(wspace=0.2, hspace=0.4)
for i, path in enumerate(paths):
summary = self.load_summary_log(path)
summary['t'] = (summary.t / 3600).astype(int) * 3600
summary = summary.groupby('t').mean().reset_index()
summary.t = [time_utils.get_local_datetime(t) for t in summary.t]
plt.subplot(len(paths), 2, +i * 2 + 1)
plt.plot(summary.t, summary.n_requests, label="request")
plt.plot(summary.t,
summary.n_requests - summary.n_matching,
label="reject",
linestyle=':')
plt.plot(summary.t,
summary.n_dispatch,
label="dispatch",
alpha=0.7)
plt.ylabel("count/minute")
plt.ylim([0, 610])
if i != len(paths) - 1:
plt.xticks([])
if i == 0:
plt.legend(loc='upper right')
plt.subplot(len(paths), 2, i * 2 + 2)
plt.title(labels[i])
plt.plot(summary.t, summary.n_vehicles, label="working")
plt.plot(summary.t,
summary.occupied_vehicles,
label="occupied",
linestyle=':')
plt.ylabel("# of vehicles")
plt.ylim([0, 10100])
if i != len(paths) - 1:
plt.xticks([])
if i == 0:
plt.legend(loc='upper right')
# plt.subplot(313)
# plt.plot(summary.t, summary.average_wt, alpha=1.0)
# plt.ylim([0, 450])
# plt.ylabel("waiting time (s)")
# plt.xlabel("simulation time (s)")
return plt
def step(self):
for customer in CustomerRepository.get_all():
customer.step(self.__dt)
if customer.is_arrived() or customer.is_disappeared():
CustomerRepository.delete(customer.get_id())
for vehicle in VehicleRepository.get_all():
vehicle.step(self.__dt)
if vehicle.exit_market():
score = ','.join(
map(str, [self.get_current_time(),
vehicle.get_id()] + vehicle.get_score()))
sim_logger.log_score(score)
VehicleRepository.delete(vehicle.get_id())
self.__populate_new_customers()
self.__update_time()
if self.__t % 3600 == 0:
self.logger.info("Elapsed : {}".format(get_local_datetime(
self.__t)))
self.vehicle_queue.pop(0)
self.simulator.populate_vehicle(vehicle_id, location)
else:
break
if __name__ == '__main__':
start = time.time()
# For DQN
dispatch_policy = load()
# setup_base_log_dir(FLAGS.tag)
if FLAGS.days > 0:
start_time = FLAGS.start_time + int(60 * 60 * 24 * FLAGS.start_offset)
# print(start_time, MAX_DISPATCH_CYCLE, MIN_DISPATCH_CYCLE)
print("Start Datetime: {}".format(get_local_datetime(start_time)))
end_time = start_time + int(60 * 60 * 24 * FLAGS.days)
print("End Datetime : {}".format(get_local_datetime(end_time)))
# For DQN
Sim_experiment = simulator_driver(
start_time, TIMESTEP, matching_policy.GreedyMatchingPolicy(),
dispatch_policy, pricing_policy.PricingPolicy())
# Sim_experiment = simulator_driver(start_time, TIMESTEP, matching_policy.GreedyMatchingPolicy())
# header = "TimeStamp, Unix TIme, Vehicles, Occupied Vehicles, Requests, Matchings, Rejects, Accepts, Avg Wait Time per request, Avg Earnings, " \
# "Avg Cost, Avg Profit for DQN, Avg Profit for dummy, Avg Total Dist, Avg Capacity per vehicle, Avg Idle Time"
# sim_logger.log_summary(header)
# header = "TimeStamp, Request ID, Status Code, Waiting_Time"
# sim_logger.log_customer_event(header)
# header = "V_id', V_lat, V_lon, Speed, Status, Dest_lat, Dest_lon, Type, Travel_Dist, Price_per_travel_m, Price_per_wait_min, Gas_price,"\
TIMESTEP, START_OFFSET, SIM_DAYS, START_TIME, TRAINING_CYCLE, UPDATE_CYCLE, SAVING_CYCLE
from common.time_utils import get_local_datetime
from simulator.simulator_sequential import Simulator
from dqn_agent.dqn_agent import DeepQNetworkAgent
import numpy as np
import time
# ---------------MAIN FILE---------------
if __name__ == '__main__':
if SIM_DAYS > 0:
start_time = START_TIME + int(
60 * 60 * 24 * START_OFFSET) # start_time = 0
print("Simulate Episode Start Datetime: {}".format(
get_local_datetime(start_time)))
end_time = start_time + int(60 * 60 * 24 * SIM_DAYS)
print("Simulate Episode End Datetime : {}".format(
get_local_datetime(end_time)))
simulator = Simulator(start_time, TIMESTEP)
simulator.init(HEX_SHP_PATH, CS_SHP_PATH, TRIP_FILE, TRAVEL_TIME_FILE,
NUM_NEAREST_CS)
dqn_agent = DeepQNetworkAgent()
n_steps = int(3600 * 24 / TIMESTEP) # 60 per minute
with open('logs/parsed_results_inf.csv', 'w') as f, open(
'logs/target_charging_stations_inf.csv',
'w') as g, open('logs/training_hist_inf_new.csv', 'a') as h:
f.writelines(
'{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n'.format(
"time", "num_idle", "num_serving", "num_charging",
from config.hex_setting import HEX_SHP_PATH, CS_SHP_PATH, NUM_NEAREST_CS, TRIP_FILE, TRAVEL_TIME_FILE, \
TIMESTEP, START_OFFSET, SIM_DAYS, START_TIME, TRAINING_CYCLE, UPDATE_CYCLE, SAVING_CYCLE
from common.time_utils import get_local_datetime
from simulator.simulator_sequential import Simulator
from dqn_agent.dqn_agent import DeepQNetworkAgent
import numpy as np
import time
# ---------------MAIN FILE---------------
if __name__ == '__main__':
if SIM_DAYS > 0:
start_time = START_TIME + int(60 * 60 * 24 * START_OFFSET) # start_time = 0
print("Simulate Episode Start Datetime: {}".format(get_local_datetime(start_time)))
end_time = start_time + int(60 * 60 * 24 * SIM_DAYS)
print("Simulate Episode End Datetime : {}".format(get_local_datetime(end_time)))
simulator = Simulator(start_time, TIMESTEP)
simulator.init(HEX_SHP_PATH, CS_SHP_PATH, TRIP_FILE, TRAVEL_TIME_FILE, NUM_NEAREST_CS)
dqn_agent = DeepQNetworkAgent()
n_steps = int(3600 * 24 / TIMESTEP) # 60 per minute
with open('logs/parsed_results_21days.csv', 'w') as f, open('logs/training_hist_21days.csv', 'w') as h:
f.writelines(
'{},{},{},{},{},{},{},{},{},{},{},{}\n'.format("time", "num_idle", "num_serving", "num_charging",
"num_cruising", "num_assigned", "num_waitpile",
"num_tobedisptached", "num_offduty",
"num_matches", "pass_arrivals", "removed_pass"))
h.writelines('{},{},{},{}\n'.format("step","loss","reward","len_replay_buffer"))
for day in range(SIM_DAYS):
print("############################ SUMMARY ################################")
