def test_save_conf(self):
bench = CMAESBenchmark()
bench.save_config("test_conf.json")
with open("test_conf.json", "r") as fp:
recovered = json.load(fp)
for k in bench.config.keys():
self.assertTrue(k in recovered.keys())
os.remove("test_conf.json")
def test_setup(self):
bench = CMAESBenchmark()
self.assertTrue(bench.config is not None)
config = {"dummy": 0}
with open("test_conf.json", "w+") as fp:
json.dump(config, fp)
bench = CMAESBenchmark("test_conf.json")
self.assertTrue(bench.config.dummy == 0)
os.remove("test_conf.json")
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 test_read_instances(self):
bench = CMAESBenchmark()
bench.read_instance_set()
self.assertTrue(len(bench.config.instance_set.keys()) == 100)
self.assertTrue(len(bench.config.instance_set[0]) == 4)
self.assertTrue(bench.config.instance_set[0][2] == 0.6445072293504781)
inst = bench.config.instance_set[0]
bench2 = CMAESBenchmark()
env = bench2.get_environment()
self.assertTrue(len(env.instance_set[0]) == 4)
self.assertTrue(len(env.instance_set.keys()) == 100)
self.assertTrue(inst == env.instance_set[0])
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_get_env(self):
bench = CMAESBenchmark()
env = bench.get_environment()
self.assertTrue(issubclass(type(env), CMAESEnv))
def test_rendering(self):
bench = FastDownwardBenchmark()
env = bench.get_environment()
wrapped = ActionFrequencyWrapper(env, 2)
wrapped.reset()
for _ in range(10):
wrapped.step(1)
img = wrapped.render_action_tracking()
self.assertTrue(img.shape[-1] == 3)
bench = CMAESBenchmark()
env = bench.get_environment()
wrapped = ActionFrequencyWrapper(env, 2)
wrapped.reset()
wrapped.step(np.ones(10))
img = wrapped.render_action_tracking()
self.assertTrue(img.shape[-1] == 3)
class dict_action_env:
def __init__(self):
self.action_space = gym.spaces.Dict({
"one":
gym.spaces.Discrete(2),
"two":
gym.spaces.Box(low=np.array([-1, 1]),
high=np.array([1, 5])),
})
self.observation_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = dict_action_env()
wrapped = ActionFrequencyWrapper(env)
wrapped.reset()
with self.assertRaises(NotImplementedError):
wrapped.render_action_tracking()
class tuple_action_env:
def __init__(self):
self.action_space = gym.spaces.Tuple((
gym.spaces.Discrete(2),
gym.spaces.Box(low=np.array([-1, 1]),
high=np.array([1, 5])),
))
self.observation_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = tuple_action_env()
wrapped = ActionFrequencyWrapper(env)
wrapped.reset()
with self.assertRaises(NotImplementedError):
wrapped.render_action_tracking()
class multi_discrete_action_env:
def __init__(self):
self.action_space = gym.spaces.MultiDiscrete([2, 3])
self.observation_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = multi_discrete_action_env()
wrapped = ActionFrequencyWrapper(env, 5)
wrapped.reset()
for _ in range(10):
wrapped.step([1, 2])
img = wrapped.render_action_tracking()
self.assertTrue(img.shape[-1] == 3)
class multi_binary_action_env:
def __init__(self):
self.action_space = gym.spaces.MultiBinary(2)
self.observation_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = multi_binary_action_env()
wrapped = ActionFrequencyWrapper(env)
wrapped.reset()
wrapped.step([1, 0])
img = wrapped.render_action_tracking()
self.assertTrue(img.shape[-1] == 3)
class large_action_env:
def __init__(self):
self.action_space = gym.spaces.Box(low=np.zeros(15),
high=np.ones(15))
self.observation_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = large_action_env()
wrapped = ActionFrequencyWrapper(env)
wrapped.reset()
wrapped.step(0.5 * np.ones(15))
img = wrapped.render_action_tracking()
self.assertTrue(img.shape[-1] == 3)
from pathlib import Path
from dacbench.logger import Logger
from dacbench.wrappers import PerformanceTrackingWrapper, ObservationWrapper
from examples.example_utils import make_chainer_a3c
from dacbench.benchmarks import CMAESBenchmark
# Make logger object
logger = Logger(experiment_name="CMAESBenchmark",
output_path=Path("../plotting/data"))
# Make CMA-ES environment
# We use the configuration from the "Learning to Optimize Step-size Adaption in CMA-ES" Paper by Shala et al.
bench = CMAESBenchmark()
env = bench.get_benchmark()
logger.set_env(env)
# Wrap to track performance
performance_logger = logger.add_module(PerformanceTrackingWrapper)
env = PerformanceTrackingWrapper(env=env, logger=performance_logger)
# Also wrap to make the dictionary observations into an easy to work with list
env = ObservationWrapper(env)
# Make chainer agent
obs_size = env.observation_space.low.size
action_size = env.action_space.low.size
agent = make_chainer_a3c(obs_size, action_size)
# Training
num_episodes = 3
for i in range(num_episodes):
def test_rendering(self):
bench = CMAESBenchmark()
env = bench.get_environment()
wrapped = StateTrackingWrapper(env)
wrapped.reset()
with pytest.raises(NotImplementedError):
wrapped.render_state_tracking()
bench = CMAESBenchmark()
def dummy():
return [1, [2, 3]]
bench.config.state_method = dummy
bench.config.observation_space = gym.spaces.Tuple(
(
gym.spaces.Discrete(2),
gym.spaces.Box(low=np.array([-1, 1]), high=np.array([5, 5])),
)
)
env = bench.get_environment()
wrapped = StateTrackingWrapper(env)
wrapped.reset()
with pytest.raises(NotImplementedError):
wrapped.render_state_tracking()
def dummy2():
return [0.5]
bench.config.state_method = dummy2
bench.config.observation_space = gym.spaces.Box(
low=np.array([0]), high=np.array([1])
)
env = bench.get_environment()
wrapped = StateTrackingWrapper(env)
wrapped.reset()
wrapped.step(1)
wrapped.step(1)
img = wrapped.render_state_tracking()
self.assertTrue(img.shape[-1] == 3)
bench = LubyBenchmark()
env = bench.get_environment()
wrapped = StateTrackingWrapper(env, 2)
wrapped.reset()
wrapped.step(1)
wrapped.step(1)
img = wrapped.render_state_tracking()
self.assertTrue(img.shape[-1] == 3)
class discrete_obs_env:
def __init__(self):
self.observation_space = gym.spaces.Discrete(2)
self.action_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return 1
def step(self, action):
return 1, 1, 1, 1
env = discrete_obs_env()
wrapped = StateTrackingWrapper(env, 2)
wrapped.reset()
wrapped.step(1)
img = wrapped.render_state_tracking()
self.assertTrue(img.shape[-1] == 3)
class multi_discrete_obs_env:
def __init__(self):
self.observation_space = gym.spaces.MultiDiscrete([2, 3])
self.action_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return [1, 2]
def step(self, action):
return [1, 2], 1, 1, 1
env = multi_discrete_obs_env()
wrapped = StateTrackingWrapper(env)
wrapped.reset()
wrapped.step(1)
img = wrapped.render_state_tracking()
self.assertTrue(img.shape[-1] == 3)
class multi_binary_obs_env:
def __init__(self):
self.observation_space = gym.spaces.MultiBinary(2)
self.action_space = gym.spaces.Discrete(2)
self.reward_range = (1, 2)
self.metadata = {}
def reset(self):
return [1, 1]
def step(self, action):
return [1, 1], 1, 1, 1
env = multi_binary_obs_env()
wrapped = StateTrackingWrapper(env)
wrapped.reset()
wrapped.step(1)
img = wrapped.render_state_tracking()
self.assertTrue(img.shape[-1] == 3)
def get_test_env(self) -> AbstractEnv:
bench = CMAESBenchmark()
env = bench.get_benchmark(seed=42)
return env
