def test_obs_traj(self):
map_filename = "external/bark_ml_project/bark_ml/environments/blueprints/highway/city_highway_straight.xodr"
params = ParameterServer()
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
env = HyDiscreteHighway(params=params,
map_filename=map_filename,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=True)
env.reset()
actions = np.random.randint(0, 7, 100)
for action in actions:
concatenated_state, _, _, _ = env.step(action)
nn_ip_state = concatenated_state
ego_nn_input_state = deepcopy(
concatenated_state[0:observer._len_ego_state])
reverted_observed_state = observer.rev_observe_for_ego_vehicle(
nn_ip_state)
ext_reverted_observed_state = np.zeros(
(reverted_observed_state.shape[0] + 1))
ext_reverted_observed_state[1:] = reverted_observed_state
renormed_ego_state = observer._select_state_by_index(
observer._norm(ext_reverted_observed_state))
time.sleep(0.2)
np.testing.assert_array_almost_equal(ego_nn_input_state,
renormed_ego_state)
def GetFeatureSpace(env):
"""This method extracts the observation feature space from the given environment.
Args:
env (gym.environment): The environment from which the feature space is extracted.
Returns:
FeatureSpace: The feature space with the low and high bounds set
"""
observation = env.reset()
observer = NearestAgentsObserver()
observer._max_num_vehicles = int(len(observation) / 4) - 1
observer.Reset(env._world)
space = list(
np.array([
observer._world_x_range, observer._world_y_range,
observer._ThetaRange, observer._VelocityRange
] * (observer._max_num_vehicles + 1)).transpose())
class FeatureSpace:
"""The feature space wrapper.
"""
def __init__(self, low, high):
"""Constructor
"""
self.high = high
self.low = low
return FeatureSpace(space[0], space[1])
def main():
args = configure_args()
if is_local:
dir_prefix = ""
else:
dir_prefix="hy-iqn-lfd-full-exp.runfiles/hythe/"
logging.info(f"Executing job: {args.jobname}")
logging.info(f"Experiment server at: {os.getcwd()}")
params = ParameterServer(filename=os.path.join(dir_prefix, params_file),
log_if_default=True)
params = configure_params(params, seed=args.jobname)
experiment_id = params["Experiment"]["random_seed"]
params_filename = os.path.join(params["Experiment"]["dir"], "params_{}.json".format(experiment_id))
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
# extract params and save experiment parameters
params["ML"]["BaseAgent"]["SummaryPath"] = os.path.join(params["Experiment"]["dir"], "agent/summaries")
params["ML"]["BaseAgent"]["CheckpointPath"] = os.path.join(params["Experiment"]["dir"], "agent/checkpoints")
params.Save(filename=params_filename)
logging.info('-' * 60)
logging.info("Writing params to :{}".format(params_filename))
logging.info('-' * 60)
# database creation
dbs1 = DatabaseSerializer(test_scenarios=1, test_world_steps=2,
num_serialize_scenarios=num_demo_scenarios)
dbs1.process(os.path.join(dir_prefix, "configuration/database"),
filter_sets="**/**/interaction_merging_light_dense_1D.json")
local_release_filename = dbs1.release(version="lfd_offline")
db1 = BenchmarkDatabase(database_root=local_release_filename)
scenario_generator1, _, _ = db1.get_scenario_generator(0)
env = HyDiscreteHighway(params=params,
scenario_generation=scenario_generator1,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=False)
scenario, _ = scenario_generator1.get_next_scenario()
world = scenario.GetWorldState()
observer.Reset(world)
assert env.action_space._n == 8, "Action Space is incorrect!"
run(args, params, env, db=db1)
params.Save(params_filename)
logging.info('-' * 60)
logging.info("Writing params to :{}".format(params_filename))
logging.info('-' * 60)
def simulate_scenario(param_server: ParameterServer, sim_time_step: float,
renderer: str = "") -> dict:
"""Simulates one scenario with the given parameters.
Args:
param_server (ParameterServer): The parameters that specify the scenario.
sim_time_step (float): The timestep used for the simulation.
renderer (str, optional): The renderer used during simulation [pygame, matplotlib]. Defaults to "".
Returns:
dict: The expert trajectories recorded during simulation.
"""
scenario, start_ts, end_ts = create_scenario(param_server)
sim_steps = int((end_ts - start_ts) / sim_time_step)
sim_time_step_seconds = sim_time_step / 1000
param_server["ML"]["StateObserver"]["MaxNumAgents"] = 3
observer = NearestAgentsObserver(param_server)
observer_not_normalized = NearestAgentsObserver(param_server)
observer_not_normalized._NormalizationEnabled = False
expert_trajectories = {}
viewer = None
if renderer:
viewer = get_viewer(param_server, renderer)
# Run the scenario in a loop
world_state = scenario.GetWorldState()
for i in range(0, sim_steps):
if i % 25 == 0:
print(f"Simulated {i}/{sim_steps} timesteps.")
if viewer:
if renderer == "matplotlib_jupyter":
viewer = get_viewer(param_server, renderer)
clear_output(wait=True)
viewer.clear()
viewer.drawWorld(world_state, scenario.eval_agent_ids)
observations = measure_world(
world_state, observer, observer_not_normalized)
for agent_id, values in observations.items():
if agent_id not in expert_trajectories:
expert_trajectories[agent_id] = defaultdict(list)
expert_trajectories[agent_id]["obs_norm"].append(values["obs_norm"])
expert_trajectories[agent_id]["obs"].append(values["obs"])
expert_trajectories[agent_id]["time"].append(values["time"])
expert_trajectories[agent_id]["wheelbase"].append(2.7)
world_state.Step(sim_time_step_seconds)
if viewer:
plt.close()
return expert_trajectories
def test_iqn_agent(self):
params = ParameterServer()
params["ML"]["BaseAgent"]["NumSteps"] = 2
params["ML"]["BaseAgent"]["MaxEpisodeSteps"] = 2
bp = DiscreteHighwayBlueprint(params,
number_of_senarios=10,
random_seed=0)
env = SingleAgentRuntime(blueprint=bp, render=False)
env._observer = NearestAgentsObserver(params)
env._action_wrapper = BehaviorDiscreteMacroActionsML(params)
iqn_agent = IQNAgent(agent_save_dir="./save_dir",
env=env,
params=params)
iqn_agent.train_episode()
iqn_agent.save(checkpoint_type="best")
iqn_agent.save(checkpoint_type="last")
loaded_agent = IQNAgent(agent_save_dir="./save_dir",
checkpoint_load="best")
loaded_agent2 = IQNAgent(agent_save_dir="./save_dir",
checkpoint_load="last")
loaded_agent_with_env = IQNAgent(env=env,
agent_save_dir="./save_dir",
checkpoint_load="last")
loaded_agent_with_env.train_episode()
self.assertEqual(loaded_agent.ml_behavior.action_space.n,
iqn_agent.ml_behavior.action_space.n)
return
def test_create_environment(self):
map_interface = self.map_interface
observer = NearestAgentsObserver()
env = ExternalRuntime(map_interface=map_interface,
observer=observer,
params=self.params)
self.assertTrue(isinstance(env.observation_space, gym.spaces.box.Box))
def test_collect_demonstrations(self):
params = ParameterServer()
bp = DiscreteHighwayBlueprint(params,
number_of_senarios=10,
random_seed=0)
env = SingleAgentRuntime(blueprint=bp, render=False)
env._observer = NearestAgentsObserver(params)
env._action_wrapper = BehaviorDiscreteMacroActionsML(params)
env._evaluator = TestEvaluator()
demo_behavior = bark_ml.library_wrappers.lib_fqf_iqn_qrdqn.\
tests.test_demo_behavior.TestDemoBehavior(params)
collector = DemonstrationCollector()
collection_result = collector.CollectDemonstrations(env, demo_behavior, 4, "./test_demo_collected", \
use_mp_runner=False, runner_init_params={"deepcopy" : False})
self.assertTrue(
os.path.exists("./test_demo_collected/collection_result"))
print(collection_result.get_data_frame().to_string())
experiences = collector.ProcessCollectionResult(
eval_criteria={"goal_r1": lambda x: x})
# expected length = 2 scenarios (only every second reaches goal) x 3 steps (4 executed, but first not counted)
self.assertEqual(len(experiences), 2 * 3)
collector.dump("./final_collections")
loaded_collector = DemonstrationCollector.load("./final_collections")
experiences_loaded = loaded_collector.GetDemonstrationExperiences()
print(experiences_loaded)
self.assertEqual(len(experiences_loaded), 2 * 3)
def test_nearest_observer(self):
params = ParameterServer()
bp = ContinuousHighwayBlueprint(params)
env = SingleAgentRuntime(blueprint=bp, render=True)
env.reset()
world = env._world
# under test
observer = NearestAgentsObserver(params)
eval_id = env._scenario._eval_agent_ids[0]
observed_world = world.Observe([eval_id])[0]
start_time = time.time()
observed_state = observer.Observe(observed_world)
end_time = time.time()
print(f"It took {end_time-start_time} seconds.")
print(observed_state, observer.observation_space.shape)
def create_runtime_and_setup_empty_world(self, params):
map_interface = self.map_interface
observer = NearestAgentsObserver()
env = ExternalRuntime(map_interface=map_interface,
observer=observer,
params=params,
viewer=viewer)
env.setupWorld()
return env
def main():
map_filename = "external/bark_ml_project/bark_ml/environments/blueprints/highway/city_highway_straight.xodr"
params_filename = glob.glob(os.path.join(demo_root, "params_[!behavior]*"))
params = ParameterServer(filename=params_filename[0], log_if_default=True)
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
if is_belief_observer:
splits = 2
bparams_filename = glob.glob(os.path.join(demo_root, "behavior_*"))
params_behavior = ParameterServer(filename=bparams_filename[0])
behavior_space = BehaviorSpace(params_behavior)
hypothesis_set, hypothesis_params = behavior_space.create_hypothesis_set_fixed_split(
split=splits)
observer = BeliefObserver(params, hypothesis_set, splits=splits)
else:
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
env = HyDiscreteHighway(params=params,
map_filename=map_filename,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=False)
env.reset()
ego_world_states = []
_, demonstrations = unpack_load_demonstrations(demo_root)
for demo in demonstrations:
ego_state = np.zeros((observer._len_ego_state + 1))
(nn_ip_state, action, reward, next_state, done, is_demo) = demo
ego_nn_input_state = deepcopy(nn_ip_state[0:observer._len_ego_state])
ego_state[1:] = ego_nn_input_state
reverted_observed_state = observer.rev_observe_for_ego_vehicle(
ego_state)
ego_world_states.append(
(reverted_observed_state[int(StateDefinition.X_POSITION)],
reverted_observed_state[int(StateDefinition.Y_POSITION)],
reverted_observed_state[int(StateDefinition.THETA_POSITION)],
reverted_observed_state[int(StateDefinition.VEL_POSITION)],
action, int(is_demo)))
df = pd.DataFrame(ego_world_states,
columns=[
'pos_x', 'pos_y', 'orientation', 'velocity',
'action', 'is_demo'
])
print(df.head(10))
df.to_pickle(os.path.join(demo_root, "demonstrations/demo_dataframe"))
return
def test_create_sac_agent(self):
params = ParameterServer()
map_interface = self.map_interface
observer = NearestAgentsObserver()
env = ExternalRuntime(map_interface=map_interface,
observer=observer,
params=params)
env.ml_behavior = BehaviorContinuousML(params)
sac_agent = BehaviorSACAgent(environment=env, params=params)
env.ml_behavior = sac_agent
self.assertTrue(isinstance(env.ml_behavior, BehaviorSACAgent))
def test_agent_wrapping(self):
params = ParameterServer()
env = gym.make("highway-v1", params=params)
env._observer = NearestAgentsObserver(params)
env.reset()
params["ML"]["BaseAgent"]["MaxEpisodeSteps"] = 2
params["ML"]["BaseAgent"]["NumEvalEpisodes"] = 2
train_bench = TrainingBenchmarkDatabase()
agent = FQFAgent(env=env,
params=params,
agent_save_dir="./temp_save",
training_benchmark=train_bench)
agent.train_episode()
agent.evaluate()
def main():
args = configure_args()
exp_dir = args.exp_dir or "results/training/toy_evaluation"
params_filename = glob.glob(os.path.join(exp_dir, "params_*"))
params = ParameterServer(filename=params_filename[0])
behavior_params_filename = glob.glob(
os.path.join(exp_dir, "behavior_params*"))
if behavior_params_filename:
splits = 8
behavior_params = ParameterServer(filename=behavior_params_filename[0])
behavior_space = BehaviorSpace(behavior_params)
hypothesis_set, _ = behavior_space.create_hypothesis_set_fixed_split(
split=splits)
observer = BeliefObserver(params, hypothesis_set, splits=splits)
behavior = BehaviorDiscreteMacroActionsML(behavior_params)
else:
behavior = BehaviorDiscreteMacroActionsML(params)
observer = NearestAgentsObserver(params)
evaluator = GoalReached(params)
scenario_params = ParameterServer(
filename=
"configuration/database/scenario_sets/interaction_merging_light_dense_1D.json"
)
scenario_generator = ConfigurableScenarioGeneration(params=scenario_params,
num_scenarios=5)
scenario_file = glob.glob(os.path.join(exp_dir, "scenarios_list*"))
scenario_generator.load_scenario_list(scenario_file[0])
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
env = HyDiscreteHighway(behavior=behavior,
observer=observer,
evaluator=evaluator,
viewer=viewer,
scenario_generation=scenario_generator,
render=True)
env.reset()
actions = [0, 1, 2, 3, 4, 5, 6]
for action in actions:
print(action)
env.step(action)
agent = FQFAgent(env=env, test_env=env, params=params)
agent.load_models(os.path.join(exp_dir, "agent/checkpoints/final"))
def test_env(self):
map_filename = "external/bark_ml_project/bark_ml/environments/blueprints/highway/city_highway_straight.xodr"
params = ParameterServer()
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
env = HyDiscreteHighway(params=params,
map_filename=map_filename,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=True)
env.reset()
actions = [5] * 100
print(actions)
for action in actions:
env.step(action)
time.sleep(0.2)
return
def __init__(self,
params=None,
ml_behavior=None,
num_scenarios=100,
viewer=True):
# NOTE: scneario number is wrong
scenario_generation = ConfigurableScenarioGeneration(
num_scenarios=num_scenarios, params=params)
if viewer:
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
dt = 0.2
# NOTE: evaluator and observer could be overwritten
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
ml_behavior = ml_behavior
super().__init__(scenario_generation=scenario_generation,
viewer=viewer,
dt=dt,
evaluator=evaluator,
observer=observer,
ml_behavior=ml_behavior)
def main():
print("Experiment server at:", os.getcwd())
params = ParameterServer(
filename=
"hy-exp-run.runfiles/hythe/configuration/params/default_exp_runne_params.json"
)
params = configure_params(params)
num_scenarios = 5
random_seed = 0
behavior = BehaviorDiscreteMacroActionsML(params)
# evaluator = GoalReachedGuiding(params)
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
experiment_id = params["Experiment"]["random_seed"]
params_filename = "./{}_default_exp_runner_params.json".format(
experiment_id)
print(params_filename)
params.Save(filename=params_filename)
# database creation
dbs = DatabaseSerializer(
test_scenarios=2, test_world_steps=2, num_serialize_scenarios=20
) # increase the number of serialize scenarios to 100
dbs.process("hy-exp-run.runfiles/hythe/configuration/database")
local_release_filename = dbs.release(version="test",
sub_dir="hy_bark_packaged_databases")
db = BenchmarkDatabase(database_root=local_release_filename)
# switch this to other generator to get other index
# scenario_generator, _, _ = db.get_scenario_generator(0)
scenario_generator, _, _ = db.get_scenario_generator(1)
#
# env = GymSingleAgentRuntime(ml_behavior = behavior,
# observer = observer,
# evaluator = evaluator,
# step_time=0.2,
# viewer=viewer,
# scenario_generator=scenario_generator,
# render=False)
env = HyDiscreteHighway(params=params,
scenario_generation=scenario_generator,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=False)
run(params, env)
# video_renderer.drawWorld(env._world)
env._viewer.export_video("./test_video")
# from gym.envs.registration import register
# register(
# id='highway-v1',
# entry_point='bark_ml.environments.gym:DiscreteHighwayGym'
# )
# import gym
# env = gym.make("highway-v1")
# env.reset()
# actions = [5]*100
# print(actions)
# for action in actions:
# env.step(action)
# time.sleep(0.2)
return
def __init__(self,
params=None,
num_scenarios=250,
random_seed=0,
ml_behavior=None,
viewer=True,
mode="dense"):
params["BehaviorIDMClassic"]["BrakeForLaneEnd"] = True
params["BehaviorIDMClassic"]["BrakeForLaneEndEnabledDistance"] = 100.
params["BehaviorIDMClassic"]["BrakeForLaneEndDistanceOffset"] = 30.
params["BehaviorIDMClassic"]["DesiredVelocity"] = 10.
params["World"]["remove_agents_out_of_map"] = False
# TODO: modify dense
# ds_min and ds_max
if mode == "dense":
ds_min = 7.
ds_max = 12.
if mode == "medium":
ds_min = 12.
ds_max = 17.
left_lane = MergingLaneCorridorConfig(params=params,
road_ids=[0, 1],
ds_min=ds_min,
ds_max=ds_max,
min_vel=9.,
max_vel=11.,
s_min=5.,
s_max=45.,
lane_corridor_id=0,
controlled_ids=None)
right_lane = MergingLaneCorridorConfig(params=params,
road_ids=[0, 1],
lane_corridor_id=1,
ds_min=ds_min,
ds_max=ds_max,
s_min=5.,
s_max=25.,
min_vel=9.,
max_vel=11.,
controlled_ids=True)
scenario_generation = \
ConfigWithEase(
num_scenarios=num_scenarios,
map_file_name=os.path.join(os.path.dirname(__file__), "../../../environments/blueprints/merging/DR_DEU_Merging_MT_v01_centered.xodr"), # pylint: disable=unused-import
random_seed=random_seed,
params=params,
lane_corridor_configs=[left_lane, right_lane])
if viewer:
viewer = BufferedMPViewer(params=params,
x_range=[-25, 25],
y_range=[-25, 25],
follow_agent_id=True)
dt = 0.2
params["ML"]["RewardShapingEvaluator"]["PotentialVelocityFunctor"][
"DesiredVel", "Desired velocity for the ego agent.", 20]
evaluator = RewardShapingEvaluator(params)
observer = NearestAgentsObserver(params)
ml_behavior = ml_behavior
super().__init__(scenario_generation=scenario_generation,
viewer=viewer,
dt=dt,
evaluator=evaluator,
observer=observer,
ml_behavior=ml_behavior)
def main():
map_filename = "external/bark_ml_project/bark_ml/environments/blueprints/highway/city_highway_straight.xodr"
params = ParameterServer(filename=os.path.join(
exp_root, "params_iqn_pre_exp_2sdi64.json"),
log_if_default=True)
params_behavior = ParameterServer(filename=os.path.join(
exp_root, "behavior_params_iqn_pre_exp_2sdi64.json"))
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
if is_belief_observer:
splits = 2
behavior_space = BehaviorSpace(params_behavior)
hypothesis_set, hypothesis_params = behavior_space.create_hypothesis_set_fixed_split(
split=splits)
observer = BeliefObserver(params, hypothesis_set, splits=splits)
else:
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
# database creation
dbs1 = DatabaseSerializer(test_scenarios=1,
test_world_steps=2,
num_serialize_scenarios=1)
dbs1.process(os.path.join("", "configuration/database"),
filter_sets="**/**/interaction_merging_light_dense_1D.json")
local_release_filename = dbs1.release(version="lfd_offline")
db1 = BenchmarkDatabase(database_root=local_release_filename)
scenario_generator1, _, _ = db1.get_scenario_generator(0)
env = HyDiscreteHighway(params=params,
scenario_generation=scenario_generator1,
map_filename=map_filename,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=False)
scenario, _ = scenario_generator1.get_next_scenario()
world = scenario.GetWorldState()
observer.Reset(world)
env.reset()
agent = pick_agent(exp_root, env, params)
ego_world_states = []
memory = agent.memory
learned_states = memory["state"]
actions = memory['action']
is_demos = memory['is_demo']
for state, action, is_demo in zip(learned_states, actions, is_demos):
ego_state = np.zeros((observer._len_ego_state + 1))
ego_nn_input_state = deepcopy(state[0:observer._len_ego_state])
ego_state[1:] = ego_nn_input_state
reverted_observed_state = observer.rev_observe_for_ego_vehicle(
ego_state)
ego_world_states.append(
(reverted_observed_state[int(StateDefinition.X_POSITION)],
reverted_observed_state[int(StateDefinition.Y_POSITION)],
reverted_observed_state[int(StateDefinition.THETA_POSITION)],
reverted_observed_state[int(StateDefinition.VEL_POSITION)],
action[0], is_demo[0]))
df = pd.DataFrame(ego_world_states,
columns=[
'pos_x', 'pos_y', 'orientation', 'velocity',
'action', 'is_demo'
])
print(df.head(10))
if not os.path.exists(os.path.join(exp_root, "demonstrations")):
os.makedirs(os.path.join(exp_root, "demonstrations"))
df.to_pickle(os.path.join(exp_root, "demonstrations", "learned_dataframe"))
return
from bark_ml.environments.single_agent_runtime import SingleAgentRuntime
from bark_ml.observers.nearest_state_observer import NearestAgentsObserver
from bark_ml.environments.blueprints import DiscreteMergingBlueprint
# create scenario
if not os.path.exists("examples"):
logging.info("changing directory")
os.chdir("diadem_dqn.runfiles/bark_ml")
bark_params = ParameterServer(
filename="examples/example_params/diadem_params.json")
bp = DiscreteMergingBlueprint(bark_params,
number_of_senarios=100,
random_seed=0)
observer = NearestAgentsObserver(bark_params)
runtime = SingleAgentRuntime(blueprint=bp, observer=observer, render=True)
def run_dqn_algorithm(parameter_files):
exp_dir = "tmp_exp_dir"
diadem_params = Params(filename=parameter_files)
config_logging(console=True)
environment = DiademBarkEnvironment(runtime=runtime)
context = AgentContext(environment=environment,
datamanager=None,
preprocessor=None,
optimizer=tf.train.AdamOptimizer,
summary_service=PandasSummary())
agent = AgentManager(params=diadem_params, context=context)
def main():
args = configure_args()
if is_local:
dir_prefix = ""
else:
dir_prefix = "hy-iqn-exp.runfiles/hythe/"
print("Executing job :", args.jobname)
print("Experiment server at :", os.getcwd())
params = ParameterServer(filename=os.path.join(
dir_prefix, "configuration/params/iqn_params.json"),
log_if_default=True)
params = configure_params(params, seed=args.jobname)
experiment_id = params["Experiment"]["random_seed"]
params_filename = os.path.join(params["Experiment"]["dir"],
"params_{}.json".format(experiment_id))
# check if exp exists and handle preemption
exp_exists = check_if_exp_exists(params)
if exp_exists:
print("Loading existing experiment from: {}".format(
args.jobname, (params["Experiment"]["dir"])))
if os.path.isfile(params_filename):
params = ParameterServer(filename=params_filename,
log_if_default=True)
else:
Path(params["Experiment"]["dir"]).mkdir(parents=True, exist_ok=True)
behavior = BehaviorDiscreteMacroActionsML(params)
evaluator = GoalReached(params)
observer = NearestAgentsObserver(params)
viewer = MPViewer(params=params,
x_range=[-35, 35],
y_range=[-35, 35],
follow_agent_id=True)
# extract params and save experiment parameters
params["ML"]["BaseAgent"]["SummaryPath"] = os.path.join(
params["Experiment"]["dir"], "agent/summaries")
params["ML"]["BaseAgent"]["CheckpointPath"] = os.path.join(
params["Experiment"]["dir"], "agent/checkpoints")
params.Save(filename=params_filename)
logging.info('-' * 60)
logging.info("Writing params to :{}".format(params_filename))
logging.info('-' * 60)
# database creation
dbs = DatabaseSerializer(test_scenarios=2,
test_world_steps=2,
num_serialize_scenarios=num_scenarios)
dbs.process(os.path.join(dir_prefix, "configuration/database"),
filter_sets="**/**/interaction_merging_light_dense_1D.json")
local_release_filename = dbs.release(version="test")
db = BenchmarkDatabase(database_root=local_release_filename)
scenario_generator, _, _ = db.get_scenario_generator(0)
env = HyDiscreteHighway(params=params,
scenario_generation=scenario_generator,
behavior=behavior,
evaluator=evaluator,
observer=observer,
viewer=viewer,
render=False)
assert env.action_space._n == 8, "Action Space is incorrect!"
run(params, env, exp_exists)
params.Save(params_filename)
logging.info('-' * 60)
logging.info("Writing params to :{}".format(params_filename))
logging.info('-' * 60)
def __init__(self,
params=None,
num_scenarios=250,
random_seed=0,
ml_behavior=None,
viewer=True):
lane_corridors = []
lane_corridors.append(
IntersectionLaneCorridorConfig(
params=params,
source_pos=[-40, -3],
sink_pos=[40, -3],
behavior_model=BehaviorMobilRuleBased(params),
min_vel=10.,
max_vel=12.,
ds_min=10.,
ds_max=25.,
s_min=5.,
s_max=50.,
controlled_ids=None))
lane_corridors.append(
IntersectionLaneCorridorConfig(
params=params,
source_pos=[40, 3],
sink_pos=[-40, 3],
behavior_model=BehaviorMobilRuleBased(params),
min_vel=10.,
max_vel=12.,
ds_min=15.,
ds_max=25.,
s_min=5.,
s_max=50.,
controlled_ids=None))
lane_corridors.append(
IntersectionLaneCorridorConfig(
params=params,
source_pos=[3, -30],
sink_pos=[-40, 3],
behavior_model=BehaviorMobilRuleBased(params),
min_vel=5.,
max_vel=10.,
ds_min=40.,
ds_max=40.,
s_min=30.,
s_max=40.,
controlled_ids=True))
scenario_generation = \
ConfigWithEase(
num_scenarios=num_scenarios,
map_file_name=os.path.join(os.path.dirname(__file__), "../../../environments/blueprints/intersection/4way_intersection.xodr"), # pylint: disable=unused-import
random_seed=random_seed,
params=params,
lane_corridor_configs=lane_corridors)
if viewer:
viewer = BufferedMPViewer(params=params,
x_range=[-30, 30],
y_range=[-30, 30],
follow_agent_id=True)
dt = 0.2
params["ML"]["RewardShapingEvaluator"]["PotentialVelocityFunctor"][
"DesiredVel", "Desired velocity for the ego agent.", 6]
evaluator = RewardShapingEvaluator(params)
observer = NearestAgentsObserver(params)
ml_behavior = ml_behavior
super().__init__(scenario_generation=scenario_generation,
viewer=viewer,
dt=dt,
evaluator=evaluator,
observer=observer,
ml_behavior=ml_behavior)
scenario_generator, _, _ = db.get_scenario_generator(0)
# load belief observer specifics
if is_belief_observer:
splits = 2
behavior_params_filename = glob.glob(os.path.join(exp_dir, "behavior_params*"))[0]
params_behavior = ParameterServer(filename=behavior_params_filename, log_if_default=True)
behavior_space = BehaviorSpace(params_behavior)
hypothesis_set, hypothesis_params = behavior_space.create_hypothesis_set_fixed_split(split=splits)
observer = BeliefObserver(params, hypothesis_set, splits=splits)
behavior = BehaviorDiscreteMacroActionsML(params_behavior)
# if not, load default observer
else:
behavior = BehaviorDiscreteMacroActionsML(params)
observer = NearestAgentsObserver(params)
evaluator = GoalReached(params)
viewer = MPViewer(
params=params,
center= [960, 1000.8],
enforce_x_length=True,
x_length = 100.0,
use_world_bounds=False)
# load env
env = HyDiscreteHighway(params=params,
scenario_generation=scenario_generator,
behavior=behavior,
evaluator=evaluator,
