def main(): Scenario(oracles=[CuckooFilter(fpp_threshold)]).run() Scenario(oracles=[CuckooFilter(fpp_threshold), CuckooFilter(0.00002)]).run() Scenario(oracles=[ CuckooFilter(fpp_threshold), CuckooFilter(0.000001), CuckooFilter(0.00001) ]).run() logger.print()
def main(): cfgs = Global_Cfgs() scenario = Scenario(scenario_name=cfgs.get('scenario')) start_scene = cfgs.get('start_scene') try: for scene in iter(scenario): if start_scene is None or scene.scene_name.strip().lower( ) == start_scene.strip().lower(): start_scene = None scene.run_scene() else: Console_UI().inform_user( f'Skip \'{scene.scene_name}\' - waiting for \'{start_scene}\'' ) except RuntimeError as error: Console_UI().warn_user(error) Console_UI().inform_user("\n\n Traceback: \n") traceback.print_exc() except KeyboardInterrupt: Console_UI().inform_user( f'\nInterrupted by ctrl+c - stopped ad "{scene.scene_name}"') else: Console_UI().inform_user("Done with all scenarios!") Console_UI().inform_user('To view results, checkout the tensorboard:') Console_UI().inform_user( f'tensorboard --logdir /media/max/HD_1_3TB/log/{cfgs.sub_log_path}/tensorboard' )
def create_scenarios(): alt_opt_cfg = join(faster_rcnn_root, "experiments/cfgs/faster_rcnn_alt_opt.yml") base_scenario = Scenario( scenarios_dir=scenarios_dir, scenario="scales_2_4_8", train_imdb="technicaldrawings_single-numbers_train", test_imdb="technicaldrawings_single-numbers_val", weights_path=join(faster_rcnn_root, "data/imagenet_models/ZF.v2.caffemodel"), # you have to download this first gpu_id=0, max_iters=[1, 1, 1, 1], # max iters rpn_config=RpnConfig(num_classes=2, anchor_scales=[8, 16, 32], anchor_feat_stride=16), fast_rcnn_config=FastRcnnConfig(num_classes=2), solver_config=SolverConfig(), config=yaml.load(open(alt_opt_cfg)) ) small_scales = deepcopy(base_scenario) small_scales.name("scales_4_8_16") small_scales.rpn_config.anchor_scales = [4, 8, 16] small_scales.fast_rcnn_config.anchor_scales = small_scales.rpn_config.anchor_scales default_scales = deepcopy(base_scenario) default_scales.name("scales_8_16_32") default_scales.rpn_config.anchor_scales = [8, 16, 32] default_scales.fast_rcnn_config.anchor_scales = default_scales.rpn_config.anchor_scales large_scales = deepcopy(base_scenario) large_scales.name("scales_16_32_64") large_scales.rpn_config.anchor_scales = [16, 32, 64] large_scales.fast_rcnn_config.anchor_scales = large_scales.rpn_config.anchor_scales return small_scales, default_scales, large_scales
def main(): random.seed(42) scenario_file = "input/market_patterns.csv" df_scenarios = pd.read_csv(scenario_file) for col in ["start", "end"]: df_scenarios[col] = pd.to_datetime(df_scenarios[col]) scenarios = [] for i, row in df_scenarios.iterrows(): if row["skip"] == "yes": continue del row["skip"] s = Scenario(**row) s.populate_data() scenarios.append(s) stg_class = ExpRatioStrategy # stg_class = LinearRatioStrategy for i, scenario in enumerate(scenarios): st = StrategyTrainer(stg_class=stg_class) st.prepare(pop_size=100, ngen=100, sigma_divider=1000) # if i == 1: # continue print(f"Training under {scenario}...") st.update_scenario(scenario) stg = st.train(verbose=True) print(f"Best strategy under {scenario}: {stg}") print("Scenario: {}".format("\t".join(map(str, stg.params))))
def add_new_scenario(self, settings, yeah_id=None, next_block_id=0, next_link_id=0): """ Adds a new scenario to the kernel, using the settings given as argument. Other optional arguments may be given - they are only used when this function is used in the process of persistence: at restoration, we must ensure that scenarios have the same id than they had before saving. :param settings: The settings dictionary that will be used to initialize the scenario. :type element: :class:`python dict` :param yeah_id: (optional) the id to give to the new scenario, only used in the process of persistence. :type element: :class:`string` :param next_block_id: (optional) used to set the next_block_id attribute of the new scenario, only used in the process of persistence :type element: :class:`int` :param next_link_id: (optional) sed to set the next_link_id attribute of the new scenario, only used in the process of persistence :type element: :class:`int` """ new_scenario = Scenario(self, settings=settings, next_block_id=next_block_id, next_link_id=next_link_id) if yeah_id == None: self.id = self.next_scenario_id new_scenario.id = 'scenario' + str(self.next_scenario_id) self.next_scenario_id += 1 else: new_scenario.id = yeah_id self.add(new_scenario) return new_scenario
def main(scenario_name, ic_name='std_ic', save=False): """Run the offline path planner. This function import the scenario named 'scenario_name' from the folder /cfg/ and takes the initial conditions named 'ic_name' from the yaml file /cfg/initial_conditions.yaml. After importing, it solves it and saves it (if save flag is true) in a .pickle file in the /example/ folder. Args: scenario_name (str): The name of the scenario which should be solved. ic_name (str): The initial condition name which should be used. save (bool): Boolean flag to save and store the result. Return: tot_dV (float): Total amount of deltaV consumed in km/s. chaser (Chaser): Chaser state after the mission (used for testing). """ # Import scenario and initial conditions scenario = Scenario() scenario.import_yaml_scenario(scenario_name, ic_name) # Solve scenario solver = Solver() solver.initialize_solver(scenario) solver.solve_scenario() # Save manoeuvre plan if save: scenario.export_solved_scenario(solver.manoeuvre_plan) return solver.tot_dV, solver.chaser
def test_scenario_one_multiple_searcher(self): m = BasicMap(15, 15) middle = (7,7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) searchers = [] for i in range(10): # Add some searchers to the map searcher = RandomWalkSearcher(m) searcher.init(middle) searchers.append(searcher) s = Scenario(m, [lp00], searchers) s.simulate(100) # Simulate for N time steps print("lost person history: \n") print(lp00.get_history()) print("\n") for i in range(10): print("searcher history: " , i) print(searchers[i].get_history()) print("\n")
def create_latency_vs_percent_found(max_latency, number_samples, max_timestep): iterations = [] for i in trange(max_latency): num_yes = 0 for j in range(number_samples): m = BasicMap(15, 15) middle = (7, 7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Add some searchers to the map searcher00 = RandomWalkSearcher(m) searcher00.init(middle) s = Scenario(m, [lp00], [searcher00], i) count = s.simulate(max_timestep) # Simulate for N time steps if s.num_rescued > 0: num_yes += 1 perc_found = num_yes / number_samples iterations.append(perc_found * 100) plt.plot(iterations) plt.xlabel('Latency') plt.ylabel('% lost persons found') plt.savefig('latency_vs_percent_found.pdf', bbox_inches='tight') plt.close()
def create_searchers_vs_time(max_searchers, latency, number_samples, num_time_steps): iterations = [] for num_searchers in trange(1, max_searchers + 1): total = 0 for i in range(number_samples): m = BasicMap(15, 15) middle = (7, 7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) searchers = [] for j in range(num_searchers): # Add some searchers to the map searcher = RandomWalkSearcher(m) searcher.init(middle) searchers.append(searcher) s = Scenario(m, [lp00], searchers) count = s.simulate(num_time_steps) # Simulate for N time steps total += count avg = total / number_samples iterations.append(avg) plt.plot(list(range(1, max_searchers + 1)), iterations) plt.xlabel('Number of searchers') plt.ylabel('Average number of search time steps') plt.savefig('searchers_vs_time.pdf', bbox_inches='tight') plt.close()
def get_latest_scenario(scenario_id, my_jwt=None): my_saved_scenario = SavedScenario.query.get(scenario_id) if my_saved_scenario: package_id = my_saved_scenario.package_id else: package_id = DEMO_PACKAGE_ID if scenario_id.startswith("demo"): tablename = "jump_scenario_details_demo" else: tablename = "jump_scenario_details_paid" rows = None with get_db_cursor() as cursor: command = u"""select scenario_json from {} where scenario_id='{}' order by updated desc limit 1;""".format( tablename, scenario_id) # print command cursor.execute(command) rows = cursor.fetchall() scenario_data = None if rows: scenario_data = json.loads(rows[0]["scenario_json"]) my_scenario = Scenario(package_id, scenario_data, my_jwt=my_jwt) return my_scenario
def create_latency_vs_timestep(max_latency, number_samples, max_timestep): iterations = [] for i in trange(max_latency): total = 0 for j in range(number_samples): m = BasicMap(15, 15) middle = (7, 7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Add some searchers to the map searcher00 = RandomWalkSearcher(m) searcher00.init(middle) s = Scenario(m, [lp00], [searcher00], i) count = s.simulate(max_timestep) # Simulate for N time steps total += count avg = total / number_samples iterations.append(avg) plt.plot(iterations) plt.xlabel('Latency') plt.ylabel('Average number of search time steps') plt.savefig('latency_vs_time_steps.pdf', bbox_inches='tight') plt.close()
def get_quadrantPartitionPerformance(num_searchers=15, max_timestep=100, latency=15, number_samples=1000): iterations = [] for i in range(0, num_searchers + 1): total = 0 for j in range(number_samples): m = BasicMap(15, 15) partitioner = QuadrantPartitioner() [rows_midpoint, cols_midpoint] = partitioner.partition(m) quad01_rows = (0, rows_midpoint) quad01_cols = (0, cols_midpoint) quad02_rows = (0, rows_midpoint) quad02_cols = (cols_midpoint, m.numColumns() - 1) quad03_rows = (rows_midpoint, m.numRows() - 1) quad03_cols = (0, cols_midpoint - 1) quad04_rows = (rows_midpoint, m.numRows() - 1) quad04_cols = (cols_midpoint, m.numColumns() - 1) middle = (7, 7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Add some searchers to the map searchers = [] for j in range(0, i): if j % 4 == 0: # Assign to quadrant 1 searcher = RandomWalkSearcher(m, quad01_rows, quad01_cols) elif j % 4 == 1: # Assign to quadrant 2 searcher = RandomWalkSearcher(m, quad02_rows, quad02_cols) elif j % 4 == 2: # Assign to quadrant 3 searcher = RandomWalkSearcher(m, quad03_rows, quad03_cols) else: # Assign to quadrant 4 searcher = RandomWalkSearcher(m, quad04_rows, quad04_cols) searcher.init(middle) searchers.append(searcher) s = Scenario(m, [lp00], searchers, latency) count = s.simulate(max_timestep) # Simulate for N time steps total += count avg = total / number_samples iterations.append(avg) plt.title("searchers vs time step") plt.plot(list(range(len(iterations))), iterations) plt.xlabel('searchers') plt.ylabel('time step') plt.show() print(iterations) return iterations
def runSimulation(seed): ''' Temporarily putting a main function here to cycle through scenarios''' print("===========================================") print("THE ETHICAL ENGINE") print("===========================================") print() set_seed(seed) keepRunning = True while keepRunning: scene = Scenario() print(scene) print() result = ruleset1(scene) # result = ruleset2(scene) # result = ruleset3(scene) # result = my_decision(scene) print() input('Hit any key to see decision: ') print('I choose to save the', result) print() # For breaking the loop response = input("Hit 'q' to quit or 'enter' to continue: ") if response == 'q': keepRunning = False print('Done')
def run_exp(scenario, remove_small, or_level, current_sites, remove_timeout, exclude_sites, _rnd): config.OR_LEVEL = config.OR_LEVEL if or_level is None else or_level config.REMOVE_SMALL = (config.REMOVE_SMALL if remove_small is None else remove_small) config.REMOVE_TIMEOUT = (config.REMOVE_TIMEOUT if remove_timeout is None else remove_timeout) scenario_obj = Scenario(scenario, exclude_sites=exclude_sites) traces = scenario_obj.get_traces(current_sites=current_sites) result = analyse.simulated_original(traces) X, y, d = scenario_obj.get_features_cumul(current_sites) X = preprocessing.MinMaxScaler().fit_transform(X) # scaling is idempotent clf = result.clf.estimator y_pred = model_selection.cross_val_predict(clf, X, y, cv=10, n_jobs=config.JOBS_NUM) _add_as_artifact(y.tolist(), "y_true") _add_as_artifact(y_pred.tolist(), "y_prediction") _add_as_artifact(d, "y_domains") return { 'C': result.clf.estimator.C, 'gamma': result.clf.estimator.gamma, 'sites': traces.keys(), 'score': result.best_score_, 'type': "cumul", 'C_gamma_result': _format_results(result.results), # todo: remove duplicates (or_level...), after checking that they match 'outlier_removal': scenario_obj.trace_args, 'size_increase': scenario_obj.size_increase(), 'time_increase': scenario_obj.time_increase() }
def start(self): pygame.init() scenario = Scenario(self.width, self.height) clock = pygame.time.Clock() scenario.create_scenario() while True: clock.tick(30) scenario.create_character() # scenario.create_scenario() # print(clock.get_fps()) keys = pygame.key.get_pressed() # Este -for- "vigia" cada evento do jogo, caso a letra q seja pressionada # ou clique no botão de fechar a janela o jogo encerra. for event in pygame.event.get(): if event.type == QUIT or keys[pygame.K_ESCAPE]: print("Bye...") pygame.quit() exit() pygame.display.update()
def make_env(): w = Scenario() world = w.make_world() env = MultiAgentEnv(world, w.reset_world, w.reward, w.observation, w.get_direct_angle, w.has_winner) return env
def get_game_scenario(self, location): x, y = location try: game_scenario = self.game_scenarios[str(x) + "x" + str(y)] except KeyError: game_scenario = self.game_scenarios["default"] return Scenario(**game_scenario)
def start(self, input_event=None): with self.__lock: if self.status() == 0: if input_event: self.__scenario = input_event try: if not isinstance(self.__scenario, Scenario): if self.__scenario is None: raise Exception( "No input given (either dict or scenario)") self.__scenario = Scenario(self.__scenario) self.__status = 1 self.msg("Input event = " + str(self.__scenario)) #self.msg("Database event = "+ self.__scenario.dbstr()) except Exception as e: if _DEBUG_: import traceback traceback.print_exc() self.stop(e) #raise e return self
def __init__(self, w, h): super().__init__(w, h) self.scenario = Scenario() self.width_bound = [1, w - 1] self.height_bound = [1, h - 1] self.evaluation_unit = 10 #Enables/Disables EA self.strategy_aware = True self.goal_aware = True # each goal can be seperately turned on/off self.resource_aware = True #awareness of broken bulbs #awarenss of window and its control system self.context_aware = True #window controls system self.domain_aware = True #window gives light # time awareness: Pattern detected --> the mid section is always empty # Mid section should be ignore in initial population and mutations, it will lead to more efficient strategy generation. it worked! mutate() and generate_individuals() have been updated to reflect this. self.time_aware = True self.time_aware_width_bound = [0, self.width] self.time_aware_height_bound = [ int(self.height * 0.35), int(self.width * 0.65) ] # hypothesis:? self.goals = { 'luminosity': { 'enabled': True, 'maximize': True, 'evaluate': self.evaluate_luminosity }, 'cost': { 'enabled': True, 'maximize': False, 'evaluate': self.evaluate_cost } } self.weight = { 'present': 6.0, #luminosity 'cost': 4.0, 'penalty_broken_bulb': 12.0, 'context': 3.5 #time: } #self.presence, self.bulbs = self.scenario.diagonal(self.width, self.height) #self.presence, self.bulbs = self.scenario.stripes(self.width, self.height) #self.presence, self.bulbs = self.scenario.corners(self.width, self.height) self.presence, self.bulbs = self.scenario.corners2( self.width, self.height) #self.presence, self.bulbs = self.scenario.extreme(self.width, self.height) if self.strategy_aware: self.init_deap()
def __init__(self, w, h): super().__init__(w,h) self.scenario = Scenario() self.width_bound = [1, w-2] self.height_bound = [1, h-2] #self.presence, self.bulbs = self.scenario.diagonal(self.width, self.height) #self.presence, self.bulbs = self.scenario.corners(self.width, self.height) self.presence, self.bulbs = self.scenario.corners2(self.width, self.height) self.init_figures()
def run(working_map:Map): """ La fonction 'run' lance l'animation sur la Map passé en paramètre :parameters working_map: Classe `Map` correspondant à la carte sur laquelle faire l'animation """ # Création du contexte graphique fig, ax = plt.subplots() plt.ion() ax.margins(0,0) ax.axis("equal") # Création de la carte simulation_map = working_map(ax) # Création de la carte # Option d'affage de la route (voie des véhicules) if SHOW_ROADS: for roadmap in simulation_map.roadmap: ax.plot( [pos.x for pos in roadmap], [pos.y for pos in roadmap], color='lightgray', linestyle='--' # Affiche en pointillé gris clair ) # Création de la liste de véhicules traffic = [Vehicule(axe=ax, path=simulation_map.roadmap[rd.randint(0, len(simulation_map.roadmap) - 1)]) for x in range(NB_VEHICULE)] # Génération de l'animation departure_time = [x for x in range(0, MAX_DEPARTURE, MIN_TIME)] # On définit les heures de départ possibles for i, vehicule in enumerate(traffic): # Pour chaque véhicule ... # ... on choisit une heure de départ au hasard et jamais la même heure vehicule.start(departure_time.pop(rd.randint(0,len(departure_time)-1))) # ... On choisie au hasard une vitesse initiale de véhicule vehicule.speed = [1,2,3,4][rd.randint(0,3)] # Création du film (instantiation du scénario) movie = Scenario(ax) # Affichage du paysage simulation_map.landscape() # Lancement de l'animation ani = animation.FuncAnimation(fig=fig, func=movie, frames=movie.get_sequence(), interval=FRAMES_INTERVAL, blit=True, save_count=2000, # Nombre de frame tampon (calculé par avance ) #ani.save('./video_TIPE.mp4', fps=30) plt.show(True) return ani
def __init__(self, w, h): super().__init__(w, h) self.width_bound = [1, w - 2] self.height_bound = [1, h - 2] self.scenario = Scenario() #self.presence, self.bulbs = self.scenario.diagonal(self.width, self.height) #self.presence, self.bulbs = self.scenario.corners(self.width, self.height) self.presence, self.bulbs = self.scenario.corners2( self.height, self.width) #self.presence, self.bulbs = self.scenario.stripes(self.width, self.height) self.plans = [] self.generate_plans(20)
def get_lanePartitionPerformance(num_searchers=15, max_timestep=100, max_latency=15, number_samples=100): # TODO - Finish this. iterations = [] num_rows = 15 num_cols = 15 for i in range(1, num_searchers + 1): # Get our lanes!!! lanes = [] lane_size = (num_cols - 1) / i for j in range(0, i): lower = j * lane_size upper = (j + 1) * lane_size lanes.append((math.floor(lower) + 1, math.floor(upper))) lanes[0] = (0, lanes[0][1]) print(lanes) total = 0 for j in range(number_samples): m = BasicMap(15, 15) middle = (7, 7) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Add some searchers to the map searchers = [] for k in range(0, len(lanes)): searcher = VerticalSweepSearcher(m, lanes[k]) searcher.init((0, math.floor((lanes[k][0] + lanes[k][1]) / 2))) searchers.append(searcher) s = Scenario(m, [lp00], searchers, max_latency) count = s.simulate(max_timestep) # Simulate for N time steps total += count avg = total / number_samples iterations.append(avg) plt.title("latency vs time step") plt.plot(list(range(len(iterations))), iterations) plt.xlabel('latency') plt.ylabel('time step') plt.show() print(iterations) return iterations
def getNoPartitionStats(num_searchers, number_samples, max_timestep, latency): num_yes = 0 avg_found = [] perc_found = 0 num_timesteps_successful = [] num_timesteps_overall = [] for i in range(number_samples): m = BasicMap(101, 101) middle = (50, 50) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Add some searchers to the map searchers = [] for j in range(0, num_searchers): searcher = RandomWalkSearcher(m) searcher.init(middle) searchers.append(searcher) s = Scenario(m, [lp00], searchers, latency=latency) count = s.simulate(max_timestep) # Simulate for N time steps if count < max_timestep: num_yes += 1 num_timesteps_successful.append(count) num_timesteps_overall.append(count) perc_found = num_yes / (i + 1) perc_found = perc_found * 100 avg_found.append(perc_found) # Graph convergence plt.title( "Convergence to expected probability of success, no partitioning") plt.plot(list(range(number_samples)), avg_found) plt.xlabel('Number of Samples') plt.ylabel('Probability of Success') plt.savefig('convergence_psucess.png') print("Result: Percent Lost Person Discovered = " + str(perc_found)) print("Average Number of Time Steps (when successful): " + str(sum(num_timesteps_successful) / len(num_timesteps_successful))) print("Standard deviation: " + str(statistics.stdev(num_timesteps_successful))) print("Average Number of Time Steps (overall): " + str(sum(num_timesteps_overall) / len(num_timesteps_overall))) print("Standard deviation: " + str(statistics.stdev(num_timesteps_overall)))
def __init__(self, w, h): super().__init__(w,h) self.scenario = Scenario() #self.presence, self.bulbs = self.scenario.diagonal(self.width, self.height) #self.presence, self.bulbs = self.scenario.stripes(self.width, self.height) self.presence, self.bulbs = self.scenario.corners(self.width, self.height) self.init_deap() self.init_figures() self.pop = self.toolbox.population(n=1000)
def test_scenario_randomWalker(self): m = BasicMap(10, 10) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init((2, 5)) # Add some searchers to the map searcher00 = StationarySearcher(m) searcher00.init((4, 8)) s = Scenario(m, [lp00], [searcher00]) s.simulate(10) # Simulate for N time steps print(lp00.get_history()) print(searcher00.get_history())
def test_scenario_shortestPath(self): m = BasicMap(10, 10) # Add some lost persons to the map lp00 = ShortestPathLostPerson(m, (0, 9)) lp00.init((2, 5)) # Add some searchers to the map searcher00 = StationarySearcher(m) searcher00.init((1, 9)) s = Scenario(m, [lp00], [searcher00], True) s.simulate(100) # Simulate for N time steps print(lp00.get_history()) print(searcher00.get_history())
def test_quadrant_partitioner(self): m = BasicMap(25, 25) middle = (12, 12) # Add some lost persons to the map lp00 = RandomWalkLostPerson(m) lp00.init(middle) # Partition map into quadrants searchers = [] partitioner = QuadrantPartitioner() [rows_midpoint, cols_midpoint] = partitioner.partition(m) quad01_rows = (0, rows_midpoint) quad01_cols = (0, cols_midpoint) s00 = RandomWalkSearcher(m, quad01_rows, quad01_cols) s00.init(middle) searchers.append(s00) quad02_rows = (0, rows_midpoint) quad02_cols = (cols_midpoint, m.numColumns()-1) s01 = RandomWalkSearcher(m, quad02_rows, quad02_cols) s01.init(middle) searchers.append(s01) quad03_rows = (rows_midpoint, m.numRows()-1) quad03_cols = (0, cols_midpoint-1) s02 = RandomWalkSearcher(m, quad03_rows, quad03_cols) s02.init(middle) searchers.append(s02) quad04_rows = (rows_midpoint, m.numRows()-1) quad04_cols = (cols_midpoint, m.numColumns()-1) s03 = RandomWalkSearcher(m, quad04_rows, quad04_cols) s03.init(middle) searchers.append(s03) scenario = Scenario(m, [lp00], searchers, latency=50) scenario.simulate(100) print("lost person history: \n") print(lp00.get_history()) print("\n") for i in range(4): print("searcher history: " , i) print(searchers[i].get_history()) print("\n")
def __init__(self, settings): # ----- init simulator ----- self.simulation_id = settings['simulation_id'] if settings[ 'simulation_id'] else random.randint(1000, 9999) self.time = 0.0 self.time_step = 1.0 random.seed(self.simulation_id) # ----- create scenario ----- scenario = Scenario(settings['scenario_type'], settings['scenario_id']) self.scenario_type = scenario.scenario_type self.scenario_id = scenario.scenario_id self.time_max = scenario.time_max # ----- init logger ----- self.logger = Logger(settings['logger_verbose_level']) # ----- init reporter ----- reporter_settings = { 'print_enabled': settings['reporter_print'], 'export_enabled': settings['reporter_export'] } reporter_init_data = { 'experiment_id': settings['experiment_id'], 'scenario_type': self.scenario_type, 'scenario_id': self.scenario_id, 'time_max': self.time_max, 'simulation_id': self.simulation_id, 'planner': settings['planner'], 'agents_ids': [ agent_specs['id'] for agent_specs in scenario.team_specs['agents_specs'] ], } self.reporter = Reporter(reporter_settings, reporter_init_data) # ----- init behavior & team ----- self.behavior = Behavior(scenario.behavior_specs, scenario.actions_names, self.logger) self.team = Team(scenario.team_specs, settings['planner'], self.logger, self.reporter)
def audit(decision_fn, num_scenarios=100000, seed=None): log_file = get_log_file(decision_fn.__name__) if seed is not None: set_seed(seed) for _ in range(num_scenarios): scenario = Scenario(youInCar=False, legalCrossing=False, pedsInLane=True) decision = decision_fn(scenario) if decision not in ['passengers', 'pedestrians']: print(scenario) message = 'Expected "passengers" or "pedestrian", ' message += 'but got "{}" instead'.format(decision) raise ValueError(message) log_scenario(log_file, scenario, decision) calculate_stats(log_file)