def register_marl_env(
env_name,
env_class,
n_agents,
grid_size,
view_size,
view_tile_size=8,
view_offset=0,
agent_color=None,
env_kwargs={},
):
colors = ["red", "blue", "purple", "orange", "olive", "pink"]
assert n_agents <= len(colors)
class RegEnv(env_class):
def __new__(cls):
instance = super(env_class, RegEnv).__new__(env_class)
instance.__init__(
agents=[
GridAgentInterface(
color=c if agent_color is None else agent_color,
view_size=view_size,
view_tile_size=8,
view_offset=view_offset,
) for c in colors[:n_agents]
],
grid_size=grid_size,
**env_kwargs,
)
return instance
env_class_name = f"env_{len(registered_envs)}"
setattr(this_module, env_class_name, RegEnv)
registered_envs.append(env_name)
gym_register(env_name, entry_point=f"marlgrid.envs:{env_class_name}")
def register_marl_env(
env_name,
env_class,
n_agents,
grid_size,
view_size,
view_tile_size=8,
done_condition="all",
env_kwargs={},
):
colors = ["red", "blue", "purple", "orange", "olive"]
assert n_agents <= len(colors)
class RegEnv(env_class):
def __init__(self):
super().__init__(
agents=[
InteractiveGridAgent(color=c,
view_size=view_size,
view_tile_size=8)
for c in colors[:n_agents]
],
grid_size=grid_size,
done_condition=done_condition,
**env_kwargs,
)
env_class_name = f"env_{len(registered_envs)}"
setattr(this_module, env_class_name, RegEnv)
registered_envs.append(env_name)
gym_register(env_name, entry_point=f"marlgrid.envs:{env_class_name}")
def register(
id,
num_agents,
num_preies,
num_obstacles,
direction_alpha,
use_human_command,
entry_point,
reward_threshold=0.95
):
assert id.startswith("MiniGrid-")
assert id not in env_list
# Register the environment with OpenAI gym
gym_register(
id=id,
entry_point=entry_point,
kwargs={'num_agents': num_agents, \
'num_preies': num_preies, \
'num_obstacles': num_obstacles, \
'direction_alpha': direction_alpha,\
'use_human_command': use_human_command},
reward_threshold=reward_threshold
)
# Add the environment to the set
env_list.append(id)
def register(id, entry_point, **kwargs):
if not id in gym_registry.env_specs:
try:
gym_register(id=id, entry_point=entry_point, **kwargs)
except Exception as e:
print("warning: failed to register environment\n" + str(e))
envs[id] = (entry_point, kwargs)
def register(id, entry_point, reward_threshold=0.95):
# Register the environment with OpenAI gym
gym_register(id=id,
entry_point=entry_point,
reward_threshold=reward_threshold)
# Add the environment to the set
env_list.append(id)
def setup(self):
if self.env_name == 'GridworldEnv':
env = GridworldEnv(self.env_param)
else:
env_name = f'{self.env_name}-{self.id}-v0'
gym_register(id=env_name,entry_point=self.env_factory, max_episode_steps=200,)
env = gym.make(env_name).unwrapped
self.env = env
self.set_seed(self.seed)
def register(id, entry_point, reward_threshold=0.95):
assert id.startswith("MiniGrid-")
assert id not in env_list
# Register the environment with OpenAI gym
gym_register(id=id, entry_point=entry_point, reward_threshold=reward_threshold)
# Add the environment to the set
env_list.append(id)
def register(env_id, entry_point, reward_threshold=0.95):
"""Register a new environment with OpenAI gym based on id."""
assert env_id.startswith("MultiGrid-")
if env_id in env_list:
del gym.envs.registry.env_specs[id]
else:
# Add the environment to the set
env_list.append(id)
# Register the environment with OpenAI gym
gym_register(id=env_id, entry_point=entry_point, reward_threshold=reward_threshold)
def register(id: str, order_enforce: bool = False, **kwargs):
COMPILER_GYM_ENVS.append(id)
# As of gym==0.21.0 a new OrderEnforcing wrapper is enabled by default. Turn
# this off as CompilerEnv already enforces this and the wrapper obscures the
# docstrings of the base class.
gym_version = _parse_version_string(gym.__version__)
if gym_version and gym_version >= (0, 21):
kwargs["order_enforce"] = order_enforce
gym_register(id=id, **kwargs)
def setup(self):
env_name = f'{self.env_name}-{self.id}-v0'
gym_register(
id=env_name,
entry_point=self.env_factory,
max_episode_steps=200,
)
env = gym.make(env_name)
self.env = NormalizedActions(env)
self.set_seed(self.seed)
self.ou_noise = OUNoise(self.env.action_space)
def register():
global _registered
name = 'Cards-v0'
if not _registered:
from gym.envs.registration import register as gym_register
gym_register(
id=name,
entry_point='cards_env:CardsEnv',
nondeterministic=True,
)
_registered = True
return name
def register(
id,
entry_point,
reward_threshold=900
):
assert id.startswith("MiniGrid-")
assert id not in env_list
# Register the environment with OpenAI gym
gym_register(
id=id,
entry_point=entry_point,
reward_threshold=reward_threshold
)
# Add the environment to the set
env_list.append(id)
def register():
gym_register(ENV_ID,
entry_point="lib.microtaur:FourShortLegsEnv",
max_episode_steps=1000)
sfx0 = 'Clr' if random_colors else ''
sfx1 = resolution_suffix(resolution, obs_ptcloud)
sfx1 += dbg_viz_suffix(dbg)
env_id = base_env_name + sfx0 + 'BulletEnv' + sfx1 + '-v' + str(
env_v)
kwargs = {
'base_env_name': base_env_name,
'env_v': env_v,
'random_colors': random_colors,
'obs_resolution': resolution,
'obs_ptcloud': obs_ptcloud,
'debug': dbg == 1,
'visualize': dbg == 2
}
gym_register(id=env_id,
entry_point='bulb.envs:AuxBulletEnv',
kwargs=kwargs)
#print(env_id)
# Register rearrangement envs.
num_versions = 6 * 2 # 6 versions and their black-background variants
for robot in ['Reacher', 'Franka']:
for variant in ['Ycb', 'OneYcb', 'Geom', 'OneGeom']:
for resolution in OBS_RESOLUTIONS:
for obs_ptcloud in [False, True]:
if obs_ptcloud and resolution is None: continue
for version in range(num_versions):
for dbg in [0, 1, 2]:
sfx = resolution_suffix(resolution, obs_ptcloud)
sfx += dbg_viz_suffix(dbg)
env_id = robot + 'Rearrange' + variant + sfx + '-v' + str(
def reregister():
for env in envs:
del gym_registry.env_specs[env]
gym_register(id=env, entry_point=envs[env][0], **envs[env][1])
from gym.envs.registration import register as gym_register
from gym_minigrid.envs.distshift import DistShiftEnv
class DistShift3(DistShiftEnv):
def __init__(self, agent_start_pos=(1, 1), agent_start_dir=0):
super().__init__(strip2_row=2, agent_start_pos=agent_start_pos,
agent_start_dir=agent_start_dir)
class DistShift4(DistShiftEnv):
def __init__(self, agent_start_pos=(1, 1), agent_start_dir=0):
super().__init__(strip2_row=5, agent_start_pos=agent_start_pos,
agent_start_dir=agent_start_dir)
# Register the environment with OpenAI gym
gym_register(
id='MiniGrid-DistShift1-v1',
entry_point='mod_envs.distshift:DistShift3',
reward_threshold=0.95
)
gym_register(
id='MiniGrid-DistShift2-v1',
entry_point='mod_envs.distshift:DistShift4',
reward_threshold=0.95
)
def __init__(self, n=5, max_steps=6):
self.observation_space = gym.spaces.Discrete(n)
self.action_space = gym.spaces.Discrete(n)
self.max_steps = max_steps
self.i = None
self.seq = None
self.target = None
def reset(self):
self.i = 0
self.seq = np.random.randint(self.observation_space.n,
size=[self.max_steps])
self.target = self.seq[0]
return self.seq[0]
def step(self, action):
self.i += 1
if self.i < len(self.seq):
return self.seq[self.i], 0, False, {}
else:
return 0, float(action == self.target), True, {}
gym_register(
id="MemoryTest-v0",
entry_point="envs:MemoryTest",
)
elif actionV[i] > bounds[1][i]:
actionV[i] = bounds[1][i]
return actionV
from rlsimenv.config import SIMULATION_ENVIRONMENTS
from gym.envs.registration import register as gym_register
# Use the gym_register because it allows us to set the max_episode_steps.
# try:
print("Registering rlsimenv environments")
gym_register(
id='ContinuousMaxwellsDemon-v0',
entry_point='rlsimenv.MaxwellsDemon:MaxwellsDemonPartiallyObserved',
reward_threshold=0.95,
max_episode_steps=500,
)
gym_register(
id='ContinuousMaxwellsDemonFullyObserved-v0',
entry_point='rlsimenv.MaxwellsDemon:MaxwellsDemonFullyObserved',
reward_threshold=0.95,
max_episode_steps=500,
)
gym_register(id='MiniCraftBoxesFullyObserved-v0',
entry_point='rlsimenv.MiniCraftBoxes:MiniCraftBoxesFullyObserved',
reward_threshold=0.95,
max_episode_steps=500,
kwargs={'gui': False})
def register(id, *args, **kwargs): # pylint: disable=redefined-builtin
assert id.startswith('POMDP-')
#print(env_list)
assert id not in env_list
env_list.append(id)
gym_register(id, *args, **kwargs)
from gym.envs.registration import register as gym_register
gym_register(
id='MiniGrid-MaxwellsDemon-v0',
entry_point='surprise.envs.minigrid.envs.maxwells_demon_room:MaxwellsDemonEnv',
reward_threshold=0.95,
max_episode_steps=500,
)
gym_register(
id='MiniGrid-SimpleEnemyEnvHMMMarginal-v0',
entry_point='surprise.envs.minigrid.envs.simple_room_hmm_marginal:SimpleEnemyEnvHMMMarginal',
reward_threshold=0.95,
max_episode_steps=5000,
)
gym_register(
id='MiniGrid-SimpleEnemyTagEnvHMM-v0',
entry_point='surprise.envs.minigrid.envs.simple_room_tag_hmm:SimpleEnemyTagEnvHMM',
reward_threshold=0.95,
max_episode_steps=5000,
)
gym_register(
id='MiniGrid-SimpleEnemyTAgEnvHMMMarginal-v0',
entry_point='surprise.envs.minigrid.envs.simple_room_hmm_tag_marginal:SimpleEnemyEnvTagHMMMarginal',
reward_threshold=0.95,
max_episode_steps=5000,
)
return self._get_obs()
class Reacher_Fixed_Train(Reacher_Fixed):
def __init__(self):
super().__init__(mode=0)
class Reacher_Fixed_Test(Reacher_Fixed):
def __init__(self):
super().__init__(mode=1)
gym_register(
id='ReacherFixedTrain-v0',
entry_point=Reacher_Fixed_Train,
max_episode_steps=50,
reward_threshold=-3.75,
)
gym_register(
id='ReacherFixedTest-v0',
entry_point=Reacher_Fixed_Test,
max_episode_steps=10000,
reward_threshold=-3.75,
)
class OracleHalfCheetahTest(ICML_envs.OracleHalfCheetah_Friction):
def __init__(self):
super().__init__(density_set=[
500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000, 1050, 1100,
file = open(terrainRL_PATH + "/args/envs.json")
env_data = json.load(file)
file.close()
return env_data
from gym.envs.registration import register as gym_register
# Use the gym_register because it allows us to set the max_episode_steps.
env_data = getEnvsList()
gym_register(id='PD_Biped2D_Flat-v0',
entry_point='simAdapter.terrainRLSim:TerrainRLSimWrapper',
reward_threshold=0.95,
max_episode_steps=512,
kwargs={
'config': env_data["PD_Biped2D_Flat-v0"],
"render": True
})
gym_register(id='PD_Biped2D_Gaps_Terrain-v0',
entry_point='simAdapter.terrainRLSim:TerrainRLSimWrapper',
reward_threshold=0.95,
max_episode_steps=512,
kwargs={
'config': env_data["PD_Biped2D_Gaps_Terrain-v0"],
"render": True,
"flatten_observation": True,
"fall_check": False
})
def register(id: str, **kwargs):
COMPILER_GYM_ENVS.append(id)
gym_register(id=id, **kwargs)
def register(id, *args, **kwargs):
assert id.startswith('POMDP-')
assert id not in env_list
env_list.append(id)
gym_register(id, *args, **kwargs)
def step(self, action):
first_phase = self.i // self.seq_size == 0
obs = 0
reward = 0
done = False
if first_phase:
if action != 0:
reward -= 1
if self.i + 1 < self.seq_size:
obs = self.seq[self.i + 1]
else:
i = self.i - self.seq_size
if action == self.seq[i]:
reward += 1
if i + 1 >= self.seq_size:
done = True
self.i += 1
return obs, reward, done, {}
gym_register(
id="SeqCopy-v0",
entry_point="envs:SeqCopy",
)
