Delete prng.py

gym/core.py

@@ -190,45 +190,6 @@ def compute_reward(self, achieved_goal, desired_goal, info):
         """
         raise NotImplementedError()
 
-# Space-related abstractions
-
-class Space(object):
-    """Defines the observation and action spaces, so you can write generic
-    code that applies to any Env. For example, you can choose a random
-    action.
-    """
-    def __init__(self, shape=None, dtype=None):
-        import numpy as np # takes about 300-400ms to import, so we load lazily
-        self.shape = None if shape is None else tuple(shape)
-        self.dtype = None if dtype is None else np.dtype(dtype)
-
-    def sample(self):
-        """
-        Uniformly randomly sample a random element of this space
-        """
-        raise NotImplementedError
-
-    def contains(self, x):
-        """
-        Return boolean specifying if x is a valid
-        member of this space
-        """
-        raise NotImplementedError
-
-    def __contains__(self, x):
-        return self.contains(x)
-
-    def to_jsonable(self, sample_n):
-        """Convert a batch of samples from this space to a JSONable data type."""
-        # By default, assume identity is JSONable
-        return sample_n
-
-    def from_jsonable(self, sample_n):
-        """Convert a JSONable data type to a batch of samples from this space."""
-        # By default, assume identity is JSONable
-        return sample_n
-
-
 warn_once = True
 
 def deprecated_warn_once(text):

gym/envs/tests/test_determinism.py

@@ -1,27 +1,25 @@
 import numpy as np
 import pytest
-from gym import spaces
+
 from gym.envs.tests.spec_list import spec_list
 
+
 @pytest.mark.parametrize("spec", spec_list)
 def test_env(spec):
-
     # Note that this precludes running this test in multiple
     # threads. However, we probably already can't do multithreading
     # due to some environments.
-    spaces.seed(0)
-
     env1 = spec.make()
     env1.seed(0)
+    env1.action_space.seed(0)
     action_samples1 = [env1.action_space.sample() for i in range(4)]
     initial_observation1 = env1.reset()
     step_responses1 = [env1.step(action) for action in action_samples1]
     env1.close()
 
-    spaces.seed(0)
-
     env2 = spec.make()
     env2.seed(0)
+    env2.action_space.seed(0)
     action_samples2 = [env2.action_space.sample() for i in range(4)]
     initial_observation2 = env2.reset()
     step_responses2 = [env2.step(action) for action in action_samples2]

gym/envs/toy_text/kellycoinflip.py

@@ -6,7 +6,6 @@
 import gym
 from gym import spaces
 from gym.utils import seeding
-from gym.spaces import prng
 
 
 def flip(edge, np_random):
@@ -81,10 +80,12 @@ def __init__(self, initialWealth=25.0, edgePriorAlpha=7, edgePriorBeta=3, maxWea
         self.maxRoundsMean=maxRoundsMean
         self.maxRoundsSD=maxRoundsSD
 
+        if reseed or not hasattr(self, 'np_random') : self.seed()
+
         # draw this game's set of parameters:
-        edge = prng.np_random.beta(edgePriorAlpha, edgePriorBeta)
-        maxWealth = round(genpareto.rvs(maxWealthAlpha, maxWealthM, random_state=prng.np_random))
-        maxRounds = int(round(prng.np_random.normal(maxRoundsMean, maxRoundsSD)))
+        edge = self.np_random.beta(edgePriorAlpha, edgePriorBeta)
+        maxWealth = round(genpareto.rvs(maxWealthAlpha, maxWealthM, random_state=self.np_random))
+        maxRounds = int(round(self.np_random.normal(maxRoundsMean, maxRoundsSD)))
 
         # add an additional global variable which is the sufficient statistic for the Pareto distribution on wealth cap;
         # alpha doesn't update, but x_m does, and simply is the highest wealth count we've seen to date:
@@ -109,7 +110,6 @@ def __init__(self, initialWealth=25.0, edgePriorAlpha=7, edgePriorBeta=3, maxWea
         self.maxRounds = maxRounds
         self.rounds = self.maxRounds
         self.maxWealth = maxWealth
-        if reseed or not hasattr(self, 'np_random') : self.seed()
 
     def seed(self, seed=None):
         self.np_random, seed = seeding.np_random(seed)

gym/spaces/__init__.py

@@ -1,9 +1,9 @@
+from gym.spaces.space import Space
 from gym.spaces.box import Box
 from gym.spaces.discrete import Discrete
 from gym.spaces.multi_discrete import MultiDiscrete
 from gym.spaces.multi_binary import MultiBinary
-from gym.spaces.prng import seed, np_random
 from gym.spaces.tuple_space import Tuple
 from gym.spaces.dict_space import Dict
 
-__all__ = ["Box", "Discrete", "MultiDiscrete", "MultiBinary", "Tuple", "Dict"]
+__all__ = ["Space", "Box", "Discrete", "MultiDiscrete", "MultiBinary", "Tuple", "Dict"]

gym/spaces/box.py

@@ -2,8 +2,10 @@
 
 import gym
 from gym import logger
+from .space import Space
 
-class Box(gym.Space):
+
+class Box(Space):
     """
     A box in R^n.
     I.e., each coordinate is bounded.
@@ -32,10 +34,14 @@ def __init__(self, low=None, high=None, shape=None, dtype=None):
             logger.warn("gym.spaces.Box autodetected dtype as {}. Please provide explicit dtype.".format(dtype))
         self.low = low.astype(dtype)
         self.high = high.astype(dtype)
-        gym.Space.__init__(self, shape, dtype)
+        super().__init__(shape, dtype)
+        self.np_random = np.random.RandomState()
+
+    def seed(self, seed):
+        self.np_random.seed(seed)
 
     def sample(self):
