mirror of
https://github.com/Farama-Foundation/Gymnasium.git
synced 2025-08-19 05:25:54 +00:00
3354451300
* Add a case for the Box shape where the low and high values are both scalars
* Add seeding.RandomNumberGenerator parameter to Dict seed. Modify __repr__ for the dictionary space string looks similar to an actual dictionary
* Add seeding.RandomNumberGenerator parameter to Multi Binary seed
* Add seeding.RandomNumberGenerator parameter to Multi Binary seed. Modify nvec typing to include np.ndarray
* Space seed typing can be a seeding.RandomNumberGenerator. If a seeding.RNG is provided then it is assigned to _np_random and .seed is not run
* Fixed the tuple seeding type as List[int] is not a valid Space seed type
* Added typing to batch_space. The batch_space seed is equal to the space's seeding
* Fixed the seeding type
* Add test for batch space seeds are identical to the original space's seeding
* Add equivalence function for RandomNumberGenerator comparing the bit_generator.state
* The batch_space functions uses a copy of the seed for the original space
* Set the action space seed for sync_vector_env seed testing
* Add test for the seeding of the sync vector environment
* Update the test_batch_space_seed to check the resulting sampling are equivalent for testing
* Revert representation back to the original version
* Remove additional Box shape initialisation
* Remove additional typing of MultiDiscrete
* Fixed bug of Space batch space where the original space's np_random is not a complete copy of the original space
* Add CustomSpace to the batched space seed test
* Modify the CustomSpace sample to produce a random number not a static value
* Fix CustomSpace to reflect the sample function
* Copy the space.np_random for the batched_space seed to ensure that the original space doesn't sampling doesn't effect the batched_space
* Parameterized the batch_space_seed, added testing for rng_different_at_each_index and test_deterministic
* Black and isort pre-commit changes
* Pre-commit fix
* MacOS, test_read_from_shared_memory throws an error that the inner _process_write function was unpicklable. Making the function a top-level function solves this error
* Fixed typing of seed where a space's seed function differs from Space.seed's typing
* Added check that the sample lengths are equal and explicitly provided the number of batched spaces n=1
* Removed relative imports for absolute imports
* Use deepcopy instead of copy
* Replaces `from numpy.testing._private.utils import assert_array_equal` with `from numpy.testing import assert_array_equal`
* Using the seeding `__eq__` function, replace `np_random.bit_generator.state` with `np_random`
* Added docstrings and comments to the tests to explain their purpose
* Remove __eq__ from RandomNumberGenerator and add to tests/vector/utils
* Add sync vector determinism test for issue #2680
* Fixed bug for 462101d384 (r850740825)
* Made the new seeds a list of integers
140 lines
3.6 KiB
Python
140 lines
3.6 KiB
Python
import time
|
|
from typing import Optional
|
|
|
|
import numpy as np
|
|
|
|
import gym
|
|
from gym.spaces import Box, Dict, Discrete, MultiBinary, MultiDiscrete, Tuple
|
|
from gym.utils.seeding import RandomNumberGenerator
|
|
|
|
spaces = [
|
|
Box(low=np.array(-1.0), high=np.array(1.0), dtype=np.float64),
|
|
Box(low=np.array([0.0]), high=np.array([10.0]), dtype=np.float64),
|
|
Box(
|
|
low=np.array([-1.0, 0.0, 0.0]), high=np.array([1.0, 1.0, 1.0]), dtype=np.float64
|
|
),
|
|
Box(
|
|
low=np.array([[-1.0, 0.0], [0.0, -1.0]]), high=np.ones((2, 2)), dtype=np.float64
|
|
),
|
|
Box(low=0, high=255, shape=(), dtype=np.uint8),
|
|
Box(low=0, high=255, shape=(32, 32, 3), dtype=np.uint8),
|
|
Discrete(2),
|
|
Discrete(5, start=-2),
|
|
Tuple((Discrete(3), Discrete(5))),
|
|
Tuple(
|
|
(
|
|
Discrete(7),
|
|
Box(low=np.array([0.0, -1.0]), high=np.array([1.0, 1.0]), dtype=np.float64),
|
|
)
|
|
),
|
|
MultiDiscrete([11, 13, 17]),
|
|
MultiBinary(19),
|
|
Dict(
|
|
{
|
|
"position": Discrete(23),
|
|
"velocity": Box(
|
|
low=np.array([0.0]), high=np.array([1.0]), dtype=np.float64
|
|
),
|
|
}
|
|
),
|
|
Dict(
|
|
{
|
|
"position": Dict({"x": Discrete(29), "y": Discrete(31)}),
|
|
"velocity": Tuple(
|
|
(Discrete(37), Box(low=0, high=255, shape=(), dtype=np.uint8))
|
|
),
|
|
}
|
|
),
|
|
]
|
|
|
|
HEIGHT, WIDTH = 64, 64
|
|
|
|
|
|
class UnittestSlowEnv(gym.Env):
|
|
def __init__(self, slow_reset=0.3):
|
|
super().__init__()
|
|
self.slow_reset = slow_reset
|
|
self.observation_space = Box(
|
|
low=0, high=255, shape=(HEIGHT, WIDTH, 3), dtype=np.uint8
|
|
)
|
|
self.action_space = Box(low=0.0, high=1.0, shape=(), dtype=np.float32)
|
|
|
|
def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
|
|
super().reset(seed=seed)
|
|
if self.slow_reset > 0:
|
|
time.sleep(self.slow_reset)
|
|
return self.observation_space.sample()
|
|
|
|
def step(self, action):
|
|
time.sleep(action)
|
|
observation = self.observation_space.sample()
|
|
reward, done = 0.0, False
|
|
return observation, reward, done, {}
|
|
|
|
|
|
class CustomSpace(gym.Space):
|
|
"""Minimal custom observation space."""
|
|
|
|
def sample(self):
|
|
return self.np_random.integers(0, 10, ())
|
|
|
|
def contains(self, x):
|
|
return 0 <= x <= 10
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, CustomSpace)
|
|
|
|
|
|
custom_spaces = [
|
|
CustomSpace(),
|
|
Tuple((CustomSpace(), Box(low=0, high=255, shape=(), dtype=np.uint8))),
|
|
]
|
|
|
|
|
|
class CustomSpaceEnv(gym.Env):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.observation_space = CustomSpace()
|
|
self.action_space = CustomSpace()
|
|
|
|
def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
|
|
super().reset(seed=seed)
|
|
return "reset"
|
|
|
|
def step(self, action):
|
|
observation = f"step({action:s})"
|
|
reward, done = 0.0, False
|
|
return observation, reward, done, {}
|
|
|
|
|
|
def make_env(env_name, seed):
|
|
def _make():
|
|
env = gym.make(env_name)
|
|
env.action_space.seed(seed)
|
|
env.reset(seed=seed)
|
|
return env
|
|
|
|
return _make
|
|
|
|
|
|
def make_slow_env(slow_reset, seed):
|
|
def _make():
|
|
env = UnittestSlowEnv(slow_reset=slow_reset)
|
|
env.reset(seed=seed)
|
|
return env
|
|
|
|
return _make
|
|
|
|
|
|
def make_custom_space_env(seed):
|
|
def _make():
|
|
env = CustomSpaceEnv()
|
|
env.reset(seed=seed)
|
|
return env
|
|
|
|
return _make
|
|
|
|
|
|
def assert_rng_equal(rng_1: RandomNumberGenerator, rng_2: RandomNumberGenerator):
|
|
assert rng_1.bit_generator.state == rng_2.bit_generator.state
|