def figure_eight_example(render=None): """Perform a simulation of vehicles on a figure eight. 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 on a figure eight. """ sim_params = AimsunParams(sim_step=0.5, render=False, emission_path='data') if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add(veh_id="human", acceleration_controller=(IDMController, {}), num_vehicles=14) env_params = EnvParams() net_params = NetParams(additional_params=ADDITIONAL_NET_PARAMS.copy()) scenario = Figure8Scenario(name="figure8", vehicles=vehicles, net_params=net_params) env = TestEnv(env_params, sim_params, scenario, simulator='aimsun') return Experiment(env)
def sugiyama_example(render=None): """Perform a simulation of vehicles on a ring road. 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 on a ring road. """ sim_params = AimsunParams(sim_step=0.5, render=True, emission_path='data') if render is not None: sim_params.render = render vehicles = VehicleParams() vehicles.add(veh_id="idm", acceleration_controller=(IDMController, {}), num_vehicles=22) env_params = EnvParams() additional_net_params = ADDITIONAL_NET_PARAMS.copy() net_params = NetParams(additional_params=additional_net_params) initial_config = InitialConfig(bunching=20) network = RingNetwork(name="sugiyama", vehicles=vehicles, net_params=net_params, initial_config=initial_config) env = TestEnv(env_params, sim_params, network, simulator='aimsun') return Experiment(env)
# name of the experiment exp_tag='aimsun_small_template', # name of the flow environment the experiment is running on env_name=TestEnv, # name of the network class the experiment is running on network=Network, # simulator that is used by the experiment simulator='aimsun', # sumo-related parameters (see flow.core.params.SumoParams) sim=AimsunParams(sim_step=0.1, render=True, emission_path='data', replication_name="Replication 930", centroid_config_name="Centroid Configuration 910"), # environment related parameters (see flow.core.params.EnvParams) env=EnvParams(horizon=3000, ), # network-related parameters (see flow.core.params.NetParams and the # network's documentation or ADDITIONAL_NET_PARAMS component) net=NetParams(inflows=InFlows(), template=template_path), # vehicles to be placed in the network at the start of a rollout (see # flow.core.params.VehicleParams) veh=vehicles, )
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 = AimsunParams(sim_step=0.5, render=render, restart_instance=restart_instance) vehicles = VehicleParams() vehicles.add(veh_id="human", 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": 30 / 3.6} net_params = NetParams(inflows=inflow, additional_params=additional_net_params) initial_config = InitialConfig(spacing="random", min_gap=5, lanes_distribution=float("inf"), edges_distribution=["2", "3", "4", "5"]) network = BottleneckNetwork(name="bay_bridge_toll", vehicles=vehicles, net_params=net_params, initial_config=initial_config, traffic_lights=traffic_lights) env = BottleneckEnv(env_params, sim_params, network, simulator='aimsun') return Experiment(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)
def run_task(*_): """Implement the run_task method needed to run experiments with rllab.""" sim_params = AimsunParams(sim_step=0.5, render=False, seed=0) vehicles = VehicleParams() 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": None, "max_accel": 1, "max_decel": 1 } env_params = EnvParams(horizon=HORIZON, additional_params=additional_env_params, warmup_steps=1500) additional_net_params = { "length": 230, "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, vehicles, net_params, initial_config=initial_config) env_name = "WaveAttenuationPOEnv" simulator = 'aimsun' pass_params = (env_name, sim_params, vehicles, env_params, net_params, initial_config, scenario, simulator) 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=(3, 3), ) 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(),
# Get the flow_params object. module = __import__("exp_configs.non_rl", fromlist=[flags.exp_config]) flow_params = getattr(module, flags.exp_config).flow_params # Get the custom callables for the runner. if hasattr(getattr(module, flags.exp_config), "custom_callables"): callables = getattr(module, flags.exp_config).custom_callables else: callables = None flow_params['sim'].render = not flags.no_render flow_params['simulator'] = 'aimsun' if flags.aimsun else 'traci' # If Aimsun is being called, replace SumoParams with AimsunParams. if flags.aimsun: sim_params = AimsunParams() sim_params.__dict__.update(flow_params['sim'].__dict__) flow_params['sim'] = sim_params # Specify an emission path if they are meant to be generated. if flags.gen_emission: flow_params['sim'].emission_path = "./data" # Create the flow_params object fp_ = flow_params['exp_tag'] dir_ = flow_params['sim'].emission_path with open(os.path.join(dir_, "{}.json".format(fp_)), 'w') as outfile: json.dump(flow_params, outfile, cls=FlowParamsEncoder, sort_keys=True,