def setUp_gen_start_pos(
self, initial_config=InitialConfig()):
"""
Replace with any scenario you would like to test gen_gaussian_start_pos
on. In ordering for all the tests to be meaningful, the scenario must
contain MORE THAN TWO LANES.
"""
# create a multi-lane ring road network
additional_net_params = {"length": 230, "lanes": 4, "speed_limit": 30,
"resolution": 40}
net_params = NetParams(additional_params=additional_net_params)
# place 5 vehicles in the network (we need at least more than 1)
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=15)
initial_config.spacing = "gaussian_additive"
if initial_config.downscale == InitialConfig().downscale:
initial_config.downscale = np.inf
# create the environment and scenario classes for a ring road
self.env, scenario = ring_road_exp_setup(net_params=net_params,
initial_config=initial_config,
vehicles=vehicles)
def setUp(self):
# add a few vehicles to the network using the requested model
# also make sure that the input params are what is expected
contr_params = {
"v0": 30,
"T": 1,
"a": 1,
"b": 1.5,
"delta": 4,
"s0": 2,
"s1": 0,
"decel_max": -5,
"dt": 0.1,
"noise": 0
}
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(IDMController,
contr_params),
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
# create the environment and scenario classes for a ring road
self.env, scenario = ring_road_exp_setup(vehicles=vehicles)
def test_no_crash_LinearOVM(self):
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(LinearOVM, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=10)
self.setUp_failsafe(vehicles=vehicles)
# run the experiment, see if it fails
self.exp.run(1, 200)
self.tearDown_failsafe()
def setUp(self):
# place 15 vehicles in the network (we need at least more than 1)
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=15)
initial_config = InitialConfig(spacing="gaussian", scale=0, x0=150)
# create the environment and scenario classes for a ring road
self.env, scenario = figure_eight_exp_setup(
initial_config=initial_config,
vehicles=vehicles
)
def setUp(self):
# add a few vehicles to the network using the requested model
# also make sure that the input params are what is expected
contr_params = \
{"k_d": 1, "k_v": 1, "k_c": 1, "d_des": 1, "v_des": 8,
"accel_max": 15, "decel_max": -5, "tau": 0, "dt": 0.1, "noise": 0}
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(BCMController,
contr_params),
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
# create the environment and scenario classes for a ring road
self.env, scenario = ring_road_exp_setup(vehicles=vehicles)
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 setUp(self):
# turn on vehicle arrangement shuffle
sumo_params = SumoParams(vehicle_arrangement_shuffle=True)
# place 5 vehicles in the network (we need at least more than 1)
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
initial_config = InitialConfig(x0=5)
# create the environment and scenario classes for a ring road
self.env, scenario = ring_road_exp_setup(sumo_params=sumo_params,
initial_config=initial_config,
vehicles=vehicles)
def setUp(self):
# create a 2-lane ring road network
additional_net_params = {"length": 230, "lanes": 3, "speed_limit": 30,
"resolution": 40}
net_params = NetParams(additional_params=additional_net_params)
# turn on starting position shuffle
sumo_params = SumoParams(starting_position_shuffle=True)
# place 5 vehicles in the network (we need at least more than 1)
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="test",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
# create the environment and scenario classes for a ring road
self.env, scenario = ring_road_exp_setup(net_params=net_params,
sumo_params=sumo_params,
vehicles=vehicles)
def loop_merge_exp_setup(vehicles=None):
sumo_params = SumoParams(time_step=0.1,
human_speed_mode="no_collide",
sumo_binary="sumo")
if vehicles is None:
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="idm",
acceleration_controller=(IDMController, {}),
lane_change_controller=(StaticLaneChanger, {}),
num_vehicles=5)
vehicles.add_vehicles(veh_id="merge-idm",
acceleration_controller=(IDMController, {}),
lane_change_controller=(StaticLaneChanger, {}),
num_vehicles=5)
additional_env_params = {"target_velocity": 8, "max-deacc": -6,
"max-acc": 3}
env_params = EnvParams(additional_params=additional_env_params)
additional_net_params = {"merge_in_length": 200, "merge_in_angle": pi / 9,
"merge_out_length": 200,
"merge_out_angle": pi * 17 / 9,
"ring_radius": 200 / (2 * pi), "resolution": 40,
"lanes": 1, "speed_limit": 30}
net_params = NetParams(no_internal_links=False,
additional_params=additional_net_params)
initial_config = InitialConfig(spacing="custom",
additional_params={"merge_bunching": 0})
scenario = LoopMergesScenario("loop-merges", LoopMergesGenerator, vehicles,
net_params,
initial_config=initial_config)
env = SimpleLoopMergesEnvironment(env_params, sumo_params, scenario)
return env, scenario
from flow.controllers.routing_controllers import *
from flow.core.vehicles import Vehicles
from flow.core.experiment import SumoExperiment
from flow.envs.loop_accel import SimpleAccelerationEnvironment
from flow.scenarios.figure8.gen import Figure8Generator
from flow.scenarios.figure8.figure8_scenario import Figure8Scenario
from flow.controllers.car_following_models import *
from flow.controllers.lane_change_controllers import *
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), (StaticLaneChanger, {}),
(ContinuousRouter, {}), 0, 14)
additional_env_params = {"target_velocity": 8, "num_steps": 500}
env_params = EnvParams(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)
scenario = Figure8Scenario("figure8", Figure8Generator, vehicles, net_params)
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, 30)
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": 1500,
"horizontal_length_out": 1500,
"horizontal_lanes": 2,
"vertical_length_in": 1500,
"vertical_length_out": 1500,
"vertical_lanes": 2,
"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)
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, hidden_sizes=(64, 64))
#policy.set_no_rl_vehicles(30)
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=100,
discount=0.999,
# step_size=0.01,
)
algo.train()
from flow.core.experiment import SumoExperiment
from flow.envs.two_intersection import TwoIntersectionEnvironment
from flow.scenarios.intersections.gen import TwoWayIntersectionGenerator
from flow.scenarios.intersections.intersection_scenario import *
from flow.controllers.car_following_models import *
import logging
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1,
emission_path="./data/",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), None, None, 0, 20)
intensity = .2
v_enter = 10
env_params = EnvParams(
additional_params={
"target_velocity": v_enter,
"max-deacc": -6,
"max-acc": 3,
"control-length": 150,
"max_speed": v_enter
})
additional_net_params = {
"horizontal_length_in": 400,
from flow.core.vehicles import Vehicles
from flow.core.experiment import SumoExperiment
from flow.envs.loop_merges import SimpleLoopMergesEnvironment
from flow.scenarios.loop_merges.gen import LoopMergesGenerator
from flow.scenarios.loop_merges.loop_merges_scenario import LoopMergesScenario
from numpy import pi
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1, emission_path="./data/", human_speed_mode="no_collide",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), (StaticLaneChanger, {}), None, 0, 14)
vehicles.add_vehicles("merge-idm", (IDMController, {}), (StaticLaneChanger, {}), None, 0, 14)
additional_env_params = {"target_velocity": 8, "fail-safe": "None"}
env_params = EnvParams(additional_params=additional_env_params)
additional_net_params = {"merge_in_length": 500, "merge_in_angle": pi/9,
"merge_out_length": 500, "merge_out_angle": pi * 17/9,
"ring_radius": 400 / (2 * pi), "resolution": 40, "lanes": 1, "speed_limit": 30}
net_params = NetParams(no_internal_links=False, additional_params=additional_net_params)
initial_config = InitialConfig(spacing="custom",
additional_params={"merge_bunching": 250})
scenario = LoopMergesScenario("loop-merges", LoopMergesGenerator, vehicles, net_params,
initial_config=initial_config)
from flow.controllers.routing_controllers import ContinuousRouter
from flow.controllers.car_following_models import *
from flow.envs.loop_accel import SimpleAccelerationEnvironment
from flow.scenarios.loop.gen import CircleGenerator
from flow.scenarios.loop.loop_scenario import LoopScenario
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1,
human_speed_mode="aggressive",
sumo_binary="sumo-gui")
vehicles = Vehicles()
vehicles.add_vehicles("idm", (IDMController, {}), None, (ContinuousRouter, {}),
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
}
from flow.controllers.routing_controllers import *
from flow.envs.two_loops_one_merging import TwoLoopsOneMergingEnvironment
from flow.scenarios.two_loops_one_merging.gen import TwoLoopOneMergingGenerator
from flow.scenarios.two_loops_one_merging.two_loops_one_merging_scenario import TwoLoopsOneMergingScenario
logging.basicConfig(level=logging.INFO)
sumo_params = SumoParams(time_step=0.1, emission_path="./data/", human_speed_mode="no_collide",
sumo_binary="sumo-gui")
# note that the vehicles are added sequentially by the generator,
# so place the merging vehicles after the vehicles in the ring
vehicles = Vehicles()
vehicles.add_vehicles(veh_id="idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=12)
vehicles.add_vehicles(veh_id="merge-idm",
acceleration_controller=(IDMController, {}),
routing_controller=(ContinuousRouter, {}),
num_vehicles=5)
additional_env_params = {"target_velocity": 8, "max-deacc": -6, "max-acc": 3}
env_params = EnvParams(additional_params=additional_env_params)
additional_net_params = {"ring_radius": 230/(2*np.pi), "lanes": 1,
"speed_limit": 30, "resolution": 40}
net_params = NetParams(
no_internal_links=False,
additional_params=additional_net_params
)
