def grid0_baseline(num_runs, sumo_binary="sumo-gui"):
"""Run script for the grid0 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
sumo_binary: str, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
# we place a sufficient number of vehicles to ensure they confirm with the
# total number specified above. We also use a "right_of_way" speed mode to
# support traffic light compliance
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
sumo_car_following_params=SumoCarFollowingParams(
min_gap=2.5,
max_speed=V_ENTER,
),
routing_controller=(GridRouter, {}),
num_vehicles=(N_LEFT + N_RIGHT) * N_COLUMNS +
(N_BOTTOM + N_TOP) * N_ROWS,
speed_mode="right_of_way")
# inflows of vehicles are place on all outer edges (listed here)
outer_edges = []
outer_edges += ["left{}_{}".format(N_ROWS, i) for i in range(N_COLUMNS)]
outer_edges += ["right0_{}".format(i) for i in range(N_ROWS)]
outer_edges += ["bot{}_0".format(i) for i in range(N_ROWS)]
outer_edges += ["top{}_{}".format(i, N_COLUMNS) for i in range(N_ROWS)]
# equal inflows for each edge (as dictate by the EDGE_INFLOW constant)
inflow = InFlows()
for edge in outer_edges:
inflow.add(veh_type="human",
edge=edge,
vehs_per_hour=EDGE_INFLOW,
departLane="free",
departSpeed="max")
# define the traffic light logic
tl_logic = TrafficLights(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGGrrrGGGrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyrrryyyrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrGGGrrrGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrryyyrrryyy"
}]
for i in range(N_ROWS * N_COLUMNS):
tl_logic.add("center" + str(i),
tls_type="actuated",
phases=phases,
programID=1)
net_params = NetParams(
in_flows=inflow,
no_internal_links=False,
additional_params={
"speed_limit": V_ENTER + 5,
"grid_array": {
"short_length": SHORT_LENGTH,
"inner_length": INNER_LENGTH,
"long_length": LONG_LENGTH,
"row_num": N_ROWS,
"col_num": N_COLUMNS,
"cars_left": N_LEFT,
"cars_right": N_RIGHT,
"cars_top": N_TOP,
"cars_bot": N_BOTTOM,
},
"horizontal_lanes": 1,
"vertical_lanes": 1,
},
)
sumo_params = SumoParams(
restart_instance=False,
sim_step=1,
sumo_binary=sumo_binary,
)
env_params = EnvParams(
evaluate=True, # Set to True to evaluate traffic metrics
horizon=HORIZON,
additional_params={
"switch_time": 2.0,
"num_observed": 2,
"tl_type": "actuated",
},
)
initial_config = InitialConfig(shuffle=True)
scenario = SimpleGridScenario(name="grid",
generator_class=SimpleGridGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = PO_TrafficLightGridEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
total_delay = np.mean(results["returns"])
return total_delay
def bottleneck1_baseline(num_runs, sumo_binary="sumo-gui"):
"""Run script for the bottleneck1 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
sumo_binary: str, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
vehicles = Vehicles()
vehicles.add(veh_id="human",
speed_mode=9,
routing_controller=(ContinuousRouter, {}),
lane_change_mode=1621,
num_vehicles=1 * SCALING)
controlled_segments = [("1", 1, False), ("2", 2, True), ("3", 2, True),
("4", 2, True), ("5", 1, False)]
num_observed_segments = [("1", 1), ("2", 3), ("3", 3), ("4", 3), ("5", 1)]
additional_env_params = {
"target_velocity": 40,
"disable_tb": True,
"disable_ramp_metering": True,
"controlled_segments": controlled_segments,
"symmetric": False,
"observed_segments": num_observed_segments,
"reset_inflow": False,
"lane_change_duration": 5,
"max_accel": 3,
"max_decel": 3,
"inflow_range": [1000, 2000]
}
# flow rate
flow_rate = 1900 * SCALING
# percentage of flow coming out of each lane
inflow = InFlows()
inflow.add(veh_type="human",
edge="1",
vehs_per_hour=flow_rate,
departLane="random",
departSpeed=10)
traffic_lights = TrafficLights()
if not DISABLE_TB:
traffic_lights.add(node_id="2")
if not DISABLE_RAMP_METER:
traffic_lights.add(node_id="3")
additional_net_params = {"scaling": SCALING}
net_params = NetParams(in_flows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
sumo_params = SumoParams(
sim_step=0.5,
sumo_binary=sumo_binary,
print_warnings=False,
restart_instance=False,
)
env_params = EnvParams(
evaluate=True, # Set to True to evaluate traffic metrics
warmup_steps=40,
sims_per_step=1,
horizon=HORIZON,
additional_params=additional_env_params,
)
initial_config = InitialConfig(
spacing="uniform",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"],
)
scenario = BottleneckScenario(name="bay_bridge_toll",
generator_class=BottleneckGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = DesiredVelocityEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
avg_outflow = np.mean(
[outflow[-1] for outflow in results["per_step_returns"]])
return avg_outflow
def evaluate_policy(benchmark, _get_actions, _get_states=None):
"""Evaluate the performance of a controller on a predefined benchmark.
Parameters
----------
benchmark : str
name of the benchmark, must be printed as it is in the
benchmarks folder; otherwise a ValueError will be raised
_get_actions : method
the mapping from states to actions for the RL agent(s)
_get_states : method, optional
a mapping from the environment object in Flow to some state, which
overrides the _get_states method of the environment. Note that the
same cannot be done for the actions.
Returns
-------
float
mean of the evaluation return of the benchmark from NUM_RUNS number
of simulations
float
standard deviation of the evaluation return of the benchmark from
NUM_RUNS number of simulations
Raises
------
ValueError
If the specified benchmark is not available.
"""
if benchmark not in AVAILABLE_BENCHMARKS.keys():
raise ValueError(
"benchmark {} is not available. Check spelling?".format(benchmark))
# get the flow params from the benchmark
flow_params = AVAILABLE_BENCHMARKS[benchmark]
exp_tag = flow_params["exp_tag"]
sumo_params = flow_params["sumo"]
vehicles = flow_params["veh"]
env_params = flow_params["env"]
env_params.evaluate = True # Set to true to get evaluation returns
net_params = flow_params["net"]
initial_config = flow_params.get("initial", InitialConfig())
traffic_lights = flow_params.get("tls", TrafficLights())
# import the environment, scenario, and generator classes
module = __import__("flow.envs", fromlist=[flow_params["env_name"]])
env_class = getattr(module, flow_params["env_name"])
module = __import__("flow.scenarios", fromlist=[flow_params["scenario"]])
scenario_class = getattr(module, flow_params["scenario"])
module = __import__("flow.scenarios", fromlist=[flow_params["generator"]])
generator_class = getattr(module, flow_params["generator"])
# recreate the scenario and environment
scenario = scenario_class(name=exp_tag,
generator_class=generator_class,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# make sure the _get_states method of the environment is the one
# specified by the user
if _get_states is not None:
class _env_class(env_class):
def get_state(self):
return _get_states(self)
env_class = _env_class
env = env_class(env_params=env_params,
sumo_params=sumo_params,
scenario=scenario)
# create a SumoExperiment object with the "rl_actions" method as
# described in the inputs. Note that the state may not be that which is
# specified by the environment.
exp = SumoExperiment(env=env, scenario=scenario)
# run the experiment and return the reward
res = exp.run(num_runs=NUM_RUNS,
num_steps=env.env_params.horizon,
rl_actions=_get_actions)
return np.mean(res["returns"]), np.std(res["returns"])
def merge_example(render=None):
"""
Perform a simulation of vehicles on a merge.
Parameters
----------
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on a merge.
"""
sumo_params = SumoParams(
render=True,
emission_path="./data/",
sim_step=0.2,
restart_instance=False,
lateral_resolution=0.2,
)
if render is not None:
sumo_params.render = render
vehicles = Vehicles()
vehicles.add(
veh_id="1",
acceleration_controller=(
IDMController,
{
# "noise": 0.2
}),
routing_controller=(WeaveRouter, {}),
speed_mode="all_checks",
lane_change_mode="strategic",
num_vehicles=5)
vehicles.add(
veh_id="2",
acceleration_controller=(
IDMController,
{
# "noise": 0.2
}),
routing_controller=(WeaveRouter, {}),
speed_mode="all_checks",
lane_change_mode="strategic",
num_vehicles=5)
vehicles.add(
veh_id="3",
acceleration_controller=(
IDMController,
{
# "noise": 0.2
}),
routing_controller=(WeaveRouter, {}),
speed_mode="all_checks",
lane_change_mode="strategic",
num_vehicles=5)
vehicles.add(
veh_id="4",
acceleration_controller=(
IDMController,
{
# "noise": 0.2
}),
routing_controller=(WeaveRouter, {}),
speed_mode="all_checks",
lane_change_mode="strategic",
num_vehicles=5)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS,
sims_per_step=5,
warmup_steps=0)
inflow = InFlows()
inflow.add(
veh_type="1",
edge="inflow_highway",
vehs_per_hour=FLOW_RATE * 0.6, # TODO: change
departLane="free",
departSpeed=10)
inflow.add(
veh_type="2",
edge="inflow_highway",
vehs_per_hour=FLOW_RATE * 0.4, # TODO: change
departLane="free",
departSpeed=10)
inflow.add(
veh_type="3",
edge="inflow_merge",
vehs_per_hour=FLOW_RATE * 0.3, # TODO: change
departLane="free",
departSpeed=7.5)
inflow.add(
veh_type="4",
edge="inflow_merge",
vehs_per_hour=FLOW_RATE * 0.1, # TODO: change
departLane="free",
departSpeed=7.5)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
additional_net_params["merge_lanes"] = 1
additional_net_params["diverge_lanes"] = 1
additional_net_params["highway_lanes"] = 2
additional_net_params["pre_merge_length"] = 300
additional_net_params["post_merge_length"] = 200
additional_net_params["post_diverge_length"] = 400
additional_net_params["merge_length"] = 100
additional_net_params["diverge_length"] = 200
net_params = NetParams(inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="uniform", perturbation=5.0)
scenario = EntryExitScenario(name="merge-baseline",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = WaveAttenuationMergePOEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
evaluate=True, # Set to True to evaluate traffic metrics
warmup_steps=40,
sims_per_step=1,
horizon=HORIZON,
additional_params=additional_env_params,
)
initial_config = InitialConfig(
spacing="uniform",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"],
)
scenario = BottleneckScenario(name="bay_bridge_toll",
generator_class=BottleneckGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = DesiredVelocityEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
num_runs = 2
results = exp.run(num_runs, HORIZON)
avg_outflow = np.mean([outflow[-1] for outflow in results["per_step_returns"]])
print('The average outflow over 500 seconds '
'across {} runs is {}'.format(num_runs, avg_outflow))
def setUp(self):
# create the environment and scenario classes for a ring road
env, scenario = ring_road_exp_setup()
# instantiate an experiment class
self.exp = SumoExperiment(env, scenario)
def setUp(self):
# create the environment and scenario classes for a ring road
self.env, self.scenario = grid_mxn_exp_setup()
# instantiate an experiment class
self.exp = SumoExperiment(self.env, self.scenario)
def loop_merge_example(render=None):
"""
Perform a simulation of vehicles on a loop merge.
Parameters
----------
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on a loop merge.
"""
sumo_params = SumoParams(sim_step=0.1,
emission_path="./data/",
render=True)
if render is not None:
sumo_params.render = render
# note that the vehicles are added sequentially by the generator,
# so place the merging vehicles after the vehicles in the ring
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=7,
speed_mode="no_collide",
sumo_car_following_params=SumoCarFollowingParams(minGap=0.0,
tau=0.5),
sumo_lc_params=SumoLaneChangeParams())
vehicles.add(veh_id="merge-idm",
acceleration_controller=(IDMController, {}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=10,
speed_mode="no_collide",
sumo_car_following_params=SumoCarFollowingParams(minGap=0.01,
tau=0.5),
sumo_lc_params=SumoLaneChangeParams())
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
additional_net_params["ring_radius"] = 50
additional_net_params["inner_lanes"] = 1
additional_net_params["outer_lanes"] = 1
additional_net_params["lane_length"] = 75
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(x0=50,
spacing="uniform",
additional_params={"merge_bunching": 0})
scenario = TwoLoopsOneMergingScenario(
name="two-loop-one-merging",
generator_class=TwoLoopOneMergingGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def figure_eight_baseline(num_runs, render=True):
"""Run script for all figure eight baselines.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
# We place 1 autonomous vehicle and 13 human-driven vehicles in the network
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
speed_mode="no_collide",
num_vehicles=14)
sumo_params = SumoParams(
sim_step=0.1,
render=render,
)
env_params = EnvParams(
horizon=HORIZON,
evaluate=True, # Set to True to evaluate traffic metrics
additional_params={
"target_velocity": 20,
"max_accel": 3,
"max_decel": 3,
},
)
initial_config = InitialConfig()
net_params = NetParams(
no_internal_links=False,
additional_params=ADDITIONAL_NET_PARAMS,
)
scenario = Figure8Scenario(name="figure_eight",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
avg_speed = np.mean(results["mean_returns"])
return avg_speed
def bottleneck_example(flow_rate, horizon, render=None):
"""
Perform a simulation of vehicles on a bottleneck.
Parameters
----------
flow_rate : float
total inflow rate of vehicles into the bottlneck
horizon : int
time horizon
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on a bottleneck.
"""
if render is None:
render = False
sumo_params = SumoParams(sim_step=0.5,
render=render,
overtake_right=False,
restart_instance=True)
vehicles = Vehicles()
vehicles.add(veh_id="human",
speed_mode=25,
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
lane_change_mode=1621,
num_vehicles=1)
additional_env_params = {
"target_velocity": 40,
"max_accel": 1,
"max_decel": 1,
"lane_change_duration": 5,
"add_rl_if_exit": False,
"disable_tb": DISABLE_TB,
"disable_ramp_metering": DISABLE_RAMP_METER
}
env_params = EnvParams(horizon=horizon,
additional_params=additional_env_params)
inflow = InFlows()
inflow.add(veh_type="human",
edge="1",
vehsPerHour=flow_rate,
departLane="random",
departSpeed=10)
traffic_lights = TrafficLights()
if not DISABLE_TB:
traffic_lights.add(node_id="2")
if not DISABLE_RAMP_METER:
traffic_lights.add(node_id="3")
additional_net_params = {"scaling": SCALING}
net_params = NetParams(inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="random",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"])
scenario = BottleneckScenario(name="bay_bridge_toll",
generator_class=BottleneckGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = BottleneckEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
from flow.envs.loop_accel import SimpleAccelerationEnvironment
from flow.scenarios.loop.loop_scenario import LoopScenario
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1, human_speed_mode="no_collide", human_lane_change_mode="strategic",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), None, (ContinuousRouter, {}), 0, 20)
env_params = EnvParams()
additional_net_params = {"length": 200, "lanes": 2, "speed_limit": 35, "resolution": 40}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = LoopScenario("single-lane-one-contr", CircleGenerator, vehicles, net_params,
initial_config)
env = SimpleAccelerationEnvironment(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
logging.info("Experiment Set Up complete")
exp.run(2, 1000)
exp.env.terminate()
def bottleneck0_baseline(num_runs, render=True):
"""Run script for the bottleneck0 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sumo_params = flow_params['sumo']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
traffic_lights = flow_params.get('tls', TrafficLights())
# we want no autonomous vehicles in the simulation
vehicles = Vehicles()
vehicles.add(veh_id='human',
speed_mode=9,
routing_controller=(ContinuousRouter, {}),
lane_change_mode=0,
num_vehicles=1 * SCALING)
# only include human vehicles in inflows
flow_rate = 1900 * SCALING
inflow = InFlows()
inflow.add(veh_type='human',
edge='1',
vehs_per_hour=flow_rate,
departLane='random',
departSpeed=10)
net_params.inflows = inflow
# modify the rendering to match what is requested
sumo_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# import the scenario class
module = __import__('flow.scenarios', fromlist=[flow_params['scenario']])
scenario_class = getattr(module, flow_params['scenario'])
# create the scenario object
scenario = scenario_class(name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# import the environment class
module = __import__('flow.envs', fromlist=[flow_params['env_name']])
env_class = getattr(module, flow_params['env_name'])
# create the environment object
env = env_class(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, env_params.horizon)
return np.mean(results['returns']), np.std(results['returns'])
def minicity_example(render=None,
save_render=None,
sight_radius=None,
pxpm=None,
show_radius=None):
"""
Perform a simulation of vehicles on modified minicity of University of
Delaware.
Parameters
----------
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on the minicity scenario.
"""
sumo_params = SumoParams(sim_step=0.25)
if render is not None:
sumo_params.render = render
if save_render is not None:
sumo_params.save_render = save_render
if sight_radius is not None:
sumo_params.sight_radius = sight_radius
if pxpm is not None:
sumo_params.pxpm = pxpm
if show_radius is not None:
sumo_params.show_radius = show_radius
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(MinicityRouter, {}),
speed_mode=1,
lane_change_mode="no_lat_collide",
initial_speed=0,
num_vehicles=90)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(MinicityRouter, {}),
speed_mode="no_collide",
initial_speed=0,
num_vehicles=10)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="random", min_gap=5)
scenario = MiniCityScenario(name="minicity",
vehicles=vehicles,
initial_config=initial_config,
net_params=net_params)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def merge_baseline(num_runs, render=True):
"""Run script for all merge baselines.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
# We consider a highway network with an upstream merging lane producing
# shockwaves
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
additional_net_params["merge_lanes"] = 1
additional_net_params["highway_lanes"] = 1
additional_net_params["pre_merge_length"] = 500
# RL vehicles constitute 5% of the total number of vehicles
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
speed_mode=9,
num_vehicles=5)
# Vehicles are introduced from both sides of merge, with RL vehicles
# entering from the highway portion as well
inflow = InFlows()
inflow.add(veh_type="human", edge="inflow_highway",
vehs_per_hour=FLOW_RATE,
departLane="free", departSpeed=10)
inflow.add(veh_type="human", edge="inflow_merge", vehs_per_hour=100,
departLane="free", departSpeed=7.5)
sumo_params = SumoParams(
restart_instance=True,
sim_step=0.5, # time step decreased to prevent occasional crashes
render=render,
)
env_params = EnvParams(
horizon=HORIZON,
sims_per_step=5, # value raised to ensure sec/step match experiment
warmup_steps=0,
evaluate=True, # Set to True to evaluate traffic metric performance
additional_params={
"max_accel": 1.5,
"max_decel": 1.5,
"target_velocity": 20,
"num_rl": NUM_RL,
},
)
initial_config = InitialConfig()
net_params = NetParams(
inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params,
)
scenario = MergeScenario(name="merge",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = WaveAttenuationMergePOEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
avg_speed = np.mean(results["mean_returns"])
return avg_speed
class TestBottleneck(unittest.TestCase):
def test_it_runs(self):
self.env, self.scenario = setup_bottlenecks()
self.exp = SumoExperiment(self.env, self.scenario)
self.exp.run(5, 50)
"start_time": 0,
"end_time": 3000,
"cfg_path": "traffic/flow-dev/leah/cfg/"
}
# initial_positions = [("top", 0), ("top", 70), ("top", 140), \
# ("left", 0), ("left", 70), ("left", 140), \
# ("bottom", 0), ("bottom", 70), ("bottom", 140), \
# ("right", 0), ("right", 70), ("right", 140)]
initial_config = {"shuffle": False}
scenario = LoopScenario("leah-test-exp", type_params, net_params,
cfg_params) #, initial_config=initial_config)
exp = SumoExperiment(SimpleVelocityEnvironment, env_params, sumo_binary,
sumo_params, scenario)
logging.info("Experiment Set Up complete")
print("experiment initialized")
env = normalize(exp.env)
stub(globals())
for seed in [1]: # [1, 5, 10, 73, 56]
policy = GaussianMLPPolicy(env_spec=env.spec, hidden_sizes=(16, ))
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
def test_it_runs(self):
self.env, self.scenario = setup_bottlenecks()
self.exp = SumoExperiment(self.env, self.scenario)
self.exp.run(5, 50)
"horizontal": 30,
"vertical": 30
}
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
cfg_params = {"start_time": 0, "end_time": 3000, "cfg_path": "debug/cfg/"}
initial_config = InitialConfig(spacing="custom",
additional_params={
"intensity": intensity,
"enter_speed": v_enter
})
scenario = TwoWayIntersectionScenario("two-way-intersection",
TwoWayIntersectionGenerator,
vehicles,
net_params,
initial_config=initial_config)
env = TwoIntersectionEnvironment(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
logging.info("Experiment Set Up complete")
exp.run(1, 1500)
exp.env.terminate()
class TestCollisions(unittest.TestCase):
"""Tests that collisions do not cause the experiments to terminate
prematurely."""
def test_collide(self):
"""Tests collisions in the absence of inflows."""
# create the environment and scenario classes for a ring road
sumo_params = SumoParams(sim_step=1, sumo_binary="sumo")
total_vehicles = 20
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(SumoCarFollowingController, {}),
routing_controller=(GridRouter, {}),
sumo_car_following_params=SumoCarFollowingParams(
tau=0.1, carFollowModel="Krauss", minGap=2.5),
num_vehicles=total_vehicles,
speed_mode=0b00000)
grid_array = {"short_length": 100, "inner_length": 100,
"long_length": 100, "row_num": 1,
"col_num": 1,
"cars_left": int(total_vehicles / 4),
"cars_right": int(total_vehicles / 4),
"cars_top": int(total_vehicles / 4),
"cars_bot": int(total_vehicles / 4)}
additional_net_params = {"speed_limit": 35, "grid_array": grid_array,
"horizontal_lanes": 1, "vertical_lanes": 1,
"traffic_lights": 1}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
self.env, self.scenario = grid_mxn_exp_setup(row_num=1, col_num=1,
sumo_params=sumo_params,
vehicles=vehicles,
net_params=net_params)
# go through the env and set all the lights to green
for i in range(self.env.rows * self.env.cols):
self.env.traci_connection.trafficlight.setRedYellowGreenState(
'center' + str(i), "gggggggggggg")
# instantiate an experiment class
self.exp = SumoExperiment(self.env, self.scenario)
self.exp.run(50, 50)
def test_collide_inflows(self):
"""Tests collisions in the presence of inflows."""
# create the environment and scenario classes for a ring road
sumo_params = SumoParams(sim_step=1, sumo_binary="sumo")
total_vehicles = 12
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(SumoCarFollowingController, {}),
routing_controller=(GridRouter, {}),
sumo_car_following_params=SumoCarFollowingParams(
tau=0.1, carFollowModel="Krauss", minGap=2.5),
num_vehicles=total_vehicles,
speed_mode=0b00000)
grid_array = {"short_length": 100, "inner_length": 100,
"long_length": 100, "row_num": 1,
"col_num": 1,
"cars_left": 3,
"cars_right": 3,
"cars_top": 3,
"cars_bot": 3}
additional_net_params = {"speed_limit": 35, "grid_array": grid_array,
"horizontal_lanes": 1, "vertical_lanes": 1,
"traffic_lights": 1}
inflows = InFlows()
inflows.add(veh_type="idm", edge="bot0_0", vehsPerHour=1000)
inflows.add(veh_type="idm", edge="top0_1", vehsPerHour=1000)
net_params = NetParams(no_internal_links=False,
in_flows=inflows,
additional_params=additional_net_params)
self.env, self.scenario = grid_mxn_exp_setup(row_num=1, col_num=1,
sumo_params=sumo_params,
vehicles=vehicles,
net_params=net_params)
# go through the env and set all the lights to green
for i in range(self.env.rows * self.env.cols):
self.env.traci_connection.trafficlight.setRedYellowGreenState(
'center' + str(i), "gggggggggggg")
# instantiate an experiment class
self.exp = SumoExperiment(self.env, self.scenario)
self.exp.run(50, 50)
def bottleneck_example(flow_rate, horizon, sumo_binary=None):
if sumo_binary is None:
sumo_binary = "sumo"
sumo_params = SumoParams(sim_step=0.5,
sumo_binary=sumo_binary,
overtake_right=False,
restart_instance=True)
vehicles = Vehicles()
vehicles.add(veh_id="human",
speed_mode=25,
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
lane_change_mode=1621,
num_vehicles=1)
additional_env_params = {
"target_velocity": 40,
"max_accel": 1,
"max_decel": 1,
"lane_change_duration": 5,
"add_rl_if_exit": False,
"disable_tb": DISABLE_TB,
"disable_ramp_metering": DISABLE_RAMP_METER
}
env_params = EnvParams(horizon=horizon,
additional_params=additional_env_params)
inflow = InFlows()
inflow.add(veh_type="human",
edge="1",
vehsPerHour=flow_rate,
departLane="random",
departSpeed=10)
traffic_lights = TrafficLights()
if not DISABLE_TB:
traffic_lights.add(node_id="2")
if not DISABLE_RAMP_METER:
traffic_lights.add(node_id="3")
additional_net_params = {"scaling": SCALING}
net_params = NetParams(in_flows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="random",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"])
scenario = BottleneckScenario(name="bay_bridge_toll",
generator_class=BottleneckGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = BottleneckEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def grid_example(sumo_binary=None):
inner_length = 300
long_length = 500
short_length = 300
n = 2
m = 3
num_cars_left = 20
num_cars_right = 20
num_cars_top = 20
num_cars_bot = 20
tot_cars = (num_cars_left + num_cars_right) * m \
+ (num_cars_top + num_cars_bot) * n
grid_array = {
"short_length": short_length,
"inner_length": inner_length,
"long_length": long_length,
"row_num": n,
"col_num": m,
"cars_left": num_cars_left,
"cars_right": num_cars_right,
"cars_top": num_cars_top,
"cars_bot": num_cars_bot
}
sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo-gui")
if sumo_binary is not None:
sumo_params.sumo_binary = sumo_binary
vehicles = Vehicles()
vehicles.add(veh_id="human",
routing_controller=(GridRouter, {}),
num_vehicles=tot_cars)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLights(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGGrrrGGGrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyrrryyyrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrGGGrrrGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrryyyrrryyy"
}]
tl_logic.add("center0", phases=phases, programID=1)
tl_logic.add("center1", phases=phases, programID=1)
tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1)
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = SimpleGridScenario(name="grid-intersection",
generator_class=SimpleGridGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def bay_bridge_bottleneck_example(sumo_binary=None, use_traffic_lights=False):
"""
Performs a non-RL simulation of the bottleneck portion of the Oakland-San
Francisco Bay Bridge. This consists of the toll booth and sections of the
road leading up to it.
Parameters
----------
sumo_binary: bool, optional
specifies whether to use sumo's gui during execution
use_traffic_lights: bool, optional
whether to activate the traffic lights in the scenario
Note
----
Unlike the bay_bridge_example, inflows are always activated here.
"""
sumo_params = SumoParams(sim_step=0.4, overtake_right=True)
if sumo_binary is not None:
sumo_params.sumo_binary = sumo_binary
sumo_car_following_params = SumoCarFollowingParams(speedDev=0.2)
sumo_lc_params = SumoLaneChangeParams(model="LC2013",
lcCooperative=0.2,
lcSpeedGain=15)
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
routing_controller=(BayBridgeRouter, {}),
speed_mode="all_checks",
lane_change_mode="no_lat_collide",
sumo_car_following_params=sumo_car_following_params,
sumo_lc_params=sumo_lc_params,
num_vehicles=50)
additional_env_params = {}
env_params = EnvParams(additional_params=additional_env_params)
inflow = InFlows()
inflow.add(veh_type="human",
edge="393649534",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="4757680",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="32661316",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="90077193#0",
vehs_per_hour=2000,
departLane="random",
departSpeed=10)
net_params = NetParams(in_flows=inflow,
no_internal_links=False,
netfile=NETFILE)
# download the netfile from AWS
if use_traffic_lights:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_TL_all_green.net.xml"
else:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_junction_fix.net.xml"
my_file = urllib.request.urlopen(my_url)
data_to_write = my_file.read()
with open(
os.path.join(os.path.dirname(os.path.abspath(__file__)), NETFILE),
"wb+") as f:
f.write(data_to_write)
initial_config = InitialConfig(
spacing="uniform", # "random",
min_gap=15)
scenario = BayBridgeTollScenario(name="bay_bridge_toll",
generator_class=BayBridgeTollGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = BayBridgeEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def setUp(self):
# create the environment and scenario classes for a ring road
self.env, scenario = two_loops_one_merging_exp_setup()
# instantiate an experiment class
self.exp = SumoExperiment(self.env, scenario)
def figure_eight_baseline(num_runs, flow_params, render=True):
"""Run script for all figure eight baselines.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
flow_params : dict
the flow meta-parameters describing the structure of a benchmark.
Must be one of the figure eight flow_params
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sumo_params = flow_params['sumo']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
traffic_lights = flow_params.get('tls', TrafficLights())
# modify the rendering to match what is requested
sumo_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# we want no autonomous vehicles in the simulation
vehicles = Vehicles()
vehicles.add(veh_id='human',
acceleration_controller=(IDMController, {'noise': 0.2}),
routing_controller=(ContinuousRouter, {}),
speed_mode='no_collide',
num_vehicles=14)
# import the scenario class
module = __import__('flow.scenarios', fromlist=[flow_params['scenario']])
scenario_class = getattr(module, flow_params['scenario'])
# create the scenario object
scenario = scenario_class(
name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights
)
# import the environment class
module = __import__('flow.envs', fromlist=[flow_params['env_name']])
env_class = getattr(module, flow_params['env_name'])
# create the environment object
env = env_class(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, env_params.horizon)
avg_speed = np.mean(results['mean_returns'])
return avg_speed
def bay_bridge_example(render=None,
use_inflows=False,
use_traffic_lights=False):
"""
Perform a simulation of vehicles on the Oakland-San Francisco Bay Bridge.
Parameters
----------
render: bool, optional
specifies whether to use sumo's gui during execution
use_inflows: bool, optional
whether to activate inflows from the peripheries of the network
use_traffic_lights: bool, optional
whether to activate the traffic lights in the scenario
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles simulated by sumo on the Bay Bridge.
"""
sumo_params = SumoParams(sim_step=0.6, overtake_right=True)
if render is not None:
sumo_params.render = render
sumo_car_following_params = SumoCarFollowingParams(speedDev=0.2)
sumo_lc_params = SumoLaneChangeParams(
lc_assertive=20,
lc_pushy=0.8,
lc_speed_gain=4.0,
model="LC2013",
# lcKeepRight=0.8
)
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
routing_controller=(BayBridgeRouter, {}),
speed_mode="all_checks",
lane_change_mode="no_lat_collide",
sumo_car_following_params=sumo_car_following_params,
sumo_lc_params=sumo_lc_params,
num_vehicles=1400)
additional_env_params = {}
env_params = EnvParams(additional_params=additional_env_params)
traffic_lights = TrafficLights()
inflow = InFlows()
if use_inflows:
# south
inflow.add(veh_type="human",
edge="183343422",
vehsPerHour=528,
departLane="0",
departSpeed=20)
inflow.add(veh_type="human",
edge="183343422",
vehsPerHour=864,
departLane="1",
departSpeed=20)
inflow.add(veh_type="human",
edge="183343422",
vehsPerHour=600,
departLane="2",
departSpeed=20)
inflow.add(veh_type="human",
edge="393649534",
probability=0.1,
departLane="0",
departSpeed=20) # no data for this
# west
inflow.add(veh_type="human",
edge="11189946",
vehsPerHour=1752,
departLane="0",
departSpeed=20)
inflow.add(veh_type="human",
edge="11189946",
vehsPerHour=2136,
departLane="1",
departSpeed=20)
inflow.add(veh_type="human",
edge="11189946",
vehsPerHour=576,
departLane="2",
departSpeed=20)
# north
inflow.add(veh_type="human",
edge="28413687#0",
vehsPerHour=2880,
departLane="0",
departSpeed=20)
inflow.add(veh_type="human",
edge="28413687#0",
vehsPerHour=2328,
departLane="1",
departSpeed=20)
inflow.add(veh_type="human",
edge="28413687#0",
vehsPerHour=3060,
departLane="2",
departSpeed=20)
inflow.add(veh_type="human",
edge="11198593",
probability=0.1,
departLane="0",
departSpeed=20) # no data for this
inflow.add(veh_type="human",
edge="11197889",
probability=0.1,
departLane="0",
departSpeed=20) # no data for this
# midway through bridge
inflow.add(veh_type="human",
edge="35536683",
probability=0.1,
departLane="0",
departSpeed=20) # no data for this
net_params = NetParams(inflows=inflow, no_internal_links=False)
net_params.netfile = NETFILE
# download the netfile from AWS
if use_traffic_lights:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_TL_all_green.net.xml"
else:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_junction_fix.net.xml"
my_file = urllib.request.urlopen(my_url)
data_to_write = my_file.read()
with open(
os.path.join(os.path.dirname(os.path.abspath(__file__)), NETFILE),
"wb+") as f:
f.write(data_to_write)
initial_config = InitialConfig(spacing="uniform", min_gap=15)
scenario = BayBridgeScenario(name="bay_bridge",
vehicles=vehicles,
traffic_lights=traffic_lights,
net_params=net_params,
initial_config=initial_config)
env = BayBridgeEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
class TestInstantaneousFailsafe(unittest.TestCase):
"""
Tests that the instantaneous failsafe of the base acceleration controller
does not allow vehicles to crash under situations where they otherwise
would. This is tested on two crash-prone controllers: OVM and LinearOVM
"""
def setUp_failsafe(self, vehicles):
additional_env_params = {
"target_velocity": 8,
"max-deacc": 3,
"max-acc": 3
}
env_params = EnvParams(additional_params=additional_env_params,
longitudinal_fail_safe="instantaneous")
additional_net_params = {
"length": 100,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=10)
# create the environment and scenario classes for a ring road
env, scenario = ring_road_exp_setup(vehicles=vehicles,
env_params=env_params,
net_params=net_params,
initial_config=initial_config)
# instantiate an experiment class
self.exp = SumoExperiment(env, scenario)
def tearDown_failsafe(self):
# free data used by the class
self.exp = None
def test_no_crash_OVM(self):
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(OVMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=10)
self.setUp_failsafe(vehicles=vehicles)
# run the experiment, see if it fails
self.exp.run(1, 200)
self.tearDown_failsafe()
def test_no_crash_LinearOVM(self):
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(LinearOVM, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=10)
self.setUp_failsafe(vehicles=vehicles)
# run the experiment, see if it fails
self.exp.run(1, 200)
self.tearDown_failsafe()
def grid_example(render=None):
"""
Perform a simulation of vehicles on a grid.
Parameters
----------
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles and balanced traffic lights on a grid.
"""
inner_length = 300
long_length = 500
short_length = 300
n = 2
m = 3
num_cars_left = 0
num_cars_right = 0
num_cars_top = 0
num_cars_bot = 0
tot_cars = (num_cars_left + num_cars_right) * m \
+ (num_cars_top + num_cars_bot) * n
grid_array = {
"short_length": short_length,
"inner_length": inner_length,
"long_length": long_length,
"row_num": n,
"col_num": m,
"cars_left": num_cars_left,
"cars_right": num_cars_right,
"cars_top": num_cars_top,
"cars_bot": num_cars_bot
}
sumo_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sumo_params.render = render
vehicles = Vehicles()
vehicles.add(veh_id="human",
routing_controller=(GridRouter, {}),
num_vehicles=tot_cars)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLights(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGGrrrGGGrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyrrryyyrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrGGGrrrGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrryyyrrryyy"
}]
tl_logic.add("center0", phases=phases, programID=1)
tl_logic.add("center1", phases=phases, programID=1)
tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1)
""""""
inflow = InFlows()
inflow.add(veh_type="human",
edge="bot1_0",
probability=1,
departLane="free",
departSpeed=20)
"""
inflow.add(
veh_type="human",
edge="bot0_0",
probability=0.25,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="top1_3",
probability=1,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="top0_3",
probability=0.25,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="left2_0",
probability=1,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="left2_1",
probability=0.25,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="left2_2",
probability=1,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="right0_0",
probability=1,
departLane="free",
departSpeed=20)
inflow.add(
veh_type="human",
edge="right0_1",
probability=0.25,
departLane="free",
departSpeed=20) """
inflow.add(veh_type="human",
edge="right0_2",
probability=1,
departLane="free",
departSpeed=20)
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
net_params = NetParams(inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = SimpleGridScenario(name="grid-intersection",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def grid1_baseline(num_runs, render=True):
"""Run script for the grid1 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render: bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sumo_params = flow_params['sumo']
vehicles = flow_params['veh']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
# define the traffic light logic
tl_logic = TrafficLights(baseline=False)
phases = [{'duration': '31', 'minDur': '5', 'maxDur': '45',
'state': 'GGGrrrGGGrrr'},
{'duration': '2', 'minDur': '2', 'maxDur': '2',
'state': 'yyyrrryyyrrr'},
{'duration': '31', 'minDur': '5', 'maxDur': '45',
'state': 'rrrGGGrrrGGG'},
{'duration': '2', 'minDur': '2', 'maxDur': '2',
'state': 'rrryyyrrryyy'}]
for i in range(N_ROWS*N_COLUMNS):
tl_logic.add('center'+str(i), tls_type='actuated', phases=phases,
programID=1)
# modify the rendering to match what is requested
sumo_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# import the scenario class
module = __import__('flow.scenarios', fromlist=[flow_params['scenario']])
scenario_class = getattr(module, flow_params['scenario'])
# create the scenario object
scenario = scenario_class(
name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic
)
# import the environment class
module = __import__('flow.envs', fromlist=[flow_params['env_name']])
env_class = getattr(module, flow_params['env_name'])
# create the environment object
env = env_class(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, env_params.horizon)
total_delay = np.mean(results['returns'])
return total_delay
