def create_environment(level_name, seed, is_test=False):
"""Creates an environment wrapped in a `FlowEnvironment`."""
if level_name.startswith('doom_'):
config = None
p = py_process.PyProcess(PyProcessDoom, level_name, config,
FLAGS.num_action_repeats, seed)
return environments.FlowEnvironment(p.proxy)
else:
if level_name in dmlab30.ALL_LEVELS:
level_name = 'contributed/dmlab30/' + level_name
# Note, you may want to use a level cache to speed of compilation of
# environment maps. See the documentation for the Python interface of DeepMind
# Lab.
config = {
'width': FLAGS.width,
'height': FLAGS.height,
'datasetPath': FLAGS.dataset_path,
'logLevel': 'WARN',
'gpuDeviceIndex': '0',
'renderer': FLAGS.renderer,
'benchmark_mode': FLAGS.benchmark_mode,
}
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
p = py_process.PyProcess(environments.PyProcessDmLab, level_name,
config, FLAGS.num_action_repeats, seed)
return environments.FlowEnvironment(p.proxy)
def test_close_on_error(self):
with tempfile.NamedTemporaryFile() as tmp:
class Example(object):
def __init__(self, filename):
self._filename = filename
def something(self):
raise ValueError('foo')
def close(self):
with tf.gfile.Open(self._filename, 'w') as f:
f.write('was_closed')
@staticmethod
def _tensor_specs(method_name, unused_kwargs,
unused_constructor_kwargs):
if method_name == 'something':
return ()
with tf.Graph().as_default():
p = py_process.PyProcess(Example, tmp.name)
result = p.proxy.something()
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]) as session:
with self.assertRaisesRegexp(Exception, 'foo'):
session.run(result)
self.assertEqual('was_closed', tmp.read())
def test_args(self):
class Example(object):
def __init__(self, dim0):
self._dim0 = dim0
def compute(self, dim1):
return np.zeros([self._dim0, dim1], dtype=np.int32)
@staticmethod
def _tensor_specs(method_name, kwargs, constructor_kwargs):
dim0 = constructor_kwargs['dim0']
dim1 = kwargs['dim1']
if method_name == 'compute':
return tf.contrib.framework.TensorSpec([dim0, dim1], tf.int32)
with tf.Graph().as_default():
p = py_process.PyProcess(Example, 1)
result = p.proxy.compute(2)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]) as session:
self.assertEqual([1, 2], result.shape)
self.assertAllEqual([[0, 0]], session.run(result))
def test_close(self):
with tempfile.NamedTemporaryFile() as tmp:
class Example(object):
def __init__(self, filename):
self._filename = filename
def close(self):
with tf.gfile.Open(self._filename, 'w') as f:
f.write('was_closed')
@staticmethod
def _tensor_specs(method_name, unused_kwargs,
unused_constructor_kwargs):
if method_name == 'something':
return ()
with tf.Graph().as_default():
py_process.PyProcess(Example, tmp.name)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]):
pass
self.assertEqual('was_closed', tmp.read())
def test_small(self):
class Example(object):
def __init__(self, a):
self._a = a
def inc(self):
self._a += 1
def compute(self, b):
return np.array(self._a + b, dtype=np.int32)
@staticmethod
def _tensor_specs(method_name, unused_args,
unused_constructor_kwargs):
if method_name == 'compute':
return tf.contrib.framework.TensorSpec([], tf.int32)
elif method_name == 'inc':
return ()
with tf.Graph().as_default():
p = py_process.PyProcess(Example, 1)
inc = p.proxy.inc()
compute = p.proxy.compute(2)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]) as session:
self.assertTrue(isinstance(inc, tf.Operation))
session.run(inc)
self.assertEqual([], compute.shape)
self.assertEqual(4, session.run(compute))
def test_threading(self):
class Example(object):
def __init__(self):
pass
def wait(self):
time.sleep(.2)
return None
@staticmethod
def _tensor_specs(method_name, unused_args,
unused_constructor_kwargs):
if method_name == 'wait':
return tf.contrib.framework.TensorSpec([], tf.int32)
with tf.Graph().as_default():
p = py_process.PyProcess(Example)
wait = p.proxy.wait()
hook = py_process.PyProcessHook()
with tf.train.SingularMonitoredSession(hooks=[hook]) as session:
def run():
with self.assertRaises(tf.errors.OutOfRangeError):
session.run(wait)
t = self.checkedThread(target=run)
t.start()
time.sleep(.1)
t.join()
def create_atari_environment(env_id, seed, is_test=False):
# print("Before env proxy")
config = {'width': 84, 'height': 84, 'level': env_id, 'logLevel': 'warn'}
env_proxy = py_process.PyProcess(environments.PyProcessAtari, env_id,
config, FLAGS.num_action_repeats, seed)
environment = environments.FlowEnvironment(env_proxy.proxy)
return environment
def benchmark_one(self):
with tf.Graph().as_default():
p = py_process.PyProcess(PyProcessBenchmarks.Example)
compute = p.proxy.compute(2)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]) as session:
self.run_op_benchmark(name='process_one',
sess=session,
op_or_tensor=compute,
burn_iters=10,
min_iters=5000)
def create_environment(level_name, seed, is_test=False):
"""Creates an environment wrapped in a `FlowEnvironment`."""
# Note, you may want to use a level cache to speed of compilation of
# environment maps. See the documentation for the Python interface of DeepMind
# Lab.
config = {'width': FLAGS.width, 'height': FLAGS.height}
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
p = py_process.PyProcess(environments.PyProcessGym, level_name, config)
return environments.FlowEnvironment(p.proxy)
def create_atari_environment(env_id, seed, is_test=False):
config = {'width': FLAGS.width, 'height': FLAGS.height}
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
process = py_process.PyProcess(atari_environment.PyProcessAtari, env_id,
config, seed)
proxy_env = atari_environment.FlowEnvironment(process.proxy)
return proxy_env
def benchmark_many(self):
with tf.Graph().as_default():
ps = [
py_process.PyProcess(PyProcessBenchmarks.Example)
for _ in range(200)
]
compute_ops = [p.proxy.compute(2) for p in ps]
compute = tf.group(*compute_ops)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]) as session:
self.run_op_benchmark(name='process_many',
sess=session,
op_or_tensor=compute,
burn_iters=10,
min_iters=500)
def test_close(self):
with tempfile.NamedTemporaryFile() as tmp:
class Example(object):
def __init__(self, filename):
self._filename = filename
def close(self):
with tf.gfile.Open(self._filename, 'w') as f:
f.write('was_closed')
with tf.Graph().as_default():
py_process.PyProcess(Example, tmp.name)
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]):
pass
self.assertEqual('was_closed', tmp.read())
def test_error_handling_constructor(self):
class Example(object):
def __init__(self):
raise ValueError('foo')
def something(self):
pass
@staticmethod
def _tensor_specs(method_name, unused_kwargs,
unused_constructor_kwargs):
if method_name == 'something':
return ()
with tf.Graph().as_default():
py_process.PyProcess(Example, 1)
with self.assertRaisesRegexp(Exception, 'foo'):
with tf.train.SingularMonitoredSession(
hooks=[py_process.PyProcessHook()]):
pass
def create_environment(env_sampler,
initial_task_name=None,
seed=0):
"""Creates an environment wrapped in a `FlowEnvironment`."""
# Sample a task if not provided
if initial_task_name is None:
initial_task_name = np.random.choice(env_sampler.task_names)
# config is empty dict for now
config = {}
p = py_process.PyProcess(environments.PyProcessCraftLab, env_sampler,
initial_task_name, config, FLAGS.num_action_repeats,
seed)
flow_env = environments.FlowEnvironment(p.proxy)
# TODO clean me up, useful for debugging
# obs_reset = p.proxy.initial()
# rew, done, obs_step = p.proxy.step(0)
# output_initial, state_initial = flow_env.initial()
# output_step, state_step = flow_env.step(0, state_initial)
return flow_env
def create_environment(config, is_test=False):
"""Creates an exchange environment wrapped in a `FlowEnvironment`."""
p = py_process.PyProcess(wrappers.PyProcessExchEnv, config)
return wrappers.FlowEnvironment(p.proxy)
def create_environment(config, is_test=False):
"""Creates an environment wrapped in a `FlowEnvironment`."""
p = py_process.PyProcess(environments.PyProcessPommerMan, config=config)
return environments.FlowEnvironment(p.proxy)
def create_environment(game_name, state_size):
"""Creates an environment wrapped in a `FlowEnvironment`."""
config = {'observation_size': state_size}
p = py_process.PyProcess(environments.PyProcessGym, game_name, config)
return environments.FlowEnvironment(p.proxy)
