def main(scenarios, headless, seed):
agent_spec = AgentSpec(
interface=AgentInterface.from_type(AgentType.Laner,
max_episode_steps=None),
agent_builder=None,
observation_adapter=None,
)
smarts = SMARTS(
agent_interfaces={},
traffic_sim=SumoTrafficSimulation(headless=True, auto_start=True),
envision=Envision(),
)
scenarios_iterator = Scenario.scenario_variations(
scenarios,
list([]),
)
smarts.reset(next(scenarios_iterator))
for _ in range(5000):
smarts.step({})
smarts.attach_sensors_to_vehicles(
agent_spec, smarts.vehicle_index.social_vehicle_ids())
obs, _, _, _ = smarts.observe_from(
smarts.vehicle_index.social_vehicle_ids())
def main(scenarios: Sequence[str], headless: bool, seed: int):
agent_spec = AgentSpec(
interface=AgentInterface.from_type(AgentType.Laner,
max_episode_steps=None),
agent_builder=None,
observation_adapter=None,
)
smarts = SMARTS(
agent_interfaces={},
traffic_sim=SumoTrafficSimulation(headless=headless, auto_start=True),
envision=None if headless else Envision(),
)
scenarios_iterator = Scenario.scenario_variations(
scenarios,
list([]),
)
scenario = next(scenarios_iterator)
obs = smarts.reset(scenario)
collected_data = {}
_record_data(smarts.elapsed_sim_time, obs, collected_data)
# could also include "motorcycle" or "truck" in this set if desired
vehicle_types = frozenset({"car"})
while True:
smarts.step({})
current_vehicles = smarts.vehicle_index.social_vehicle_ids(
vehicle_types=vehicle_types)
if collected_data and not current_vehicles:
print("no more vehicles. exiting...")
break
smarts.attach_sensors_to_vehicles(agent_spec, current_vehicles)
obs, _, _, dones = smarts.observe_from(current_vehicles)
_record_data(smarts.elapsed_sim_time, obs, collected_data)
# an example of how we might save the data per car
for car, data in collected_data.items():
outfile = f"data_{scenario.name}_{scenario.traffic_history.name}_{car}.pkl"
with open(outfile, "wb") as of:
pickle.dump(data, of)
smarts.destroy()
def main(scenarios, headless, seed):
agent_spec = AgentSpec(
interface=AgentInterface.from_type(AgentType.Laner,
max_episode_steps=None),
agent_builder=None,
observation_adapter=None,
)
smarts = SMARTS(
agent_interfaces={},
traffic_sim=SumoTrafficSimulation(headless=headless, auto_start=True),
envision=None if headless else Envision(),
)
scenarios_iterator = Scenario.scenario_variations(
scenarios,
list([]),
)
smarts.reset(next(scenarios_iterator))
prev_vehicles = set()
done_vehicles = set()
for _ in range(5000):
smarts.step({})
current_vehicles = smarts.vehicle_index.social_vehicle_ids()
# We explicitly watch for which agent/vehicles left the simulation here
# since we don't have a "done criteria" that detects when a vehicle's
# traffic history has played itself out.
done_vehicles = prev_vehicles - current_vehicles
prev_vehicles = current_vehicles
smarts.attach_sensors_to_vehicles(agent_spec, current_vehicles)
obs, _, _, dones = smarts.observe_from(current_vehicles)
# The `dones` returned above should be empty for traffic histories
# where all vehicles are assumed to stay on the road and not collide.
# TODO: add the following assert once the maps are accurate enough that
# we don't have any agents accidentally go off-road.
# assert not done
for v in done_vehicles:
dones[f"Agent-{v}"] = True
# TODO: save observations for imitation learning
smarts.destroy()
def main(script: str, scenarios: Sequence[str], headless: bool, seed: int):
logger = logging.getLogger(script)
logger.setLevel(logging.INFO)
agent_spec = AgentSpec(
interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None),
agent_builder=None,
observation_adapter=None,
)
smarts = SMARTS(
agent_interfaces={},
traffic_sim=SumoTrafficSimulation(headless=headless, auto_start=True),
envision=None if headless else Envision(),
)
scenario_list = Scenario.get_scenario_list(scenarios)
scenarios_iterator = Scenario.variations_for_all_scenario_roots(scenario_list, [])
for scenario in scenarios_iterator:
obs = smarts.reset(scenario)
collected_data = {}
_record_data(smarts.elapsed_sim_time, obs, collected_data)
# could also include "motorcycle" or "truck" in this set if desired
vehicle_types = frozenset({"car"})
# filter off-road vehicles from observations
vehicles_off_road = set()
while True:
smarts.step({})
current_vehicles = smarts.vehicle_index.social_vehicle_ids(
vehicle_types=vehicle_types
)
if collected_data and not current_vehicles:
print("no more vehicles. exiting...")
break
for veh_id in current_vehicles:
try:
smarts.attach_sensors_to_vehicles(agent_spec.interface, {veh_id})
except ControllerOutOfLaneException:
logger.warning(f"{veh_id} out of lane, skipped attaching sensors")
vehicles_off_road.add(veh_id)
valid_vehicles = {v for v in current_vehicles if v not in vehicles_off_road}
obs, _, _, dones = smarts.observe_from(valid_vehicles)
_record_data(smarts.elapsed_sim_time, obs, collected_data)
# an example of how we might save the data per car
observation_folder = "collected_observations"
if not os.path.exists(observation_folder):
os.makedirs(observation_folder)
for car, data in collected_data.items():
outfile = f"{observation_folder}/{scenario.name}_{scenario.traffic_history.name}_{car}.pkl"
with open(outfile, "wb") as of:
pickle.dump(data, of)
smarts.destroy()
