mirror of
https://github.com/Farama-Foundation/Gymnasium.git
synced 2025-08-04 15:05:10 +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
71 lines
2.1 KiB
Python
71 lines
2.1 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import Optional, Sequence, Union
|
|
|
|
import numpy as np
|
|
|
|
from gym.spaces.space import Space
|
|
from gym.utils import seeding
|
|
|
|
|
|
class MultiBinary(Space[np.ndarray]):
|
|
"""
|
|
An n-shape binary space.
|
|
|
|
The argument to MultiBinary defines n, which could be a number or a ``list`` of numbers.
|
|
|
|
Example Usage::
|
|
|
|
>>> self.observation_space = spaces.MultiBinary(5)
|
|
>>> self.observation_space.sample()
|
|
array([0, 1, 0, 1, 0], dtype=int8)
|
|
>>> self.observation_space = spaces.MultiBinary([3, 2])
|
|
>>> self.observation_space.sample()
|
|
array([[0, 0],
|
|
[0, 1],
|
|
[1, 1]], dtype=int8)
|
|
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
n: Union[np.ndarray, Sequence[int], int],
|
|
seed: Optional[int | seeding.RandomNumberGenerator] = None,
|
|
):
|
|
if isinstance(n, (Sequence, np.ndarray)):
|
|
self.n = input_n = tuple(int(i) for i in n)
|
|
assert (np.asarray(input_n) > 0).all() # n (counts) have to be positive
|
|
else:
|
|
self.n = n = int(n)
|
|
input_n = (n,)
|
|
assert (np.asarray(input_n) > 0).all() # n (counts) have to be positive
|
|
|
|
super().__init__(input_n, np.int8, seed)
|
|
|
|
@property
|
|
def shape(self) -> tuple[int, ...]:
|
|
"""Has stricter type than gym.Space - never None."""
|
|
return self._shape # type: ignore
|
|
|
|
def sample(self) -> np.ndarray:
|
|
return self.np_random.integers(low=0, high=2, size=self.n, dtype=self.dtype)
|
|
|
|
def contains(self, x) -> bool:
|
|
if isinstance(x, Sequence):
|
|
x = np.array(x) # Promote list to array for contains check
|
|
if self.shape != x.shape:
|
|
return False
|
|
return ((x == 0) | (x == 1)).all()
|
|
|
|
def to_jsonable(self, sample_n) -> list:
|
|
return np.array(sample_n).tolist()
|
|
|
|
def from_jsonable(self, sample_n) -> list:
|
|
return [np.asarray(sample) for sample in sample_n]
|
|
|
|
def __repr__(self) -> str:
|
|
return f"MultiBinary({self.n})"
|
|
|
|
def __eq__(self, other) -> bool:
|
|
return isinstance(other, MultiBinary) and self.n == other.n
|