def evaluate(env,
load_path=None,
logs_path=DEFAULT_LOGS_DIR,
nb_episode=DEFAULT_NB_EPISODE,
nb_process=DEFAULT_NB_PROCESS,
max_steps=DEFAULT_MAX_STEPS,
verbose=False,
save_gif=False):
runner_params = env.get_params_for_runner()
runner_params["verbose"] = args.verbose
# Build runner
runner = Runner(**runner_params,
agentClass=DoNothingAgent)
# Run
os.makedirs(logs_path, exist_ok=True)
res = runner.run(path_save=logs_path,
nb_episode=nb_episode,
nb_process=nb_process,
max_iter=max_steps,
pbar=True)
# Print summary
print("Evaluation summary:")
for _, chron_name, cum_reward, nb_time_step, max_ts in res:
msg_tmp = "chronics at: {}".format(chron_name)
msg_tmp += "\ttotal reward: {:.6f}".format(cum_reward)
msg_tmp += "\ttime steps: {:.0f}/{:.0f}".format(nb_time_step, max_ts)
print(msg_tmp)
if save_gif:
save_log_gif(logs_path, res)
def test_issue_126(self):
# run redispatch agent on one scenario for 100 timesteps
dataset = "rte_case14_realistic"
nb_episode = 1
nb_timesteps = 100
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = make(dataset, test=True)
agent = DeltaRedispatchRandomAgent(env.action_space)
runner = Runner(**env.get_params_for_runner(),
agentClass=None,
agentInstance=agent)
with tempfile.TemporaryDirectory() as tmpdirname:
res = runner.run(nb_episode=nb_episode,
path_save=tmpdirname,
nb_process=1,
max_iter=nb_timesteps,
env_seeds=[0],
agent_seeds=[0],
pbar=False)
episode_data = EpisodeData.from_disk(tmpdirname, res[0][1])
assert len(episode_data.actions.objects
) - nb_timesteps == 0, "wrong number of actions"
assert len(episode_data.actions
) - nb_timesteps == 0, "wrong number of actions"
assert len(episode_data.observations.objects) - (
nb_timesteps + 1) == 0, "wrong number of observations"
assert len(episode_data.observations) - (
nb_timesteps + 1) == 0, "wrong number of observations"
def test_multiprocess_windows_no_fail(self):
"""test that i can run multiple times parallel run of the same env (breaks on windows)"""
nb_episode = 2
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case5_example", test=True) as env:
f = tempfile.mkdtemp()
runner_params = env.get_params_for_runner()
runner = Runner(**runner_params)
res1 = runner.run(path_save=f,
nb_episode=nb_episode,
nb_process=2,
max_iter=self.max_iter)
res2 = runner.run(path_save=f,
nb_episode=nb_episode,
nb_process=1,
max_iter=self.max_iter)
res3 = runner.run(path_save=f,
nb_episode=nb_episode,
nb_process=2,
max_iter=self.max_iter)
test_ = set()
for id_chron, name_chron, cum_reward, nb_time_step, max_ts in res1:
test_.add(name_chron)
assert len(test_) == nb_episode
test_ = set()
for id_chron, name_chron, cum_reward, nb_time_step, max_ts in res2:
test_.add(name_chron)
assert len(test_) == nb_episode
test_ = set()
for id_chron, name_chron, cum_reward, nb_time_step, max_ts in res3:
test_.add(name_chron)
assert len(test_) == nb_episode
def test_load_ambiguous(self):
f = tempfile.mkdtemp()
class TestSuitAgent(BaseAgent):
def __init__(self, *args, **kwargs):
BaseAgent.__init__(self, *args, **kwargs)
def act(self, observation, reward, done=False):
# do a ambiguous action
return self.action_space({
"set_line_status": [(0, 1)],
"change_line_status": [0]
})
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make("rte_case14_test", test=True) as env:
my_agent = TestSuitAgent(env.action_space)
runner = Runner(**env.get_params_for_runner(),
agentClass=None,
agentInstance=my_agent)
# test that the right seeds are assigned to the agent
res = runner.run(nb_episode=1,
max_iter=self.max_iter,
path_save=f)
episode_data = EpisodeData.from_disk(agent_path=f, name=res[0][1])
assert int(episode_data.meta["chronics_max_timestep"]) == self.max_iter
assert len(episode_data.actions) == self.max_iter
assert len(episode_data.observations) == self.max_iter + 1
def run_env(env, path_save, parameters, scores_func, agent, nb_scenario,
max_step, env_seeds, agent_seeds, pbar, nb_process):
if scores_func is not None:
if not (EpisodeStatistics._check_if_base_reward(scores_func)
or isinstance(scores_func, dict)):
raise Grid2OpException(
"score_func should be either a dictionary or an instance of BaseReward"
)
dict_kwg = env.get_params_for_runner()
dict_kwg["parameters_path"] = parameters.to_dict()
if "other_rewards" not in dict_kwg:
dict_kwg["other_rewards"] = {}
if scores_func is not None:
if EpisodeStatistics._check_if_base_reward(scores_func):
dict_kwg["other_rewards"][
EpisodeStatistics.KEY_SCORE] = scores_func
elif isinstance(scores_func, dict):
for nm, score_fun in scores_func.items():
dict_kwg["other_rewards"][
f"{EpisodeStatistics.KEY_SCORE}_{nm}"] = score_fun
else:
raise RuntimeError(
"\"scores_func\" should inherit from \"grid2op.Reward.BaseReward\" or "
"be a dictionary")
runner = Runner(**dict_kwg, agentClass=None, agentInstance=agent)
runner.run(path_save=path_save,
nb_episode=nb_scenario,
max_iter=max_step,
env_seeds=env_seeds,
agent_seeds=agent_seeds,
pbar=pbar,
nb_process=nb_process)
def test_seed_properly_set(self):
class TestSuitAgent(RandomAgent):
def __init__(self, *args, **kwargs):
RandomAgent.__init__(self, *args, **kwargs)
self.seeds = []
def seed(self, seed):
super().seed(seed)
self.seeds.append(seed)
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
my_agent = TestSuitAgent(env.action_space)
runner = Runner(**env.get_params_for_runner(),
agentClass=None,
agentInstance=my_agent)
# test that the right seeds are assigned to the agent
res = runner.run(nb_episode=3,
max_iter=self.max_iter,
env_seeds=[1, 2, 3],
agent_seeds=[5, 6, 7])
assert np.all(my_agent.seeds == [5, 6, 7])
# test that is no seeds are set, then the "seed" funciton of the agent is not called.
my_agent.seeds = []
res = runner.run(nb_episode=3,
max_iter=self.max_iter,
env_seeds=[1, 2, 3])
assert my_agent.seeds == []
def test_init_from_env_with_other_reward(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("case14_test", other_rewards={"test":
L2RPNReward}) as env:
runner = Runner(**env.get_params_for_runner())
runner.run(nb_episode=1, max_iter=self.max_iter)
def evaluate(env,
load_path=None,
logs_path=DEFAULT_LOGS_DIR,
nb_episode=DEFAULT_NB_EPISODE,
nb_process=DEFAULT_NB_PROCESS,
max_steps=DEFAULT_MAX_STEPS,
verbose=DEFAULT_VERBOSE,
save_gif=False):
# Limit gpu usage
physical_devices = tf.config.list_physical_devices('GPU')
if len(physical_devices):
tf.config.experimental.set_memory_growth(physical_devices[0], True)
runner_params = env.get_params_for_runner()
runner_params["verbose"] = verbose
# Run
# Create agent
agent = RDQNAgent(env.observation_space,
env.action_space,
is_training=False)
# Load weights from file
agent.load(load_path)
# Build runner
runner = Runner(**runner_params,
agentClass=None,
agentInstance=agent)
# Print model summary
if verbose:
stringlist = []
agent.Qmain.model.summary(print_fn=lambda x: stringlist.append(x))
short_model_summary = "\n".join(stringlist)
print(short_model_summary)
# Run
os.makedirs(logs_path, exist_ok=True)
res = runner.run(path_save=logs_path,
nb_episode=nb_episode,
nb_process=nb_process,
max_iter=max_steps,
pbar=verbose)
# Print summary
if verbose:
print("Evaluation summary:")
for _, chron_name, cum_reward, nb_time_step, max_ts in res:
msg_tmp = "chronics at: {}".format(chron_name)
msg_tmp += "\ttotal reward: {:.6f}".format(cum_reward)
msg_tmp += "\ttime steps: {:.0f}/{:.0f}".format(nb_time_step,
max_ts)
print(msg_tmp)
if save_gif:
save_log_gif(logs_path, res)
return res
def test_seed_par(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
runner = Runner(**env.get_params_for_runner())
res = runner.run(nb_episode=2, nb_process=2, max_iter=self.max_iter, env_seeds=[1, 2], agent_seeds=[3, 4])
for i, _, cum_reward, timestep, total_ts in res:
assert int(timestep) == self.max_iter
def test_init_from_env(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
runner = Runner(**env.get_params_for_runner())
res = runner.run(nb_episode=1, max_iter=self.max_iter)
for i, _, cum_reward, timestep, total_ts in res:
assert int(timestep) == self.max_iter
def test_env_alarmtime_default(self):
"""test default values are correct"""
assert self.env.parameters.ALARM_WINDOW_SIZE == 12
assert self.env.parameters.ALARM_BEST_TIME == 12
runner = Runner(**self.env.get_params_for_runner())
env_runner = runner.init_env()
assert env_runner.parameters.ALARM_WINDOW_SIZE == 12
assert env_runner.parameters.ALARM_BEST_TIME == 12
def test_nomaxiter_par(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
runner = Runner(**env.get_params_for_runner())
runner.gridStateclass_kwargs["max_iter"] = 2 * self.max_iter
res = runner.run(nb_episode=2, nb_process=2)
for i, _, cum_reward, timestep, total_ts in res:
assert int(timestep) == 2 * self.max_iter
def test_nomaxiter(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
runner = Runner(**env.get_params_for_runner())
runner.chronics_handler.set_max_iter(2 * self.max_iter)
res = runner.run(nb_episode=1)
for i, _, cum_reward, timestep, total_ts in res:
assert int(timestep) == 2 * self.max_iter
def run(runner_params_from_env, NB_EPISODE, agent_path, max_steps_in_episode,
agent, gif_save, agent_name):
# Build runner
runner = Runner(**runner_params_from_env,
agentClass=None,
agentInstance=agent)
PATH_SAVE = os.path.join(agent_path,
agent_name) #agent_path + "\\" + agent_name
PATH_SAVE2 = agent_path + r"\_cache"
# Check if there are any previously stored results. If they are available then delete them and use the "Runner" to
# evaluate more scenarios using the agent.
if os.path.exists(PATH_SAVE):
shutil.rmtree(PATH_SAVE)
# WE ALSO REMOVE THE __CACHE WHICH IS CREATED BY THE GRID2VIZ. (This is useful especially when the agent's
# performance data or the scenario data is overwritten. Since the grid2viz then needs the cache to be reset).
# Here we always reset it to ensure the grid2viz results are displaying the most recently generated agent's behavior
# correctly. (This will increase the running time of grid2viz to display initial results).
if os.path.exists(PATH_SAVE2):
shutil.rmtree(PATH_SAVE2)
os.makedirs(agent_path, exist_ok=True)
# NOTE: This code does not support the "runner.run" to use multiple cores.
res = runner.run(nb_episode=NB_EPISODE,
path_save=PATH_SAVE,
max_iter=max_steps_in_episode)
# print(agent.action_list)
if gif_save:
# Parameters to save the gif image of the performance of the agent.
gif_name = "episode"
ep_replay = EpisodeReplay(agent_path=PATH_SAVE)
print("The results for the trained agent are:")
for _, chron_name, cum_reward, nb_time_step, max_ts in res:
msg_tmp = "\tFor chronics located at {}\n".format(chron_name)
msg_tmp += "\t\t - cumulative reward: {:.6f}\n".format(cum_reward)
msg_tmp += "\t\t - number of time steps completed: {:.0f} / {:.0f}".format(
nb_time_step, max_ts)
print(msg_tmp)
if gif_save:
# Uncomment the below code to save the gif image to "PATH_SAVE"
ep_replay.replay_episode(
chron_name, # which chronic was started
gif_name=gif_name, # Name of the gif file
display=False, # dont wait before rendering each frames
fps=3.0) # limit to 3 frames per second
def test_generate_and_read_agent_redisp(self):
with make(self.case, param=self.param, backend=self.backend) as env:
agent = RandomRedispatchAgent(env.action_space, env)
runner = Runner(**env.get_params_for_runner(),
agentClass=None,
agentInstance=agent)
# need to be seeded for reproducibility as this takes random redispatching actions
runner.run(nb_episode=1,
path_save=os.path.join(self.agents_path, self.agent_name),
nb_process=1,
max_iter=10,
env_seeds=[0],
agent_seeds=[0],
pbar=True)
env.close()
def run_env(env, path_save, parameters, scores_func, agent, nb_scenario,
max_step, env_seeds, agent_seeds, pbar, nb_process):
dict_kwg = env.get_params_for_runner()
dict_kwg["parameters_path"] = parameters.to_dict()
if scores_func is not None:
if not issubclass(scores_func, BaseReward):
raise RuntimeError("\"scores_func\" should inherit from \"grid2op.Reward.BaseReward\"")
dict_kwg["other_rewards"] = {EpisodeStatistics.KEY_SCORE: scores_func}
runner = Runner(**dict_kwg, agentClass=None, agentInstance=agent)
runner.run(path_save=path_save,
nb_episode=nb_scenario,
max_iter=max_step,
env_seeds=env_seeds,
agent_seeds=agent_seeds,
pbar=pbar,
nb_process=nb_process)
def test_complex_agent(self):
nb_episode = 4
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case5_example", test=True) as env:
f = tempfile.mkdtemp()
runner_params = env.get_params_for_runner()
runner = Runner(**runner_params)
res = runner.run(path_save=f,
nb_episode=nb_episode,
nb_process=2,
max_iter=self.max_iter)
test_ = set()
for id_chron, name_chron, cum_reward, nb_time_step, max_ts in res:
test_.add(name_chron)
assert len(test_) == nb_episode
def test_custom_reward_runner(self):
"""test i can generate the reward and use it in the envs"""
reward_cls = RedispReward.generate_class_custom_params(
alpha_redisph=2,
min_load_ratio=0.15,
worst_losses_ratio=0.05,
min_reward=-10.,
reward_illegal_ambiguous=0.,
least_losses_ratio=0.015)
env_name = "l2rpn_case14_sandbox"
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make(env_name, test=True,
reward_class=reward_cls) as env:
obs = env.reset()
runner = Runner(**env.get_params_for_runner())
res = runner.run(nb_episode=2, nb_process=2)
def get_runner(path_chronics=PATH_DATA, submission_dir="."):
submitted_controler = get_submitted_controller(submission_dir)
runner = Runner(init_grid_path=L2RPN2019_CASEFILE,
path_chron=path_chronics,
names_chronics_to_backend=L2RPN2019_DICT_NAMES,
gridStateclass_kwargs={"gridvalueClass": ReadPypowNetData},
rewardClass=L2RPNReward,
agentClass=submitted_controler)
return runner
def setUp(self):
super().setUp()
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
self.env = grid2op.make("l2rpn_case14_sandbox",
test=True,
backend=LightSimBackend())
self.runner = Runner(**self.env.get_params_for_runner())
def test_one_process_par(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
res = Runner._one_process_parrallel(self.runner, [0], 0, None, None, self.max_iter)
assert len(res) == 1
_, el1, el2, el3, el4 = res[0]
assert el1 == "1"
assert np.abs(el2 - self.real_reward) <= self.tol_one
assert el3 == 10
assert el4 == 10
def setUp(self):
self.init_grid_path = os.path.join(PATH_DATA_TEST_PP,
"test_case14.json")
self.path_chron = PATH_ADN_CHRONICS_FOLDER
self.parameters_path = None
self.max_iter = 10
self.real_reward = dt_float(7748.425)
self.real_reward_li = [dt_float(7748.425), dt_float(7786.89599609375)]
self.all_real_rewards = [
dt_float(el) for el in [
761.3295, 768.10144, 770.2673, 767.767, 768.69, 768.71246,
779.1029, 783.2737, 788.7833, 792.39764
]
]
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
self.env = grid2op.make("l2rpn_case14_sandbox", test=True)
self.runner = Runner(**self.env.get_params_for_runner())
def main(path_casefile=None,
path_chronics=None,
path_parameters=None,
chronics_class=Multifolder,
backend_class=PandaPowerBackend,
agent_class=DoNothingAgent,
reward_class=FlatReward,
observation_class=CompleteObservation,
legalAct_class=AlwaysLegal,
nb_episode=3,
nb_process=1,
path_save=None,
names_chronics_to_backend=None,
gridStateclass_kwargs={}):
if path_casefile is None:
init_grid_path = DEFAULT_TEST_CASE
else:
init_grid_path = os.path.abspath(path_casefile)
if path_chronics is None:
path_chron = DEFAULT_CHRONICS_DATA
else:
path_chron = os.path.abspath(path_chronics)
parameters_path = path_parameters
runner = Runner(init_grid_path=init_grid_path,
path_chron=path_chron,
parameters_path=parameters_path,
names_chronics_to_backend=names_chronics_to_backend,
gridStateclass=chronics_class,
gridStateclass_kwargs=gridStateclass_kwargs,
backendClass=backend_class,
rewardClass=reward_class,
agentClass=agent_class,
observationClass=observation_class,
legalActClass=legalAct_class)
res = runner.run(nb_episode=nb_episode,
nb_process=nb_process,
path_save=path_save)
return res
def test_collection_wrapper_after_run(self):
OneChange = OneChangeThenNothing.gen_next(
{"set_bus": {
"lines_or_id": [(1, -1)]
}})
runner = Runner(
init_grid_path=self.init_grid_path,
path_chron=self.path_chron,
parameters_path=self.parameters_path,
names_chronics_to_backend=self.names_chronics_to_backend,
gridStateclass=self.gridStateclass,
backendClass=self.backendClass,
rewardClass=L2RPNReward,
other_rewards={"test": L2RPNReward},
max_iter=self.max_iter,
name_env="test_episodedata_env",
agentClass=OneChange)
_, cum_reward, timestep, episode_data = runner.run_one_episode(
max_iter=self.max_iter, detailed_output=True)
# Check that the type of first action is set bus
assert episode_data.actions[0].get_types()[2]
def test_backward_compatibility(self):
backward_comp_version = ["1.0.0", "1.1.0", "1.1.1", "1.2.0", "1.2.1", "1.2.2", "1.2.3", "1.3.0", "1.3.1",
"1.4.0"]
curr_version = "current_version"
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case5_example", test=True) as env, \
tempfile.TemporaryDirectory() as path:
runner = Runner(**env.get_params_for_runner(), agentClass=RandomAgent)
runner.run(nb_episode=2,
path_save=os.path.join(path, curr_version),
pbar=False,
max_iter=100,
env_seeds=[1, 0],
agent_seeds=[42, 69])
# check that i can read this data generate for this runner
self._aux_backward(path, curr_version)
for grid2op_version in backward_comp_version:
# check that i can read previous data stored from previous grid2Op version
self._aux_backward(PATH_PREVIOUS_RUNNER, f"res_agent_{grid2op_version}")
def test_runner(self):
"""test i can create properly a runner"""
runner = Runner(**self.env.get_params_for_runner())
# normal run
res = runner.run(nb_episode=1, nb_process=1, max_iter=self.max_iter)
assert res[0][-1] == 10
assert res[0][-2] == 10
assert res[0][-3] == 1.0
# run + episode data
with tempfile.TemporaryDirectory() as f:
res = runner.run(nb_episode=1,
nb_process=1,
max_iter=self.max_iter,
path_save=f)
ep_dat = EpisodeData.from_disk(agent_path=f, name=res[0][1])
assert len(ep_dat) == 10
assert ep_dat.observations[0].attention_budget == 3
assert ep_dat.observations[1].attention_budget == 3 + 1. / (12. *
8.)
def test_backward_compatibility(self):
backward_comp_version = [
"1.0.0", "1.1.0", "1.1.1", "1.2.0", "1.2.1", "1.2.2", "1.2.3",
"1.3.0", "1.3.1", "1.4.0", "1.5.0", "1.5.1", "1.5.1.post1", "1.5.2"
]
curr_version = "test_version"
assert 'curtailment' in CompleteObservation.attr_list_vect, "error at the beginning"
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case5_example", test=True) as env, \
tempfile.TemporaryDirectory() as path:
runner = Runner(**env.get_params_for_runner(),
agentClass=RandomAgent)
runner.run(nb_episode=2,
path_save=os.path.join(path, curr_version),
pbar=False,
max_iter=100,
env_seeds=[1, 0],
agent_seeds=[42, 69])
# check that i can read this data generate for this runner
self._aux_backward(path, curr_version, curr_version)
assert 'curtailment' in CompleteObservation.attr_list_vect, "error after the first runner"
# check that it raises a warning if loaded on the compatibility version
grid2op_version = backward_comp_version[0]
with self.assertWarns(UserWarning):
self._aux_backward(PATH_PREVIOUS_RUNNER,
f"res_agent_{grid2op_version}", grid2op_version)
for grid2op_version in backward_comp_version:
# check that i can read previous data stored from previous grid2Op version
# can be loaded properly
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
self._aux_backward(PATH_PREVIOUS_RUNNER,
f"res_agent_{grid2op_version}",
grid2op_version)
assert 'curtailment' in CompleteObservation.attr_list_vect, f"error after the legacy version " \
f"{grid2op_version}"
def setUp(self):
"""
The case file is a representation of the case14 as found in the ieee14 powergrid.
:return:
"""
self.init_grid_path = os.path.join(PATH_DATA_TEST_PP, "test_case14.json")
self.path_chron = PATH_ADN_CHRONICS_FOLDER
self.parameters_path = None
self.max_iter = 10
self.real_reward = dt_float(199.99800)
self.names_chronics_to_backend = {"loads": {"2_C-10.61": 'load_1_0', "3_C151.15": 'load_2_1',
"14_C63.6": 'load_13_2', "4_C-9.47": 'load_3_3',
"5_C201.84": 'load_4_4',
"6_C-6.27": 'load_5_5', "9_C130.49": 'load_8_6',
"10_C228.66": 'load_9_7',
"11_C-138.89": 'load_10_8', "12_C-27.88": 'load_11_9',
"13_C-13.33": 'load_12_10'},
"lines": {'1_2_1': '0_1_0', '1_5_2': '0_4_1', '9_10_16': '8_9_2',
'9_14_17': '8_13_3',
'10_11_18': '9_10_4', '12_13_19': '11_12_5', '13_14_20': '12_13_6',
'2_3_3': '1_2_7', '2_4_4': '1_3_8', '2_5_5': '1_4_9',
'3_4_6': '2_3_10',
'4_5_7': '3_4_11', '6_11_11': '5_10_12', '6_12_12': '5_11_13',
'6_13_13': '5_12_14', '4_7_8': '3_6_15', '4_9_9': '3_8_16',
'5_6_10': '4_5_17',
'7_8_14': '6_7_18', '7_9_15': '6_8_19'},
"prods": {"1_G137.1": 'gen_0_4', "3_G36.31": "gen_2_1", "6_G63.29": "gen_5_2",
"2_G-56.47": "gen_1_0", "8_G40.43": "gen_7_3"},
}
self.gridStateclass = Multifolder
self.backendClass = PandaPowerBackend
self.runner = Runner(init_grid_path=self.init_grid_path,
path_chron=self.path_chron,
parameters_path=self.parameters_path,
names_chronics_to_backend=self.names_chronics_to_backend,
gridStateclass=self.gridStateclass,
backendClass=self.backendClass,
rewardClass=L2RPNReward,
max_iter=self.max_iter,
name_env="test_runner_env")
def test_env_alarmtime_changed(self):
"""test everything is correct when something is modified"""
param = Parameters()
param.ALARM_WINDOW_SIZE = 99
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env_nm = os.path.join(PATH_DATA_TEST,
"l2rpn_neurips_2020_track1_with_alert")
env = grid2op.make(env_nm,
test=True,
chronics_class=ChangeNothing,
param=param)
assert env.parameters.ALARM_WINDOW_SIZE == 99
assert env.parameters.ALARM_BEST_TIME == 12
runner = Runner(**env.get_params_for_runner())
env_runner = runner.init_env()
assert env_runner.parameters.ALARM_WINDOW_SIZE == 99
assert env_runner.parameters.ALARM_BEST_TIME == 12
param = Parameters()
param.ALARM_BEST_TIME = 42
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env_nm = os.path.join(PATH_DATA_TEST,
"l2rpn_neurips_2020_track1_with_alert")
env = grid2op.make(env_nm,
test=True,
chronics_class=ChangeNothing,
param=param)
assert env.parameters.ALARM_WINDOW_SIZE == 12
assert env.parameters.ALARM_BEST_TIME == 42
runner = Runner(**env.get_params_for_runner())
env_runner = runner.init_env()
assert env_runner.parameters.ALARM_WINDOW_SIZE == 12
assert env_runner.parameters.ALARM_BEST_TIME == 42
def test_always_same_order(self):
# test that a call to "run" will do always the same chronics in the same order
# regardless of the seed or the parallelism or the number of call to runner.run
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with make("rte_case14_test", test=True) as env:
runner = Runner(**env.get_params_for_runner())
res = runner.run(nb_episode=2,
nb_process=2,
max_iter=self.max_iter,
env_seeds=[1, 2],
agent_seeds=[3, 4])
first_ = [el[0] for el in res]
res = runner.run(nb_episode=2,
nb_process=1,
max_iter=self.max_iter,
env_seeds=[1, 2],
agent_seeds=[3, 4])
second_ = [el[0] for el in res]
res = runner.run(nb_episode=2,
nb_process=1,
max_iter=self.max_iter,
env_seeds=[9, 10])
third_ = [el[0] for el in res]
res = runner.run(nb_episode=2,
nb_process=2,
max_iter=self.max_iter,
env_seeds=[1, 2],
agent_seeds=[3, 4])
fourth_ = [el[0] for el in res]
assert np.all(first_ == second_)
assert np.all(first_ == third_)
assert np.all(first_ == fourth_)
