def run_task(*_):
"""Implement the run_task method needed to run experiments with rllab."""
sim_params = SumoParams(sim_step=0.1, render=False)
vehicles = VehicleParams()
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1)
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=21)
additional_env_params = {
"ring_length": [220, 270],
"max_accel": 1,
"max_decel": 1
}
env_params = EnvParams(horizon=HORIZON,
additional_params=additional_env_params,
warmup_steps=750)
additional_net_params = {
"length": 260,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(spacing="uniform", bunching=50)
scenario = LoopScenario(exp_tag,
vehicles,
net_params,
initial_config=initial_config)
env_name = "WaveAttenuationPOEnv"
pass_params = (env_name, sim_params, vehicles, env_params, net_params,
initial_config, scenario)
env = GymEnv(env_name, record_video=False, register_params=pass_params)
horizon = env.horizon
env = normalize(env)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(3, 3),
)
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=60000,
max_path_length=horizon,
n_itr=500,
# whole_paths=True,
discount=0.999,
# step_size=v["step_size"],
)
algo.train(),
def ring_road_exp_setup(sim_params=None,
vehicles=None,
env_params=None,
net_params=None,
initial_config=None,
traffic_lights=None):
"""
Create an environment and scenario pair for ring road test experiments.
Parameters
----------
sim_params : flow.core.params.SumoParams
sumo-related configuration parameters, defaults to a time step of 0.1s
and no sumo-imposed failsafe on human or rl vehicles
vehicles : Vehicles type
vehicles to be placed in the network, default is one vehicles with an
IDM acceleration controller and ContinuousRouter routing controller.
env_params : flow.core.params.EnvParams
environment-specific parameters, defaults to a environment with no
failsafes, where other parameters do not matter for non-rl runs
net_params : flow.core.params.NetParams
network-specific configuration parameters, defaults to a single lane
ring road of length 230 m
initial_config : flow.core.params.InitialConfig
specifies starting positions of vehicles, defaults to evenly
distributed vehicles across the length of the network
traffic_lights : flow.core.params.TrafficLightParams
traffic light signals, defaults to no traffic lights in the network
"""
logging.basicConfig(level=logging.WARNING)
if sim_params is None:
# set default sim_params configuration
sim_params = SumoParams(sim_step=0.1, render=False)
if vehicles is None:
# set default vehicles configuration
vehicles = VehicleParams()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="aggressive", ),
num_vehicles=1)
if env_params is None:
# set default env_params configuration
additional_env_params = {
"target_velocity": 8,
"max_accel": 1,
"max_decel": 1,
"sort_vehicles": False,
}
env_params = EnvParams(additional_params=additional_env_params)
if net_params is None:
# set default net_params configuration
additional_net_params = {
"length": 230,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(additional_params=additional_net_params)
if initial_config is None:
# set default initial_config configuration
initial_config = InitialConfig(lanes_distribution=1)
if traffic_lights is None:
# set default to no traffic lights
traffic_lights = TrafficLightParams()
# create the scenario
scenario = LoopScenario(name="RingRoadTest",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# create the environment
env = AccelEnv(env_params=env_params,
sim_params=sim_params,
scenario=scenario)
# reset the environment
env.reset()
return env, scenario
