def start():
"""Start a environment object with ray."""
sumo_params = SumoParams(sim_step=0.1, render=False)
vehicles = Vehicles()
vehicles.add(
veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(
name="sugiyama",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
env._close()
def followerstopper_example(render=None):
"""Perform a simulation of vehicles on a ring road.
In this simulation, one vehicle is automated, and switches from
human-driving to begins to automated vehicles after the time specified in
AUTOMATED_TIME.
Parameters
----------
render : bool, optional
specifies whether to use the gui during execution
Returns
-------
exp: flow.core.experiment.Experiment
A non-rl experiment demonstrating the performance of human-driven
vehicles on a ring road.
"""
sim_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(veh_id='automated',
acceleration_controller=(FollowerStopper, {
'v_des': 4.15
}),
car_following_params=SumoCarFollowingParams(accel=1),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1)
vehicles.add(veh_id='human',
acceleration_controller=(IDMController, {
'noise': 0.2
}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=21)
env_params = EnvParams(
additional_params={'automated_time': AUTOMATED_TIME})
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
additional_net_params['length'] = LENGTH
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = LoopScenario(name='sugiyama',
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = ControllerEnv(env_params, sim_params, scenario)
return Experiment(env)
def sugiyama_example(render=None):
"""
Perform a simulation of vehicles on a ring road.
Parameters
----------
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.Experiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on a ring road.
"""
sumo_params = SumoParams(sim_step=SUMO_STEP, render=True)
if render is not None:
sumo_params.render = render
vehicles = VehicleParams()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=8)
# in sugiyama taken from .../flow/scenarios/loop/loop_accel.py
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
# in sugiyama taken from .../flow/scenarios/loop.py
net_params = NetParams(additional_params=ADDITIONAL_NET_PARAMS)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(name="sugiyama",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
return Experiment(env)
def sugiyama_example(render=None):
"""
Perform a simulation of vehicles on a ring road.
Parameters
----------
render : bool, optional
specifies whether to use the gui during execution
Returns
-------
exp: flow.core.experiment.Experiment
A non-rl experiment demonstrating the performance of human-driven
vehicles on a ring road.
"""
sim_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(
veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(
name="sugiyama",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sim_params, scenario)
return Experiment(env)
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
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(),