def testInitArgs(self):
with self.assertRaisesRegex(TypeError, 'must be dict, not list'):
deepmind_lab.Lab('tests/demo_map', [], ['wrongconfig'])
with self.assertRaisesRegex(TypeError, 'str'):
deepmind_lab.Lab('tests/demo_map', [], {'wrongtype': 3})
with self.assertRaisesRegex(TypeError, 'must be list, not None'):
deepmind_lab.Lab('tests/demo_map', None, {})
with self.assertRaisesRegex(ValueError, 'Unknown observation'):
deepmind_lab.Lab('tests/demo_map', ['nonexisting_obs'], {})
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(length, width, height, fps, level):
"""Spins up an environment and runs the random agent."""
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
# use DiscretizedRandomAgent().
agent = SpringAgent(env.action_spec())
reward = 0
for _ in range(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 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 range(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 testRunClosed(self):
env = deepmind_lab.Lab('lt_chasm', ['RGB_INTERLACED'])
env.reset(episode=42, seed=7)
env.close()
action = np.zeros((7, ), dtype=np.intc)
with self.assertRaisesRegex(RuntimeError, 'wrong status to advance'):
env.step(action)
with self.assertRaisesRegex(RuntimeError, 'wrong status'):
env.observations()
def testRun(self, steps=10, observation='RGB_INTERLACED'):
env = deepmind_lab.Lab('lt_chasm', [observation])
env.reset()
for _ in range(steps):
obs = env.observations()
action = np.zeros((7, ), dtype=np.intc)
reward = env.step(action, num_steps=4)
self.assertEqual(obs[observation].shape, (240, 320, 3))
self.assertEqual(reward, 0.0)
def testWidthHeight(self, width=80, height=80, steps=10, num_steps=1):
observations = ['RGBD']
env = deepmind_lab.Lab('lt_chasm',
observations,
config={
'height': str(height),
'width': str(width)
})
env.reset()
for _ in range(steps):
obs = env.observations()
action = np.zeros((7, ), dtype=np.intc)
reward = env.step(action, num_steps=num_steps)
self.assertEqual(obs[observations[0]].shape, (4, width, height))
self.assertEqual(reward, 0.0)
def game_process(conn):
env = deepmind_lab.Lab('nav_maze_static_01',
['RGBD_INTERLACED', 'VEL.TRANS', 'VEL.ROT'],
config={
'width': '84',
'height': '84'
})
conn.send(0)
prev_action_vector = np.array([0] * config.N_ACTION, dtype=np.intc)
action_vector = np.array([[0, 0, 0, 1, 0, 0, 0], [0, 0, 0, -1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0], [0, 0, -1, 0, 0, 0, 0],
[-20, 0, 0, 0, 0, 0, 0], [20, 0, 0, 0, 0, 0, 0]],
dtype=np.intc)
while True:
cmd, arg = conn.recv()
if cmd == 'reset':
env.reset()
prev_action_vector = np.array([0] * 7, dtype=np.intc)
conn.send(env.observations())
elif cmd == 'action':
reward = 0.0
if arg >= 0 and arg < 6:
prev_action_vector = np.copy(action_vector[arg])
reward = env.step(prev_action_vector, num_steps=4)
elif arg == 6:
prev_action_vector[0] = 20
reward = env.step(prev_action_vector, num_steps=4)
elif arg == 7:
prev_action_vector[0] = -20
reward = env.step(prev_action_vector, num_steps=4)
running = env.is_running()
obs = env.observations() if running else 0
conn.send([obs, reward, running])
elif cmd == 'observe':
conn.send([env.observations()['RGBD_INTERLACED']])
elif cmd == 'running':
running = env.is_running()
conn.send([running])
elif cmd == 'stop':
break
env.close()
conn.send(0)
conn.close()
def test_discretized_random_agent_run(self, length=100):
env = deepmind_lab.Lab('tests/demo_map', ['RGB_INTERLACED'],
config={
'fps': '60',
'width': '80',
'height': '80'
})
env.reset()
agent = random_agent.DiscretizedRandomAgent()
reward = 0
for _ in range(length):
if not env.is_running():
print('Environment stopped early')
env.reset()
obs = env.observations()
action = agent.step(reward, obs['RGB_INTERLACED'])
reward = env.step(action, 1)
self.assertIsInstance(reward, float)
def testOpenClose(self):
labs = [deepmind_lab.Lab('tests/demo_map', []) for _ in range(5)]
for lab in labs:
self.assertTrue(lab.close())
def testReset(self):
lab = deepmind_lab.Lab('tests/demo_map', [], {})
with self.assertRaisesRegex(
ValueError, '\'seed\' must be int or None, was \'str\''):
lab.reset(seed='invalid')
def testVeloctyObservations(self, width=80, height=80):
noop_action = np.zeros((7, ), dtype=np.intc)
forward_action = np.array([0, 0, 0, 1, 0, 0, 0], dtype=np.intc)
backward_action = -forward_action
look_sideways_action = np.array([512, 0, 0, 0, 0, 0, 0], dtype=np.intc)
env = deepmind_lab.Lab('seekavoid_arena_01', ['VEL.TRANS', 'VEL.ROT'],
config={
'height': str(height),
'width': str(width),
'fps': '60'
})
env.reset(seed=1)
# Initial landing on the ground.
env.step(noop_action, num_steps=180)
for _ in range(3):
# Doing nothing should result in velocity observations of zero.
env.step(noop_action, num_steps=100)
obs = env.observations()
np.testing.assert_array_equal(obs['VEL.TRANS'], np.zeros((3, )))
np.testing.assert_array_equal(obs['VEL.ROT'], np.zeros((3, )))
env.step(forward_action, num_steps=100)
obs = env.observations()
forward_vel = obs['VEL.TRANS']
self.assertEqual(forward_vel[2],
0.0) # zero velocity in z direction
self.assertTrue(np.any(forward_vel))
np.testing.assert_array_equal(obs['VEL.ROT'], np.zeros((3, )))
env.step(noop_action, num_steps=4)
# Going backward should result in negative velocity of going forward
env.step(backward_action, num_steps=100)
obs = env.observations()
self.assertAlmostEqual(np.linalg.norm(obs['VEL.TRANS'] +
forward_vel),
0.0,
delta=3)
np.testing.assert_array_equal(obs['VEL.ROT'], np.zeros((3, )))
env.reset(seed=1)
for _ in range(3):
env.step(noop_action, num_steps=100)
obs = env.observations()
np.testing.assert_array_equal(obs['VEL.TRANS'], np.zeros((3, )))
np.testing.assert_array_equal(obs['VEL.ROT'], np.zeros((3, )))
env.step(look_sideways_action, num_steps=100)
obs = env.observations()
sideways_vel = obs['VEL.ROT']
self.assertEqual(sideways_vel[2], 0.0)
self.assertTrue(np.any(forward_vel))
np.testing.assert_array_equal(obs['VEL.TRANS'], np.zeros((3, )))
env.step(noop_action, num_steps=4)
env.step(-look_sideways_action, num_steps=100)
obs = env.observations()
self.assertAlmostEqual(np.linalg.norm(obs['VEL.ROT'] +
sideways_vel),
0.0,
delta=3)
np.testing.assert_array_equal(obs['VEL.TRANS'], np.zeros((3, )))
