def run_optimal(results_path, benchmark_name, num_episodes, seeds=np.arange(10)): bench = getattr(benchmarks, benchmark_name)() if benchmark_name == "LubyBenchmark": policy = optimal_luby elif benchmark_name == "SigmoidBenchmark": policy = optimal_sigmoid elif benchmark_name == "FastDownwardBenchmark": policy = optimal_fd elif benchmark_name == "CMAESBenchmark": policy = csa else: print("No comparison policy found for this benchmark") return for s in seeds: env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper(env) agent = GenericAgent(env, policy) run_benchmark(env, agent, num_episodes) performance = env.get_performance()[0] filedir = results_path + "/" + benchmark_name + "/optimal" filename = f"{filedir}/seed_{s}.json" if not os.path.exists(results_path): os.makedirs(results_path) if not os.path.exists(results_path + "/" + benchmark_name): os.makedirs(results_path + "/" + benchmark_name) if not os.path.exists(filedir): os.makedirs(filedir) with open(filename, "w+") as fp: json.dump(performance, fp)
def run_static(results_path, benchmark_name, action, num_episodes, seeds=np.arange(10)): bench = getattr(benchmarks, benchmark_name)() for s in seeds: env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper(env) agent = StaticAgent(env, action) run_benchmark(env, agent, num_episodes) performance = env.get_performance()[0] filedir = results_path + "/" + benchmark_name + "/static_" + str( action) filename = f"{filedir}/seed_{s}.json" if not os.path.exists(results_path): os.makedirs(results_path) if not os.path.exists(results_path + "/" + benchmark_name): os.makedirs(results_path + "/" + benchmark_name) if not os.path.exists(filedir): os.makedirs(filedir) with open(filename, "w+") as fp: json.dump(performance, fp)
def run_policy(results_path, benchmark_name, num_episodes, policy, seeds=np.arange(10)): bench = getattr(benchmarks, benchmark_name)() for s in seeds: if benchmark_name == "CMAESBenchmark": experiment_name = f"csa_{s}" else: experiment_name = f"optimal_{s}" logger = Logger(experiment_name=experiment_name, output_path=results_path / benchmark_name) env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper( env, logger=logger.add_module(PerformanceTrackingWrapper)) agent = GenericAgent(env, policy) logger.add_agent(agent) logger.add_benchmark(bench) logger.set_env(env) run_benchmark(env, agent, num_episodes, logger) logger.close()
def test_dict_logging(self): temp_dir = tempfile.TemporaryDirectory() seed = 0 episodes = 2 logger = Logger( output_path=Path(temp_dir.name), experiment_name="test_dict_logging", step_write_frequency=None, episode_write_frequency=1, ) bench = CMAESBenchmark() bench.set_seed(seed) env = bench.get_environment() state_logger = logger.add_module(StateTrackingWrapper) wrapped = StateTrackingWrapper(env, logger=state_logger) agent = StaticAgent(env, 3.5) logger.set_env(env) run_benchmark(wrapped, agent, episodes, logger) state_logger.close() logs = load_logs(state_logger.get_logfile()) dataframe = log2dataframe(logs, wide=False) state_parts = { "Loc": 10, "Past Deltas": 40, "Population Size": 1, "Sigma": 1, "History Deltas": 80, "Past Sigma Deltas": 40, } names = dataframe.name.unique() def field(name: str): state, field_, *idx = name.split("_") return field_ parts = groupby(sorted(names), key=field) for part, group_members in parts: expected_number = state_parts[part] actual_number = len(list(group_members)) self.assertEqual(expected_number, actual_number) temp_dir.cleanup()
def run_random(results_path, benchmark_name, num_episodes, seeds, fixed): bench = getattr(benchmarks, benchmark_name)() for s in seeds: if fixed > 1: experiment_name = f"random_fixed{fixed}_{s}" else: experiment_name = f"random_{s}" logger = Logger(experiment_name=experiment_name, output_path=results_path / benchmark_name) env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper( env, logger=logger.add_module(PerformanceTrackingWrapper)) agent = DynamicRandomAgent(env, fixed) logger.add_agent(agent) logger.add_benchmark(bench) logger.set_env(env) run_benchmark(env, agent, num_episodes, logger) logger.close()
def test_box_logging(self): temp_dir = tempfile.TemporaryDirectory() seed = 0 episodes = 10 logger = Logger( output_path=Path(temp_dir.name), experiment_name="test_box_logging", step_write_frequency=None, episode_write_frequency=1, ) bench = LubyBenchmark() bench.set_seed(seed) env = bench.get_environment() state_logger = logger.add_module(StateTrackingWrapper) wrapped = StateTrackingWrapper(env, logger=state_logger) agent = StaticAgent(env, 1) logger.set_env(env) run_benchmark(wrapped, agent, episodes, logger) state_logger.close() logs = load_logs(state_logger.get_logfile()) dataframe = log2dataframe(logs, wide=True) sate_columns = [ "state_Action t (current)", "state_Step t (current)", "state_Action t-1", "state_Action t-2", "state_Step t-1", "state_Step t-2", ] for state_column in sate_columns: self.assertTrue(state_column in dataframe.columns) self.assertTrue((~dataframe[state_column].isna()).all()) temp_dir.cleanup()
def run_optimal(results_path, benchmark_name, num_episodes, seeds=np.arange(10)): bench = getattr(benchmarks, benchmark_name)() if benchmark_name == "LubyBenchmark": policy = optimal_luby elif benchmark_name == "SigmoidBenchmark": policy = optimal_sigmoid elif benchmark_name == "FastDownwardBenchmark": policy = optimal_fd elif benchmark_name == "CMAESBenchmark": policy = csa else: print("No comparison policy found for this benchmark") return for s in seeds: if benchmark_name == "CMAESBenchmark": experiment_name = f"csa_{s}" else: experiment_name = f"optimal_{s}" logger = Logger(experiment_name=experiment_name, output_path=results_path / benchmark_name) env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper( env, logger=logger.add_module(PerformanceTrackingWrapper)) agent = GenericAgent(env, policy) logger.add_agent(agent) logger.add_benchmark(bench) logger.set_env(env) logger.set_additional_info(seed=s) run_benchmark(env, agent, num_episodes, logger) logger.close()
def run_static(results_path, benchmark_name, action, num_episodes, seeds=np.arange(10)): bench = getattr(benchmarks, benchmark_name)() for s in seeds: logger = Logger( experiment_name=f"static_{action}_{s}", output_path=results_path / benchmark_name, ) env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper( env, logger=logger.add_module(PerformanceTrackingWrapper)) agent = StaticAgent(env, action) logger.add_agent(agent) logger.add_benchmark(bench) logger.set_env(env) logger.set_additional_info(seed=s, action=action) run_benchmark(env, agent, num_episodes, logger) logger.close()
def test_logging(self): temp_dir = tempfile.TemporaryDirectory() episodes = 5 logger = Logger( output_path=Path(temp_dir.name), experiment_name="test_logging", ) bench = LubyBenchmark() env = bench.get_environment() time_logger = logger.add_module(EpisodeTimeWrapper) wrapped = EpisodeTimeWrapper(env, logger=time_logger) agent = StaticAgent(env=env, action=1) run_benchmark(wrapped, agent, episodes, logger) logger.close() logs = load_logs(time_logger.get_logfile()) dataframe = log2dataframe(logs, wide=True) # all steps must have logged time self.assertTrue((~dataframe.step_duration.isna()).all()) # each episode has a recored time episodes = dataframe.groupby("episode") last_steps_per_episode = dataframe.iloc[episodes.step.idxmax()] self.assertTrue( (~last_steps_per_episode.episode_duration.isna()).all()) # episode time equals the sum of the steps in episode calculated_episode_times = episodes.step_duration.sum() recorded_episode_times = last_steps_per_episode.episode_duration self.assertListEqual(calculated_episode_times.tolist(), recorded_episode_times.tolist()) temp_dir.cleanup()
from pathlib import Path from dacbench.agents import RandomAgent from dacbench.logger import Logger from dacbench.runner import run_benchmark from dacbench.benchmarks import CMAESBenchmark from dacbench.wrappers import StateTrackingWrapper # Make CMAESBenchmark environment bench = CMAESBenchmark() env = bench.get_environment() # Make Logger object to track state information logger = Logger(experiment_name=type(bench).__name__, output_path=Path("../plotting/data")) logger.set_env(env) # Wrap env with StateTrackingWrapper env = StateTrackingWrapper(env, logger=logger.add_module(StateTrackingWrapper)) # Run random agent for 5 episodes and log state information to file # You can plot these results with the plotting examples agent = RandomAgent(env) run_benchmark(env, agent, 5, logger=logger) logger.close()
def test_logging_multi_discrete(self): temp_dir = tempfile.TemporaryDirectory() seed = 0 logger = Logger( output_path=Path(temp_dir.name), experiment_name="test_multi_discrete_logging", step_write_frequency=None, episode_write_frequency=1, ) bench = ModeaBenchmark() bench.set_seed(seed) env = bench.get_environment() env.seed_action_space(seed) action_logger = logger.add_module(ActionFrequencyWrapper) wrapped = ActionFrequencyWrapper(env, logger=action_logger) agent = RandomAgent(env) logger.set_env(env) run_benchmark(wrapped, agent, 1, logger) action_logger.close() logs = load_logs(action_logger.get_logfile()) dataframe = log2dataframe(logs, wide=True) expected_actions = pd.DataFrame({ "action_0": { 0: 0, 1: 1, 2: 0, 3: 1, 4: 1, 5: 0, 6: 1, 7: 1, 8: 0, 9: 0, 10: 0, }, "action_1": { 0: 1, 1: 0, 2: 1, 3: 0, 4: 0, 5: 1, 6: 0, 7: 1, 8: 0, 9: 0, 10: 1, }, "action_10": { 0: 0, 1: 0, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0, 7: 2, 8: 1, 9: 2, 10: 1, }, "action_2": { 0: 1, 1: 1, 2: 1, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1, 8: 0, 9: 0, 10: 1, }, "action_3": { 0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 0, 8: 0, 9: 1, 10: 1, }, "action_4": { 0: 0, 1: 1, 2: 1, 3: 0, 4: 1, 5: 0, 6: 0, 7: 1, 8: 0, 9: 1, 10: 0, }, "action_5": { 0: 1, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 0, 8: 0, 9: 0, 10: 1, }, "action_6": { 0: 0, 1: 1, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 1, 9: 0, 10: 0, }, "action_7": { 0: 1, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 1, 8: 1, 9: 1, 10: 0, }, "action_8": { 0: 0, 1: 1, 2: 0, 3: 1, 4: 1, 5: 1, 6: 0, 7: 1, 8: 0, 9: 0, 10: 1, }, "action_9": { 0: 1, 1: 2, 2: 1, 3: 0, 4: 0, 5: 1, 6: 1, 7: 1, 8: 2, 9: 0, 10: 2, }, }) for column in expected_actions.columns: # todo: seems to be an bug here. Every so ofter the last action is missing. # Double checked not a logging problem. Could be a seeding issue self.assertListEqual( dataframe[column].to_list()[:10], expected_actions[column].to_list()[:10], f"Column {column}", ) temp_dir.cleanup()
def test_logging_discrete(self): temp_dir = tempfile.TemporaryDirectory() seed = 0 logger = Logger( output_path=Path(temp_dir.name), experiment_name="test_discrete_logging", step_write_frequency=None, episode_write_frequency=1, ) bench = LubyBenchmark() bench.set_seed(seed) env = bench.get_environment() env.seed_action_space(seed) action_logger = logger.add_module(ActionFrequencyWrapper) wrapped = ActionFrequencyWrapper(env, logger=action_logger) agent = RandomAgent(env) logger.set_env(env) run_benchmark(wrapped, agent, 10, logger) action_logger.close() logs = load_logs(action_logger.get_logfile()) dataframe = log2dataframe(logs, wide=True) expected_actions = [ 0, 3, 5, 4, 3, 5, 5, 5, 3, 3, 2, 1, 0, 1, 2, 0, 1, 1, 0, 1, 2, 4, 3, 0, 1, 3, 0, 3, 3, 3, 4, 4, 4, 5, 4, 0, 4, 2, 1, 3, 4, 2, 1, 3, 3, 2, 0, 5, 2, 5, 2, 1, 5, 3, 2, 5, 1, 0, 2, 3, 1, 3, 2, 3, 2, 4, 3, 4, 0, 5, 5, 1, 5, 0, 1, 5, 5, 3, 3, 2, ] self.assertListEqual(dataframe.action.to_list(), expected_actions) temp_dir.cleanup()
for s in seeds: # Log the seed logger.set_additional_info(seed=s) # Make & wrap benchmark environment env = bench.get_benchmark(seed=s) env = PerformanceTrackingWrapper(env, logger=performance_logger) env = StateTrackingWrapper(env, logger=state_logger) # Add env to logger logger.set_env(env) # Run random agent agent = RandomAgent(env) run_benchmark(env, agent, num_episodes, logger) # Close logger object logger.close() # Load performance of last seed into pandas DataFrame logs = load_logs(performance_logger.get_logfile()) dataframe = log2dataframe(logs, wide=True) # Plot overall performance plot_performance(dataframe) plt.show() # Plot performance per instance plot_performance_per_instance(dataframe) plt.show()