def grid0_baseline(num_runs, render=True):
"""Run script for the grid0 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
"""
sim_params = flow_params['sim']
env_params = flow_params['env']
# define the traffic light logic
tl_logic = TrafficLightParams(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GrGr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryry"
}]
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
sim_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
flow_params['env'].horizon = env_params.horizon
exp = Experiment(flow_params)
results = exp.run(num_runs)
total_delay = np.mean(results['returns'])
return total_delay
"minDur": "8",
"maxDur": "45",
"state": "rGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryry"
}]
for traffic_id in range(0, (n_rows * n_columns)):
tl_logic.add("center" + str(traffic_id),
showDetectors=True,
programID=1,
phases=phases,
maxGap=3.0,
detectorGap=0.8,
tls_type="actuated")
additional_net_params = {
"grid_array": grid_array,
"speed_limit": V_TARGET,
"horizontal_lanes": 1,
"vertical_lanes": 1,
'traffic_lights': True
}
if USE_INFLOWS:
initial_config, net_params = get_flow_params(
col_num=n_columns,
"duration": "5",
"minDur": "3",
"maxDur": "6",
"state": "rrrryyggrrrryygg"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrrrrrGGrrrrrrGG"
}, {
"duration": "5",
"minDur": "3",
"maxDur": "6",
"state": "rrrrrryyrrrrrryy"
}]
tl_logic.add("n_i3", phases=phases1, programID=1)
tl_logic.add("n_i4", phases=phases, programID=1)
additional_net_params = {"traffic_lights": True}
net_params = NetParams(additional_params=additional_net_params)
##################################################
flow_params = dict(
# name of the experiment
exp_tag='minicity',
# name of the flow environment the experiment is running on
env_name=AccelEnv,
# name of the network class the experiment is running on
network=MiniCityNetwork(name="city",
vehicles=VehicleParams(),
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryryryryryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrGrGrGrGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryryryryryry"
}]
tl_logic.add("center0", phases=phases, programID=1, tls_type="static")
tl_logic.add("center1", phases=phases, programID=1, tls_type="static")
tl_logic.add("center2", phases=phases, programID=1, tls_type="static")
tl_logic.add("center3", phases=phases, programID=1, tls_type="static")
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
if USE_INFLOWS:
initial_config, net_params = get_flow_params(
col_num=n_columns,
row_num=n_rows,
def setup_flow_params(args):
DISABLE_TB = True
DISABLE_RAMP_METER = True
AV_FRAC = args.av_frac
if args.lc_on:
lc_mode = 1621
else:
lc_mode = 512
vehicles = VehicleParams()
if not np.isclose(AV_FRAC, 1):
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=lc_mode, ),
num_vehicles=1)
vehicles.add(
veh_id="av",
acceleration_controller=(RLController, {}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(speed_mode=31, ),
lane_change_params=SumoLaneChangeParams(lane_change_mode=0, ),
num_vehicles=1)
else:
vehicles.add(
veh_id="av",
acceleration_controller=(RLController, {}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(speed_mode=31, ),
lane_change_params=SumoLaneChangeParams(lane_change_mode=0, ),
num_vehicles=1)
# flow rate
flow_rate = 1900 * args.scaling
controlled_segments = [('1', 1, False), ('2', 3, True), ('3', 3, False),
('4', 2, False), ('5', 1, False)]
num_observed_segments = [('1', 1 * args.state_space_scaling),
('2', 3 * args.state_space_scaling),
('3', 3 * args.state_space_scaling),
('4', 3 * args.state_space_scaling),
('5', 1 * args.state_space_scaling)]
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': True,
'lane_change_duration': 5,
'max_accel': 3,
'max_decel': 3,
'inflow_range': [args.low_inflow, args.high_inflow],
'start_inflow': flow_rate,
'congest_penalty': args.congest_penalty,
"life_penalty": args.life_penalty,
"av_frac": args.av_frac,
"lc_mode": lc_mode,
"congest_penalty_start": args.congest_penalty_start,
"num_sample_seconds": args.num_sample_seconds,
"speed_reward": args.speed_reward,
"fair_reward": args.fair_reward,
"exit_history_seconds": args.exit_history_seconds,
}
# percentage of flow coming out of each lane
inflow = InFlows()
if not np.isclose(args.av_frac, 1.0):
inflow.add(veh_type='human',
edge='1',
vehs_per_hour=flow_rate * (1 - args.av_frac),
departLane='random',
departSpeed=10.0)
inflow.add(veh_type='av',
edge='1',
vehs_per_hour=flow_rate * args.av_frac,
departLane='random',
departSpeed=10.0)
else:
inflow.add(veh_type='av',
edge='1',
vehs_per_hour=flow_rate,
departLane='random',
departSpeed=10.0)
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': args.scaling, "speed_limit": 23.0}
flow_params = dict(
# name of the experiment
exp_tag=args.exp_title,
# name of the flow environment the experiment is running on
env_name='DesiredVelocityEnv',
# name of the scenario class the experiment is running on
scenario='BottleneckScenario',
# simulator that is used by the experiment
simulator='traci',
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(
sim_step=args.sim_step,
render=args.render,
print_warnings=False,
restart_instance=True,
),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
warmup_steps=int(args.warmup_steps /
(args.sims_per_step * args.sim_step)),
sims_per_step=args.sims_per_step,
horizon=args.horizon,
additional_params=additional_env_params,
),
# network-related parameters (see flow.core.params.NetParams and the
# scenario's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(
inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params,
),
# vehicles to be placed in the network at the start of a rollout (see
# flow.core.vehicles.Vehicles)
veh=vehicles,
# parameters specifying the positioning of vehicles upon initialization/
# reset (see flow.core.params.InitialConfig)
initial=InitialConfig(
spacing='uniform',
min_gap=5,
lanes_distribution=float('inf'),
edges_distribution=['2', '3', '4', '5'],
),
# traffic lights to be introduced to specific nodes (see
# flow.core.traffic_lights.TrafficLights)
tls=traffic_lights,
)
return flow_params
def para_produce_rl(HORIZON=3000):
# Create default environment parameters
env_params = EnvParams()
# Vehicle definition
vehicles = VehicleParams()
num_vehicles = 1
vehicles.add(
veh_id="human",
routing_controller=(GridRouter, {}),
lane_change_controller=(SimLaneChangeController, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
decel=7.5, # avoid collisions at emergency stops
),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=1621,
),
num_vehicles=num_vehicles)
# whether to allow turns at intersections
ALLOW_TURNS = False
# initialize traffic lights, used when you want define your own traffic lights
tl_logic = TrafficLightParams(baseline=False) # To see static traffic lights in action, the `TrafficLightParams` object should be instantiated with `baseline=False`
# when use off_ramp_grid.net.xml file, you should use a phase state example as "GGGgrrrrGGGgrrrr"
# when use off_ramp_grid_turn.net.xml file, you should use a phase state example as "GGGggrrrrrGGGggrrrrr"
if ALLOW_TURNS:
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
# for actuated traffic lights, you can add these optional values below
# "maxGap": int, describes the maximum time gap between successive vehicle sthat will cause the current phase to be prolonged
# "detectorGap": int, determines the time distance between the (automatically generated) detector and the stop line in seconds
# "showDetectors": bool, toggles whether or not detectors are shown in sumo-gui
"state": "GGGggrrrrrGGGggrrrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyyyrrrrryyyyyrrrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrrrGGGggrrrrrGGGgg"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrrrryyyyyrrrrryyyyy"
}]
tl_logic.add("center0", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center1", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center2", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center3", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
else:
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
# for actuated traffic lights, you can add these optional values below
# "maxGap": int, describes the maximum time gap between successive vehicle sthat will cause the current phase to be prolonged
# "detectorGap": int, determines the time distance between the (automatically generated) detector and the stop line in seconds
# "showDetectors": bool, toggles whether or not detectors are shown in sumo-gui
"state": "GGGgrrrrGGGgrrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyyrrrryyyyrrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrrGGGgrrrrGGGg"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrrryyyyrrrryyyy"
}]
# THIS IS A BUG THAT I DON'T KNOW WHY IT HAPPENS!!!!!!
phase0 = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGrrGGrrGGrrGGrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyrryyrryyrryyrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrGGrrGGrrGGrrGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rryyrryyrryyrryy"
}]
tl_logic.add("center0", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center1", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center2", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
tl_logic.add("center3", phases=phases, programID=1, detectorGap=1,tls_type="actuated")
flow_params = dict(
exp_tag='offramp_multiagent_inflow_1.0_speed_20',
env_name=MultiTrafficLightGridPOEnv,
network=offRampGrid,
simulator='traci',
sim=SumoParams(
sim_step=0.1,
render=False,
#emission_path='./data',
restart_instance=True,
),
env=EnvParams(
horizon=3000, additional_params=ADDITIONAL_ENV_PARAMS.copy(),
),
net=net_params,
veh=vehicles,
initial=initial_config,
# used when you define your own traffic lights
#tls=tl_logic,
)
#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 grid_example(render=None, use_inflows=False):
"""
Perform a simulation of vehicles on a grid.
Parameters
----------
render: bool, optional
specifies whether to use the gui during execution
use_inflows : bool, optional
set to True if you would like to run the experiment with inflows of
vehicles from the edges, and False otherwise
Returns
-------
exp: flow.core.experiment.Experiment
A non-rl experiment demonstrating the performance of human-driven
vehicles and balanced traffic lights on a grid.
"""
v_enter = 10
inner_length = 300
long_length = 500
short_length = 300
n_rows = 2
n_columns = 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) * n_columns \
+ (num_cars_top + num_cars_bot) * n_rows
grid_array = {
"short_length": short_length,
"inner_length": inner_length,
"long_length": long_length,
"row_num": n_rows,
"col_num": n_columns,
"cars_left": num_cars_left,
"cars_right": num_cars_right,
"cars_top": num_cars_top,
"cars_bot": num_cars_bot
}
sim_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
routing_controller=(GridRouter, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
decel=7.5, # avoid collisions at emergency stops
),
num_vehicles=tot_cars)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLightParams(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GrGrGrGrGrGr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryryryryryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrGrGrGrGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryryryryryry"
}]
tl_logic.add("center0", phases=phases, programID=1)
tl_logic.add("center1", phases=phases, programID=1)
tl_logic.add("center2", phases=phases, programID=1, tls_type="actuated")
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
if use_inflows:
initial_config, net_params = get_flow_params(
col_num=n_columns,
row_num=n_rows,
additional_net_params=additional_net_params)
else:
initial_config, net_params = get_non_flow_params(
enter_speed=v_enter, add_net_params=additional_net_params)
scenario = SimpleGridScenario(name="grid-intersection",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sim_params, scenario)
return Experiment(env)
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryry"
}]
tl_logic.add("center0", phases=phases, programID=1)
# tl_logic.add("center1", phases=phases, programID=1)
# tl_logic.add("center2", phases=phases, programID=1, tls_type="actuated")
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
if USE_INFLOWS:
initial_config, net_params = get_flow_params(
col_num=n_columns,
row_num=n_rows,
additional_net_params=additional_net_params)
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryryryryryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrGrGrGrGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryryryryryry"
}]
tl_logic.add("IT", phases=phases, programID=1)
#tl_logic.add("center1", phases=phases, programID=1)
#tl_logic.add("center2", phases=phases, programID=1, tls_type="actuated")
flow_params = dict(
# name of the experiment
exp_tag='grid-intersection',
# name of the flow environment the experiment is running on
env_name=AccelEnv,
# name of the network class the experiment is running on
network=Traffic_Network,
# simulator that is used by the experiment
simulator='traci',
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(
sim_step=0.1,
def bottleneck_example(flow_rate, horizon, restart_instance=False,
render=False, scaling=1, disable_ramp_meter=True, disable_tb=True,
lc_on=False, n_crit=8.0, q_max=None, q_min=None, feedback_coef=1, q_init=2300,
penetration_rate=0.4):
"""
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
scaling: int, optional
This sets the number of lanes so that they go from 4 * scaling -> 2 * scaling -> 1 * scaling
disable_tb: bool, optional
whether the toll booth should be active
disable_ramp_meter: bool, optional
specifies if ALINEA should be active. For more details, look at the BottleneckEnv documentation
lc_on: bool, optional
if true, the vehicles have LC mode 1621 which is all safe lane changes allowed. Otherwise, it is 0 for
no lane changing.
n_crit: float, optional
number of vehicles in the bottleneck we feedback around. Look at BottleneckEnv for details
q_max: float, optional
maximum permissible ALINEA flow. Look at BottleneckEnv for details
q_min: float, optional
minimum permissible ALINEA flow. Look at BottleneckEnv for details
feedback_coeff: float, optional
gain coefficient for ALINEA. Look at BottleneckEnv for details
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,
restart_instance=restart_instance)
vehicles = VehicleParams()
if lc_on:
lc_mode = 1621
else:
lc_mode = 0
controlled_segments = [("1", 1, True), ("2", 8, True), ("3", 3, True),
("4", 1, True), ("5", 3, True)] # 12 controllable segments
num_observed_segments = [('1', 1), ('2', 3), ('3', 3), ('4', 3), ('5', 1)]
v_regions = [23,
23, 23, 10, 5, 5, 23, 23, 23,
23, 23, 23,
23,
23, 23, 23]
# set default q_max, q_min values
if not q_max:
if disable_ramp_meter:
q_max = 14401
else:
q_max = 3000
if not q_min:
if disable_ramp_meter:
q_min = 200
else:
q_min = 900
additional_env_params = {
"target_velocity": 40,
"max_accel": 3,
"max_decel": 3,
"lane_change_duration": 5,
"add_rl_if_exit": False,
"disable_tb": disable_tb,
"disable_ramp_metering": disable_ramp_meter,
"n_crit": n_crit,
"q_max": 14401,
"q_min": 200,
"q_init": q_init,
"feedback_coeff": feedback_coef,
"controlled_segments": controlled_segments,
"inflow_range": [flow_rate, flow_rate],
"reset_inflow": False,
"symmetric": True,
"observed_segments": num_observed_segments,
"congest_penalty": False,
"lc_mode": lc_mode,
'start_inflow': flow_rate,
'life_penalty': 0.00,
'keep_past_actions': False,
"num_sample_seconds": 0.5,
"speed_reward": False,
'fair_reward': False, # This doesn't do anything, remove
'exit_history_seconds': 10, # This doesn't do anything, remove
}
if penetration_rate != 0.0:
vehicles.add(
veh_id="AV",
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
# acceleration_controller=(CFMController, {"v_des": 10, "d_des": 30, "k_d": 30, "k_v": 15}),
# acceleration_controller=(HandTunedVelocityController, {"v_regions": v_regions}),
# acceleration_controller=(DecentralizedALINEAController, {"stop_edge": "2", "stop_pos": 310, "additional_env_params": additional_env_params}),
acceleration_controller=(FakeDecentralizedALINEAController, {"stop_edge": "2", "stop_pos": 310, "additional_env_params": additional_env_params}),
car_following_params=SumoCarFollowingParams(
speed_mode=31,
),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=lc_mode
),
num_vehicles=1)
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=lc_mode
),
num_vehicles=1)
env_params = EnvParams(
horizon=horizon, additional_params=additional_env_params)
inflow = InFlows()
if penetration_rate != 0.0:
av_veh_per_hour = flow_rate * (penetration_rate)
human_veh_per_hour = flow_rate * (1 - penetration_rate)
inflow.add(
veh_type="AV",
edge="1",
vehsPerHour=av_veh_per_hour,
departLane="random",
departSpeed=23)
else:
human_veh_per_hour = flow_rate
inflow.add(
veh_type="human",
edge="1",
vehsPerHour=human_veh_per_hour,
departLane="random",
departSpeed=23)
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": 60}
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",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = DesiredVelocityEnv(env_params, sim_params, scenario)
return BottleneckDensityExperiment(env, int(flow_rate))
def bottleneck(render="drgb"):
# time horizon of a single rollout
HORIZON = 1500
SCALING = 1
NUM_LANES = 4 * SCALING # number of lanes in the widest highway
DISABLE_TB = True
DISABLE_RAMP_METER = True
AV_FRAC = 0.10
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(speed_mode=9, ),
lane_change_params=SumoLaneChangeParams(lane_change_mode=0, ),
num_vehicles=1 * SCALING,
)
vehicles.add(
veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(speed_mode=9, ),
lane_change_params=SumoLaneChangeParams(lane_change_mode=0, ),
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": [1200, 2500],
}
# flow rate
flow_rate = 2500 * SCALING
# percentage of flow coming out of each lane
inflow = InFlows()
inflow.add(
veh_type="human",
edge="1",
vehs_per_hour=flow_rate * (1 - AV_FRAC),
depart_lane="random",
depart_speed=10,
)
inflow.add(
veh_type="rl",
edge="1",
vehs_per_hour=flow_rate * AV_FRAC,
depart_lane="random",
depart_speed=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,
additional_params=additional_net_params)
flow_params = dict(
# name of the experiment
exp_tag="bottleneck_0",
# name of the flow environment the experiment is running on
env_name=BottleneckDesiredVelocityEnv,
# name of the network class the experiment is running on
network=BottleneckNetwork,
# simulator that is used by the experiment
simulator="traci",
# sumo-related parameters (see flow.core.params.SumoParams)
sim=SumoParams(
sim_step=0.5,
render=render,
save_render=True,
print_warnings=False,
restart_instance=True,
),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
warmup_steps=40,
sims_per_step=1,
horizon=HORIZON,
additional_params=additional_env_params,
),
# network-related parameters (see flow.core.params.NetParams and the
# network's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(
inflows=inflow,
additional_params=additional_net_params,
),
# 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(
spacing="uniform",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"],
),
# traffic lights to be introduced to specific nodes (see
# flow.core.params.TrafficLightParams)
tls=traffic_lights,
)
return flow_params
"duration": "31",
"state": "GrGr"
}, {
"duration": "6",
"state": "yryr"
}, {
"duration": "31",
"state": "rGrG"
}, {
"duration": "6",
"state": "ryry"
}]
for nodeid in nodes:
tl_logic.add(nodeid,
tls_type="static",
programID=1,
offset=None,
phases=phases)
# vehicles
vehicles = VehicleParams()
vehicles.add("human",
acceleration_controller=(SimCarFollowingController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="right_of_way", min_gap=2.5),
routing_controller=(GridRouter, {}),
num_vehicles=tot_cars)
# inflow, probleem met de inflow is er nog steeds, geen routes gedefinieerd
inflow = InFlows()
outer_edges = []
outer_edges += ["left{}_{}".format(rows, i) for i in range(columns)]
outer_edges += ["right0_{}".format(i) for i in range(rows)]
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=25, ),
lane_change_params=SumoLaneChangeParams(
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 = 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="bay_bridge_toll",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = BottleneckEnv(env_params, sim_params, scenario)
return BottleneckDensityExperiment(env)
def grid_example(render=None):
"""
Perform a simulation of vehicles on a grid.
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 and balanced traffic lights on a grid.
"""
inner_length = 300
long_length = 500
short_length = 300
N_ROWS = 2
N_COLUMNS = 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) * N_COLUMNS \
+ (num_cars_top + num_cars_bot) * N_ROWS
grid_array = {
"short_length": short_length,
"inner_length": inner_length,
"long_length": long_length,
"row_num": N_ROWS,
"col_num": N_COLUMNS,
"cars_left": num_cars_left,
"cars_right": num_cars_right,
"cars_top": num_cars_top,
"cars_bot": num_cars_bot
}
sim_params = AimsunParams(sim_step=0.5, render=True)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(veh_id="human", num_vehicles=tot_cars)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLightParams(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"yellow": "3",
"state": "GGGrrrGGGrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"yellow": "3",
"state": "yyyrrryyyrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"yellow": "3",
"state": "rrrGGGrrrGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"yellow": "3",
"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)
tl_logic.add("center3", phases=phases, programID=1)
tl_logic.add("center4", phases=phases, programID=1)
tl_logic.add("center5", 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(spacing='custom')
scenario = SimpleGridScenario(name="grid-intersection",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sim_params, scenario, simulator='aimsun')
return Experiment(env)
tl_logic = TrafficLightParams(baseline=False)
phases = [{
"duration": "100000",
"state": "GGGGr"
}, {
"duration": "4",
"state": "yyyyr"
}, {
"duration": "10",
"state": "rrrrG"
}, {
"duration": "10",
"state": "rrrrr"
}]
tl_logic.add("C", phases=phases, programID="custom", offset="0")
# specify the routes for vehicles in the network
class PedCrossing(Network):
def specify_routes(self, net_params):
return {'EC': ['EC', 'CW'], 'WC': ['WC', 'CE']}
flow_params = dict(
exp_tag='ped_movexy',
env_name=FmtPedEnvNoLtlReward,
network=PedCrossing,
simulator='traci',
sim=sim_params,
env=env_params,
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryryryryryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrGrGrGrGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryryryryryry"
}]
tl_logic.add("center0", phases=phases, programID=1)
tl_logic.add("center1", phases=phases, programID=1)
tl_logic.add("center2", phases=phases, programID=1, tls_type="actuated")
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
if USE_INFLOWS:
initial_config, net_params = get_flow_params(
col_num=n_columns,
row_num=n_rows,
additional_net_params=additional_net_params)
veh_type="human",
edge="1",
#whats happening here
vehs_per_hour=flow_rate * (1 - AV_FRAC),
departLane="random",
departSpeed=10)
inflow.add(
veh_type="followerstopper",
edge="1",
vehs_per_hour=flow_rate * AV_FRAC,
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,
additional_params=additional_net_params)
flow_params = dict(
# name of the experiment
exp_tag="DesiredVelocity",
# name of the flow environment the experiment is running on
env_name="BottleneckDesiredVelocityEnv",
def grid0_baseline(num_runs, render=True):
"""Run script for the grid0 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']
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 = TrafficLightParams(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GrGr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yryr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rGrG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "ryry"
}]
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
sim_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# import the network class
network_class = flow_params['network']
# create the network object
network = network_class(name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
# import the environment class
env_class = flow_params['env_name']
# create the environment object
env = env_class(env_params, sim_params, network)
exp = Experiment(env)
results = exp.run(num_runs, env_params.horizon)
total_delay = np.mean(results['returns'])
return total_delay
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 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']
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 = TrafficLightParams(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
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=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, sim_params, scenario)
exp = Experiment(env)
results = exp.run(num_runs, env_params.horizon)
total_delay = np.mean(results['returns'])
return total_delay
def da_yuan_example(render=None, use_inflows=True):
"""
Perform a simulation of vehicles on a traffic light grid.
Parameters
----------
render: bool, optional
specifies whether to use the gui during execution
use_inflows : bool, optional
set to True if you would like to run the experiment with inflows of
vehicles from the edges, and False otherwise
Returns
-------
exp: flow.core.experiment.Experiment
A non-rl experiment demonstrating the performance of human-driven
vehicles and balanced traffic lights on a traffic light grid.
"""
v_enter = 10
sim_params = SumoParams(sim_step=0.05, render=True)
if render is not None:
sim_params.render = render
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
routing_controller=(GridRouter, {}),
car_following_params=SumoCarFollowingParams(
min_gap=2.5,
decel=7.5, # avoid collisions at emergency stops
),
num_vehicles=6)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLightParams(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrGGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rryyyy"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGrrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyrrrr"
}]
tl_logic.add("inner0", phases=phases, programID=1)
tl_logic.add("inner1", phases=phases, programID=1)
tl_logic.add("inner2", phases=phases, programID=1, tls_type="actuated")
tl_logic.add("inner3", phases=phases, programID=1, tls_type="actuated")
additional_net_params = {
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
if use_inflows:
initial_config, net_params = get_flow_params(
additional_net_params=additional_net_params)
else:
initial_config, net_params = get_non_flow_params(enter_speed=v_enter)
network = DaYuanNetwork(name="grid-intersection",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sim_params, network)
return Experiment(env)
