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="obey_safe_speed",
),
num_vehicles=1)
vehicles.add(
veh_id="idm",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
routing_controller=(ContinuousRouter, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
),
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(),
import collections
# create some default parameters parameters
HORIZON = 3000
env_params = EnvParams(
horizon=HORIZON,
sims_per_step=1,
warmup_steps=0,
additional_params={
"max_accel": 3,
"max_decel": -2,
"target_velocity": 20,
"lane_change_duration": 4,
"num_rl": 5,
})
initial_config = InitialConfig(edges_distribution=['highway_0'])
vehicles = VehicleParams()
vehicles.add(
veh_id="human",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
# lane_change_controller=(StaticLaneChanger, {}),
car_following_params=SumoCarFollowingParams(
speed_mode="obey_safe_speed",
),
lane_change_params=SumoLaneChangeParams(
lane_change_mode=1621,
model="SL2015",
lc_impatience="0.1",
),
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
horizon=HORIZON,
sims_per_step=2,
warmup_steps=0,
additional_params={
"max_accel": 1.5,
"max_decel": 1.5,
"target_velocity": 20,
"num_rl": NUM_RL,
},
),
# 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(),
)
"num_local_lights": 4,
},
),
# network-related parameters (see flow.core.params.NetParams and the
# network's documentation or ADDITIONAL_NET_PARAMS component)
net=myNetParams,
# 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,
),
)
#############################以下为训练部分#################################
def cover_actions(c_a, s_a,num):
# for i in range(len(c_a)):
# if c_a[i] == 1:
# s_a[i] = abs(s_a[i] - 1)
for i in range(num):
if i == c_a:
s_a[i] = 1
return s_a
def data_collection(env, vels, queues):
sims_per_step=1,
horizon=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(
in_flows=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,
)
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 = 0
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', 2, True), ('3', 2, True),
('4', 2, True), ('5', 1, False)]
num_observed_segments = [('1', 1), ('2', 3), ('3', 3), ('4', 3), ('5', 1)]
if np.isclose(args.av_frac, 0.4):
q_init = 1000
else:
q_init = 600
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,
'communicate': args.communicate,
"centralized_obs": args.central_obs,
"aggregate_info": args.aggregate_info,
"av_frac": args.av_frac,
"congest_penalty_start": args.congest_penalty_start,
"lc_mode": lc_mode,
"life_penalty": args.life_penalty,
'keep_past_actions': args.keep_past_actions,
"num_sample_seconds": args.num_sample_seconds,
"speed_reward": args.speed_reward,
'fair_reward': False, # This doesn't do anything, remove
'exit_history_seconds': 0, # This doesn't do anything, remove
# parameters for the staggering controller that we imitate
"n_crit": 8,
"q_max": 15000,
"q_min": 200,
"q_init": q_init, #
"feedback_coeff": 1, #
'num_imitation_iters': args.num_imitation_iters,
}
# 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=23.0)
inflow.add(veh_type='av',
edge='1',
vehs_per_hour=flow_rate * args.av_frac,
departLane='random',
departSpeed=23.0)
else:
inflow.add(veh_type='av',
edge='1',
vehs_per_hour=flow_rate,
departLane='random',
departSpeed=23.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}
if args.imitate:
env_name = 'MultiBottleneckImitationEnv'
else:
env_name = 'MultiBottleneckEnv'
flow_params = dict(
# name of the experiment
exp_tag=args.exp_title,
# name of the flow environment the experiment is running on
env_name=env_name,
# 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(0 / args.sim_step),
sims_per_step=2,
horizon=args.horizon,
clip_actions=False,
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
speed_mode="obey_safe_speed",
),
num_vehicles=10
)
vehicles.add("human",
acceleration_controller=(IDMController, {}),
lane_change_controller=(SimLaneChangeController, {}),
car_following_params=SumoCarFollowingParams(
speed_mode=25
),
lane_change_params = SumoLaneChangeParams(lane_change_mode=1621),
num_vehicles=0)
# specify the edges vehicles can originate on
initial_config = InitialConfig(
edges_distribution=["edge4"]
)
# specify the routes for vehicles in the network
class Network(Network):
def specify_routes(self, net_params):
return {
"edge1": ["edge1","edge2","edge3","edge4","edge5","edge6"],
#"edge3": ["edge3","edge4","edge5","edge10","edge11","edge12","edge3"],
"edge4": ["edge4","edge5","edge10","edge11","edge12","edge3","edge4"],
}
inflow = InFlows()
inflow.add(veh_type="human",
# length of one rollout
horizon=horizon, )
# the simulation parameters
sim_params = SumoParams(
sim_step=sim_step,
render=True,
show_radius=True, # show a circle on top of RL agents
overtake_right=
True, # overtake on right to simulate more aggressive behavior
emission_path=Params.DATA_DIR,
restart_instance=False,
)
# setting initial configuration files
initial_config = InitialConfig(shuffle=True, )
# Adding inflows
inflow = InFlows()
human_inflow = dict(
veh_type="human",
probability=0.001,
depart_lane="random",
depart_speed="random",
begin=5, # time in seconds to start the inflow
)
# adding human inflows
inflow_random_edges(inflow, **human_inflow)
"target_velocity": 20,
"sort_vehicles": True,
},
)
net_params = NetParams(
inflows=inflow,
#no_internal_links=False,
additional_params=additional_net_params,
template={
"net": scenario_road_data["net"], # see above
"rou": scenario_road_data["rou"], # see above
})
initial_config = InitialConfig(
#scenario_road_data["edges_distribution"]
edges_distribution=scenario_road_data["edges_distribution"], )
if __name__ == "__main__":
scenario = i696Scenario(
name='i696',
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
)
#env = AccelEnv(env_params,sumo_params,scenario)
env = TestEnv(env_params, sumo_params, scenario)
exp = Experiment(env)
_ = exp.run(100, 5000) #,convert_to_csv=True)
#from IPython import embed
#embed()
with open("info.pkl", "wb") as f:
def figure_eight_baseline(num_runs, render=True):
"""Run script for all figure eight baselines.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
Experiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sumo_params = flow_params['sumo']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
traffic_lights = flow_params.get('tls', TrafficLightParams())
# modify the rendering to match what is requested
sumo_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# we want no autonomous vehicles in the simulation
vehicles = Vehicles()
vehicles.add(veh_id='human',
acceleration_controller=(IDMController, {
'noise': 0.2
}),
routing_controller=(ContinuousRouter, {}),
sumo_car_following_params=SumoCarFollowingParams(
speed_mode='no_collide', ),
num_vehicles=14)
# import the scenario class
module = __import__('flow.scenarios', fromlist=[flow_params['scenario']])
scenario_class = getattr(module, flow_params['scenario'])
# create the scenario object
scenario = scenario_class(name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# import the environment class
module = __import__('flow.envs', fromlist=[flow_params['env_name']])
env_class = getattr(module, flow_params['env_name'])
# create the environment object
env = env_class(env_params, sumo_params, scenario)
exp = Experiment(env)
results = exp.run(num_runs, env_params.horizon)
avg_speed = np.mean(results['mean_returns'])
return avg_speed
def bottleneck1_baseline(num_runs, render=True):
"""Run script for the bottleneck1 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render: str, 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=1621, ),
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 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=traffic_lights)
# 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)
return np.mean(results['returns']), np.std(results['returns'])
def bay_bridge_toll_example(render=None, use_traffic_lights=False):
"""Perform a simulation of the toll portion of the Bay Bridge.
This consists of the toll booth and sections of the road leading up to it.
Parameters
----------
render : bool, optional
specifies whether to use sumo's gui during execution
use_traffic_lights: bool, optional
whether to activate the traffic lights in the scenario
Note
----
Unlike the bay_bridge_example, inflows are always activated here.
"""
sumo_params = SumoParams(sim_step=0.4, overtake_right=True)
if render is not None:
sumo_params.render = render
sumo_car_following_params = SumoCarFollowingParams(speedDev=0.2)
sumo_lc_params = SumoLaneChangeParams(model="LC2013",
lcCooperative=0.2,
lcSpeedGain=15)
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
routing_controller=(BayBridgeRouter, {}),
speed_mode="all_checks",
lane_change_mode="no_lat_collide",
sumo_car_following_params=sumo_car_following_params,
sumo_lc_params=sumo_lc_params,
num_vehicles=50)
additional_env_params = {}
env_params = EnvParams(additional_params=additional_env_params)
inflow = InFlows()
inflow.add(veh_type="human",
edge="393649534",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="4757680",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="32661316",
probability=0.2,
departLane="random",
departSpeed=10)
inflow.add(veh_type="human",
edge="90077193#0",
vehs_per_hour=2000,
departLane="random",
departSpeed=10)
net_params = NetParams(inflows=inflow,
no_internal_links=False,
netfile=NETFILE)
# download the netfile from AWS
if use_traffic_lights:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_TL_all_green.net.xml"
else:
my_url = "https://s3-us-west-1.amazonaws.com/flow.netfiles/" \
"bay_bridge_junction_fix.net.xml"
my_file = urllib.request.urlopen(my_url)
data_to_write = my_file.read()
with open(
os.path.join(os.path.dirname(os.path.abspath(__file__)), NETFILE),
"wb+") as f:
f.write(data_to_write)
initial_config = InitialConfig(
spacing="uniform", # "random",
min_gap=15)
scenario = BayBridgeTollScenario(name="bay_bridge_toll",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = BayBridgeEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def __init__(self,
name,
vehicles,
net_params,
initial_config=InitialConfig(),
traffic_lights=TrafficLightParams()):
"""Initialize a highway with on and off ramps network."""
for p in ADDITIONAL_NET_PARAMS.keys():
if p not in net_params.additional_params:
raise KeyError('Network parameter "{}" not supplied'.format(p))
# load parameters into class
params = net_params.additional_params
self.highway_length = params['highway_length']
self.on_ramps_length = params['on_ramps_length']
self.off_ramps_length = params['off_ramps_length']
self.highway_lanes = params['highway_lanes']
self.on_ramps_lanes = params['on_ramps_lanes']
self.off_ramps_lanes = params['off_ramps_lanes']
self.highway_speed = params['highway_speed']
self.on_ramps_speed = params['on_ramps_speed']
self.off_ramps_speed = params['off_ramps_speed']
self.on_ramps_pos = params['on_ramps_pos']
self.off_ramps_pos = params['off_ramps_pos']
self.p = params['next_off_ramp_proba']
self.angle_on_ramps = params['angle_on_ramps']
self.angle_off_ramps = params['angle_off_ramps']
# generate position of all network nodes
self.ramps_pos = sorted(self.on_ramps_pos + self.off_ramps_pos)
self.nodes_pos = sorted(
list(set([0] + self.ramps_pos + [self.highway_length])))
# highway_pos[x] = id of the highway node whose starting position is x
self.highway_pos = {x: i for i, x in enumerate(self.nodes_pos)}
# ramp_pos[x] = id of the ramp node whose intersection with the highway
# is at position x
self.ramp_pos = {
x: "on_ramp_{}".format(i)
for i, x in enumerate(self.on_ramps_pos)
}
self.ramp_pos.update({
x: "off_ramp_{}".format(i)
for i, x in enumerate(self.off_ramps_pos)
})
# make sure network is constructable
if (len(self.ramps_pos) > 0
and (min(self.ramps_pos) <= 0
or max(self.ramps_pos) >= self.highway_length)):
raise ValueError('All ramps positions should be positive and less '
'than highway length. Current ramps positions: {}'
'. Current highway length: {}.'.format(
self.ramps_pos, self.highway_length))
if len(self.ramps_pos) != len(list(set(self.ramps_pos))):
raise ValueError('Two ramps positions cannot be equal.')
super().__init__(name, vehicles, net_params, initial_config,
traffic_lights)
def run_task(*_):
"""Implement the run_task method needed to run experiments with rllab."""
sim_params = SumoParams(sim_step=0.2, render=True)
# 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",
acceleration_controller=(IDMController, {
"noise": 0.2
}),
lane_change_controller=(SimLaneChangeController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=10,
car_following_params=SumoCarFollowingParams(minGap=0.0, tau=0.5),
lane_change_params=SumoLaneChangeParams())
env_params = EnvParams(
horizon=HORIZON,
additional_params={
"target_velocity": 10,
"max_accel": 3,
"max_decel": 3,
"sort_vehicles": False
})
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
additional_net_params["ring_radius"] = 50
additional_net_params["inner_lanes"] = 1
additional_net_params["outer_lanes"] = 1
additional_net_params["lane_length"] = 75
net_params = NetParams(
no_internal_links=False, additional_params=additional_net_params)
initial_config = InitialConfig(x0=50, spacing="uniform")
scenario = TwoLoopsOneMergingScenario(
name=exp_tag,
vehicles=vehicles,
net_params=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=(100, 50, 25))
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=64 * 3 * horizon,
max_path_length=horizon,
# whole_paths=True,
n_itr=1000,
discount=0.999,
# step_size=0.01,
)
algo.train()
def __init__(self,
name,
generator_class,
vehicles,
net_params,
initial_config=InitialConfig(),
traffic_lights=TrafficLights()):
"""Base scenario class.
Initializes a new scenario. Scenarios are used to specify features of
a network, including the positions of nodes, properties of the edges
and junctions connecting these nodes, properties of vehicles and
traffic lights, and other features as well.
Several network specific features can be acquired from this class via a
plethora of get methods (see documentation).
This class can be instantiated once and reused in multiple experiments.
Note that this function stores all the relevant parameters. The
generate() function still needs to be called separately.
Attributes
----------
name: str
A tag associated with the scenario
generator_class: Generator type
Class for generating configuration and net files with placed
vehicles, e.g. CircleGenerator
vehicles: Vehicles type
see flow/core/vehicles.py
net_params: NetParams type
see flow/core/params.py
initial_config: InitialConfig type
see flow/core/params.py
traffic_lights: flow.core.traffic_lights.TrafficLights type
see flow/core/traffic_lights.py
"""
# Invoke serializable if using rllab
if Serializable is not object:
Serializable.quick_init(self, locals())
self.name = name
self.generator_class = generator_class
self.vehicles = vehicles
self.net_params = net_params
self.initial_config = initial_config
self.traffic_lights = traffic_lights
# create a generator instance
self.generator = self.generator_class(self.net_params, self.name)
# create the network configuration file from the generator
self._edges, self._connections = self.generator.generate_net(
self.net_params, self.traffic_lights)
# list of edges and internal links (junctions)
self._edge_list = [
edge_id for edge_id in self._edges.keys() if edge_id[0] != ":"
]
self._junction_list = list(
set(self._edges.keys()) - set(self._edge_list))
# parameters to be specified under each unique subclass's
# __init__() function
self.edgestarts = self.specify_edge_starts()
# these optional parameters need only be used if "no-internal-links"
# is set to "false" while calling sumo's netconvert function
self.internal_edgestarts = self.specify_internal_edge_starts()
self.intersection_edgestarts = self.specify_intersection_edge_starts()
# in case the user did not write the intersection edge-starts in
# internal edge-starts as well (because of redundancy), merge the two
# together
self.internal_edgestarts += self.intersection_edgestarts
seen = set()
self.internal_edgestarts = \
[item for item in self.internal_edgestarts
if item[1] not in seen and not seen.add(item[1])]
self.internal_edgestarts_dict = dict(self.internal_edgestarts)
# total_edgestarts and total_edgestarts_dict contain all of the above
# edges, with the former being ordered by position
if self.net_params.no_internal_links:
self.total_edgestarts = self.edgestarts
else:
self.total_edgestarts = self.edgestarts + self.internal_edgestarts
self.total_edgestarts.sort(key=lambda tup: tup[1])
self.total_edgestarts_dict = dict(self.total_edgestarts)
# length of the network, or the portion of the network in
# which cars are meant to be distributed
# (may be overridden by subclass __init__())
if not hasattr(self, "length"):
self.length = sum([
self.edge_length(edge_id) for edge_id in self.get_edge_list()
])
# generate starting position for vehicles in the network
if self.initial_config.positions is None:
self.initial_config.positions, self.initial_config.lanes = \
self.generate_starting_positions()
# create the sumo configuration files using the generator class
cfg_name = self.generator.generate_cfg(self.net_params)
self.generator.make_routes(self, self.initial_config)
# specify the location of the sumo configuration file
self.cfg = self.generator.cfg_path + cfg_name
def bottleneck0_baseline(num_runs, render=True):
"""Run script for the bottleneck0 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
vehicles = Vehicles()
vehicles.add(veh_id="human",
speed_mode=9,
routing_controller=(ContinuousRouter, {}),
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": [1000, 2000]
}
# flow rate
flow_rate = 1900 * SCALING
# percentage of flow coming out of each lane
inflow = InFlows()
inflow.add(veh_type="human", edge="1",
vehs_per_hour=flow_rate,
departLane="random", departSpeed=10)
traffic_lights = TrafficLights()
if not DISABLE_TB:
traffic_lights.add(node_id="2")
if not DISABLE_RAMP_METER:
traffic_lights.add(node_id="3")
additional_net_params = {"scaling": SCALING}
net_params = NetParams(inflows=inflow,
no_internal_links=False,
additional_params=additional_net_params)
sumo_params = SumoParams(
sim_step=0.5,
render=render,
print_warnings=False,
restart_instance=False,
)
env_params = EnvParams(
evaluate=True, # Set to True to evaluate traffic metrics
warmup_steps=40,
sims_per_step=1,
horizon=HORIZON,
additional_params=additional_env_params,
)
initial_config = InitialConfig(
spacing="uniform",
min_gap=5,
lanes_distribution=float("inf"),
edges_distribution=["2", "3", "4", "5"],
)
scenario = BottleneckScenario(name="bay_bridge_toll",
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
env = DesiredVelocityEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
return np.mean(results["returns"]), np.std(results["returns"])
def grid1_baseline(num_runs, sumo_binary="sumo-gui"):
"""Run script for the grid1 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
sumo_binary: str, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
# we place a sufficient number of vehicles to ensure they confirm with the
# total number specified above. We also use a "right_of_way" speed mode to
# support traffic light compliance
vehicles = Vehicles()
vehicles.add(veh_id="human",
acceleration_controller=(SumoCarFollowingController, {}),
sumo_car_following_params=SumoCarFollowingParams(
min_gap=2.5,
max_speed=V_ENTER,
),
routing_controller=(GridRouter, {}),
num_vehicles=(N_LEFT+N_RIGHT)*N_COLUMNS +
(N_BOTTOM+N_TOP)*N_ROWS,
speed_mode="right_of_way")
# inflows of vehicles are place on all outer edges (listed here)
outer_edges = []
outer_edges += ["left{}_{}".format(N_ROWS, i) for i in range(N_COLUMNS)]
outer_edges += ["right0_{}".format(i) for i in range(N_ROWS)]
outer_edges += ["bot{}_0".format(i) for i in range(N_ROWS)]
outer_edges += ["top{}_{}".format(i, N_COLUMNS) for i in range(N_ROWS)]
# equal inflows for each edge (as dictate by the EDGE_INFLOW constant)
inflow = InFlows()
for edge in outer_edges:
inflow.add(veh_type="human", edge=edge, vehs_per_hour=EDGE_INFLOW,
departLane="free", departSpeed="max")
# define the traffic light logic
tl_logic = TrafficLights(baseline=False)
phases = [{"duration": "31", "minDur": "8", "maxDur": "45",
"state": "GGGrrrGGGrrr"},
{"duration": "6", "minDur": "3", "maxDur": "6",
"state": "yyyrrryyyrrr"},
{"duration": "31", "minDur": "8", "maxDur": "45",
"state": "rrrGGGrrrGGG"},
{"duration": "6", "minDur": "3", "maxDur": "6",
"state": "rrryyyrrryyy"}]
for i in range(N_ROWS*N_COLUMNS):
tl_logic.add("center"+str(i), tls_type="actuated", phases=phases,
programID=1)
net_params = NetParams(
in_flows=inflow,
no_internal_links=False,
additional_params={
"speed_limit": V_ENTER + 5,
"grid_array": {
"short_length": SHORT_LENGTH,
"inner_length": INNER_LENGTH,
"long_length": LONG_LENGTH,
"row_num": N_ROWS,
"col_num": N_COLUMNS,
"cars_left": N_LEFT,
"cars_right": N_RIGHT,
"cars_top": N_TOP,
"cars_bot": N_BOTTOM,
},
"horizontal_lanes": 1,
"vertical_lanes": 1,
},
)
sumo_params = SumoParams(
restart_instance=False,
sim_step=1,
sumo_binary=sumo_binary,
)
env_params = EnvParams(
evaluate=True, # Set to True to evaluate traffic metrics
horizon=HORIZON,
additional_params={
"switch_time": 2.0,
"num_observed": 2,
"tl_type": "actuated",
},
)
initial_config = InitialConfig(shuffle=True)
scenario = SimpleGridScenario(name="grid",
generator_class=SimpleGridGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = PO_TrafficLightGridEnv(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, HORIZON)
total_delay = np.mean(results["returns"])
return total_delay
def bottleneck1_baseline(num_runs, render=True):
"""Run script for the bottleneck1 baseline.
Parameters
----------
num_runs : int
number of rollouts the performance of the environment is evaluated
over
render: str, optional
specifies whether to use sumo's gui during execution
Returns
-------
SumoExperiment
class needed to run simulations
"""
exp_tag = flow_params['exp_tag']
sumo_params = flow_params['sumo']
env_params = flow_params['env']
net_params = flow_params['net']
initial_config = flow_params.get('initial', InitialConfig())
traffic_lights = flow_params.get('tls', TrafficLights())
# we want no autonomous vehicles in the simulation
vehicles = Vehicles()
vehicles.add(veh_id='human',
speed_mode=9,
routing_controller=(ContinuousRouter, {}),
lane_change_mode=1621,
num_vehicles=1 * SCALING)
# only include human vehicles in inflows
flow_rate = 1900 * SCALING
inflow = InFlows()
inflow.add(veh_type='human',
edge='1',
vehs_per_hour=flow_rate,
departLane='random',
departSpeed=10)
net_params.inflows = inflow
# modify the rendering to match what is requested
sumo_params.render = render
# set the evaluation flag to True
env_params.evaluate = True
# import the scenario class
module = __import__('flow.scenarios', fromlist=[flow_params['scenario']])
scenario_class = getattr(module, flow_params['scenario'])
# create the scenario object
scenario = scenario_class(name=exp_tag,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# import the environment class
module = __import__('flow.envs', fromlist=[flow_params['env_name']])
env_class = getattr(module, flow_params['env_name'])
# create the environment object
env = env_class(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
results = exp.run(num_runs, env_params.horizon)
return np.mean(results['returns']), np.std(results['returns'])
def main():
model_logs_path = args.model_logs_path
rewards_logs_path = args.rewards_logs_path
label = args.label
load_path = args.load_path
print('LOAD PATH -- main:', load_path)
train = True
experiments = 2
runs = 5000
steps_per_run = 250
#1. Set the logs object, creating the logs paths, if it does not exists yet, and the experiments logs path
save_logs = SaveLogs(label, experiments, runs, steps_per_run)
save_logs.create_logs_path()
save_logs.create_experiments_logs_path()
#2. Iniciate the variables used to store informations from the simulation
performance = np.zeros(runs)
collisions = np.zeros(runs)
rewards = np.zeros(runs)
#3. Run a set number of experiments
for i in range(experiments):
#1. Create a Vehicle object containing the vehicles that will be in the simulation
# The tau parameter must be lower than the simulation step in order to allow collisions
sumo_car_following_params = SumoCarFollowingParams(sigma=1,
security=False,
tau=0.1)
vehicles = Vehicles()
# The speed mode parameter controlls how the vehicle controlls the speed. All the options for this parameter
#can be found in: http://sumo.dlr.de/wiki/TraCI/Change_Vehicle_State#speed_mode_.280xb3.29
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {
'T': 0.1,
's0': 0.1
}),
routing_controller=(GridRouter, {}),
num_vehicles=4,
speed_mode=1100,
lane_change_mode='aggressive',
sumo_car_following_params=sumo_car_following_params)
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(GridRouter, {}),
num_vehicles=1,
speed_mode=0000,
lane_change_mode='aggressive',
sumo_car_following_params=sumo_car_following_params)
#2. Initite the parameters for a sumo simulation and the initial configurations of the simulation
sumo_params = SumoParams(sim_step=0.5, render=True)
edges_distribution = [
'bottom', 'right'
] #set the vehicles to just star on the bottom and right edges
initial_config = InitialConfig(edges_distribution=edges_distribution,
spacing='custom')
#3. Set the environment parameter
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
#4. Set the netfile parameters with the path to the .net.xml network file
net_params = NetParams(netfile=os.getcwd() +
'/sumo/one_junction.net.xml')
#5. Create instances of the scenario and environment
scenario = OneJunctionScenario( # we use the NetFileScenario scenario class for one junction scenario...
name="test_NetFile_scenario",
generator_class=
OneJunctionGenerator, # ... as well as the newly netfile generator class
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = OneJuntionCrashEnv(env_params, sumo_params, scenario)
#6. create a instance of a sumo experiment
exp = Experiment(env, scenario)
#7. Run the sumo simulation for a set number of runs and time steps per run
if train:
info = exp.run_train(runs,
steps_per_run,
run=i,
saveLogs=save_logs,
train=True,
load_path=load_path)
else:
info = exp.run_eval(runs,
steps_per_run,
run=i,
saveLogs=save_logs,
train=False,
load_path=load_path)
performance = performance + info['performance']
collisions = collisions + info['collisions']
rewards = rewards + info['returns']
save_logs.save_graph(label, 'exp' + str(i), performance, collisions,
rewards)
#4. Average the total performance of the experiments
performance = performance / experiments
collisions = collisions / experiments
rewards = rewards / experiments
#5. Store all the statitics of the simulation
save_logs.save_config_and_statistics()
#6. Save the graphs produced
save_logs.save_graph(label, 'final', performance, collisions, rewards)
# scenario's documentation or ADDITIONAL_NET_PARAMS component)
net=NetParams(
inflows=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,
},
),
# 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(shuffle=True),
)
"main_human": MAIN_HUMAN,
"merge_human": MERGE_HUMAN,
#"use_seeds":"/home/cuijiaxun/flow_2020_07_14_19_32_55.589614/seeds.pkl",
},
),
# 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()
initial=InitialConfig(
spacing='uniform',
#edges_distribution=['left', 'inflow_highway']
edges_distribution={
"inflow_highway": MAIN_HUMAN / 5 + MAIN_RL / 5,
"left": MAIN_HUMAN * 4 / 5 + MAIN_RL * 4 / 5,
'bottom': MERGE_HUMAN * 4 / 5,
'inflow_merge': MERGE_HUMAN / 5,
}),
)
# environment related parameters (see flow.core.params.EnvParams)
env=EnvParams(
horizon=HORIZON,
sims_per_step=1,
warmup_steps=0,
additional_params={
"max_accel": 3,
"max_decel": -2,
"target_velocity": 20,
"lane_change_duration": 4,
"num_rl": 5,
},
),
# 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(edges_distribution=['highway_0']),
)
net=NetParams(
additional_params={
'length': 230,
'lanes': 1,
'speed_limit': 30,
'resolution': 40,
'num_rings': NUM_RINGS
}, ),
# 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(bunching=20.0, spacing='custom'),
)
create_env, env_name = make_create_env(params=flow_params, version=0)
# Register as rllib env
register_env(env_name, create_env)
test_env = create_env()
obs_space = test_env.observation_space
act_space = test_env.action_space
def gen_policy():
"""Generate a policy in RLlib."""
def run_task(*_):
auton_cars = 20
sumo_params = SumoParams(time_step=0.1,
human_speed_mode="no_collide",
rl_speed_mode="no_collide",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (RLController, {}), None, None, 0, 20)
intensity = .2
v_enter = 10
env_params = EnvParams(additional_params={
"target_velocity": v_enter,
"control-length": 150,
"max_speed": v_enter
})
additional_net_params = {
"horizontal_length_in": 400,
"horizontal_length_out": 800,
"horizontal_lanes": 1,
"vertical_length_in": 400,
"vertical_length_out": 800,
"vertical_lanes": 1,
"speed_limit": {
"horizontal": v_enter,
"vertical": v_enter
}
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
cfg_params = {"start_time": 0, "end_time": 3000, "cfg_path": "debug/cfg/"}
initial_config = InitialConfig(spacing="custom",
additional_params={
"intensity": intensity,
"enter_speed": v_enter
})
scenario = TwoWayIntersectionScenario("two-way-intersection",
TwoWayIntersectionGenerator,
vehicles,
net_params,
initial_config=initial_config)
env = TwoIntersectionEnvironment(env_params, sumo_params, scenario)
env_name = "TwoIntersectionEnvironment"
pass_params = (env_name, sumo_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)
logging.info("Experiment Set Up complete")
print("experiment initialized")
env = normalize(env)
policy = GaussianMLPPolicy(env_spec=env.spec, hidden_sizes=(64, 64))
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=30000,
max_path_length=horizon,
# whole_paths=True,
n_itr=200,
discount=0.999,
# step_size=0.01,
)
algo.train()
inflows=inflow,
#no_internal_links=False,
additional_params=additional_net_params,
template={
"net": scenario_road_data["net"], # see above
"rou": scenario_road_data["rou"], # see above
}),
# 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(
# Distributing only at the beginning of routes
scenario_road_data["edges_distribution"]),
)
'''
def setup_exps(seeds_file=None):
alg_run = "PPO"
agent_cls = get_agent_class(alg_run)
config = agent_cls._default_config.copy()
config["num_workers"] = N_CPUS
config["train_batch_size"] = HORIZON * N_ROLLOUTS
config["gamma"] = 0.999 # discount rate
config["model"].update({"fcnet_hiddens": [32, 32, 32]})
config["use_gae"] = True
config["lambda"] = 0.97
"vertical_length_in": 1500,
"vertical_length_out": 1500,
"vertical_lanes": 2,
"speed_limit": {
"horizontal": v_enter,
"vertical": v_enter
}
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
cfg_params = {"start_time": 0, "end_time": 3000, "cfg_path": "debug/cfg/"}
initial_config = InitialConfig(spacing="custom",
additional_params={
"intensity": intensity,
"enter_speed": v_enter
})
scenario = MyTwoWayIntersectionScenario("two-way-intersection",
MyTwoWayIntersectionGenerator,
vehicles,
net_params,
initial_config=initial_config)
env = TwoIntersectionEnvironment(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
logging.info("Experiment Set Up complete")
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 sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles and balanced traffic lights on a grid.
"""
inner_length = 300
long_length = 500
short_length = 300
n = 2
m = 3
num_cars_left = 20
num_cars_right = 20
num_cars_top = 20
num_cars_bot = 20
tot_cars = (num_cars_left + num_cars_right) * m \
+ (num_cars_top + num_cars_bot) * n
grid_array = {
"short_length": short_length,
"inner_length": inner_length,
"long_length": long_length,
"row_num": n,
"col_num": m,
"cars_left": num_cars_left,
"cars_right": num_cars_right,
"cars_top": num_cars_top,
"cars_bot": num_cars_bot
}
sumo_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sumo_params.render = render
vehicles = Vehicles()
vehicles.add(veh_id="human",
routing_controller=(GridRouter, {}),
num_vehicles=tot_cars)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
tl_logic = TrafficLights(baseline=False)
phases = [{
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "GGGrrrGGGrrr"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "yyyrrryyyrrr"
}, {
"duration": "31",
"minDur": "8",
"maxDur": "45",
"state": "rrrGGGrrrGGG"
}, {
"duration": "6",
"minDur": "3",
"maxDur": "6",
"state": "rrryyyrrryyy"
}]
tl_logic.add("center0", phases=phases, programID=1)
tl_logic.add("center1", phases=phases, programID=1)
tl_logic.add("center2", tls_type="actuated", phases=phases, programID=1)
additional_net_params = {
"grid_array": grid_array,
"speed_limit": 35,
"horizontal_lanes": 1,
"vertical_lanes": 1
}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = SimpleGridScenario(name="grid-intersection",
generator_class=SimpleGridGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=tl_logic)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
# all other imports are standard
from flow.core.params import VehicleParams
from flow.core.params import NetParams
from flow.core.params import InitialConfig
from flow.core.params import EnvParams
from flow.core.params import SumoParams
from flow.networks import Network
net_params = NetParams(osm_path='map.osm')
# create the remainding parameters
env_params = EnvParams()
sim_params = SumoParams(render=True)
initial_config = InitialConfig()
vehicles = VehicleParams()
vehicles.add('human', num_vehicles=1000)
flow_params = dict(
exp_tag='bay_bridge',
env_name=TestEnv,
network=Network,
simulator='traci',
sim=sim_params,
env=env_params,
net=net_params,
veh=vehicles,
initial=initial_config,
)
def __init__(self,
name,
vehicles,
net_params,
initial_config=InitialConfig(),
traffic_lights=TrafficLightParams(),
detector_params=None):
"""Instantiate the base network class.
Attributes
----------
name : str
A tag associated with the network
vehicles : flow.core.params.VehicleParams
see flow/core/params.py
net_params : flow.core.params.NetParams
see flow/core/params.py
initial_config : flow.core.params.InitialConfig
see flow/core/params.py
traffic_lights : flow.core.params.TrafficLightParams
see flow/core/params.py
"""
self.orig_name = name # To avoid repeated concatenation upon reset
self.name = name + time.strftime('_%Y%m%d-%H%M%S') + str(time.time())
self.vehicles = vehicles
self.net_params = net_params
self.initial_config = initial_config
self.traffic_lights = traffic_lights
self.detector_params = detector_params if detector_params else DetectorParams(
)
# specify routes vehicles can take
self.routes = self.specify_routes(net_params)
if net_params.template is None and net_params.osm_path is None:
# specify the attributes of the nodes
self.nodes = self.specify_nodes(net_params)
# collect the attributes of each edge
self.edges = self.specify_edges(net_params)
# specify the types attributes (default is None)
self.types = self.specify_types(net_params)
# specify the connection attributes (default is None)
self.connections = self.specify_connections(net_params)
# this is to be used if file paths other than the the network geometry
# file is specified
elif type(net_params.template) is dict:
if 'rou' in net_params.template:
veh, rou = self._vehicle_infos(net_params.template['rou'])
vtypes = self._vehicle_type(net_params.template.get('vtype'))
cf = self._get_cf_params(vtypes)
lc = self._get_lc_params(vtypes)
# add the vehicle types to the VehicleParams object
for t in vtypes:
vehicles.add(veh_id=t,
length=vtypes[t]['length'],
car_following_params=cf[t],
lane_change_params=lc[t],
num_vehicles=0)
# add the routes of the vehicles that will be departed later
# under the name of the vehicle. This will later be identified
# by k.vehicles._add_departed
self.routes = rou
# vehicles to be added with different departure times
self.template_vehicles = veh
if 'add' in net_params.template:
e1Detectors, e2Detectors = self._get_detector_params(
net_params.template['add'])
for e1Detector in e1Detectors:
self.detector_params.add_induction_loop_detector(
name=e1Detector['id'],
lane_id=e1Detector['lane'],
position=e1Detector['pos'],
frequency=e1Detector['freq'],
storage_file=e1Detector['file'],
)
for e2Detector in e2Detectors:
self.detector_params.add_lane_area_detector(
name=e2Detector['id'],
lane_id=e2Detector['lane'],
position=e2Detector['pos'],
frequency=e2Detector['freq'],
storage_file=e2Detector['file'],
)
self.types = None
self.nodes = None
self.edges = None
self.connections = None
# osm_path or template as type str
else:
self.nodes = None
self.edges = None
self.types = None
self.connections = None
# optional parameters, used to get positions from some global reference
self.edge_starts = self.specify_edge_starts()
self.internal_edge_starts = self.specify_internal_edge_starts()
self.intersection_edge_starts = [] # this will be deprecated
