Update for latest gym

component/atari_wrapper.py

@@ -13,7 +13,7 @@ class NoopResetEnv(gym.Wrapper):
         self.noop_max = noop_max
         assert env.unwrapped.get_action_meanings()[0] == 'NOOP'
 
-    def _reset(self):
+    def reset(self):
         """ Do no-op action for a number of steps in [1, noop_max]."""
         self.env.reset()
         noops = np.random.randint(1, self.noop_max + 1)
@@ -21,6 +21,9 @@ class NoopResetEnv(gym.Wrapper):
             obs, _, _, _ = self.env.step(0)
         return obs
 
+    def step(self, action):
+        return self.env.step(action)
+
 class FireResetEnv(gym.Wrapper):
     def __init__(self, env=None):
         """Take action on reset for environments that are fixed until firing."""
@@ -28,12 +31,15 @@ class FireResetEnv(gym.Wrapper):
         assert env.unwrapped.get_action_meanings()[1] == 'FIRE'
         assert len(env.unwrapped.get_action_meanings()) >= 3
 
-    def _reset(self):
+    def reset(self):
         self.env.reset()
         obs, _, _, _ = self.env.step(1)
         obs, _, _, _ = self.env.step(2)
         return obs
 
+    def step(self, action):
+        return self.env.step(action)
+
 class EpisodicLifeEnv(gym.Wrapper):
     def __init__(self, env=None):
         """Make end-of-life == end-of-episode, but only reset on true game over.
@@ -42,9 +48,9 @@ class EpisodicLifeEnv(gym.Wrapper):
         super(EpisodicLifeEnv, self).__init__(env)
         self.lives = 0
         self.was_real_done  = True
-        self.was_real_reset = False
+        self.was_realreset = False
 
-    def _step(self, action):
+    def step(self, action):
         obs, reward, done, info = self.env.step(action)
         self.was_real_done = done
         # check current lives, make loss of life terminal,
@@ -58,18 +64,18 @@ class EpisodicLifeEnv(gym.Wrapper):
         self.lives = lives
         return obs, reward, done, info
 
-    def _reset(self):
+    def reset(self):
         """Reset only when lives are exhausted.
         This way all states are still reachable even though lives are episodic,
         and the learner need not know about any of this behind-the-scenes.
         """
         if self.was_real_done:
             obs = self.env.reset()
-            self.was_real_reset = True
+            self.was_realreset = True
         else:
             # no-op step to advance from terminal/lost life state
             obs, _, _, _ = self.env.step(0)
-            self.was_real_reset = False
+            self.was_realreset = False
         self.lives = self.env.unwrapped.ale.lives()
         return obs
 
@@ -81,7 +87,7 @@ class MaxAndSkipEnv(gym.Wrapper):
         self._obs_buffer = deque(maxlen=2)
         self._skip       = skip
 
-    def _step(self, action):
+    def step(self, action):
         total_reward = 0.0
         done = None
         for _ in range(self._skip):
@@ -95,7 +101,7 @@ class MaxAndSkipEnv(gym.Wrapper):
 
         return max_frame, total_reward, done, info
 
-    def _reset(self):
+    def reset(self):
         """Clear past frame buffer and init. to first obs. from inner env."""
         self._obs_buffer.clear()
         obs = self.env.reset()
@@ -115,13 +121,13 @@ class DatasetEnv(gym.Wrapper):
         self.saved_obs = []
         self.saved_actions = []
 
-    def _step(self, action):
+    def step(self, action):
         obs, reward, done, info = self.env.step(action)
         self.saved_actions.append(action)
         self.saved_obs.append(obs)
         return obs, reward, done, info
 
-    def _reset(self):
+    def reset(self):
         obs = self.env.reset()
         self.saved_obs.append(obs)
         return obs
@@ -130,7 +136,7 @@ class ProcessFrame(gym.Wrapper):
     def __init__(self, env=None, frame_size=84):
         super(ProcessFrame, self).__init__(env)
         self.frame_size = frame_size
-        self.observation_space = spaces.Box(low=0, high=255, shape=(1, frame_size, frame_size))
+        self.observation_space = spaces.Box(low=0, high=255, shape=(1, frame_size, frame_size), dtype=np.uint8)
 
     def process(self, obs):
         obs = color.rgb2gray(obs)
@@ -138,11 +144,11 @@ class ProcessFrame(gym.Wrapper):
         obs = (255 * obs).astype(np.uint8).reshape((1, ) + obs.shape)
         return obs
 
-    def _step(self, action):
+    def step(self, action):
         obs, reward, done, info = self.env.step(action)
         return self.process(obs), reward, done, info
 
-    def _reset(self):
+    def reset(self):
         return self.process(self.env.reset())
 
 class NormalizeFrame(gym.Wrapper):
@@ -152,11 +158,11 @@ class NormalizeFrame(gym.Wrapper):
     def _normalize(self, obs):
         return np.asarray(obs, dtype=np.float32) / 255.0
 
-    def _step(self, action):
+    def step(self, action):
         obs, reward, done, info = self.env.step(action)
         return self._normalize(obs), reward, done, info
 
-    def _reset(self):
+    def reset(self):
         return self._normalize(self.env.reset())
 
 class StackFrame(gym.Wrapper):
@@ -165,12 +171,12 @@ class StackFrame(gym.Wrapper):
         self.history_length = history_length
         self.buffer = None
 
-    def _reset(self):
+    def reset(self):
         state = self.env.reset()
         self.buffer = [state] * self.history_length
         return np.vstack(self.buffer)
 
-    def _step(self, action):
+    def step(self, action):
         state, reward, done, info = self.env.step(action)
         self.buffer.pop(0)
         self.buffer.append(state)

component/task.py

@@ -127,6 +127,7 @@ class Roboschool(BasicTask):
 def sub_task(parent_pipe, pipe, task_fn):
     parent_pipe.close()
     task = task_fn()
+    task.env.seed(np.random.randint(0, sys.maxsize))
     while True:
         op, data = pipe.recv()
         if op == 'step':