def test_agent_indicator():
let = ["a", "a", "b"]
base_obs = {
"{}_{}".format(let[idx], idx): np.zeros([2, 3])
for idx in range(3)
}
base_obs_space = {
"{}_{}".format(let[idx], idx): Box(low=np.float32(0.0),
high=np.float32(10.0),
shape=[2, 3])
for idx in range(3)
}
base_act_spaces = {
"{}_{}".format(let[idx], idx): Discrete(5)
for idx in range(3)
}
base_env = DummyEnv(base_obs, base_obs_space, base_act_spaces)
env = supersuit.agent_indicator_v0(base_env, type_only=True)
env.reset()
obs, _, _, _ = env.last()
assert obs.shape == (2, 3, 3)
assert env.observation_space("a_0").shape == (2, 3, 3)
first_obs = env.step(2)
env = supersuit.agent_indicator_v0(base_env, type_only=False)
env.reset()
obs, _, _, _ = env.last()
assert obs.shape == (2, 3, 4)
assert env.observation_space("a_0").shape == (2, 3, 4)
env.step(2)
def env_creator(args):
env = game_env.env(obs_type='grayscale_image')
#env = clip_reward_v0(env, lower_bound=-1, upper_bound=1)
env = sticky_actions_v0(env, repeat_action_probability=0.25)
env = resize_v0(env, 84, 84)
#env = color_reduction_v0(env, mode='full')
#env = frame_skip_v0(env, 4)
env = frame_stack_v0(env, 4)
env = agent_indicator_v0(env, type_only=False)
return env
def get_env(config):
name = env_name.replace('-', '_')
env = __import__(f'pettingzoo.atari.{name}', fromlist=[None])
env = env.parallel_env(obs_type='grayscale_image')
env = frame_skip_v0(env, 4)
env = resize_v0(env, 84, 84)
env = frame_stack_v1(env, 4)
env = agent_indicator_v0(env)
return ParallelPettingZooEnv(
env,
random_action=config['random_action'],
random_proba=config['random_action_probability'])
def unwrapped_check(env):
env.reset()
agents = env.agents
if image_observation(env, agents):
env = max_observation_v0(env, 2)
env = color_reduction_v0(env, mode="full")
env = normalize_obs_v0(env)
if box_action(env, agents):
env = clip_actions_v0(env)
env = scale_actions_v0(env, 0.5)
if observation_homogenizable(env, agents):
env = pad_observations_v0(env)
env = frame_stack_v1(env, 2)
env = agent_indicator_v0(env)
env = black_death_v3(env)
if (not_dict_observation(env, agents)
and not_discrete_observation(env, agents)
and not_multibinary_observation(env, agents)):
env = dtype_v0(env, np.float16)
env = flatten_v0(env)
env = frame_skip_v0(env, 2)
if action_homogenizable(env, agents):
env = pad_action_space_v0(env)
env = clip_reward_v0(env, lower_bound=-1, upper_bound=1)
env = delay_observations_v0(env, 2)
env = sticky_actions_v0(env, 0.5)
env = nan_random_v0(env)
env = nan_zeros_v0(env)
assert env.unwrapped.__class__ == DummyEnv, f"Failed to unwrap {env}"
return PettingzooWrap(DummyEnv(base_obs, base_obs_space, base_act_spaces))
wrappers = [
supersuit.color_reduction_v0(new_dummy(), "R"),
supersuit.resize_v0(dtype_v0(new_dummy(), np.uint8), x_size=5, y_size=10),
supersuit.resize_v0(dtype_v0(new_dummy(), np.uint8), x_size=5, y_size=10, linear_interp=True),
supersuit.dtype_v0(new_dummy(), np.int32),
supersuit.flatten_v0(new_dummy()),
supersuit.reshape_v0(new_dummy(), (64, 3)),
supersuit.normalize_obs_v0(new_dummy(), env_min=-1, env_max=5.0),
supersuit.frame_stack_v1(new_dummy(), 8),
supersuit.pad_observations_v0(new_dummy()),
supersuit.pad_action_space_v0(new_dummy()),
supersuit.agent_indicator_v0(new_dummy(), True),
supersuit.agent_indicator_v0(new_dummy(), False),
supersuit.reward_lambda_v0(new_dummy(), lambda x: x / 10),
supersuit.clip_reward_v0(new_dummy()),
supersuit.clip_actions_v0(new_continuous_dummy()),
supersuit.frame_skip_v0(new_dummy(), 4),
supersuit.sticky_actions_v0(new_dummy(), 0.75),
supersuit.delay_observations_v0(new_dummy(), 3),
]
@pytest.mark.parametrize("env", wrappers)
def test_basic_wrappers(env):
env.seed(5)
env.reset()
obs, _, _, _ = env.last()
supersuit.resize_v0(dtype_v0(knights_archers_zombies_v4.env(), np.uint8),
x_size=5,
y_size=10,
linear_interp=True),
supersuit.dtype_v0(knights_archers_zombies_v4.env(), np.int32),
supersuit.flatten_v0(knights_archers_zombies_v4.env()),
supersuit.reshape_v0(knights_archers_zombies_v4.env(), (512 * 512, 3)),
supersuit.normalize_obs_v0(dtype_v0(knights_archers_zombies_v4.env(),
np.float32),
env_min=-1,
env_max=5.0),
supersuit.frame_stack_v1(knights_archers_zombies_v4.env(), 8),
supersuit.pad_observations_v0(knights_archers_zombies_v4.env()),
supersuit.pad_action_space_v0(knights_archers_zombies_v4.env()),
supersuit.black_death_v0(knights_archers_zombies_v4.env()),
supersuit.agent_indicator_v0(knights_archers_zombies_v4.env(), True),
supersuit.agent_indicator_v0(knights_archers_zombies_v4.env(), False),
supersuit.reward_lambda_v0(knights_archers_zombies_v4.env(),
lambda x: x / 10),
supersuit.clip_reward_v0(knights_archers_zombies_v4.env()),
supersuit.clip_actions_v0(prison_v2.env(continuous=True)),
supersuit.frame_skip_v0(knights_archers_zombies_v4.env(), 4),
supersuit.sticky_actions_v0(knights_archers_zombies_v4.env(), 0.75),
supersuit.delay_observations_v0(knights_archers_zombies_v4.env(), 3),
]
@pytest.mark.parametrize("env", wrappers)
def test_pettingzoo_aec_api(env):
api_test.api_test(env)
supersuit.delay_observations_v0(
generated_agents_parallel_v0.parallel_env(), 3),
supersuit.max_observation_v0(generated_agents_parallel_v0.parallel_env(),
3),
]
@pytest.mark.parametrize("env", parallel_wrappers)
def test_pettingzoo_parallel_api_gen(env):
parallel_test.parallel_api_test(env, num_cycles=50)
wrapper_fns = [
lambda: supersuit.pad_action_space_v0(generated_agents_parallel_v0.env()),
lambda: supersuit.pad_observations_v0(generated_agents_parallel_v0.env()),
lambda: supersuit.agent_indicator_v0(generated_agents_parallel_v0.env()),
lambda: supersuit.vectorize_aec_env_v0(generated_agents_parallel_v0.env(),
2),
lambda: supersuit.pad_action_space_v0(generated_agents_parallel_v0.
parallel_env()),
lambda: supersuit.pad_observations_v0(generated_agents_parallel_v0.
parallel_env()),
lambda: supersuit.agent_indicator_v0(generated_agents_parallel_v0.
parallel_env()),
lambda: supersuit.pettingzoo_env_to_vec_env_v1(generated_agents_parallel_v0
.parallel_env()),
]
@pytest.mark.parametrize("wrapper_fn", wrapper_fns)
def test_pettingzoo_missing_optional_error_message(wrapper_fn):
writer = SummaryWriter(f"/tmp/{experiment_name}")
# TRY NOT TO MODIFY: seeding
device = torch.device(
'cuda' if torch.cuda.is_available() and args.cuda else 'cpu')
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.backends.cudnn.deterministic = args.torch_deterministic
# https://github.com/cpnota/autonomous-learning-library/blob/5ee29eac4ad22d6de00f89345dce6f9c55569149/all/environments/multiagent_atari.py#L26
# def make_atari(env_name, pettingzoo_params):
env = importlib.import_module(
args.gym_id).parallel_env(obs_type='grayscale_image')
env = ss.agent_indicator_v0(env)
env = ss.clip_reward_v0(env)
env = max_observation_v0(env, 2)
env = frame_skip_v0(env, 4)
env = resize_v0(env, 84, 84)
env = ss.pettingzoo_env_to_vec_env_v0(env)
envs = ss.concat_vec_envs_v0(env,
args.num_envs,
num_cpus=args.num_envs,
base_class='stable_baselines3')
envs = VecMonitor(envs)
if args.capture_video:
envs = VecVideoRecorder(envs,
f'videos/{experiment_name}',
record_video_trigger=lambda x: x % 150000 == 0,
video_length=400)
