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'