-        return gym.spaces.np_random.uniform(low=self.low, high=self.high + (0 if self.dtype.kind == 'f' else 1), size=self.low.shape).astype(self.dtype)
+        return self.np_random.uniform(low=self.low, high=self.high + (0 if self.dtype.kind == 'f' else 1), size=self.low.shape).astype(self.dtype)
 
     def contains(self, x):
         return x.shape == self.shape and (x >= self.low).all() and (x <= self.high).all()

gym/spaces/dict_space.py

@@ -1,7 +1,9 @@
 import gym
 from collections import OrderedDict
+from .space import Space
 
-class Dict(gym.Space):
+
+class Dict(Space):
     """
     A dictionary of simpler spaces.
 
@@ -39,7 +41,10 @@ def __init__(self, spaces=None, **spaces_kwargs):
         if isinstance(spaces, list):
             spaces = OrderedDict(spaces)
         self.spaces = spaces
-        gym.Space.__init__(self, None, None) # None for shape and dtype, since it'll require special handling
+        super().__init__(None, None) # None for shape and dtype, since it'll require special handling
+
+    def seed(self, seed):
+        [space.seed(seed) for space in self.spaces.values()]
 
     def sample(self):
         return OrderedDict([(k, space.sample()) for k, space in self.spaces.items()])

gym/spaces/discrete.py

@@ -1,7 +1,9 @@
 import numpy as np
 import gym
+from .space import Space
 
-class Discrete(gym.Space):
+
+class Discrete(Space):
     """
     {0,1,...,n-1}
 
@@ -10,10 +12,14 @@ class Discrete(gym.Space):
     """
     def __init__(self, n):
         self.n = n
-        gym.Space.__init__(self, (), np.int64)
+        super().__init__((), np.int64)
+        self.np_random = np.random.RandomState()
+
+    def seed(self, seed):
+        self.np_random.seed(seed)
 
     def sample(self):
-        return gym.spaces.np_random.randint(self.n)
+        return self.np_random.randint(self.n)
 
     def contains(self, x):
         if isinstance(x, int):

gym/spaces/multi_binary.py

@@ -1,13 +1,19 @@
 import gym
 import numpy as np
+from .space import Space
 
-class MultiBinary(gym.Space):
+
+class MultiBinary(Space):
     def __init__(self, n):
         self.n = n
-        gym.Space.__init__(self, (self.n,), np.int8)
+        super().__init__((self.n,), np.int8)
+        self.np_random = np.random.RandomState()
+
+    def seed(self, seed):
+        self.np_random.seed(seed)
 
     def sample(self):
-        return gym.spaces.np_random.randint(low=0, high=2, size=self.n).astype(self.dtype)
+        return self.np_random.randint(low=0, high=2, size=self.n).astype(self.dtype)
 
     def contains(self, x):
         return ((x==0) | (x==1)).all()

gym/spaces/multi_discrete.py

@@ -1,17 +1,24 @@
 import gym
 import numpy as np
+from .space import Space
 
-class MultiDiscrete(gym.Space):
+
+class MultiDiscrete(Space):
     def __init__(self, nvec):
         """
         nvec: vector of counts of each categorical variable
         """
         assert (np.array(nvec) > 0).all(), 'nvec (counts) have to be positive'
         self.nvec = np.asarray(nvec, dtype=np.uint32)
-        gym.Space.__init__(self, self.nvec.shape, np.uint32)
+
+        super().__init__(self.nvec.shape, np.uint32)
+        self.np_random = np.random.RandomState()
+
+    def seed(self, seed):
+        self.np_random.seed(seed)
 
     def sample(self):
-        return (gym.spaces.np_random.random_sample(self.nvec.shape) * self.nvec).astype(self.dtype)
+        return (self.np_random.random_sample(self.nvec.shape) * self.nvec).astype(self.dtype)
 
     def contains(self, x):
         # if nvec is uint32 and space dtype is uint32, then 0 <= x < self.nvec guarantees that x

gym/spaces/space.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+
+class Space(object):
+    """Defines the observation and action spaces, so you can write generic
+    code that applies to any Env. For example, you can choose a random
+    action.
+    """
+    def __init__(self, shape=None, dtype=None):
+        import numpy as np # takes about 300-400ms to import, so we load lazily
+        self.shape = None if shape is None else tuple(shape)
+        self.dtype = None if dtype is None else np.dtype(dtype)
+
+    def sample(self):
+        """
+        Uniformly randomly sample a random element of this space
+        """
+        raise NotImplementedError
+
+    def seed(self, seed):
+        """Set the seed for this space's pseudo-random number generator. """
+        raise NotImplementedError
+
+    def contains(self, x):
+        """
+        Return boolean specifying if x is a valid
+        member of this space
+        """
+        raise NotImplementedError
+
+    def __contains__(self, x):
+        return self.contains(x)
+
+    def to_jsonable(self, sample_n):
+        """Convert a batch of samples from this space to a JSONable data type."""
+        # By default, assume identity is JSONable
+        return sample_n
+
+    def from_jsonable(self, sample_n):
+        """Convert a JSONable data type to a batch of samples from this space."""
+        # By default, assume identity is JSONable
+        return sample_n

gym/spaces/tuple_space.py

@@ -1,6 +1,8 @@
 import gym
+from .space import Space
 
-class Tuple(gym.Space):
+
+class Tuple(Space):
     """
     A tuple (i.e., product) of simpler spaces
 
@@ -9,7 +11,10 @@ class Tuple(gym.Space):
     """
     def __init__(self, spaces):
         self.spaces = spaces
-        gym.Space.__init__(self, None, None)
+        super().__init__(None, None)
+
+    def seed(self, seed):
+        [space.seed(seed) for space in self.spaces]
 
     def sample(self):
         return tuple([space.sample() for space in self.spaces])