def test_no_solver(self):
generator_params = {
"dataset_type": "hexagon",
"n": 10,
"time_periods": 144,
"days": 1,
"orders_density": 0.1,
"number_of_cars": 2,
"order_distr": "uniform"
}
np.random.seed(777)
gen = Generator("testOrigSolvers", generator_params)
graph_info = gen.generate()
world_graph, idle_driver_locations, real_orders, onoff_driver_locations, random_average, dist = gen.load_complete_set()
solver_params = {
"dataset": graph_info,
"alpha": 0.1,
"wc": 0,
"tag": "testOrigSolvers",
"gamma": 0.9,
"train_test_split": 0.5
}
solver = OrigNoSolver(**solver_params)
solver.run()
def load_dataset(self):
'''
load complete dataset
note that orders are merged into a single day, and then sampled out of there
'''
dataset_params = self.params['dataset']
gen = Generator(self.params['tag'], dataset_params)
assert dataset_params['dataset_type'] == 'hexagon', "Only hexagon dataset supported"
world, idle_driver_locations, real_orders, \
onoff_driver_locations, random_average, dist = gen.load_complete_set(dataset_id=self.params['dataset']['dataset_id'])
self.l_max = 9 # default 9 (1.5h orders) can be served max. should not matter if orders are "real" and not generated
self.n_side = 6 # number of neighbors to travel
self.M = dataset_params['n']
self.N = dataset_params['n']
self.mapped_matrix_int = np.reshape(np.arange(0,len(world)), (self.N, self.M)) # should be positive for some reason
self.order_num_dist = None # should be used only for synthetic orders, we always generate orders ourselves
self.order_time_dist = None
self.order_price_dist = None
self.idle_driver_dist_time = None # [time, mean, std] -- we generate total number of drivers not randomly, but load them from generator
self.idle_driver_location_mat = idle_driver_locations
self.onoff_driver_location_mat = onoff_driver_locations
# collect all orders in one day and sample them
self.order_real = np.array(real_orders)
for i in np.arange(len(self.order_real)):
self.order_real[i][2] = self.order_real[i][2] % 144 # merge all together
self.order_sample_p = 1./self.days
def load_env_params(self):
'''
load complete dataset
note that orders are merged into a single day, and then sampled out of there
'''
dataset_params = self.params['dataset']
gen = Generator(self.params['tag'], dataset_params)
world, idle_driver_locations, real_orders, onoff_driver_locations, random_average, dist = gen.load_complete_set(dataset_id=self.params['dataset']['dataset_id'])
params = {
"world": world,
"orders": real_orders,
"order_sampling_rate": 1./self.days*self.params['dataset']['order_sampling_multiplier'],
"drivers_per_node": idle_driver_locations[0,:],
"n_intervals": self.params['dataset']['time_periods'],
"wc": self.params['wc'],
"count_neighbors": self.params['count_neighbors'] == 1,
"weight_poorest": self.params['weight_poorest'] == 1,
"normalize_rewards": self.params['normalize_rewards'] == 1,
"minimum_reward": self.params['minimum_reward'] == 1,
"include_income_to_observation": self.params['include_income_to_observation'] == 1,
"poorest_first": self.params.get("poorest_first", 0) == 1
}
return params
def test_chicago(self):
generator_params = {
"dataset_type": "chicago",
"days": 5,
"number_of_cars": 10,
'order_sampling_multiplier': 1
}
gen = Generator("testOrientedSolver", generator_params)
graph_info = gen.generate()
world_graph, idle_driver_locations, real_orders, \
onoff_driver_locations, random_average, dist = gen.load_complete_set()
solver_params = {
"dataset": graph_info,
"wc": 0.1,
"tag": "testOrientedSolver",
"count_neighbors": 1,
"weight_poorest": 0,
"normalize_rewards": 1,
"minimum_reward": 0,
"include_income_to_observation": 0,
"training_iterations": 10,
"testing_epochs": 2
}
solver = OrientedSolver(**solver_params)
solver.run()
def load_dataset(self):
'''
load complete dataset
note that orders are merged into a single day, and then sampled out of there
'''
dataset_params = self.params['dataset']
gen = Generator(self.params['tag'], dataset_params)
self.world, self.idle_driver_locations, self.real_orders, \
self.onoff_driver_locations, random_average, dist = gen.load_complete_set(dataset_id=self.params['dataset']['dataset_id'])
def test_include_observation(self):
generator_params = {
"dataset_type": "hexagon",
"n": 10,
"time_periods": 2,
"days": 2,
"orders_density": 2,
"number_of_cars": 200,
"order_distr": "star",
"order_sampling_multiplier": 1
}
gen = Generator("testTaxiEnvBatch", generator_params)
graph_info = gen.generate()
world_graph, idle_driver_locations, real_orders, \
onoff_driver_locations, random_average, dist = gen.load_complete_set()
# use OrigSolver as wrapper for params
orig_solver_params = {
"dataset": graph_info,
"alpha": 0.1,
"wc": 0,
"iterations": 1, # 1 epoch
"tag": "testTaxiEnvBatch",
"gamma": 0.9,
"order_sampling_multiplier": 1
}
ca2c_params = {
"dataset": graph_info,
"wc": 0,
"iterations": 1, # 1 epoch
"tag": "testTaxiEnvBatch",
"epsilon": 0.5,
"gamma": 0.9,
"learning_rate": 1e-3,
"count_neighbors": 1,
"weight_poorest": 0,
"normalize_rewards": 1,
"minimum_reward": 0,
"batch_size": 20,
"include_income_to_observation": 1,
"testing_epochs": 2
}
solv = cA2CSolver(**ca2c_params)
# driver+order dist + income + onehot node id + time
assert solv.env.observation_space_shape == ((2+3)*len(world_graph) + generator_params["time_periods"],)
observation = solv.env.reset()
init_info = solv.env.get_reset_info()
assert observation.shape == solv.env.observation_space_shape
curr_state, info, income_mat = solv.observation_to_old_fashioned_info(observation, init_info)
assert (income_mat == np.zeros((len(world_graph),3))).all()
solv.run()
def test_predict(self):
'''
Test predict function, that should return multidriver action for multidriver observation,
given the trained single driver model under stable-baselines framework
'''
generator_params = {
"dataset_type": "grid",
"n": 3,
"time_periods": 2, # should work for any network
"days": 2,
"orders_density": 10,
"number_of_cars": 10,
"order_distr": "star",
"order_sampling_multiplier": 1
}
gen = Generator("testGymSolver", generator_params)
graph_info = gen.generate()
world_graph, idle_driver_locations, real_orders, \
onoff_driver_locations, random_average, dist = gen.load_complete_set()
# use OrigSolver as wrapper for params
solver_params = {
"dataset": graph_info,
"wc": 0.1,
"tag": "testGymSolver",
"count_neighbors": 1,
"weight_poorest": 0,
"normalize_rewards": 1,
"minimum_reward": 0,
"include_income_to_observation": 0,
"num_cpu": 4,
"training_iterations": 1000, # check testing while training
"testing_epochs": 2
}
solver = GymSolver(**solver_params)
solver.train()
solver.save()
solver = GymSolver(**solver_params)
solver.load()
solver.test()
solver_params["include_income_to_observation"] = 1
solver_params["continuous_observation"] = 1
solver = GymSolver(**solver_params)
solver.run()
def generate_datasets(self, force=False):
if force:
self.db.dataset.delete_many({'tag': self.tag})
if self.db.dataset.find_one({'tag': self.tag}) != None:
logging.info("Dataset for {} has been found".format(self.tag))
return 0
total_datasets = list(self.pm.get_data_param_sets())
if len(total_datasets) == 0:
raise Exception("No datasets generated, bad parameter values")
generated = 0
for p in total_datasets:
gen = Generator(self.tag, p)
dataset_info = gen.generate()
self.db.dataset.insert_one(dataset_info)
generated += 1
return generated
if args.model_type != "a":
print("ok")
net = DeBlurSingleNet(input_shape=(args.size[0], args.size[1], 3),
model_type=args.model_type)
os.makedirs(save_folder, exist_ok=True)
net.train_model(
epochs=args.epochs,
folder_weights_save=save_folder,
path_weights_load=args.load_path,
generator=Generator(
folder_sharp_images=datasets_folder + "Training/" + "Sharp/",
folder_blurred_images=datasets_folder + "Training/" +
"Blurred/",
batch_size=args.batch_size,
image_exts=(".jpg", ".png", ".jpeg"),
shuffle=True),
generator_validation=Generator(
folder_sharp_images=datasets_folder + "Validation/" + "Sharp/",
folder_blurred_images=datasets_folder + "Validation/" +
"Blurred/",
batch_size=args.batch_size,
image_exts=(".jpg", ".png", ".jpeg"),
shuffle=True))
else:
net = DeBlurAdversarialNet(input_shape=(args.size[0], args.size[1], 3))
os.makedirs(save_folder, exist_ok=True)
def __init__(self):
self.generator = Generator()
self.tot_lists = 0
self.start_date = None
self.reverse = False
self.list_name = "List"
def test_init(self):
generator_params = {
"dataset_type": "hexagon",
"n": 10,
"time_periods": 144,
"days": 2,
"orders_density": 100,
"number_of_cars": 110,
"order_distr": "star",
"order_sampling_multiplier": 1
}
gen = Generator("testTaxiEnvBatch", generator_params)
graph_info = gen.generate()
world_graph, idle_driver_locations, real_orders, \
onoff_driver_locations, random_average, dist = gen.load_complete_set()
# use OrigSolver as wrapper for params
orig_solver_params = {
"dataset": graph_info,
"alpha": 0.1,
"wc": 0,
"iterations": 1, # 1 epoch
"tag": "testTaxiEnvBatch",
"gamma": 0.9
}
ca2c_params = {
"dataset": graph_info,
"wc": 0,
"iterations": 1, # 1 epoch
"tag": "testTaxiEnvBatch",
"epsilon": 0.5,
"gamma": 0.9,
"learning_rate": 1e-3,
"count_neighbors": 1,
"weight_poorest": 0,
"normalize_rewards": 1,
"minimum_reward": 0,
"batch_size": 2000,
"include_income_to_observation": 0,
"testing_epochs": 2
}
origSolv = OrigA2CSolver(**orig_solver_params)
solv = cA2CSolver(**ca2c_params)
init_observation = origSolv.env.reset_clean() # observation here is just driver and customer distributions
temp = np.array(origSolv.env.target_grids) + origSolv.env.M * origSolv.env.N
target_id_states = origSolv.env.target_grids + temp.tolist()
stateprocessor = stateProcessor(target_id_states, origSolv.env.target_grids,origSolv.env.n_valid_grids)
curr_s = stateprocessor.utility_conver_states(init_observation)
normalized_init_observation = stateprocessor.utility_normalize_states(curr_s)
init_observation2 = solv.env.reset() # observation here is a full set of drivers, customers, and context
assert (normalized_init_observation.flatten()[:len(world_graph)] == init_observation2[:len(world_graph)]).all()
mask = np.ones(len(world_graph))
mask[0] = 0
mask[9] = 0
mask[99] = 0
mask[90] = 0
A = normalized_init_observation.flatten()[len(world_graph):2*len(world_graph)] * mask
B = init_observation2[len(world_graph):2*len(world_graph)] * mask
assert (A == B).all() # might be a bit different on the corners as there is order sampling involved
solv.train()
origSolv.train()