def __init__(self, width, height, fps, level): lab = deepmind_lab.Lab(level, []) self.env = deepmind_lab.Lab(level, ["RGB_INTERLACED"], config={ "fps": str(fps), "width": str(width), "height": str(height) }) self.env.reset() import pprint observation_spec = lab.observation_spec() print("Observation spec:") pprint.pprint(observation_spec) self.action_spec = self.env.action_spec() print("Action spec:") pprint.pprint(self.action_spec) self.indices = {a["name"]: i for i, a in enumerate(self.action_spec)} self.mins = np.array([a["min"] for a in self.action_spec]) self.maxs = np.array([a["max"] for a in self.action_spec]) self.num_actions = len(self.action_spec) print(self.num_actions) self.action = None
def test_maze_layout_spread(self): layouts = set() for i in six.moves.range(MAZE_LAYOUT_TRIALS): print('phase 1: trial {} out of {}'.format(i+1, MAZE_LAYOUT_TRIALS)) env = deepmind_lab.Lab( 'tests/maze_generation_test', [MAZE_LAYOUT_OBSERVATION], config={}) env.reset(seed=i+1) layouts.add(env.observations()[MAZE_LAYOUT_OBSERVATION]) num_layouts = len(layouts) self.assertTrue(np.isclose(num_layouts, MAZE_LAYOUT_TRIALS)) for i in six.moves.range(MAZE_LAYOUT_TRIALS): print('phase 2: trial {} out of {}'.format(i+1, MAZE_LAYOUT_TRIALS)) env = deepmind_lab.Lab( 'tests/maze_generation_test', [MAZE_LAYOUT_OBSERVATION], config={ 'mixerSeed': '0', }) env.reset(seed=i+1) layouts.add(env.observations()[MAZE_LAYOUT_OBSERVATION]) self.assertEqual(len(layouts), num_layouts) for i in six.moves.range(MAZE_LAYOUT_TRIALS): print('phase 3: trial {} out of {}'.format(i+1, MAZE_LAYOUT_TRIALS)) env = deepmind_lab.Lab( 'tests/maze_generation_test', [MAZE_LAYOUT_OBSERVATION], config={ 'mixerSeed': '1', }) env.reset(seed=i+1) layouts.add(env.observations()[MAZE_LAYOUT_OBSERVATION]) self.assertTrue(np.isclose(len(layouts) - num_layouts, MAZE_LAYOUT_TRIALS))
def __init__(self, width, height, fps, level): lab = deepmind_lab.Lab(level, []) # 定义了 Deepmind 的对象 # 加载的游戏脚本为 level # observations 中的元素分别给环境中的observation 命名 self.env = deepmind_lab.Lab(level, ["RGB_INTERLEAVED"], config={ "fps": str(fps), "width": str(width), "height": str(height) }) self.env.reset() # 在每个 epsido 结束后 调用会设置 is_running == False import pprint observation_spec = lab.observation_spec() # 所有的 observations 的名称、类型、维度 print("Observation spec:") pprint.pprint(observation_spec) self.action_spec = self.env.action_spec() # 同理 print("Action spec:") pprint.pprint(self.action_spec) self.indices = {a["name"]: i for i, a in enumerate(self.action_spec) } # 变成所有 actions 的行为的索引 self.mins = np.array([a["min"] for a in self.action_spec]) # action 的 最小值序列 self.maxs = np.array([a["max"] for a in self.action_spec]) # action 的最大值序列 self.num_actions = len(self.action_spec) # 动作的数量 print(self.num_actions) # 7个动作 self.action = None
def testInitArgs(self): with self.assertRaisesRegexp(TypeError, 'must be dict, not list'): deepmind_lab.Lab('tests/demo_map', [], ['wrongconfig']) with self.assertRaisesRegexp(TypeError, 'str'): deepmind_lab.Lab('tests/demo_map', [], {'wrongtype': 3}) with self.assertRaisesRegexp(TypeError, 'must be list, not None'): deepmind_lab.Lab('tests/demo_map', None, {}) with self.assertRaisesRegexp(ValueError, 'Unknown observation'): deepmind_lab.Lab('tests/demo_map', ['nonexisting_obs'], {})
def testInitArgs(self): with six.assertRaisesRegex(self, TypeError, 'must be dict, not list'): deepmind_lab.Lab('tests/empty_room_test', [], ['wrongconfig']) with six.assertRaisesRegex(self, TypeError, 'str|bad argument type'): deepmind_lab.Lab('tests/empty_room_test', [], {'wrongtype': 3}) with six.assertRaisesRegex(self, TypeError, 'must be list, not None'): deepmind_lab.Lab('tests/empty_room_test', None, {}) with six.assertRaisesRegex(self, ValueError, 'Unknown observation'): deepmind_lab.Lab('tests/empty_room_test', ['nonexisting_obs'], {})
def test_maze_layout(self): env = deepmind_lab.Lab('tests/debug_observation_test', [MAZE_LAYOUT_OBSERVATION], config={}) env.reset() self.assertEqual(env.observations()[MAZE_LAYOUT_OBSERVATION], TEST_MAP)
def get_game_environment(level="nav_maze_random_goal_01", width=160, height=160): """ get deepmind_lab env (see:https://github.com/dongniu0927/lab/blob/master/docs/users/observations.md) :param level: :return: """ # RGB_INTERLEAVED: Player view interleaved # RGBD_INTERLEAVED: Player view with depth # DEBUG.CAMERA.TOP_DOWN: top view # DEBUG.POS.TRANS: Player's world position # DEBUG.POS.ROT: orientation in degrees # DEBUG.FLAGS.RED_HOME: Red flag's home location and state obses = [ "RGB_INTERLEAVED", "RGBD_INTERLEAVED", "DEBUG.POS.ROT", "DEBUG.CAMERA.TOP_DOWN", "DEBUG.POS.TRANS", "DEBUG.PLAYERS.TEAM", "DEBUG.PLAYERS.EYE.ROT", "DEBUG.FLAGS.RED_HOME", "DEBUG.PLAYERS.EYE.POS", "DEBUG.FLAGS.RED", "DEBUG.FLAGS.BLUE", "DEBUG.FLAGS.BLUE_HOME", "DEBUG.FLAGS.RED_HOME" ] lab = deepmind_lab.Lab( level, obses, { 'fps': '30', 'width': width, 'height': height, "maxAltCameraWidth": width, "maxAltCameraHeight": height }) lab.reset(seed=1) return lab
def __init__(self, level, configs, observation_keys, height=84, width=84, frame_skip=4, fps=60, ): """ Create the deepmind lab environment with level :param level: level :param configs: config :param observation_keys: available observations :param height: height for RGB observation :param width: width for RGB observation :param frame_skip: frame skip :param fps: """ super(DeepmindLabEnvironment, self).__init__() # 相关的属性 self.level = level self.viewer = None self.frame_skip = frame_skip config = { 'fps': str(fps), 'width': str(width), 'height': str(height), } config.update(configs) env = deepmind_lab.Lab(level, observation_keys, config=config) self.lab = env
def test_list_properties(self): env = deepmind_lab.Lab('tests/properties_test', [], config={}) props = props_to_dictionary(env) expected_params = { 'arg1': 'true', 'arg2': '19', 'arg3': 'hello', 'arrArgs': { '1': 'arr1', '2': 'arr2', '3': 'arr3' }, 'subArgs': { 'sub1': 'val1', 'sub2': 'val2', 'sub3': 'val3' } } self.assertEqual(props['params'], expected_params) env.write_property('params.arrArgs.1', 'newarr1') props = props_to_dictionary(env) self.assertEqual(props['params']['arrArgs']['1'], 'newarr1') env.write_property('params.arg1', 'false') self.assertIsNotNone(props['func']) self.assertIsNotNone(props['func']['times10']) for i in six.moves.range(10): self.assertEqual(env.read_property('func.times10.' + str(i)), str(i * 10))
def test_pickup_apple_run(self): env = deepmind_lab.Lab('tests/extra_entities_test', ['DEBUG.POS.TRANS'], config={ 'fps': '60', 'width': '80', 'height': '80' }) action_spec = env.action_spec() action_index = { action['name']: i for i, action in enumerate(action_spec) } action = np.zeros([len(action_spec)], dtype=np.intc) action[action_index['MOVE_BACK_FORWARD']] = 1 reward = env.reset() expected_reward = 1 for _ in six.moves.range(60): reward = env.step(action, 1) if reward > 0: self.assertEqual(reward, expected_reward) if expected_reward == 5: break else: expected_reward += 1 else: print(env.observations()['DEBUG.POS.TRANS']) self.fail('Failed to pickup all apples!')
def __init__(self, game, num_action_repeats, seed, is_test, config, action_set=DEFAULT_ACTION_SET, level_cache_dir=None): if is_test: config['allowHoldOutLevels'] = 'true' # Mixer seed for evalution, see # https://github.com/deepmind/lab/blob/master/docs/users/python_api.md config['mixerSeed'] = 0x600D5EED if game in games.ALL_GAMES: game = 'contributed/dmlab30/' + game config['datasetPath'] = FLAGS.dataset_path self._num_action_repeats = num_action_repeats self._random_state = np.random.RandomState(seed=seed) if FLAGS.homepath: deepmind_lab.set_runfiles_path(FLAGS.homepath) self._env = deepmind_lab.Lab( level=game, observations=['RGB_INTERLEAVED'], level_cache=LevelCache(level_cache_dir) if level_cache_dir else None, config={k: str(v) for k, v in config.items()}, ) self._action_set = action_set self.action_space = gym.spaces.Discrete(len(self._action_set)) self.observation_space = gym.spaces.Box( low=0, high=255, shape=(config['height'], config['width'], 3), dtype=np.uint8)
def set_lab_game_setup(self): level = 'nav_maze_static_01' level = 'small_maze' #level = 'small_maze_multimap' env = deepmind_lab.Lab( level, ['RGB_INTERLACED', 'DEBUG.POS.TRANS', 'DEBUG.CAMERA.TOP_DOWN'], config={ 'fps': str(60), 'width': str(self.width), 'height': str(self.width) }) self.actions = [ self._action(-20, 0, 0, 0, 0, 0, 0), # look_left self._action(20, 0, 0, 0, 0, 0, 0), # look_right # _action( 0, 10, 0, 0, 0, 0, 0), # look_up # _action( 0, -10, 0, 0, 0, 0, 0), # look_down self._action(0, 0, -1, 0, 0, 0, 0), # strafe_left self._action(0, 0, 1, 0, 0, 0, 0), # strafe_right self._action(0, 0, 0, 1, 0, 0, 0), # forward self._action(0, 0, 0, -1, 0, 0, 0), # backward # _action( 0, 0, 0, 0, 1, 0, 0), # fire # _action( 0, 0, 0, 0, 0, 1, 0), # jump # _action( 0, 0, 0, 0, 0, 0, 1) # crouch ] return env
def run(length, width, height, fps, level, observation_spec): """Spins up an environment and runs the random agent.""" env = deepmind_lab.Lab(level, [observation_spec], config={ 'fps': str(fps), 'width': str(width), 'height': str(height) }) env.reset() agent = DiscretizedRandomAgent() reward = 0 t0 = time.time() for _ in xrange(length): if not env.is_running(): print('Environment stopped early') env.reset() agent.reset() obs = env.observations() action = agent.step(reward, obs[observation_spec]) reward = env.step(action, num_steps=1) t1 = time.time() duration = t1 - t0 print( 'resolution: %i x %i, spec: %s, steps: %i, duration: %.1f, fps: %.1f' % (width, height, observation_spec, length, duration, length / duration))
def __init__(self, level, config, num_action_repeats, seed, runfiles_path=None, level_cache=None): # Define initial attributes self._num_action_repeats = num_action_repeats self._random_state = np.random.RandomState(seed=seed) self._width = config.get('width', None) self._height = config.get('height', None) # Determine observation space if FLAGS.depth: self._observation_spec = ['RGBD_INTERLEAVED'] else: self._observation_spec = ['RGB_INTERLEAVED'] if False: self._observation_spec.extend(['DEBUG.POS.TRANS', 'DEBUG.POS.ROT']) if False: self._observation_spec.extend(['DEBUG.POS.TRANS', 'DEBUG.POS.ROT']) # Configure deepmind environment if runfiles_path: deepmind_lab.set_runfiles_path(runfiles_path) config = {k: str(v) for k, v in config.iteritems()} self._env = deepmind_lab.Lab( level=level, observations=self._observation_spec, config=config, level_cache=level_cache, )
def run(length, width, height, fps, level, agent): """Spins up an environment and runs the random agent.""" print('Starting run') env = deepmind_lab.Lab( level, ['RGB_INTERLACED'], config={ 'fps': str(fps), 'width': str(width), 'height': str(height) }) env.reset() # Starts the random spring agent. As a simpler alternative, we could also if agent == "random_discrete": agent = DiscretizedRandomAgent() elif agent == "random_spring": agent = SpringAgent(env.action_spec()) else: agent = DiscretizedRandomAgent() reward = 0 for _ in xrange(length): if not env.is_running(): print('Environment stopped early') env.reset() agent.reset() obs = env.observations() action = agent.step(reward, obs['RGB_INTERLACED']) reward = env.step(action, num_steps=1) print('Finished after %i steps. Total reward received is %f' % (length, agent.rewards))
def __init__(self, level, observation_names, config): self._lab = deepmind_lab.Lab(level, observation_names, config) self._observation_names = observation_names self._needs_reset = True lab_action_specs = self._lab.action_spec() self._action_spec = {} self._action_map = {} self._action_count = len(lab_action_specs) for i, spec in enumerate(lab_action_specs): name = spec["name"] self._action_map[name] = i self._action_spec[name] = dm_env.specs.BoundedArray( dtype=np.dtype("int32"), shape=(), name=name, minimum=spec["min"], maximum=spec["max"]) self._observation_spec = {} for spec in self._lab.observation_spec(): name = spec["name"] shape = spec["shape"] if name in self._observation_names: if 0 in shape: raise NotImplementedError( "Dynamic shapes are not supported by dm_env; requested shape for " "observation {} was {}.".format(name, shape)) self._observation_spec[name] = dm_env.specs.Array( dtype=spec["dtype"], shape=shape, name=name)
def setUp(self): self._env = test_environment_decorator.TestEnvironmentDecorator( deepmind_lab.Lab( 'seekavoid_arena_01', ['VEL.ROT', 'VEL.TRANS', 'DEBUG.POS.ROT', 'DEBUG.POS.TRANS'])) self._controller = game_controller.GameController(self._env) self._env.reset()
def testTempFolder(self): temp_folder = os.path.join(os.environ['TEST_TMPDIR'], 'test_temp_folder') lab = deepmind_lab.Lab( 'contributed/dmlab30/explore_goal_locations_small', [], {}, temp_folder=temp_folder) lab.reset() self.assertGreaterEqual(len(os.listdir(temp_folder)), 1)
def __init__( self, level, mode, render_size=(64, 64), action_repeat=4, action_set=ACTION_SET_DEFAULT, level_cache=None, seed=None, runfiles_path=None): assert mode in ('train', 'test') import deepmind_lab if runfiles_path: print('Setting DMLab runfiles path:', runfiles_path) deepmind_lab.set_runfiles_path(runfiles_path) self._config = {} self._config['width'] = render_size[0] self._config['height'] = render_size[1] self._config['logLevel'] = 'WARN' if mode == 'test': self._config['allowHoldOutLevels'] = 'true' self._config['mixerSeed'] = 0x600D5EED self._action_repeat = action_repeat self._random = np.random.RandomState(seed) self._env = deepmind_lab.Lab( level='contributed/dmlab30/'+level, observations=['RGB_INTERLEAVED'], config={k: str(v) for k, v in self._config.items()}, level_cache=level_cache) self._action_set = action_set self._last_image = None self._done = True
def __init__(self, scene, colors='RGB_INTERLEAVED', width=84, height=84, **kwargs): super(DeepmindLabEnv, self).__init__(**kwargs) if not scene in LEVELS: raise Exception('Scene %s not supported' % (scene)) self._colors = colors self._lab = deepmind_lab.Lab(scene, [self._colors, 'DEBUG.POS.TRANS', 'DEBUG.POS.ROT', 'VEL.TRANS', 'VEL.ROT'], \ dict(fps = str(60), width = str(width), height = str(height))) self.action_space = gym.spaces.Discrete(len(ACTION_LIST)) if colors == 'RGB_INTERLEAVED': self.observation_space = gym.spaces.Box(0, 255, (height, width, 3), dtype=np.uint8) elif colors == 'RGBD_INTERLEAVED': self.observation_space = gym.spaces.Box(0, 255, (height, width, 4), dtype=np.uint8) #self.observation_space = gym.spaces.Box(0, 255, (height, width, 3), dtype = np.uint8) self._last_observation = None
def __init__(self, level_id, repeat_action=1, state_attribute='RGB_INTERLACED', settings={ 'width': '320', 'height': '240', 'fps': '60', 'appendCommand': '' }): """ Initialize DeepMind Lab environment. Args: level_id: string with id/descriptor of the level, e.g. 'seekavoid_arena_01'. repeat_action: number of frames the environment is advanced, executing the given action during every frame. state_attribute: Attributes which represents the state for this environment, should adhere to the specification given in DeepMindLabEnvironment.state_spec(level_id). settings: dict specifying additional settings as key-value string pairs. The following options are recognized: 'width' (horizontal resolution of the observation frames), 'height' (vertical resolution of the observation frames), 'fps' (frames per second) and 'appendCommand' (commands for the internal Quake console). """ self.level_id = level_id self.level = deepmind_lab.Lab(level=level_id, observations=[state_attribute], config=settings) self.repeat_action = repeat_action self.state_attribute = state_attribute
def __init__(self, level, config, num_action_repeats, seed, runfiles_path=None, level_cache=None): self._num_action_repeats = num_action_repeats self._random_state = np.random.RandomState(seed=seed) if runfiles_path: deepmind_lab.set_runfiles_path(runfiles_path) config = {k: str(v) for k, v in config.items()} self._observation_spec = ['RGB_INTERLEAVED', 'INSTR'] renderer = config['renderer'] self.benchmark_mode = config['benchmark_mode'] if self.benchmark_mode: print( 'BENCHMARK MODE IS ON! USE THIS ONLY FOR TESTING AND THROUGHPUT MEASUREMENT!' ) self._env = deepmind_lab.Lab( level=level, observations=self._observation_spec, config=config, level_cache=level_cache, renderer=renderer, )
def run(length, width, height, fps, level, record, demo, video): """Spins up an environment and runs the random agent.""" config = { 'fps': str(fps), 'width': str(width), 'height': str(height) } if record: config['record'] = record if demo: config['demo'] = demo if video: config['video'] = video env = deepmind_lab.Lab(level, ['RGB_INTERLACED'], config=config) env.reset() # Starts the random spring agent. As a simpler alternative, we could also # use DiscretizedRandomAgent(). agent = SpringAgent(env.action_spec()) reward = 0 for _ in xrange(length): if not env.is_running(): print('Environment stopped early') env.reset() agent.reset() obs = env.observations() action = agent.step(reward, obs['RGB_INTERLACED']) reward = env.step(action, num_steps=1) print('Finished after %i steps. Total reward received is %f' % (length, agent.rewards))
def __init__(self, level, action_repeat, extra_cfg=None): self._width = self._height = 84 self._main_observation = 'DEBUG.CAMERA_INTERLEAVED.PLAYER_VIEW_NO_RETICLE' self._action_repeat = action_repeat self._random_state = None observation_format = [self._main_observation, 'DEBUG.POS.TRANS'] config = {'width': self._width, 'height': self._height} if extra_cfg is not None: config.update(extra_cfg) config = {k: str(v) for k, v in config.items()} renderer = 'hardware' self._dmlab = deepmind_lab.Lab( level, observation_format, config=config, renderer=renderer, level_cache=level_cache, ) self._action_set = ACTION_SET self._action_list = np.array(self._action_set, dtype=np.intc) # DMLAB requires intc type for actions self._last_observation = None self._render_scale = 5 self._render_fps = 30 self._last_frame = time.time() self.action_space = gym.spaces.Discrete(len(self._action_set)) self.observation_space = gym.spaces.Box(low=0, high=255, shape=(self._height, self._width, 3), dtype=np.uint8) self.seed()
def testSpecs(self): lab = deepmind_lab.Lab('tests/empty_room_test', []) observation_spec = lab.observation_spec() observation_spec_names = {o['name'] for o in observation_spec} observation_spec_lookup = {o['name']: o for o in observation_spec} action_names = {a['name'] for a in lab.action_spec()} observation_set = { 'RGB_INTERLEAVED', 'RGB', 'RGBD_INTERLEAVED', 'RGBD', 'BGR_INTERLEAVED', 'BGRD_INTERLEAVED' } self.assertGreaterEqual(observation_spec_names, observation_set) for k in observation_set: o = observation_spec_lookup[k] self.assertIn('shape', o) self.assertDictContainsSubset({'dtype': np.uint8}, o) self.assertSetEqual( action_names, { 'LOOK_LEFT_RIGHT_PIXELS_PER_FRAME', 'LOOK_DOWN_UP_PIXELS_PER_FRAME', 'STRAFE_LEFT_RIGHT', 'MOVE_BACK_FORWARD', 'FIRE', 'JUMP', 'CROUCH' }) for a in lab.action_spec(): self.assertIs(type(a['min']), int) self.assertIs(type(a['max']), int) self.assertTrue(lab.close())
def testSpecs(self): lab = deepmind_lab.Lab('tests/demo_map', []) observation_spec = lab.observation_spec() observation_names = {o['name'] for o in observation_spec} action_names = {a['name'] for a in lab.action_spec()} self.assertSetEqual( observation_names, {'RGB_INTERLACED', 'RGB', 'RGBD_INTERLACED', 'RGBD'}) for o in observation_spec: self.assertIn('shape', o) self.assertDictContainsSubset({'dtype': np.uint8}, o) self.assertSetEqual( action_names, { 'LOOK_LEFT_RIGHT_PIXELS_PER_FRAME', 'LOOK_DOWN_UP_PIXELS_PER_FRAME', 'STRAFE_LEFT_RIGHT', 'MOVE_BACK_FORWARD', 'FIRE', 'JUMP', 'CROUCH' }) for a in lab.action_spec(): self.assertIs(type(a['min']), int) self.assertIs(type(a['max']), int) self.assertTrue(lab.close())
def run(level_script, config, num_episodes): """Construct and start the environment.""" env = deepmind_lab.Lab(level_script, ['RGB_INTERLEAVED'], config) env.reset() observation_spec = env.observation_spec() print('Observation spec:') pprint.pprint(observation_spec) action_spec = env.action_spec() print('Action spec:') pprint.pprint(action_spec) obs = env.observations() # dict of Numpy arrays rgb_i = obs['RGB_INTERLEAVED'] print('Observation shape:', rgb_i.shape) sys.stdout.flush() # Create an action to move forwards. action = np.zeros([7], dtype=np.intc) action[3] = 1 score = 0 for _ in six.moves.range(num_episodes): while env.is_running(): # Advance the environment 4 frames while executing the action. reward = env.step(action, num_steps=4) if reward != 0: score += reward print('Score =', score) sys.stdout.flush()
def __init__(self, fps, level, width, height, frame_skip, display=False, shrink=True, no_op_max=7): self._frame_skip = frame_skip self._no_op_max = no_op_max self._width = width self._height = height self._display = display self._shrink = shrink if display: width = 640 height = 480 self.env = deepmind_lab.Lab(level, ['RGB_INTERLACED'], config={ 'fps': str(fps), 'width': str(width), 'height': str(height) }) self.s_t = None self.reset()
def worker(conn): level = ENV_NAME env = deepmind_lab.Lab( level, ['RGB_INTERLACED'], config={ 'fps': str(60), 'width': str(84), 'height': str(84) }) conn.send(0) while True: command, arg = conn.recv() if command == COMMAND_RESET: env.reset() obs = env.observations()['RGB_INTERLACED'] conn.send(obs) elif command == COMMAND_ACTION: reward = env.step(arg, num_steps=4) terminal = not env.is_running() if not terminal: obs = env.observations()['RGB_INTERLACED'] else: obs = 0 conn.send([obs, reward, terminal]) elif command == COMMAND_TERMINATE: break else: print("bad command: {}".format(command)) env.close() conn.send(0) conn.close()
def __init__(self, scene, action_repeat=4, observation='RGB_INTERLEAVED', config={}, renderer='hardware'): """Create an deepmind_lab env Args: scene (str): script for the deepmind_lab env. See available script: `<https://github.com/deepmind/lab/tree/master/game_scripts/levels>`_ action_repeat (int): the interval at which the agent experiences the game observation (str): observation format. See doc about the available observations: `<https://github.com/deepmind/lab/blob/master/docs/users/python_api.md>`_ config (dict): config for env renderer (str): 'software' or 'hardware'. If set to 'hardware', EGL or GLX is used for rendering. Make sure you have GPU if you use 'hardware'. """ super(DeepmindLabEnv, self).__init__() self._action_repeat = action_repeat self._observation = observation self._lab = deepmind_lab.Lab( scene, [self._observation], config=config, renderer=renderer) self._lab.reset() action_spec = self._lab.action_spec() action_list = action_discretize(action_spec) self.action_space = gym.spaces.Discrete(len(action_list)) self._action_list = action_list obs = self._lab.observations()[observation] self.observation_space = gym.spaces.Box( 0, 255, obs.shape, dtype=np.uint8) self._last_obs = obs