Datasets:
File size: 4,457 Bytes
faa3682 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 |
import time
import cloudpickle
import elements
import numpy as np
import portal
class Driver:
def __init__(self, make_env_fns, parallel=True, **kwargs):
assert len(make_env_fns) >= 1
self.parallel = parallel
self.kwargs = kwargs
self.length = len(make_env_fns)
if parallel:
import multiprocessing as mp
context = mp.get_context()
self.pipes, pipes = zip(*[context.Pipe() for _ in range(self.length)])
self.stop = context.Event()
fns = [cloudpickle.dumps(fn) for fn in make_env_fns]
self.procs = [
portal.Process(self._env_server, self.stop, i, pipe, fn, start=True)
for i, (fn, pipe) in enumerate(zip(fns, pipes))]
self.pipes[0].send(('act_space',))
self.act_space = self._receive(self.pipes[0])
else:
self.envs = [fn() for fn in make_env_fns]
self.act_space = self.envs[0].act_space
self.callbacks = []
self.acts = None
self.carry = None
self.reset()
def reset(self, init_policy=None):
self.acts = {
k: np.zeros((self.length,) + v.shape, v.dtype)
for k, v in self.act_space.items()}
self.acts['reset'] = np.ones(self.length, bool)
self.carry = init_policy and init_policy(self.length)
def close(self):
if self.parallel:
[proc.kill() for proc in self.procs]
else:
[env.close() for env in self.envs]
def on_step(self, callback):
self.callbacks.append(callback)
def __call__(self, policy, steps=0, episodes=0):
step, episode = 0, 0
while step < steps or episode < episodes:
step, episode = self._step(policy, step, episode)
def _step(self, policy, step, episode):
acts = self.acts
assert all(len(x) == self.length for x in acts.values())
assert all(isinstance(v, np.ndarray) for v in acts.values())
acts = [{k: v[i] for k, v in acts.items()} for i in range(self.length)]
if self.parallel:
[pipe.send(('step', act)) for pipe, act in zip(self.pipes, acts)]
obs = [self._receive(pipe) for pipe in self.pipes]
else:
obs = [env.step(act) for env, act in zip(self.envs, acts)]
obs = {k: np.stack([x[k] for x in obs]) for k in obs[0].keys()}
logs = {k: v for k, v in obs.items() if k.startswith('log/')}
obs = {k: v for k, v in obs.items() if not k.startswith('log/')}
assert all(len(x) == self.length for x in obs.values()), obs
self.carry, acts, outs = policy(self.carry, obs, **self.kwargs)
assert all(k not in acts for k in outs), (
list(outs.keys()), list(acts.keys()))
if obs['is_last'].any():
mask = ~obs['is_last']
acts = {k: self._mask(v, mask) for k, v in acts.items()}
self.acts = {**acts, 'reset': obs['is_last'].copy()}
trans = {**obs, **acts, **outs, **logs}
for i in range(self.length):
trn = elements.tree.map(lambda x: x[i], trans)
[fn(trn, i, **self.kwargs) for fn in self.callbacks]
step += len(obs['is_first'])
episode += obs['is_last'].sum()
return step, episode
def _mask(self, value, mask):
while mask.ndim < value.ndim:
mask = mask[..., None]
return value * mask.astype(value.dtype)
def _receive(self, pipe):
try:
msg, arg = pipe.recv()
if msg == 'error':
raise RuntimeError(arg)
assert msg == 'result'
return arg
except Exception:
print('Terminating workers due to an exception.')
[proc.kill() for proc in self.procs]
raise
@staticmethod
def _env_server(stop, envid, pipe, ctor):
try:
ctor = cloudpickle.loads(ctor)
env = ctor()
while not stop.is_set():
if not pipe.poll(0.1):
time.sleep(0.1)
continue
try:
msg, *args = pipe.recv()
except EOFError:
return
if msg == 'step':
assert len(args) == 1
act = args[0]
obs = env.step(act)
pipe.send(('result', obs))
elif msg == 'obs_space':
assert len(args) == 0
pipe.send(('result', env.obs_space))
elif msg == 'act_space':
assert len(args) == 0
pipe.send(('result', env.act_space))
else:
raise ValueError(f'Invalid message {msg}')
except ConnectionResetError:
print('Connection to driver lost')
except Exception as e:
pipe.send(('error', e))
raise
finally:
try:
env.close()
except Exception:
pass
pipe.close()
|