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()