def make_flow_params(n_rows, n_columns, edge_inflow):
"""
Generate the flow params for the experiment.
Parameters
----------
n_rows : int
number of rows in the traffic light grid
n_columns : int
number of columns in the traffic light grid
edge_inflow : float
Returns
-------
dict
flow_params object
"""
# 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 = VehicleParams()
num_vehicles = (N_LEFT + N_RIGHT) * n_columns + (N_BOTTOM + N_TOP) * n_rows
vehicles.add(
veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
max_speed=V_ENTER,
decel=7.5, # avoid collisions at emergency stops
speed_mode="right_of_way",
),
routing_controller=(GridRouter, {}),
num_vehicles=num_vehicles)
# 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=V_ENTER)
flow_params = dict(
# name of the experiment
exp_tag="grid_0_{}x{}_i{}_multiagent".format(n_rows, n_columns,
edge_inflow),
# name of the flow environment the experiment is running on
env_name=MultiTrafficLightGridPOEnv,
# name of the network class the experiment is running on
network=TrafficLightGridNetwork,
# simulator that is used by the experiment
simulator='traci',
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(
restart_instance=True,
sim_step=1,
render=False,
),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
horizon=HORIZON,
additional_params={
"target_velocity": 50,
"switch_time": 3,
"num_observed": 2,
"discrete": False,
"tl_type": "actuated",
"num_local_edges": 4,
"num_local_lights": 4,
},
),
# network-related parameters (see flow.core.params.NetParams and the
# network's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(
inflows=inflow,
additional_params={
"speed_limit": V_ENTER + 5, # inherited from grid0 benchmark
"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,
},
),
# vehicles to be placed in the network at the start of a rollout (see
# flow.core.params.VehicleParams)
veh=vehicles,
# parameters specifying the positioning of vehicles upon initialization
# or reset (see flow.core.params.InitialConfig)
initial=InitialConfig(
spacing='custom',
shuffle=True,
),
)
return flow_params
my_url = "http://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__)), TEMPLATE),
"wb+") as f:
f.write(data_to_write)
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
routing_controller=(BayBridgeRouter, {}),
car_following_params=SumoCarFollowingParams(
speedDev=0.2,
speed_mode="all_checks",
),
lane_change_params=SumoLaneChangeParams(
lc_assertive=20,
lc_pushy=0.8,
lc_speed_gain=4.0,
model="LC2013",
lane_change_mode="no_lc_safe",
# lcKeepRight=0.8
),
num_vehicles=1400)
inflow = InFlows()
if USE_INFLOWS:
# south
def bottleneck_example(flow_rate,
horizon,
restart_instance=False,
render=None):
"""
Perform a simulation of vehicles on a bottleneck.
Parameters
----------
flow_rate : float
total inflow rate of vehicles into the bottleneck
horizon : int
time horizon
restart_instance: bool, optional
whether to restart the instance upon reset
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 bottleneck.
"""
if render is None:
render = False
sim_params = SumoParams(sim_step=0.5,
render=render,
overtake_right=False,
restart_instance=restart_instance)
vehicles = VehicleParams()
vehicles.add(veh_id="human",
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(speed_mode=31, ),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=00, ),
num_vehicles=1)
num_observed_segments = [("1", 1), ("2", 3), ("3", 3), ("4", 3), ("5", 1)]
controlled_segments = [("1", 1, False), ("2", 2, True), ("3", 2, True),
("4", 2, True), ("5", 1, False)]
additional_env_params = {
"target_velocity": 40,
"disable_tb": True,
"disable_ramp_metering": True,
"symmetric": True,
"observed_segments": num_observed_segments,
"controlled_segments": controlled_segments,
"reset_inflow": False,
"lane_change_duration": 5,
"max_accel": 2,
"max_decel": 2,
"inflow_range": [1000, 2000]
}
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 = TrafficLightParams()
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, "speed_limit": 23}
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="tcy_base",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = DesiredVelocityEnv(env_params, sim_params, scenario)
return BottleneckDensityExperiment(env)
from flow.core.params import VehicleParams
from flow.controllers import IDMController, ContinuousRouter, RLController
from flow.networks.figure_eight import ADDITIONAL_NET_PARAMS
# time horizon of a single rollout
HORIZON = 1500
# We place 1 autonomous vehicle and 13 human-driven vehicles in the network
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
decel=1.5,
),
num_vehicles=13)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
num_vehicles=1)
flow_params = dict(
# name of the experiment
exp_tag="figure_eight_0",
# name of the flow environment the experiment is running on
env_name=AccelEnv,
}
additional_net_params = {
'speed_limit': 35,
'grid_array': grid_array,
'horizontal_lanes': 1,
'vertical_lanes': 1
}
vehicles = VehicleParams()
vehicles.add(
veh_id='idm',
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
minGap=2.5,
decel=7.5, # avoid collisions at emergency stops
max_speed=V_ENTER,
speed_mode="all_checks",
),
routing_controller=(GridRouter, {}),
num_vehicles=tot_cars)
flow_params = dict(
# name of the experiment
exp_tag='green_wave',
# name of the flow environment the experiment is running on
env_name='PO_TrafficLightGridEnv',
# name of the scenario class the experiment is running on
scenario='SimpleGridScenario',
def test_encoder_and_get_flow_params(self):
"""Tests both FlowParamsEncoder and get_flow_params.
FlowParamsEncoder is used to serialize the data from a flow_params dict
for replay by the visualizer later. Then, the get_flow_params method is
used to try and read the parameters from the config file, and is
checked to match expected results.
"""
# use a flow_params dict derived from flow/benchmarks/merge0.py
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
acceleration_controller=(IDMController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
# for testing coverage purposes, we add a routing controller
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
num_vehicles=0)
inflow = InFlows()
inflow.add(veh_type="human",
edge="inflow_highway",
vehs_per_hour=1800,
departLane="free",
departSpeed=10)
inflow.add(veh_type="rl",
edge="inflow_highway",
vehs_per_hour=200,
departLane="free",
departSpeed=10)
inflow.add(veh_type="human",
edge="inflow_merge",
vehs_per_hour=100,
departLane="free",
departSpeed=7.5)
flow_params = dict(
exp_tag="merge_0",
env_name="WaveAttenuationMergePOEnv",
scenario="MergeScenario",
sim=SumoParams(
restart_instance=True,
sim_step=0.5,
render=False,
),
env=EnvParams(
horizon=750,
sims_per_step=2,
warmup_steps=0,
additional_params={
"max_accel": 1.5,
"max_decel": 1.5,
"target_velocity": 20,
"num_rl": 5,
},
),
net=NetParams(
inflows=inflow,
additional_params={
"merge_length": 100,
"pre_merge_length": 500,
"post_merge_length": 100,
"merge_lanes": 1,
"highway_lanes": 1,
"speed_limit": 30,
},
),
veh=vehicles,
initial=InitialConfig(),
tls=TrafficLightParams(),
)
# create an config dict with space for the flow_params dict
config = {"env_config": {}}
# save the flow params for replay
flow_json = json.dumps(flow_params,
cls=FlowParamsEncoder,
sort_keys=True,
indent=4)
config['env_config']['flow_params'] = flow_json
# dump the config so we can fetch it
json_out_file = 'params.json'
with open(os.path.expanduser(json_out_file), 'w+') as outfile:
json.dump(config,
outfile,
cls=FlowParamsEncoder,
sort_keys=True,
indent=4)
# fetch values using utility function `get_flow_params`
imported_flow_params = get_flow_params(config)
# delete the created file
os.remove(os.path.expanduser('params.json'))
# test that this inflows are correct
self.assertTrue(imported_flow_params["net"].inflows.__dict__ ==
flow_params["net"].inflows.__dict__)
imported_flow_params["net"].inflows = None
flow_params["net"].inflows = None
# make sure the rest of the imported flow_params match the originals
self.assertTrue(imported_flow_params["env"].__dict__ ==
flow_params["env"].__dict__)
self.assertTrue(imported_flow_params["initial"].__dict__ ==
flow_params["initial"].__dict__)
self.assertTrue(imported_flow_params["tls"].__dict__ ==
flow_params["tls"].__dict__)
self.assertTrue(imported_flow_params["sim"].__dict__ ==
flow_params["sim"].__dict__)
self.assertTrue(imported_flow_params["net"].__dict__ ==
flow_params["net"].__dict__)
self.assertTrue(
imported_flow_params["exp_tag"] == flow_params["exp_tag"])
self.assertTrue(
imported_flow_params["env_name"] == flow_params["env_name"])
self.assertTrue(
imported_flow_params["scenario"] == flow_params["scenario"])
def search_dicts(obj1, obj2):
"""Searches through dictionaries as well as lists of dictionaries
recursively to determine if any two components are mismatched."""
for key in obj1.keys():
# if an next element is a list, either compare the two lists,
# or if the lists contain dictionaries themselves, look at each
# dictionary component recursively to check for mismatches
if isinstance(obj1[key], list):
if len(obj1[key]) > 0:
if isinstance(obj1[key][0], dict):
for i in range(len(obj1[key])):
if not search_dicts(obj1[key][i],
obj2[key][i]):
return False
elif obj1[key] != obj2[key]:
return False
# if the next element is a dict, run through it recursively to
# determine if the separate elements of the dict match
if isinstance(obj1[key], (dict, collections.OrderedDict)):
if not search_dicts(obj1[key], obj2[key]):
return False
# if it is neither a list or a dictionary, compare to determine
# if the two elements match
elif obj1[key] != obj2[key]:
# if the two elements that are being compared are objects,
# make sure that they are the same type
if not isinstance(obj1[key], type(obj2[key])):
return False
return True
# make sure that the Vehicles class that was imported matches the
# original one
self.assertTrue(
search_dicts(imported_flow_params["veh"].__dict__,
flow_params["veh"].__dict__))
# Daniel: adding vehicles and flow from osm.passenger.trips.xml
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
acceleration_controller=(
SimCarFollowingController,
{
#"noise": 0.2
}),
lane_change_controller=(SimLaneChangeController, {}),
#routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
# Define speed mode that will minimize collisions: https://sumo.dlr.de/wiki/TraCI/Change_Vehicle_State#speed_mode_.280xb3.29
speed_mode=9, #"all_checks", #"all_checks", #no_collide",
#decel=7.5, # avoid collisions at emergency stops
# desired time-gap from leader
#tau=2, #7,
#min_gap=2.5,
#speed_factor=1,
#speed_dev=0.1
),
lane_change_params=SumoLaneChangeParams(
model="SL2015",
# Define a lane changing mode that will allow lane changes
# See: https://sumo.dlr.de/wiki/TraCI/Change_Vehicle_State#lane_change_mode_.280xb6.29
# and: ~/local/flow_2019_07/flow/core/params.py, see LC_MODES = {"aggressive": 0 /*bug, 0 is no lane-changes*/, "no_lat_collide": 512, "strategic": 1621}, where "strategic" is the default behavior
lane_change_mode=
1621, #0b011000000001, # (like default 1621 mode, but no lane changes other than strategic to follow route, # 512, #(collision avoidance and safety gap enforcement) # "strategic",
#lc_speed_gain=1000000,
lc_pushy=0, #0.5, #1,
lc_assertive=5, #20,
# the following two replace default values which are not read well by xml parser
'max_decel': 1,
'target_velocity': 30
})
# CREATE VEHICLE TYPES AND INFLOWS
vehicles = VehicleParams()
inflows = InFlows()
# human vehicles
vehicles.add(
veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode=9, # for safer behavior at the merges
#tau=1.5 # larger distance between cars
),
#lane_change_params=SumoLaneChangeParams(lane_change_mode=1621)
num_vehicles=5)
# autonomous vehicles
vehicles.add(
veh_id="rl",
acceleration_controller=(RLController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode=9,
),
num_vehicles=0)
# Vehicles are introduced from both sides of merge, with RL vehicles entering
# from the highway portion as well
def grid_mxn_exp_setup(row_num=1,
col_num=1,
sim_params=None,
vehicles=None,
env_params=None,
net_params=None,
initial_config=None,
tl_logic=None):
"""
Create an environment and scenario pair for grid 1x1 test experiments.
Parameters
----------
row_num: int, optional
number of horizontal rows of edges in the grid network
col_num: int, optional
number of vertical columns of edges in the grid network
sim_params : flow.core.params.SumoParams
sumo-related configuration parameters, defaults to a time step of 1s
and no sumo-imposed failsafe on human or rl vehicles
vehicles : Vehicles type
vehicles to be placed in the network, default is 5 vehicles per edge
for a total of 20 vehicles with an IDM acceleration controller and
GridRouter routing controller.
env_params : flow.core.params.EnvParams
environment-specific parameters, defaults to a environment with
failsafes, where other parameters do not matter for non-rl runs
net_params : flow.core.params.NetParams
network-specific configuration parameters, defaults to a 1x1 grid
which traffic lights on and "no_internal_links" set to False
initial_config : flow.core.params.InitialConfig
specifies starting positions of vehicles, defaults to evenly
distributed vehicles across the length of the network
tl_logic: flow.core.params.TrafficLightParams
specifies logic of any traffic lights added to the system
"""
logging.basicConfig(level=logging.WARNING)
if tl_logic is None:
tl_logic = TrafficLightParams(baseline=False)
if sim_params is None:
# set default sim_params configuration
sim_params = SumoParams(sim_step=1, render=False)
if vehicles is None:
vehicles_per_edge = 5
num_edges = 2 * (row_num + col_num)
total_vehicles = num_edges * vehicles_per_edge
vehicles = VehicleParams()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
car_following_params=SumoCarFollowingParams(min_gap=2.5,
tau=1.1,
max_speed=30),
routing_controller=(GridRouter, {}),
num_vehicles=total_vehicles)
if env_params is None:
# set default env_params configuration
additional_env_params = {
"target_velocity": 50,
"switch_time": 3.0,
"tl_type": "controlled",
"discrete": False
}
env_params = EnvParams(additional_params=additional_env_params,
horizon=100)
if net_params is None:
# set default net_params configuration
total_vehicles = vehicles.num_vehicles
num_entries = 2 * row_num + 2 * col_num
assert total_vehicles % num_entries == 0, "{} total vehicles should " \
"be divisible by {" \
"}".format(total_vehicles,
num_entries)
grid_array = {
"short_length": 100,
"inner_length": 300,
"long_length": 3000,
"row_num": row_num,
"col_num": col_num,
"cars_left": int(total_vehicles / num_entries),
"cars_right": int(total_vehicles / num_entries),
"cars_top": int(total_vehicles / num_entries),
"cars_bot": int(total_vehicles / num_entries)
}
additional_net_params = {
"length": 200,
"lanes": 2,
"speed_limit": 35,
"resolution": 40,
"grid_array": grid_array,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
if initial_config is None:
# set default initial_config configuration
initial_config = InitialConfig(spacing="custom",
additional_params={"enter_speed": 30})
# create the scenario
scenario = SimpleGridScenario(name="Grid1x1Test",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
# create the environment
env = GreenWaveTestEnv(env_params=env_params,
sim_params=sim_params,
scenario=scenario)
# reset the environment
env.reset()
return env, scenario
def merge_example(render=None):
"""
Perform a simulation of vehicles on a merge.
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 merge.
"""
sim_params = SumoParams(render=True,
emission_path="./data/",
sim_step=0.2,
restart_instance=False)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
num_vehicles=5)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS,
sims_per_step=5,
warmup_steps=0)
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)
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
net_params = NetParams(inflows=inflow,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="uniform", perturbation=5.0)
network = MergeNetwork(name="merge-baseline",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = MergePOEnv(env_params, sim_params, network)
return Experiment(env)
# length of final edge in route
LONG_LENGTH = 100
# length of edges that vehicles start on
SHORT_LENGTH = 300
# number of vehicles originating in the left, right, top, and bottom edges
N_LEFT, N_RIGHT, N_TOP, N_BOTTOM = 1, 1, 1, 1
# 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 = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
max_speed=V_ENTER,
speed_mode="right_of_way",
),
routing_controller=(GridRouter, {}),
num_vehicles=(N_LEFT + N_RIGHT) * N_COLUMNS +
(N_BOTTOM + N_TOP) * N_ROWS)
# 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()
def reset(self):
"""Reset the environment with a new inflow rate.
The diverse set of inflows are used to generate a policy that is more
robust with respect to the inflow rate. The inflow rate is update by
creating a new network similar to the previous one, but with a new
Inflow object with a rate within the additional environment parameter
"inflow_range", which is a list consisting of the smallest and largest
allowable inflow rates.
**WARNING**: The inflows assume there are vehicles of type
"followerstopper" and "human" within the VehicleParams object.
"""
add_params = self.env_params.additional_params
if add_params.get("reset_inflow"):
inflow_range = add_params.get("inflow_range")
flow_rate = np.random.uniform(min(inflow_range),
max(inflow_range)) * self.scaling
# We try this for 100 trials in case unexpected errors during
# instantiation.
for _ in range(100):
try:
# introduce new inflows within the pre-defined inflow range
inflow = InFlows()
inflow.add(
veh_type="followerstopper", # FIXME: make generic
edge="1",
vehs_per_hour=flow_rate * .1,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="1",
vehs_per_hour=flow_rate * .9,
departLane="random",
departSpeed=10)
# all other network parameters should match the previous
# environment (we only want to change the inflow)
additional_net_params = {
"scaling":
self.scaling,
"speed_limit":
self.net_params.additional_params['speed_limit']
}
net_params = NetParams(
inflows=inflow,
additional_params=additional_net_params)
vehicles = VehicleParams()
vehicles.add(
veh_id="human", # FIXME: make generic
car_following_params=SumoCarFollowingParams(
speed_mode=9, ),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=0, # 1621,#0b100000101,
),
num_vehicles=1 * self.scaling)
vehicles.add(
veh_id="followerstopper",
acceleration_controller=(RLController, {}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode=9, ),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=0, ),
num_vehicles=1 * self.scaling)
# recreate the network object
self.network = self.network.__class__(
name=self.network.orig_name,
vehicles=vehicles,
net_params=net_params,
initial_config=self.initial_config,
traffic_lights=self.network.traffic_lights)
observation = super().reset()
# reset the timer to zero
self.time_counter = 0
return observation
except Exception as e:
print('error on reset ', e)
# perform the generic reset function
observation = super().reset()
# reset the timer to zero
self.time_counter = 0
return observation
def para_produce_rl(HORIZON = 3000,NUM_AUTOMATED = 7):
# time horizon of a single rollout
HORIZON = 1500
# number of rollouts per training iteration
N_ROLLOUTS = 20
# number of parallel workers
N_CPUS = 2
# number of automated vehicles. Must be less than or equal to 22.
NUM_AUTOMATED = NUM_AUTOMATED
assert NUM_AUTOMATED in [1, 2, 7, 14], \
"num_automated must be one of [1, 2, 7 14]"
# desired velocity for all vehicles in the network, in m/s
TARGET_VELOCITY = 20
# maximum acceleration for autonomous vehicles, in m/s^2
MAX_ACCEL = 3
# maximum deceleration for autonomous vehicles, in m/s^2
MAX_DECEL = 3
# We evenly distribute the automated vehicles in the network.
num_human = 14 - NUM_AUTOMATED
human_per_automated = int(num_human / NUM_AUTOMATED)
vehicles = VehicleParams()
for i in range(NUM_AUTOMATED):
# Add one automated vehicle.
vehicles.add(
veh_id="rl_{}".format(i),
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
accel=MAX_ACCEL,
decel=MAX_DECEL,
),
num_vehicles=1)
# Add a fraction of the human driven vehicles.
vehicles.add(
veh_id="human_{}".format(i),
acceleration_controller=(IDMController, {
"noise": 0.2
}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
decel=1.5
),
routing_controller=(ContinuousRouter, {}),
num_vehicles=human_per_automated)
flow_params = dict(
# name of the experiment
exp_tag="multiagent_figure_eight",
# name of the flow environment the experiment is running on
env_name=AccelEnv,
# name of the network class the experiment is running on
network=FigureEightNetwork,
# simulator that is used by the experiment
simulator='traci',
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(
sim_step=0.1,
render=False,
restart_instance=False
),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
horizon=HORIZON,
additional_params={
'target_velocity': TARGET_VELOCITY,
'max_accel': MAX_ACCEL,
'max_decel': MAX_DECEL,
'sort_vehicles':False
},
),
# network-related parameters (see flow.core.params.NetParams and the
# network's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(
additional_params=ADDITIONAL_NET_PARAMS.copy(),
),
# vehicles to be placed in the network at the start of a rollout (see
# flow.core.params.VehicleParams)
veh=vehicles,
# parameters specifying the positioning of vehicles upon initialization/
# reset (see flow.core.params.InitialConfig)
initial=InitialConfig())
flow_params['env'].horizon = HORIZON
return flow_params
def para_produce_rl(HORIZON=3000):
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
car_following_params=SumoCarFollowingParams(min_gap=0),
routing_controller=(ContinuousRouter, {}),
num_vehicles=21)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1)
flow_params = dict(
# name of the experiment
exp_tag="stabilizing_the_ring",
# name of the flow environment the experiment is running on
env_name=WaveAttenuationPOEnv,
# name of the network class the experiment is running on
network=RingNetwork,
# simulator that is used by the experiment
simulator='traci',
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(sim_step=0.1, render=False, restart_instance=False),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
horizon=HORIZON,
warmup_steps=750,
clip_actions=False,
additional_params={
"max_accel": 1,
"max_decel": 1,
"ring_length": [220, 270],
},
),
# network-related parameters (see flow.core.params.NetParams and the
# network's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(additional_params={
"length": 260,
"lanes": 1,
"speed_limit": 30,
"resolution": 40,
}, ),
# vehicles to be placed in the network at the start of a rollout (see
# flow.core.params.VehicleParams)
veh=vehicles,
# parameters specifying the positioning of vehicles upon initialization/
# reset (see flow.core.params.InitialConfig)
initial=InitialConfig())
flow_params['env'].horizon = HORIZON
return flow_params
def __init__(self,
network_id,
horizon=360,
net_params=None,
vehicles=None,
demand_type='constant',
demand_mode='step',
initial_config=None,
tls_type='rl'):
"""Builds a new network from inflows -- the resulting
vehicle trips will be stochastic use it for training"""
self.network_id = network_id
baseline = (tls_type == 'actuated')
self.cycle_time, self.programs = get_tls_custom(
network_id, baseline=baseline)
if initial_config is None:
initial_config = InitialConfig(
edges_distribution=tuple(get_routes(network_id).keys())
)
if net_params is None:
#TODO: check vtype
if vehicles is None:
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
decel=7.5, # Avoid collisions at emergency stops.
),
lane_change_params=SumoLaneChangeParams(
lane_change_mode='strategic'
)
)
inflows = InFlows(network_id, horizon, demand_type,
demand_mode=demand_mode, initial_config=initial_config)
net_params = NetParams(inflows,
template=get_path(network_id, 'net'))
# static program (required for rl)
tls_logic = TrafficLightParams(baseline=False)
if tls_type not in ('actuated', ):
programs = get_logic(network_id)
if programs:
for prog in programs:
node_id = prog.pop('id')
prog['tls_type'] = prog.pop('type')
prog['programID'] = int(prog.pop('programID')) + 1
tls_logic.add(node_id, **prog)
else:
for tls_id, tls_args in self.programs.items():
tls_logic.add(tls_id, **tls_args)
super(Network, self).__init__(
network_id,
vehicles,
net_params,
initial_config=initial_config,
traffic_lights=tls_logic
)
self.nodes = self.specify_nodes(net_params)
self.edges = self.specify_edges(net_params)
self.connections = self.specify_connections(net_params)
self.types = self.specify_types(net_params)
def variable_lanes_exp_setup(sim_params=None,
vehicles=None,
env_params=None,
net_params=None,
initial_config=None,
traffic_lights=None):
"""
Create an environment and scenario variable-lane ring road.
Each edge in this scenario can have a different number of lanes. Used for
test purposes.
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 figure eight
with a 30 m radius and "no_internal_links" set to False
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, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="aggressive", ),
routing_controller=(ContinuousRouter, {}),
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()
if traffic_lights is None:
# set default to no traffic lights
traffic_lights = TrafficLightParams()
# create the scenario
scenario = VariableLanesScenario(name="VariableLaneRingRoadTest",
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 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
# inflow rate at the highway
FLOW_RATE = 2000
# percent of autonomous vehicles
RL_PENETRATION = 0.06
# num_rl term (see ADDITIONAL_ENV_PARAMs)
NUM_RL = 3
# We consider a highway network with an upstream merging lane producing
# shockwaves
# is the following OK
# RL vehicles constitute 5% of the total number of vehicles
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="no_collide", ),
num_vehicles=5)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="no_collide", ),
num_vehicles=0)
# 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=(1 - RL_PENETRATION) * FLOW_RATE,
departLane="free",
departSpeed=10)
def test_make_create_env(self):
"""Tests that the make_create_env methods generates an environment with
the expected flow parameters."""
# use a flow_params dict derived from flow/benchmarks/figureeight0.py
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
num_vehicles=13)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed", ),
num_vehicles=1)
flow_params = dict(
exp_tag="figure_eight_0",
env_name="AccelEnv",
scenario="Figure8Scenario",
simulator='traci',
sim=SumoParams(
sim_step=0.1,
render=False,
),
env=EnvParams(
horizon=1500,
additional_params={
"target_velocity": 20,
"max_accel": 3,
"max_decel": 3,
"sort_vehicles": False
},
),
net=NetParams(additional_params={
"radius_ring": 30,
"lanes": 1,
"speed_limit": 30,
"resolution": 40,
}, ),
veh=vehicles,
initial=InitialConfig(),
tls=TrafficLightParams(),
)
# some random version number for testing
v = 23434
# call make_create_env
create_env, env_name = make_create_env(params=flow_params, version=v)
# check that the name is correct
self.assertEqual(env_name, '{}-v{}'.format(flow_params["env_name"], v))
# create the gym environment
env = create_env()
# Note that we expect the port number in sim_params to change, and
# that this feature is in fact needed to avoid race conditions
flow_params["sim"].port = env.sim_params.port
# check that each of the parameter match
self.assertEqual(env.env_params.__dict__, flow_params["env"].__dict__)
self.assertEqual(env.sim_params.__dict__, flow_params["sim"].__dict__)
self.assertEqual(env.scenario.traffic_lights.__dict__,
flow_params["tls"].__dict__)
self.assertEqual(env.net_params.__dict__, flow_params["net"].__dict__)
self.assertEqual(env.initial_config.__dict__,
flow_params["initial"].__dict__)
self.assertEqual(env.__class__.__name__, flow_params["env_name"])
self.assertEqual(env.scenario.__class__.__name__,
flow_params["scenario"])
RING_RADIUS = 100
NUM_MERGE_HUMANS = 9
NUM_MERGE_RL = 1
# note that the vehicles are added sequentially by the scenario,
# so place the merging vehicles after the vehicles in the ring
vehicles = VehicleParams()
# Inner ring vehicles
vehicles.add(veh_id='human',
acceleration_controller=(IDMController, {
'noise': 0.2
}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=6,
car_following_params=SumoCarFollowingParams(minGap=0.0, tau=0.5),
lane_change_params=SumoLaneChangeParams())
# A single learning agent in the inner ring
vehicles.add(veh_id='rl',
acceleration_controller=(RLController, {}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1,
car_following_params=SumoCarFollowingParams(
minGap=0.01,
tau=0.5,
speed_mode="obey_safe_speed",
),
lane_change_params=SumoLaneChangeParams())
# Outer ring vehicles
vehicles.add(veh_id='merge-human',
def add(self,
veh_id,
acceleration_controller=(SumoCarFollowingController, {}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=None,
initial_speed=0,
num_vehicles=1,
speed_mode='all_checks',
lane_change_mode="no_lat_collide",
sumo_car_following_params=None,
sumo_lc_params=None):
"""Adds a sequence of vehicles to the list of vehicles in the network.
Parameters
----------
veh_id: str
base vehicle ID for the vehicles (will be appended by a number)
acceleration_controller: tup, optional
1st element: flow-specified acceleration controller
2nd element: controller parameters (may be set to None to maintain
default parameters)
lane_change_controller: tup, optional
1st element: flow-specified lane-changer controller
2nd element: controller parameters (may be set to None to maintain
default parameters)
routing_controller: tup, optional
1st element: flow-specified routing controller
2nd element: controller parameters (may be set to None to maintain
default parameters)
initial_speed: float, optional
initial speed of the vehicles being added (in m/s)
num_vehicles: int, optional
number of vehicles of this type to be added to the network
speed_mode: str or int, optional
may be one of the following:
- "no_collide" (default): Human and RL cars are preventing from
reaching speeds that may cause crashes (also serves as a
failsafe).
- "aggressive": Human and RL cars are not limited by sumo with
regard to their accelerations, and can crash longitudinally
- "all_checks": all sumo safety checks are activated
- "custom_model": respect safe speed, right of way and
brake hard at red lights if needed. DOES NOT respect
max accel and decel which enables emergency stopping.
Necessary to prevent custom models from crashing
- int values may be used to define custom speed mode for the given
vehicles, specified at:
http://sumo.dlr.de/wiki/TraCI/Change_Vehicle_State#speed_mode_.280xb3.29
lane_change_mode: str or int, optional
may be one of the following:
- "strategic": Human cars make lane changes in accordance with SUMO
to provide speed boosts
- "no_lat_collide": Human cars will not make lane changes, RL cars
can lane change into any space, no matter how likely it is to
crash (default)
- "aggressive": RL cars are not limited by sumo with regard to
their lane-change actions, and can crash longitudinally
- int values may be used to define custom lane change modes for the
given vehicles, specified at:
http://sumo.dlr.de/wiki/TraCI/Change_Vehicle_State#lane_change_mode_.280xb6.29
sumo_car_following_params: flow.core.params.SumoCarFollowingParams type
Params object specifying attributes for Sumo car following model.
sumo_lc_params: flow.core.params.SumoLaneChangeParams type
Params object specifying attributes for Sumo lane changing model.
"""
if sumo_car_following_params is None:
sumo_car_following_params = SumoCarFollowingParams()
if sumo_lc_params is None:
sumo_lc_params = SumoLaneChangeParams()
type_params = {}
type_params.update(sumo_car_following_params.controller_params)
type_params.update(sumo_lc_params.controller_params)
# If a vehicle is not sumo or RL, let the minGap be zero so that it
# does not tamper with the dynamics of the controller
if acceleration_controller[0] != SumoCarFollowingController \
and acceleration_controller[0] != RLController:
type_params["minGap"] = 0.0
# adjust the speed mode value
if isinstance(speed_mode, str) and speed_mode in SPEED_MODES:
speed_mode = SPEED_MODES[speed_mode]
elif not (isinstance(speed_mode, int)
or isinstance(speed_mode, float)):
logging.error("Setting speed mode of {0} to "
"default.".format(veh_id))
speed_mode = SPEED_MODES["no_collide"]
# adjust the lane change mode value
if isinstance(lane_change_mode, str) and lane_change_mode in LC_MODES:
lane_change_mode = LC_MODES[lane_change_mode]
elif not (isinstance(lane_change_mode, int)
or isinstance(lane_change_mode, float)):
logging.error("Setting lane change mode of {0} to "
"default.".format(veh_id))
lane_change_mode = LC_MODES["no_lat_collide"]
# this dict will be used when trying to introduce new vehicles into
# the network via a flow
self.type_parameters[veh_id] = \
{"acceleration_controller": acceleration_controller,
"lane_change_controller": lane_change_controller,
"routing_controller": routing_controller,
"initial_speed": initial_speed,
"speed_mode": speed_mode,
"lane_change_mode": lane_change_mode,
"sumo_car_following_params": sumo_car_following_params,
"sumo_lc_params": sumo_lc_params}
self.initial.append({
"veh_id": veh_id,
"acceleration_controller": acceleration_controller,
"lane_change_controller": lane_change_controller,
"routing_controller": routing_controller,
"initial_speed": initial_speed,
"num_vehicles": num_vehicles,
"speed_mode": speed_mode,
"lane_change_mode": lane_change_mode,
"sumo_car_following_params": sumo_car_following_params,
"sumo_lc_params": sumo_lc_params})
# this is used to return the actual headways from the vehicles class
self.minGap[veh_id] = type_params["minGap"]
for i in range(num_vehicles):
v_id = veh_id + '_%d' % i
# add the vehicle to the list of vehicle ids
self.__ids.append(v_id)
self.__vehicles[v_id] = dict()
# specify the type
self.__vehicles[v_id]["type"] = veh_id
# specify the acceleration controller class
self.__vehicles[v_id]["acc_controller"] = \
acceleration_controller[0](
v_id,
sumo_cf_params=sumo_car_following_params,
**acceleration_controller[1])
# specify the lane-changing controller class
self.__vehicles[v_id]["lane_changer"] = \
lane_change_controller[0](veh_id=v_id,
**lane_change_controller[1])
# specify the routing controller class
if routing_controller is not None:
self.__vehicles[v_id]["router"] = \
routing_controller[0](veh_id=v_id,
router_params=routing_controller[1])
else:
self.__vehicles[v_id]["router"] = None
# specify the speed of vehicles at the start of a rollout
self.__vehicles[v_id]["initial_speed"] = initial_speed
# check if the vehicle is human-driven or autonomous
if acceleration_controller[0] == RLController:
self.__rl_ids.append(v_id)
else:
self.__human_ids.append(v_id)
# check if the vehicle's lane-changing / acceleration actions
# are controlled by sumo or not.
if acceleration_controller[0] != SumoCarFollowingController:
self.__controlled_ids.append(v_id)
if lane_change_controller[0] != SumoLaneChangeController:
self.__controlled_lc_ids.append(v_id)
# specify the speed and lane change mode for the vehicle
self.__vehicles[v_id]["speed_mode"] = speed_mode
self.__vehicles[v_id]["lane_change_mode"] = lane_change_mode
# update the variables for the number of vehicles in the network
self.num_vehicles = len(self.__ids)
self.num_rl_vehicles = len(self.__rl_ids)
# increase the number of unique types of vehicles in the network, and
# add the type to the list of types
self.num_types += 1
self.types.append((veh_id, type_params))
def bottleneck2_baseline(num_runs, render=True):
"""Run script for the bottleneck2 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render : bool, optional
specifies whether to use the gui during execution
Returns
-------
flow.core.experiment.Experiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sim_params = flow_params['sim']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
traffic_lights = flow_params.get('tls', TrafficLightParams())
# we want no autonomous vehicles in the simulation
vehicles = VehicleParams()
vehicles.add(veh_id='human',
car_following_params=SumoCarFollowingParams(speed_mode=9, ),
routing_controller=(ContinuousRouter, {}),
lane_change_params=SumoLaneChangeParams(lane_change_mode=0, ),
num_vehicles=1 * SCALING)
# only include human vehicles in inflows
flow_rate = 2300 * 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
sim_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, sim_params, scenario)
exp = Experiment(env)
results = exp.run(num_runs, env_params.horizon)
return np.mean(results['returns']), np.std(results['returns'])
NUM_MERGE_HUMANS = 9
NUM_MERGE_RL = 1
# note that the vehicles are added sequentially by the generator,
# so place the merging vehicles after the vehicles in the ring
vehicles = Vehicles()
# Inner ring vehicles
vehicles.add(
veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=6,
sumo_car_following_params=SumoCarFollowingParams(minGap=0.0, tau=0.5),
sumo_lc_params=SumoLaneChangeParams())
# A single learning agent in the inner ring
vehicles.add(
veh_id="rl",
acceleration_controller=(RLController, {}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
speed_mode="no_collide",
num_vehicles=1,
sumo_car_following_params=SumoCarFollowingParams(minGap=0.01, tau=0.5),
sumo_lc_params=SumoLaneChangeParams())
# Outer ring vehicles
vehicles.add(
veh_id="merge-human",
acceleration_controller=(IDMController, {
def run_task(*_):
"""Implement the run_task method needed to run experiments with rllab."""
sim_params = SumoParams(sim_step=0.1, render=True)
vehicles = VehicleParams()
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="no_collide", ),
num_vehicles=1)
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="no_collide", ),
num_vehicles=13)
additional_env_params = {
"target_velocity": 20,
"max_accel": 3,
"max_decel": 3,
"sort_vehicles": False
}
env_params = EnvParams(horizon=HORIZON,
additional_params=additional_env_params)
additional_net_params = {
"radius_ring": 30,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="uniform")
print("XXX name", exp_tag)
scenario = Figure8Scenario(exp_tag,
vehicles,
net_params,
initial_config=initial_config)
env_name = "AccelEnv"
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=(16, 16))
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=15000,
max_path_length=horizon,
n_itr=500,
# whole_paths=True,
discount=0.999,
# step_size=v["step_size"],
)
algo.train(),
RL_PENETRATION = 0.1
# num_rl term (see ADDITIONAL_ENV_PARAMs)
NUM_RL = 5
# We consider a highway network with an upstream merging lane producing
# shockwaves
additional_net_params = deepcopy(ADDITIONAL_NET_PARAMS)
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 = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(speed_mode=9, ),
num_vehicles=5)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
car_following_params=SumoCarFollowingParams(speed_mode=9, ),
num_vehicles=0)
# 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=(1 - RL_PENETRATION) * FLOW_RATE,
depart_lane="free",
depart_speed=10)
inflow.add(veh_type="rl",
# vehicles dynamics models
# time horizon of a single rollout
HORIZON = 2000
# number of rollouts per training iteration
N_ROLLOUTS = 5
# number of parallel workers
N_CPUS = 2
# We place one autonomous vehicle and 22 human-driven vehicles in the network
vehicles = VehicleParams()
vehicles.add(veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
car_following_params=SumoCarFollowingParams(min_gap=0),
routing_controller=(ContinuousRouter, {}),
num_vehicles=25)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1)
from flow.core.params import SumoParams
sim_params = SumoParams(sim_step=0.1, render=False)
# EnvParams specifies environment and experiment-specific parameters that either affect the training process or the dynamics of various components within the network. For the environment WaveAttenuationPOEnv, these parameters are used to dictate bounds on the accelerations of the autonomous vehicles, as well as the range of ring lengths (and accordingly network densities) the agent is trained on.
#Finally, it is important to specify here the horizon of the experiment, which is the duration of one episode (during which the RL-agent acquire data).
LONG_LENGTH = 100
# length of edges that vehicles start on
SHORT_LENGTH = 300
# number of vehicles originating in the left, right, top, and bottom edges
N_LEFT, N_RIGHT, N_TOP, N_BOTTOM = 1, 1, 1, 1
# 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 = VehicleParams()
vehicles.add(
veh_id="human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
max_speed=V_ENTER,
decel=7.5, # avoid collisions at emergency stops
speed_mode="right_of_way",
),
routing_controller=(GridRouter, {}),
num_vehicles=(N_LEFT + N_RIGHT) * N_COLUMNS + (N_BOTTOM + N_TOP) * N_ROWS)
# 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:
def reset(self):
add_params = self.env_params.additional_params
if add_params.get("reset_inflow"):
inflow_range = add_params.get("inflow_range")
flow_rate = np.random.uniform(
min(inflow_range), max(inflow_range)) * self.scaling
for _ in range(100):
try:
inflow = InFlows()
inflow.add(
veh_type="followerstopper",
edge="1",
vehs_per_hour=flow_rate * .1,
departLane="random",
departSpeed=10)
inflow.add(
veh_type="human",
edge="1",
vehs_per_hour=flow_rate * .9,
departLane="random",
departSpeed=10)
additional_net_params = {"scaling": self.scaling}
net_params = NetParams(
inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
vehicles = Vehicles()
vehicles.add(
veh_id="human",
sumo_car_following_params=SumoCarFollowingParams(
speed_mode=9,
),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
sumo_lc_params=SumoLaneChangeParams(
lane_change_mode=0, # 1621,#0b100000101,
),
num_vehicles=1 * self.scaling)
vehicles.add(
veh_id="followerstopper",
acceleration_controller=(RLController, {}),
lane_change_controller=(SumoLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
sumo_car_following_params=SumoCarFollowingParams(
speed_mode=9,
),
sumo_lc_params=SumoLaneChangeParams(
lane_change_mode=0,
),
num_vehicles=1 * self.scaling)
self.vehicles = vehicles
# delete the cfg and net files
net_path = self.scenario.net_path
net_name = net_path + self.scenario.name
cfg_path = self.scenario.cfg_path
cfg_name = cfg_path + self.scenario.name
for f in glob.glob(net_name + '*'):
os.remove(f)
for f in glob.glob(cfg_name + '*'):
os.remove(f)
self.scenario = self.scenario.__class__(
name=self.scenario.orig_name,
vehicles=vehicles,
net_params=net_params,
initial_config=self.scenario.initial_config,
traffic_lights=self.scenario.traffic_lights)
observation = super().reset()
# reset the timer to zero
self.time_counter = 0
return observation
except Exception as e:
print('error on reset ', e)
# perform the generic reset function
observation = super().reset()
# reset the timer to zero
self.time_counter = 0
return observation
# length of final edge in route
LONG_LENGTH = 100
# length of edges that vehicles start on
SHORT_LENGTH = 300
# number of vehicles originating in the left, right, top, and bottom edges
N_LEFT, N_RIGHT, N_TOP, N_BOTTOM = 1, 1, 1, 1
# 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:
# time horizon of a single rollout
HORIZON = 1000
# number of rollouts per training iteration
N_ROLLOUTS = 20
# number of parallel workers
N_CPUS = 2
vehicles = VehicleParams()
vehicles.add(
"rl",
acceleration_controller=(IDMController, {}),
lane_change_controller=(SimLaneChangeController, {}),
#routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
# we use the speed mode "obey_safe_speed" for better dynamics at the merge
),
num_vehicles=0)
vehicles.add(
"human",
acceleration_controller=(IDMController, {}),
lane_change_controller=(SimLaneChangeController, {}),
#routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
# we use the speed mode "obey_safe_speed" for better dynamics at the merge
),
lane_change_params=SumoLaneChangeParams(lane_change_mode="strategic",
lcpushy=1.0),
num_vehicles=0)
