Exemple #1
0
    def env_creator():
        if args.game.__package__.endswith('atari'):
            if (args.game_name.startswith('foozpong') or
                args.game_name.startswith('basketball_pong') or
                args.game_name.startswith('volleyball_pong')
                ):
                env = args.game.env(obs_type=args.atari_obs_type,
                                    max_cycles=args.max_steps['atari'],
                                    full_action_space=False,
                                    num_players=2)
            else:
                env = args.game.env(obs_type=args.atari_obs_type,
                                    full_action_space=False,
                                    max_cycles=args.max_steps['atari'])
            env = frame_skip_v0(env, args.atari_frame_skip_num)
            env = frame_stack_v1(env, args.atari_frame_stack_num)

        else:
            env = args.game.env()
        if args.game_name.startswith('rps'):
            env = one_hot_obs_wrapper(env)
        env = dtype_v0(env, dtype=float32)
        env = pad_observations_v0(env)
        env = pad_action_space_v0(env)
        if args.game_name.startswith('connect_four') or args.game_name.startswith('tictactoe'):
            env = FlattenEnvWrapper(env)
        GAUSSIAN_STD = 1.0
        assert abs(GAUSSIAN_STD - 1.0) < 1e-5, "must be 1.0, otherwise simple ensemble implementation is wrong"
        env = LatentGaussianAugmentedEnvWrapper(env,
                                                latent_parameter_dim=args.latent_para_dim,
                                                gaussian_std=1.0,
                                                use_dict_obs_space=args.use_dict_obs_space)
        return env
def env_fn():
    #env = gym.make("CartPole-v0")#
    env = simple_spread_v2.parallel_env()
    # print(env.action_spaces.values())
    # exit(0)
    env = supersuit.pad_observations_v0(env)
    env = supersuit.pad_action_space_v0(env)
    #env = supersuit.aec_wrappers.continuous_actions(env)
    venv = pettingzoo_env_to_vec_env_v0(env)
    return venv
 def comm_env(**kwargs):
     raw_env = base_env.raw_env(**kwargs)
     # Set all agents to silent
     for agent in raw_env.world.agents:
         agent.silent = True
     env = AssertOutOfBoundsWrapper(raw_env)
     env = OrderEnforcingWrapper(env)
     env = CommWrapper(env, comm_dict)
     env = pad_observations_v0(env)
     env = pad_action_space_v0(env)
     env = _PettingZooEnv(env)
     return env
 def env_creator(args):
     env = env_constr.env(
     )  #killable_knights=False, killable_archers=False)
     resize_size = 84 if model == None else 32
     env = supersuit.resize_v0(env,
                               resize_size,
                               resize_size,
                               linear_interp=True)
     env = supersuit.color_reduction_v0(env)
     env = supersuit.pad_action_space_v0(env)
     env = supersuit.pad_observations_v0(env)
     # env = supersuit.frame_stack_v0(env,2)
     env = supersuit.dtype_v0(env, np.float32)
     env = supersuit.normalize_obs_v0(env)
     if model == "MLPModelV2":
         env = supersuit.flatten_v0(env)
     env = PettingZooEnv(env)
     return env
Exemple #5
0
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}"
Exemple #6
0
    base_obs_space = {"a_{}".format(idx): Box(low=np.float32(0.0), high=np.float32(10.0), shape=[8, 8, 3]) for idx in range(2)}
    base_act_spaces = {"a_{}".format(idx): Discrete(5) for idx in range(2)}

    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)
    supersuit.resize_v0(dtype_v0(knights_archers_zombies_v4.env(), np.uint8),
                        x_size=5,
                        y_size=10),
    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 create_env(args):
    if args[env_name] == "simple_speaker_listener":
        env = simple_speaker_listener_v3.env()
        env = supersuit.pad_action_space_v0(env)
        env = supersuit.pad_observations_v0(env)
        return env
Exemple #9
0
 def create_env(args):
     env = simple_speaker_listener_v3.env()
     env = pad_action_space_v0(env)
     env = pad_observations_v0(env)
     return env
 def env(**kwargs):
     env = base_env.parallel_env(**kwargs)
     env = pad_observations_v0(env)
     env = pad_action_space_v0(env)
     env = _ParallelPettingZooEnv(env)
     return env
                                0.75),
    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)
     dtype_v0(knights_archers_zombies_v10.env(vector_state=False),
              np.uint8),
     x_size=5,
     y_size=10,
     linear_interp=True,
 ),
 supersuit.dtype_v0(knights_archers_zombies_v10.env(), np.int32),
 supersuit.flatten_v0(knights_archers_zombies_v10.env()),
 supersuit.reshape_v0(knights_archers_zombies_v10.env(vector_state=False),
                      (512 * 512, 3)),
 supersuit.normalize_obs_v0(dtype_v0(knights_archers_zombies_v10.env(),
                                     np.float32),
                            env_min=-1,
                            env_max=5.0),
 supersuit.frame_stack_v1(combined_arms_v6.env(), 8),
 supersuit.pad_observations_v0(simple_world_comm_v2.env()),
 supersuit.pad_action_space_v0(simple_world_comm_v2.env()),
 supersuit.black_death_v3(combined_arms_v6.env()),
 supersuit.agent_indicator_v0(knights_archers_zombies_v10.env(), True),
 supersuit.agent_indicator_v0(knights_archers_zombies_v10.env(), False),
 supersuit.reward_lambda_v0(knights_archers_zombies_v10.env(),
                            lambda x: x / 10),
 supersuit.clip_reward_v0(combined_arms_v6.env()),
 supersuit.nan_noop_v0(knights_archers_zombies_v10.env(), 0),
 supersuit.nan_zeros_v0(knights_archers_zombies_v10.env()),
 supersuit.nan_random_v0(chess_v5.env()),
 supersuit.nan_random_v0(knights_archers_zombies_v10.env()),
 supersuit.frame_skip_v0(combined_arms_v6.env(), 4),
 supersuit.sticky_actions_v0(combined_arms_v6.env(), 0.75),
 supersuit.delay_observations_v0(combined_arms_v6.env(), 3),
 supersuit.max_observation_v0(knights_archers_zombies_v10.env(), 3),