def register(id, entry_point, force=True, **kwargs):
env_specs = gym.envs.registry.env_specs
if id in env_specs.keys():
if not force:
return
del env_specs[id]
gym.register(id=id, entry_point=entry_point, **kwargs)
def register_env(self, task_env, max_episode_steps_per_episode=10000):
"""
Register Gym environment. This way we can load them with variable
limits. Here is where you have to PLACE YOUR NEW TASK ENV, to be
registered and accesible. return: False if the Task_Env wasnt
registered, True if it was.
"""
name = task_env.replace("_", "-")
if TASK_ENV_MAP[task_env] is not None:
env_file = 'task_envs.' + task_env + ":" + TASK_ENV_MAP[task_env]
register(id=name,
entry_point=env_file,
max_episode_steps=max_episode_steps_per_episode)
# import our training environment
# pylint: disable=exec-used
exec('from task_envs.' + task_env + ' import ' +
TASK_ENV_MAP[task_env])
# Check that it was really registered
supported_gym_envs = [env_spec.id for env_spec in envs.registry.all()]
assert (
name in supported_gym_envs), \
"Registration of the task_env {} failed.".format(name)
task_env = gym.make(name)
return task_env
def register_point_mass(suffix, **kwargs):
gym.register(
id=f"evaluating_rewards/PointMass{suffix}-v0",
entry_point=f"{PM_ROOT}:PointMassEnv",
max_episode_steps=100,
kwargs=kwargs,
)
def register_some_envs():
namespace = "MyAwesomeNamespace"
versioned_name = "MyAwesomeVersionedEnv"
unversioned_name = "MyAwesomeUnversionedEnv"
versions = [1, 3, 5]
for version in versions:
env_id = f"{namespace}/{versioned_name}-v{version}"
gym.register(
id=env_id,
entry_point="tests.envs.test_registration:ArgumentEnv",
kwargs={
"arg1": "arg1",
"arg2": "arg2",
"arg3": "arg3",
},
)
gym.register(
id=f"{namespace}/{unversioned_name}",
entry_point="tests.env.test_registration:ArgumentEnv",
kwargs={
"arg1": "arg1",
"arg2": "arg2",
"arg3": "arg3",
},
)
yield
for version in versions:
env_id = f"{namespace}/{versioned_name}-v{version}"
del gym.envs.registry[env_id]
del gym.envs.registry[f"{namespace}/{unversioned_name}"]
def register_env(gym_env_id, gym_env_filename, gym_env_class):
if not os.path.exists(gym_env_filename):
print(f"Dataset env file not found. {gym_env_filename}")
assert gym_env_filename[-3:] == ".py"
gym_env_filename = gym_env_filename[:-3] # remove ".py"
gym_env_filename = gym_env_filename.replace("/",".") # turn file path into python class path
gym.register(id=gym_env_id, entry_point=f"{gym_env_filename}:{gym_env_class}", kwargs={'render': False, 'xml': "", 'param': []})
def register_mbpo_environments():
for mbpo_environment in MBPO_ENVIRONMENT_SPECS:
gym.register(**mbpo_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in MBPO_ENVIRONMENT_SPECS)
return gym_ids
def register_environments():
for env in ENVIRONMENT_SPECS:
gym.register(**env)
gym_ids = tuple(environment_spec['id']
for environment_spec in ENVIRONMENT_SPECS)
return gym_ids
def register(id, entry_point, max_episode_steps, kwargs):
env_specs = gym.envs.registry.env_specs
if id in env_specs.keys():
del env_specs[id]
gym.register(id=id,
entry_point=entry_point,
max_episode_steps=max_episode_steps,
kwargs=kwargs)
def register_mopac_environments():
for mopac_environment in MOPAC_ENVIRONMENT_SPECS:
gym.register(**mopac_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in MOPAC_ENVIRONMENT_SPECS)
return gym_ids
def get_gym(env_config):
import gym
iterations = env_config["iterations"]
gym.register(id='dc-iroko-v0',
entry_point='dc_gym.env_iroko:DCEnv',
max_episode_steps=iterations,
)
env = gym.make('dc-iroko-v0', conf=env_config)
return env
def register_general_environments():
"""Register gym environments that don't fall under a specific category."""
for general_environment in GENERAL_ENVIRONMENT_SPECS:
gym.register(**general_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in GENERAL_ENVIRONMENT_SPECS)
return gym_ids
def register_mujoco_environments():
"""Register softlearning mujoco environments."""
for mujoco_environment in MUJOCO_ENVIRONMENT_SPECS:
gym.register(**mujoco_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in MUJOCO_ENVIRONMENT_SPECS)
return gym_ids
def register_multiworld_environments():
"""Register custom environments from multiworld package."""
for multiworld_environment in MULTIWORLD_ENVIRONMENT_SPECS:
gym.register(**multiworld_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in MULTIWORLD_ENVIRONMENT_SPECS)
return gym_ids
def register_safety_environments():
"""Register softlearning safety environments."""
for safety_environment in SAFETY_GYM_ENVIRONMENT_SPECS:
gym.register(**safety_environment)
gym_ids = tuple(environment_spec['id']
for environment_spec in SAFETY_GYM_ENVIRONMENT_SPECS)
return gym_ids
def _register_dummy_environment_fixture():
id_string = "DummyEnvironment-v0"
register(id=id_string,
entry_point=
"tests.unit.bellman.environments.test_utils:DummyEnvironment")
yield id_string
del registry.env_specs[id_string]
def init_env(env_seed, benchmark_f_name, sln_f_name, logpath=''):
args_dict = get_env_parameters(env_seed, benchmark_f_name, sln_f_name,
logpath)
env_name = 'fabricatio-v0'
if env_name in gym.envs.registry.env_specs:
del gym.envs.registry.env_specs[env_name]
register(id=env_name,
entry_point='gym_fabrikatioRL.envs:FabricatioRL',
kwargs=args_dict)
environment = gym.make(env_name)
return environment
def make_imitation_env(trick):
steps = IMITATION_LIB[trick]["end"] - IMITATION_LIB[trick]["start"]
register(
id=f"Pupper-Recording-{IMITATION_LIB[trick]['env_name']}-v0",
entry_point="stanford_quad.envs:ImitationEnv",
kwargs={
# "debug": (False if headlessness == "Headless" else True),
"trick": "walk-forward",
},
max_episode_steps=steps,
)
def init_stochasticity_test_env(seed,
optimizers,
name,
all_jobs_visible=False):
if all_jobs_visible:
n_jobs_initial = n_jobs = max_jobs_visible = 20
else:
n_jobs_initial = 10
n_jobs = 20
max_jobs_visible = 15
env_args = {
'scheduling_inputs': {
'n_jobs': n_jobs, # n
'n_machines': 7, # m
'n_tooling_lvls': 5, # l
'n_types': 5, # tests
'min_n_operations': 5,
'max_n_operations': 5, # o
'n_jobs_initial': n_jobs_initial, # jobs with arrival time 0
'max_jobs_visible': max_jobs_visible, # entries in {1 .. n}
'operation_precedence': 'POm',
'operation_types': 'Jm', # deafault_sampling
'operation_tool_sets': 'default_sampling',
'machine_speeds': 'default_sampling',
'machine_distances': 'default_sampling',
'machine_buffer_capa': np.array([1, 2, 3, 1, 2, 5, 3]),
# '' or nxo matrix (entries in {1, 2 .. })
'machine_capabilities': {
1: {1},
2: {1},
3: {2, 3},
4: {3},
5: {4},
6: {5},
7: {3}
},
'tool_switch_times': 'default_sampling',
'time_inter_release': 'default_sampling',
'time_job_due': 'default_sampling',
'perturbation_processing_time': 'default_sampling',
'perturbation_due_date': 'default_sampling',
},
'seeds': seed,
'return_transformer': StochasticityTestTransformer(),
'selectable_optimizers': optimizers,
}
if name in gym.envs.registry.env_specs:
del gym.envs.registry.env_specs[name]
register(id=name,
entry_point='gym_fabrikatioRL.envs:FabricatioRL',
kwargs=env_args)
env = gym.make(name)
return env
def register_novel_cartpole(max_episode_steps: int = 100,
random_acceleration: float = 10,
novelty_chance: float = 0.5,
reward_threshold: int = 200):
register(id='NovelCartPole-v0',
entry_point='envs.novel_cartpole:NovelCartPoleEnv',
max_episode_steps=max_episode_steps,
kwargs={
'random_acceleration': random_acceleration,
'novelty_chance': novelty_chance,
},
reward_threshold=reward_threshold)
def __init__(self, slippery=True):
if slippery:
self._env = gym.make('FrozenLake-v0')
else:
gym.register(
id='FrozenLakeNotSlippery4x4-v0',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={'map_name': '4x4', 'is_slippery': False},
max_episode_steps=1000,
)
self._env = gym.make('FrozenLakeNotSlippery4x4-v0')
self.reset()
def register_point_maze():
# Maze true length is 0.1+maze_length-2*0.02, since walls span from -0.1 to maze_length with
# 0.02 radius. (It's a bit tighter than this up-down, because of the extra dividing wall.)
# Agent particle radius is 0.03, so 0.01 gives width of 0.1+0.01-2*0.02=0.09 minus 2*0.03
# equals 0.03 space for the particle to move in -- just enough to vibrate, but not go anywhere.
# 0.6 is the default length.
for length in [0.01, 0.05, 0.1, 0.2, 0.3]:
for dname, dval in {"Left": 0, "Right": 1}.items():
gym.register(
id=f"evaluating_rewards/PointMaze{length}{dname}-v0",
entry_point="imitation.envs.examples.airl_envs.point_maze_env:PointMazeEnv",
kwargs={"maze_length": length, "direction": dval, "include_vel": True},
)
def test_training_loop_multi_control(self):
gym.register(
'FakeEnv-v0',
entry_point='trax.rl.envs.fake_env:FakeEnv',
kwargs={'n_actions': 3, 'n_controls': 2},
)
with self.tmp_dir() as output_dir:
trainer = self._make_trainer(
train_env=self.get_wrapped_env('FakeEnv-v0', 2),
eval_env=self.get_wrapped_env('FakeEnv-v0', 2),
output_dir=output_dir,
)
trainer.training_loop(n_epochs=2)
def test_training_loop_multi_control(self):
gym.register(
"FakeEnv-v0",
entry_point="tensor2tensor.trax.rl.envs.fake_env:FakeEnv",
kwargs={"n_actions": 3, "n_controls": 2},
)
with self.tmp_dir() as output_dir:
trainer = self._make_trainer(
train_env=self.get_wrapped_env("FakeEnv-v0", 2),
eval_env=self.get_wrapped_env("FakeEnv-v0", 2),
output_dir=output_dir,
)
trainer.training_loop(n_epochs=2)
def register(cls):
"""Registers a few canonical environments with OpenAI Gym."""
for name in [
"append-still", "prune-still", "append-still-easy",
"prune-still-easy", "append-spawn", "prune-spawn",
"navigation", "challenge"
]:
gym.register(
id="safelife-{}-v1".format(name),
entry_point=SafeLifeEnv,
kwargs={
'level_iterator': SafeLifeLevelIterator('random/' + name),
},
)
def _setup(self, config):
gym.register(id="rustyblocks-v0",
entry_point="custom_env_boxactions:RustyBlocksEnv")
original_env = gym.make('rustyblocks-v0')
original_env.max_invalid_tries = 3
original_env.force_progression = False
self.env = DummyVecEnv([lambda: original_env])
self.model = PPO2("MlpPolicy",
self.env,
verbose=0,
nminibatches=1,
**config)
self.training_iteration = 0
self.amount_of_iterations = 100
def register(
id: str,
entry_point: str,
max_episode_steps: int,
reward_threshold: float,
xml: str,
) -> None:
gym.register(
id=id,
entry_point=entry_point,
max_episode_steps=max_episode_steps,
reward_threshold=reward_threshold,
)
env_xml_dict[id] = xml
def create_custom_enviroment():
gym.register(
id='FrozenLakeNotSlippery8x8-v0',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={'map_name' : '8x8', 'is_slippery': False},
max_episode_steps=1000,
)
gym.register(
id='FrozenLakeNotSlippery4x4-v0',
entry_point='gym.envs.toy_text:FrozenLakeEnv',
kwargs={'map_name' : '4x4', 'is_slippery': False},
max_episode_steps=1000,
)
def __init__(self, level, max_timesteps, **kwargs):
"""Gym environment constructor.
Args:
level (str | gym.Env): Gym id, preferably without "-v" suffix;
gym.Env instance or subclass also valid.
max_timesteps (int): Abort episode (terminal=2) after given number
of timesteps.
"""
if isinstance(level, gym.Env):
# Level as gym.Env instance
assert len(kwargs) == 0
self.level = level
elif isinstance(level, type) and issubclass(level, gym.Env):
# Level as gym.Env subclass
self.level = level(**kwargs)
else:
# Level as gym id
if level not in gym.envs.registry.env_specs:
# Register version without max_episode_steps
level = max(
[x for x in gym.envs.registry.env_specs if x.startswith(level + '-v')],
key=(lambda x: int(x[x.rindex('-v') + 2:]))
)
version = int(level[level.rindex('-v') + 2:])
new_level = level[:level.rindex('-v')] + '-v' + str(version + 1)
entry_point = gym.envs.registry.env_specs[level].entry_point
reward_threshold = gym.envs.registry.env_specs[level].reward_threshold
nondeterministic = gym.envs.registry.env_specs[level].nondeterministic
_kwargs = dict(gym.envs.registry.env_specs[level]._kwargs)
gym.register(
id=new_level, entry_point=entry_point, reward_threshold=reward_threshold,
nondeterministic=nondeterministic, max_episode_steps=None, kwargs=_kwargs
)
level = new_level
# Make gym level
self.level = gym.make(id=level, **kwargs)
# State/action space
state_space = utils.convert_gym_to_dict_space(space=self.level.observation_space)
action_space = utils.convert_gym_to_dict_space(self.level.action_space)
super().__init__(
state_space=state_space, action_space=action_space, max_timesteps=max_timesteps
)
def register(self):
reg_spec = dict(
id=self.name,
entry_point=EnvSpec.ENTRYPOINT,
kwargs={
'observation_space': self.observation_space,
'action_space': self.action_space,
'docstr': self.get_docstring(),
'xml': os.path.join(MISSIONS_DIR, self.xml),
'env_spec': self,
},
max_episode_steps=self.max_episode_steps,
)
if self.reward_threshold:
reg_spec.update(dict(reward_threshold=self.reward_threshold))
gym.register(**reg_spec)
def make_env(env_id,
rank,
log_dir=None,
allow_early_resets=True,
flatten_dict=False,
kwargs=None):
"""
Create a wrapped, monitored gym.Env for MuJoCo.
:param env_id: (str) the environment ID
:param seed: (int) the inital seed for RNG
:param allow_early_resets: (bool) allows early reset of the environment
:return: (Gym Environment) The mujoco environment
"""
if env_id in ENTRY_POINT.keys():
kwargs = kwargs.copy()
max_episode_steps = None
if 'max_episode_steps' in kwargs:
max_episode_steps = kwargs['max_episode_steps']
del kwargs['max_episode_steps']
gym.register(env_id,
entry_point=ENTRY_POINT[env_id],
max_episode_steps=max_episode_steps,
kwargs=kwargs)
env = gym.make(env_id)
else:
raise NotImplementedError
if flatten_dict:
env = FlattenDictWrapper(
env, ['observation', 'achieved_goal', 'desired_goal'])
if 'FetchStack' in env_id and (
'Unlimit' not in env_id) and max_episode_steps is None:
from utils.wrapper import FlexibleTimeLimitWrapper
env = FlexibleTimeLimitWrapper(env, 100)
if kwargs['reward_type'] != 'sparse':
env = DoneOnSuccessWrapper(env, 0.0)
else:
env = DoneOnSuccessWrapper(env)
if log_dir is not None:
env = Monitor(env,
os.path.join(log_dir,
str(rank) + ".monitor.csv"),
allow_early_resets=allow_early_resets,
info_keywords=('is_success', ))
return env
# -*- coding: utf-8 -*-
import gym
from gym import error, envs
from gym.envs import registration
from gym.envs.classic_control import cartpole
class ArgumentEnv(gym.Env):
def __init__(self, arg1, arg2, arg3):
self.arg1 = arg1
self.arg2 = arg2
self.arg3 = arg3
gym.register(
id='test.ArgumentEnv-v0',
entry_point='gym.envs.tests.test_registration:ArgumentEnv',
kwargs={
'arg1': 'arg1',
'arg2': 'arg2',
}
)
def test_make():
env = envs.make('CartPole-v0')
assert env.spec.id == 'CartPole-v0'
assert isinstance(env.unwrapped, cartpole.CartPoleEnv)
def test_make_with_kwargs():
env = envs.make('test.ArgumentEnv-v0', arg2='override_arg2', arg3='override_arg3')
assert env.spec.id == 'test.ArgumentEnv-v0'
assert isinstance(env.unwrapped, ArgumentEnv)
assert env.arg1 == 'arg1'
assert env.arg2 == 'override_arg2'
