def test_issue_185(self):
for env_name in self.get_list_env():
if env_name == "blank":
continue
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make(env_name, test=True) as env:
gym_env = GymEnv(env)
gym_env.seed(0)
gym_env.observation_space.seed(0)
gym_env.action_space.seed(0)
obs_gym = gym_env.reset()
assert obs_gym["a_ex"].shape[
0] == env.n_line, f"error for {env_name}"
assert obs_gym in gym_env.observation_space, f"error for {env_name}"
def test_issue_185_act_multidiscrete_space(self):
for env_name in self.get_list_env():
if env_name == "blank":
continue
elif env_name == "l2rpn_neurips_2020_track1":
# takes too much time
continue
elif env_name == "l2rpn_neurips_2020_track2":
# takes too much time
continue
elif env_name == "rte_case118_example":
# takes too much time
continue
elif env_name == ENV_WITH_ALARM_NAME:
# takes too much time
continue
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make(env_name, test=True) as env:
gym_env = GymEnv(env)
gym_env.action_space = MultiDiscreteActSpace(gym_env.init_env.action_space)
gym_env.seed(0)
gym_env.observation_space.seed(0)
gym_env.action_space.seed(0)
obs_gym = gym_env.reset()
assert obs_gym in gym_env.observation_space, f"error for {env_name}"
act = gym_env.action_space.sample()
assert act in gym_env.action_space, f"error for {env_name}"
obs, reward, done, info = gym_env.step(act)
assert obs in gym_env.observation_space, f"error for {env_name}"
def test_keep_only_attr(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = make("educ_case14_redisp", test=True)
gym_env = GymEnv(env)
attr_kept = sorted(("rho", "line_status", "actual_dispatch", "target_dispatch"))
ob_space = gym_env.observation_space
ob_space = ob_space.keep_only_attr(attr_kept)
assert np.all(sorted(ob_space.spaces.keys()) == attr_kept)
def test_ignore_attr(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = make("educ_case14_redisp", test=True)
gym_env = GymEnv(env)
attr_deleted = sorted(("rho", "line_status", "actual_dispatch", "target_dispatch"))
ob_space = gym_env.observation_space
ob_space = ob_space.ignore_attr(attr_deleted)
for el in attr_deleted:
assert not el in ob_space.spaces
def test_split_in_3(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = make("educ_case14_redisp", test=True)
gym_env = GymEnv(env)
act_space = gym_env.action_space
act_space = act_space.reencode_space(
"redispatch",
ContinuousToDiscreteConverter(
nb_bins=3, init_space=act_space["redispatch"]))
# with 3 interval like [-10, 10] (the second generator)
# should be split => 0 -> [-10, -3.33), 1 => [-3.33, 3.33), [3.33, 10.]
# test the "all 0" action (all 0 => encoded to 1, because i have 3 bins)
g2op_object = np.array([0., 0., 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [1, 1, 0, 0, 0, 1])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(res2 == 0.)
# test the all 0 action, but one is not 0 (negative)
g2op_object = np.array([0., -3.2, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [1, 1, 0, 0, 0, 1])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(res2 == 0.)
# test the all 0 action, but one is not 0 (positive)
g2op_object = np.array([0., 3.2, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [1, 1, 0, 0, 0, 1])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(res2 == 0.)
# test one is 2
g2op_object = np.array([0., 3.4, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [1, 2, 0, 0, 0, 1])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(np.abs(res2 - [0., 5.0, 0., 0., 0., 0.]) <= self.tol)
# test one is 0
g2op_object = np.array([0., -3.4, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [1, 0, 0, 0, 0, 1])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., -5.0, 0., 0., 0., 0.]) <= self.tol)
def test_basic(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = grid2op.make("l2rpn_case14_sandbox",
test=True,
_add_to_name="for_mp_test")
env_gym = GymEnv(env)
obs_gym = env_gym.reset()
# 3. (optional) customize it (see section above for more information)
## customize action space
env_gym.action_space = env_gym.action_space.ignore_attr(
"set_bus").ignore_attr("set_line_status")
env_gym.action_space = env_gym.action_space.reencode_space(
"redispatch", ContinuousToDiscreteConverter(nb_bins=11))
env_gym.action_space = env_gym.action_space.reencode_space(
"change_bus", MultiToTupleConverter())
env_gym.action_space = env_gym.action_space.reencode_space(
"change_line_status", MultiToTupleConverter())
env_gym.action_space = env_gym.action_space.reencode_space(
"redispatch", MultiToTupleConverter())
## customize observation space
ob_space = env_gym.observation_space
ob_space = ob_space.keep_only_attr(
["rho", "gen_p", "load_p", "topo_vect", "actual_dispatch"])
ob_space = ob_space.reencode_space(
"actual_dispatch",
ScalerAttrConverter(substract=0., divide=env.gen_pmax))
ob_space = ob_space.reencode_space(
"gen_p", ScalerAttrConverter(substract=0., divide=env.gen_pmax))
ob_space = ob_space.reencode_space(
"load_p",
ScalerAttrConverter(substract=obs_gym["load_p"],
divide=0.5 * obs_gym["load_p"]))
env_gym.observation_space = ob_space
ctx = mp.get_context('spawn')
env_gym1 = copy.deepcopy(env_gym)
env_gym2 = copy.deepcopy(env_gym)
with ctx.Pool(2) as p:
p.map(TestMultiProc.f, [env_gym1, env_gym2])
def setUp(self) -> None:
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = grid2op.make("l2rpn_neurips_2020_track1", test=True)
env_gym = GymEnv(env)
ob_space = env_gym.observation_space
ob_space = ob_space.keep_only_attr(["rho", "gen_p", "load_p", "topo_vect", "actual_dispatch"])
ob_space = ob_space.reencode_space("actual_dispatch",
ScalerAttrConverter(substract=0.,
divide=env.gen_pmax
)
)
ob_space = ob_space.reencode_space("gen_p",
ScalerAttrConverter(substract=0.,
divide=env.gen_pmax
)
)
ob_space = ob_space.reencode_space("load_p",
ScalerAttrConverter(substract=0.,
divide=-1.0
)
)
env_gym.observation_space = ob_space
self.env_gym = env_gym
def test_issue_185_obs_box_space(self):
for env_name in self.get_list_env():
if env_name == "blank":
continue
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make(env_name, test=True) as env:
gym_env = GymEnv(env)
gym_env.observation_space = BoxGymObsSpace(gym_env.init_env.observation_space)
gym_env.seed(0)
gym_env.observation_space.seed(0)
gym_env.action_space.seed(0)
obs_gym = gym_env.reset()
assert obs_gym in gym_env.observation_space, f"error for {env_name}"
act = gym_env.action_space.sample()
assert act in gym_env.action_space, f"error for {env_name}"
obs, reward, done, info = gym_env.step(act)
assert obs in gym_env.observation_space, f"error for {env_name}"
def test_issue_185_act_discrete_space(self):
env_with_alarm = os.path.join(PATH_DATA_TEST,
"l2rpn_neurips_2020_track1_with_alert")
for env_name in self.get_list_env():
if env_name == "blank":
continue
elif env_name == "l2rpn_neurips_2020_track1":
# takes too much time
continue
elif env_name == "l2rpn_neurips_2020_track2":
# takes too much time
continue
elif env_name == "rte_case118_example":
# takes too much time
continue
elif env_name == env_with_alarm:
# takes too much time
continue
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
with grid2op.make(env_name, test=True) as env:
gym_env = GymEnv(env)
gym_env.action_space = DiscreteActSpace(
gym_env.init_env.action_space)
gym_env.seed(0)
gym_env.observation_space.seed(0)
gym_env.action_space.seed(0)
obs_gym = gym_env.reset()
assert obs_gym in gym_env.observation_space, f"error for {env_name}"
act = gym_env.action_space.sample()
assert act in gym_env.action_space, f"error for {env_name}"
obs, reward, done, info = gym_env.step(act)
if obs not in gym_env.observation_space:
for k in obs:
if not obs[k] in gym_env.observation_space[k]:
import pdb
pdb.set_trace()
raise RuntimeError(
f"Error for key {k} for env {env_name}")
def test_split_in_5(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
env = make("educ_case14_redisp", test=True)
gym_env = GymEnv(env)
act_space = gym_env.action_space
act_space = act_space.reencode_space(
"redispatch",
ContinuousToDiscreteConverter(
nb_bins=5, init_space=act_space["redispatch"]))
# with 5
g2op_object = np.array([0., 0., 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 2, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(res2 == 0.)
# test the all 0 action, but one is not 0 (negative)
g2op_object = np.array([0., -1.9, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 2, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(res2 == 0.)
# positive side
g2op_object = np.array([0., 2.1, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 3, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., 3.33333, 0., 0., 0., 0.]) <= self.tol)
g2op_object = np.array([0., 5.9, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 3, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., 3.33333, 0., 0., 0., 0.]) <= self.tol)
g2op_object = np.array([0., 6.1, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 4, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., 6.666666, 0., 0., 0., 0.]) <= self.tol)
# negative side
g2op_object = np.array([0., -2.1, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 1, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., -3.3333, 0., 0., 0., 0.]) <= self.tol)
g2op_object = np.array([0., -5.9, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 1, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., -3.33333, 0., 0., 0., 0.]) <= self.tol)
g2op_object = np.array([0., -6.1, 0., 0., 0., 0.])
res = act_space._keys_encoding["_redispatch"].g2op_to_gym(
g2op_object)
assert np.all(res == [2, 0, 0, 0, 0, 2])
res2 = act_space._keys_encoding["_redispatch"].gym_to_g2op(res)
assert np.all(
np.abs(res2 - [0., -6.666666, 0., 0., 0., 0.]) <= self.tol)