def __init__(self, env_params, sim_params, network=None, simulator='traci', scenario=None): """Initialize the environment class. Parameters ---------- env_params : flow.core.params.EnvParams see flow/core/params.py sim_params : flow.core.params.SimParams see flow/core/params.py network : flow.networks.Network see flow/networks/base.py simulator : str the simulator used, one of {'traci', 'aimsun'}. Defaults to 'traci' Raises ------ flow.utils.exceptions.FatalFlowError if the render mode is not set to a valid value """ self.env_params = env_params if scenario is not None: deprecated_attribute(self, "scenario", "network") self.network = scenario if scenario is not None else network self.net_params = self.network.net_params self.initial_config = self.network.initial_config self.sim_params = deepcopy(sim_params) # check whether we should be rendering self.should_render = self.sim_params.render self.sim_params.render = False time_stamp = ''.join(str(time.time()).split('.')) if os.environ.get("TEST_FLAG", 0): # 1.0 works with stress_test_start 10k times time.sleep(1.0 * int(time_stamp[-6:]) / 1e6) # FIXME: this is sumo-specific self.sim_params.port = sumolib.miscutils.getFreeSocketPort() # time_counter: number of steps taken since the start of a rollout self.time_counter = 0 # step_counter: number of total steps taken self.step_counter = 0 # initial_state: self.initial_state = {} self.state = None self.obs_var_labels = [] # simulation step size self.sim_step = sim_params.sim_step # the simulator used by this environment self.simulator = simulator # create the Flow kernel self.k = Kernel(simulator=self.simulator, sim_params=self.sim_params) # use the network class's network parameters to generate the necessary # network components within the network kernel self.k.network.generate_network(self.network) # initial the vehicles kernel using the VehicleParams object self.k.vehicle.initialize(deepcopy(self.network.vehicles)) # initialize the simulation using the simulation kernel. This will use # the network kernel as an input in order to determine what network # needs to be simulated. kernel_api = self.k.simulation.start_simulation( network=self.k.network, sim_params=self.sim_params) # pass the kernel api to the kernel and it's subclasses self.k.pass_api(kernel_api) # the available_routes variable contains a dictionary of routes # vehicles can traverse; to be used when routes need to be chosen # dynamically self.available_routes = self.k.network.rts # store the initial vehicle ids self.initial_ids = deepcopy(self.network.vehicles.ids) # store the initial state of the vehicles kernel (needed for restarting # the simulation) self.k.vehicle.kernel_api = None self.k.vehicle.master_kernel = None self.initial_vehicles = deepcopy(self.k.vehicle) self.k.vehicle.kernel_api = self.k.kernel_api self.k.vehicle.master_kernel = self.k self.setup_initial_state() # use pyglet to render the simulation if self.sim_params.render in ['gray', 'dgray', 'rgb', 'drgb']: save_render = self.sim_params.save_render sight_radius = self.sim_params.sight_radius pxpm = self.sim_params.pxpm show_radius = self.sim_params.show_radius # get network polygons network = [] # FIXME: add to network kernel instead of hack for lane_id in self.k.kernel_api.lane.getIDList(): _lane_poly = self.k.kernel_api.lane.getShape(lane_id) lane_poly = [i for pt in _lane_poly for i in pt] network.append(lane_poly) # instantiate a pyglet renderer self.renderer = Renderer(network, self.sim_params.render, save_render, sight_radius=sight_radius, pxpm=pxpm, show_radius=show_radius) # render a frame self.render(reset=True) elif self.sim_params.render in [True, False]: # default to sumo-gui (if True) or sumo (if False) if (self.sim_params.render is True) and self.sim_params.save_render: self.path = os.path.expanduser( '~') + '/flow_rendering/' + self.network.name os.makedirs(self.path, exist_ok=True) else: raise FatalFlowError('Mode %s is not supported!' % self.sim_params.render) atexit.register(self.terminate)
def __init__( self, speed_mode='right_of_way', accel=2.6, decel=4.5, sigma=0.5, tau=1.0, # past 1 at sim_step=0.1 you no longer see waves min_gap=2.5, max_speed=30, speed_factor=1.0, speed_dev=0.1, impatience=0.5, car_follow_model="IDM", **kwargs): """Instantiate SumoCarFollowingParams.""" # check for deprecations (minGap) if "minGap" in kwargs: deprecated_attribute(self, "minGap", "min_gap") min_gap = kwargs["minGap"] # check for deprecations (maxSpeed) if "maxSpeed" in kwargs: deprecated_attribute(self, "maxSpeed", "max_speed") max_speed = kwargs["maxSpeed"] # check for deprecations (speedFactor) if "speedFactor" in kwargs: deprecated_attribute(self, "speedFactor", "speed_factor") speed_factor = kwargs["speedFactor"] # check for deprecations (speedDev) if "speedDev" in kwargs: deprecated_attribute(self, "speedDev", "speed_dev") speed_dev = kwargs["speedDev"] # check for deprecations (carFollowModel) if "carFollowModel" in kwargs: deprecated_attribute(self, "carFollowModel", "car_follow_model") car_follow_model = kwargs["carFollowModel"] # create a controller_params dict with all the specified parameters self.controller_params = { "accel": accel, "decel": decel, "sigma": sigma, "tau": tau, "minGap": min_gap, "maxSpeed": max_speed, "speedFactor": speed_factor, "speedDev": speed_dev, "impatience": impatience, "carFollowModel": car_follow_model, } # adjust the speed mode value if isinstance(speed_mode, str) and speed_mode in SPEED_MODES: speed_mode = SPEED_MODES[speed_mode] elif not (isinstance(speed_mode, int) or isinstance(speed_mode, float)): logging.error("Setting speed mode of to default.") speed_mode = SPEED_MODES["obey_safe_speed"] self.speed_mode = speed_mode
def __init__(self, lane_change_mode="no_lc_safe", model="LC2013", lc_strategic=1.0, lc_cooperative=1.0, lc_speed_gain=1.0, lc_keep_right=1.0, lc_look_ahead_left=2.0, lc_speed_gain_right=1.0, lc_sublane=1.0, lc_pushy=0, lc_pushy_gap=0.6, lc_assertive=1, lc_accel_lat=1.0, **kwargs): """Instantiate SumoLaneChangeParams.""" # check for deprecations (lcStrategic) if "lcStrategic" in kwargs: deprecated_attribute(self, "lcStrategic", "lc_strategic") lc_strategic = kwargs["lcStrategic"] # check for deprecations (lcCooperative) if "lcCooperative" in kwargs: deprecated_attribute(self, "lcCooperative", "lc_cooperative") lc_cooperative = kwargs["lcCooperative"] # check for deprecations (lcSpeedGain) if "lcSpeedGain" in kwargs: deprecated_attribute(self, "lcSpeedGain", "lc_speed_gain") lc_speed_gain = kwargs["lcSpeedGain"] # check for deprecations (lcKeepRight) if "lcKeepRight" in kwargs: deprecated_attribute(self, "lcKeepRight", "lc_keep_right") lc_keep_right = kwargs["lcKeepRight"] # check for deprecations (lcLookaheadLeft) if "lcLookaheadLeft" in kwargs: deprecated_attribute(self, "lcLookaheadLeft", "lc_look_ahead_left") lc_look_ahead_left = kwargs["lcLookaheadLeft"] # check for deprecations (lcSpeedGainRight) if "lcSpeedGainRight" in kwargs: deprecated_attribute(self, "lcSpeedGainRight", "lc_speed_gain_right") lc_speed_gain_right = kwargs["lcSpeedGainRight"] # check for deprecations (lcSublane) if "lcSublane" in kwargs: deprecated_attribute(self, "lcSublane", "lc_sublane") lc_sublane = kwargs["lcSublane"] # check for deprecations (lcPushy) if "lcPushy" in kwargs: deprecated_attribute(self, "lcPushy", "lc_pushy") lc_pushy = kwargs["lcPushy"] # check for deprecations (lcPushyGap) if "lcPushyGap" in kwargs: deprecated_attribute(self, "lcPushyGap", "lc_pushy_gap") lc_pushy_gap = kwargs["lcPushyGap"] # check for deprecations (lcAssertive) if "lcAssertive" in kwargs: deprecated_attribute(self, "lcAssertive", "lc_assertive") lc_assertive = kwargs["lcAssertive"] # check for deprecations (lcAccelLat) if "lcAccelLat" in kwargs: deprecated_attribute(self, "lcAccelLat", "lc_accel_lat") lc_accel_lat = kwargs["lcAccelLat"] # check for valid model if model not in ["LC2013", "SL2015"]: logging.error("Invalid lane change model! Defaulting to LC2013") model = "LC2013" if model == "LC2013": self.controller_params = { "laneChangeModel": model, "lcStrategic": str(lc_strategic), "lcCooperative": str(lc_cooperative), "lcSpeedGain": str(lc_speed_gain), "lcKeepRight": str(lc_keep_right), # "lcLookaheadLeft": str(lc_look_ahead_left), # "lcSpeedGainRight": str(lcSpeedGainRight) } elif model == "SL2015": self.controller_params = { "laneChangeModel": model, "lcStrategic": str(lc_strategic), "lcCooperative": str(lc_cooperative), "lcSpeedGain": str(lc_speed_gain), "lcKeepRight": str(lc_keep_right), "lcLookaheadLeft": str(lc_look_ahead_left), "lcSpeedGainRight": str(lc_speed_gain_right), "lcSublane": str(lc_sublane), "lcPushy": str(lc_pushy), "lcPushyGap": str(lc_pushy_gap), "lcAssertive": str(lc_assertive), "lcAccelLat": str(lc_accel_lat) } # adjust the lane change mode value if isinstance(lane_change_mode, str) and lane_change_mode in LC_MODES: lane_change_mode = LC_MODES[lane_change_mode] elif not (isinstance(lane_change_mode, int) or isinstance(lane_change_mode, float)): logging.error("Setting lane change mode to default.") lane_change_mode = LC_MODES["no_lc_safe"] self.lane_change_mode = lane_change_mode
def deprecate(old, new): deprecated_attribute(self, old, new) new_val = kwargs[old] del kwargs[old] return new_val
def __init__(self, env_params, sim_params, network=None, simulator='traci', scenario=None): """Initialize the environment class. Parameters ---------- env_params : flow.core.params.EnvParams see flow/core/params.py sim_params : flow.core.params.SimParams see flow/core/params.py network : flow.networks.Network see flow/networks/base.py simulator : str the simulator used, one of {'traci', 'aimsun'}. Defaults to 'traci' Raises ------ flow.utils.exceptions.FatalFlowError if the render mode is not set to a valid valuefor _ in range(self.env_params.sims_per_step): self.time_counter += 1 self.step_counter += 1 # perform acceleration actions for controlled human-driven vehicles if len(self.k.vehicle.get_controlled_ids()) > 0: accel = [] for veh_id in self.k.vehicle.get_controlled_ids(): action = self.k.vehicle.get_acc_controller( veh_id).get_action(self) accel.append(action) if self.k.vehicle.get_edge(veh_id)[0] == ":": if self.k.vehicle.get_speed(veh_id) <= 0.00000001: print(self.time_counter,'veh_id:',veh_id,'its leader:',self.k.vehicle.get_leader(veh_id),'headway to leader:',self.k.vehicle.get_headway(veh_id),'action:',action,'speed:',self.k.vehicle.get_speed(veh_id)) #if self.k.vehicle.get_leader(self.k.vehicle.get_leader(veh_id))==veh_id: # break self.k.vehicle.apply_acceleration( self.k.vehicle.get_controlled_ids(), accel) # perform lane change actions for controlled human-driven vehicles if len(self.k.vehicle.get_controlled_lc_ids()) > 0: direction = [] for veh_id in self.k.vehicle.get_controlled_lc_ids(): target_lane = self.k.vehicle.get_lane_changing_controller( veh_id).get_action(self) direction.append(target_lane) self.k.vehicle.apply_lane_change( self.k.vehicle.get_controlled_lc_ids(), direction=direction) # perform (optionally) routing actions for all vehicles in the # network, including RL and SUMO-controlled vehicles routing_ids = [] routing_actions = [] for veh_id in self.k.vehicle.get_ids(): if self.k.vehicle.get_routing_controller(veh_id) \ is not None: routing_ids.append(veh_id) route_contr = self.k.vehicle.get_routing_controller( veh_id) routing_actions.append(route_contr.choose_route(self)) self.k.vehicle.choose_routes(routing_ids, routing_actions) self.apply_rl_actions(rl_actions) #self.additional_command() # advance the simulation in the simulator by one step """ self.process_seeds_file = None self.env_params = env_params self.time_with_no_vehicles = 0 if scenario is not None: deprecated_attribute(self, "scenario", "network") self.network = scenario if scenario is not None else network self.net_params = self.network.net_params self.initial_config = self.network.initial_config self.sim_params = sim_params time_stamp = ''.join(str(time.time()).split('.')) if os.environ.get("TEST_FLAG", 0): # 1.0 works with stress_test_start 10k times time.sleep(1.0 * int(time_stamp[-6:]) / 1e6) # FIXME: this is sumo-specific self.sim_params.port = sumolib.miscutils.getFreeSocketPort() # time_counter: number of steps taken since the start of a rollout self.time_counter = 0 # step_counter: number of total steps taken self.step_counter = 0 # initial_state: self.initial_state = {} self.state = None self.obs_var_labels = [] # simulation step size self.sim_step = sim_params.sim_step # the simulator used by this environment self.simulator = simulator # create the Flow kernel self.k = Kernel(simulator=self.simulator, sim_params=sim_params) # use the network class's network parameters to generate the necessary # network components within the network kernel self.k.network.generate_network(self.network) # initial the vehicles kernel using the VehicleParams object self.k.vehicle.initialize(deepcopy(self.network.vehicles)) # initialize the simulation using the simulation kernel. This will use # the network kernel as an input in order to determine what network # needs to be simulated. kernel_api = self.k.simulation.start_simulation(network=self.k.network, sim_params=sim_params) # pass the kernel api to the kernel and it's subclasses self.k.pass_api(kernel_api) # the available_routes variable contains a dictionary of routes # vehicles can traverse; to be used when routes need to be chosen # dynamically self.available_routes = self.k.network.rts # store the initial vehicle ids self.initial_ids = deepcopy(self.network.vehicles.ids) # store the initial state of the vehicles kernel (needed for restarting # the simulation) self.k.vehicle.kernel_api = None self.k.vehicle.master_kernel = None self.initial_vehicles = deepcopy(self.k.vehicle) self.k.vehicle.kernel_api = self.k.kernel_api self.k.vehicle.master_kernel = self.k self.setup_initial_state() # use pyglet to render the simulation if self.sim_params.render in ['gray', 'dgray', 'rgb', 'drgb']: save_render = self.sim_params.save_render sight_radius = self.sim_params.sight_radius pxpm = self.sim_params.pxpm show_radius = self.sim_params.show_radius # get network polygons network = [] # FIXME: add to network kernel instead of hack for lane_id in self.k.kernel_api.lane.getIDList(): _lane_poly = self.k.kernel_api.lane.getShape(lane_id) lane_poly = [i for pt in _lane_poly for i in pt] network.append(lane_poly) # instantiate a pyglet renderer self.renderer = Renderer(network, self.sim_params.render, save_render, sight_radius=sight_radius, pxpm=pxpm, show_radius=show_radius) # render a frame self.render(reset=True) elif self.sim_params.render in [True, False]: pass # default to sumo-gui (if True) or sumo (if False) else: raise FatalFlowError('Mode %s is not supported!' % self.sim_params.render) atexit.register(self.terminate)