def sugiyama_example(sumo_binary=None):
sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo-gui")
if sumo_binary is not None:
sumo_params.sumo_binary = sumo_binary
vehicles = Vehicles()
vehicles.add(
veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(
name="sugiyama",
generator_class=CircleGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def start():
sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo")
sumo_params.sumo_binary = 'sumo'
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(name="sugiyama",
generator_class=CircleGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
env._close()
def run_task(*_):
tot_cars = 6
auton_cars = 6
sumo_params = SumoParams(time_step=0.1, rl_speed_mode="no_collide", sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("rl", (RLController, {}), (StaticLaneChanger, {}), (ContinuousRouter, {}), 0, auton_cars)
env_params = EnvParams(additional_params={"target_velocity": 25, "num_steps": 1000})
additional_net_params = {"length": 220, "lanes": 1, "speed_limit": 30, "resolution": 40}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = LoopScenario("rl-test", CircleGenerator, vehicles, net_params, initial_config)
env_name = "SimpleAccelerationEnvironment"
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")
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(16,)
)
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=2000,
max_path_length=horizon,
# whole_paths=True,
n_itr=2, # 1000
# discount=0.99,
# step_size=0.01,
)
algo.train()
def sugiyama_example(render=None):
"""
Perform a simulation of vehicles on a ring road.
Parameters
----------
render : bool, optional
specifies whether to use sumo's gui during execution
Returns
-------
exp: flow.core.SumoExperiment type
A non-rl experiment demonstrating the performance of human-driven
vehicles on a ring road.
"""
sumo_params = SumoParams(sim_step=0.1, render=True)
if render is not None:
sumo_params.render = render
vehicles = Vehicles()
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
additional_net_params = ADDITIONAL_NET_PARAMS.copy()
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario(name="sugiyama",
generator_class=CircleGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config)
env = AccelEnv(env_params, sumo_params, scenario)
return SumoExperiment(env, scenario)
def create_env(*_):
# note that the vehicles are added sequentially by the generator,
# so place the merging vehicles after the vehicles in the ring
vehicles = Vehicles()
for v_param in veh_params:
vehicles.add(**v_param)
initial_config = InitialConfig(**init_params)
scenario = LoopScenario(exp_tag,
CircleGenerator,
vehicles,
net_params,
initial_config=initial_config)
pass_params = (flow_env_name, sumo_params, vehicles, env_params,
net_params, initial_config, scenario, version)
register_env(*pass_params)
env = gym.envs.make(env_name)
return env
def run_task(*_):
"""Implement the run_task method needed to run experiments with rllab."""
sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo", seed=0)
vehicles = Vehicles()
vehicles.add(veh_id="rl",
acceleration_controller=(RLController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=1)
vehicles.add(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=21)
additional_env_params = {
"target_velocity": 8,
"ring_length": [220, 270],
"max_accel": 1,
"max_decel": 1
}
env_params = EnvParams(horizon=HORIZON,
additional_params=additional_env_params,
warmup_steps=750)
additional_net_params = {
"length": 260,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(spacing="uniform", bunching=50)
print("XXX name", exp_tag)
scenario = LoopScenario(exp_tag,
CircleGenerator,
vehicles,
net_params,
initial_config=initial_config)
env_name = "WaveAttenuationPOEnv"
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)
policy = GaussianGRUPolicy(
env_spec=env.spec,
hidden_sizes=(5, ),
)
baseline = LinearFeatureBaseline(env_spec=env.spec)
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=3600 * 72 * 2,
max_path_length=horizon,
n_itr=5,
# whole_paths=True,
discount=0.999,
# step_size=v["step_size"],
)
algo.train(),
def variable_lanes_exp_setup(sumo_params=None,
vehicles=None,
env_params=None,
net_params=None,
initial_config=None,
traffic_lights=None):
"""
Creates an environment and scenario pair for a ring road network with
different number of lanes in each edge. Used for test purposes.
Parameters
----------
sumo_params: SumoParams type
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: EnvParams type
environment-specific parameters, defaults to a environment with no
failsafes, where other parameters do not matter for non-rl runs
net_params: NetParams type
network-specific configuration parameters, defaults to a figure eight
with a 30 m radius and "no_internal_links" set to False
initial_config: InitialConfig type
specifies starting positions of vehicles, defaults to evenly
distributed vehicles across the length of the network
traffic_lights: TrafficLights type
traffic light signals, defaults to no traffic lights in the network
"""
logging.basicConfig(level=logging.WARNING)
if sumo_params is None:
# set default sumo_params configuration
sumo_params = SumoParams(sim_step=0.1, sumo_binary="sumo")
if vehicles is None:
# set default vehicles configuration
vehicles = Vehicles()
vehicles.add(
veh_id="idm",
acceleration_controller=(IDMController, {}),
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,
"num_steps": 500
}
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 = TrafficLights()
# create the scenario
scenario = LoopScenario(
name="VariableLaneRingRoadTest",
generator_class=VariableLanesGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# create the environment
env = AccelEnv(
env_params=env_params, sumo_params=sumo_params, scenario=scenario)
return env, scenario
}
cfg_params = {
"start_time": 0,
"end_time": 3000,
"cfg_path": "traffic/flow-dev/leah/cfg/"
}
# initial_positions = [("top", 0), ("top", 70), ("top", 140), \
# ("left", 0), ("left", 70), ("left", 140), \
# ("bottom", 0), ("bottom", 70), ("bottom", 140), \
# ("right", 0), ("right", 70), ("right", 140)]
initial_config = {"shuffle": False}
scenario = LoopScenario("leah-test-exp", type_params, net_params,
cfg_params) #, initial_config=initial_config)
exp = SumoExperiment(SimpleVelocityEnvironment, env_params, sumo_binary,
sumo_params, scenario)
logging.info("Experiment Set Up complete")
print("experiment initialized")
env = normalize(exp.env)
stub(globals())
for seed in [1]: # [1, 5, 10, 73, 56]
policy = GaussianMLPPolicy(env_spec=env.spec, hidden_sizes=(16, ))
0, 22)
additional_env_params = {
"target_velocity": 8,
"max-deacc": 3,
"max-acc": 3,
"num_steps": 500
}
env_params = EnvParams(additional_params=additional_env_params)
additional_net_params = {
"length": 230,
"lanes": 1,
"speed_limit": 30,
"resolution": 40
}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig(bunching=20)
scenario = LoopScenario("sugiyama", CircleGenerator, vehicles, net_params,
initial_config)
env = SimpleAccelerationEnvironment(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
logging.info("Experiment Set Up complete")
exp.run(1, 1500)
from flow.core.params import SumoParams
from flow.envs.loop.loop_accel import ADDITIONAL_ENV_PARAMS
from flow.core.params import EnvParams
from flow.core.experiment import SumoExperiment
vehicles = Vehicles()
vehicles.add("human",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=22)
net_params = NetParams(additional_params=ADDITIONAL_NET_PARAMS)
initial_config = InitialConfig(spacing="uniform", perturbation=1)
traffic_lights = TrafficLights()
sumo_params = SumoParams(sim_step=0.1, render=True)
env_params = EnvParams(additional_params=ADDITIONAL_ENV_PARAMS)
# create the scenario object
scenario = LoopScenario(name="ring_example",
generator_class=CircleGenerator,
vehicles=vehicles,
net_params=net_params,
initial_config=initial_config,
traffic_lights=traffic_lights)
# create the environment object
env = AccelEnv(env_params, sumo_params, scenario)
# create the experiment object
exp = SumoExperiment(env, scenario)
# run the experiment for a set number of rollouts / time steps
exp.run(1, 3000)
from flow.envs.loop_accel import SimpleAccelerationEnvironment
from flow.scenarios.loop.loop_scenario import LoopScenario
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1, human_speed_mode="no_collide", human_lane_change_mode="strategic",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), None, (ContinuousRouter, {}), 0, 20)
env_params = EnvParams()
additional_net_params = {"length": 200, "lanes": 2, "speed_limit": 35, "resolution": 40}
net_params = NetParams(additional_params=additional_net_params)
initial_config = InitialConfig()
scenario = LoopScenario("single-lane-one-contr", CircleGenerator, vehicles, net_params,
initial_config)
env = SimpleAccelerationEnvironment(env_params, sumo_params, scenario)
exp = SumoExperiment(env, scenario)
logging.info("Experiment Set Up complete")
exp.run(2, 1000)
exp.env.terminate()