Datasets:
File size: 4,039 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 |
import collections
from functools import partial as bind
import elements
import embodied
import numpy as np
def train(make_agent, make_replay, make_env, make_stream, make_logger, args):
agent = make_agent()
replay = make_replay()
logger = make_logger()
logdir = elements.Path(args.logdir)
step = logger.step
usage = elements.Usage(**args.usage)
train_agg = elements.Agg()
epstats = elements.Agg()
episodes = collections.defaultdict(elements.Agg)
policy_fps = elements.FPS()
train_fps = elements.FPS()
batch_steps = args.batch_size * args.batch_length
should_train = elements.when.Ratio(args.train_ratio / batch_steps)
should_log = embodied.LocalClock(args.log_every)
should_report = embodied.LocalClock(args.report_every)
should_save = embodied.LocalClock(args.save_every)
@elements.timer.section('logfn')
def logfn(tran, worker):
episode = episodes[worker]
tran['is_first'] and episode.reset()
episode.add('score', tran['reward'], agg='sum')
episode.add('length', 1, agg='sum')
episode.add('rewards', tran['reward'], agg='stack')
for key, value in tran.items():
if value.dtype == np.uint8 and value.ndim == 3:
if worker == 0:
episode.add(f'policy_{key}', value, agg='stack')
elif key.startswith('log/'):
assert value.ndim == 0, (key, value.shape, value.dtype)
episode.add(key + '/avg', value, agg='avg')
episode.add(key + '/max', value, agg='max')
episode.add(key + '/sum', value, agg='sum')
if tran['is_last']:
result = episode.result()
logger.add({
'score': result.pop('score'),
'length': result.pop('length'),
}, prefix='episode')
rew = result.pop('rewards')
if len(rew) > 1:
result['reward_rate'] = (np.abs(rew[1:] - rew[:-1]) >= 0.01).mean()
epstats.add(result)
fns = [bind(make_env, i) for i in range(args.envs)]
driver = embodied.Driver(fns, parallel=not args.debug)
driver.on_step(lambda tran, _: step.increment())
driver.on_step(lambda tran, _: policy_fps.step())
driver.on_step(replay.add)
driver.on_step(logfn)
stream_train = iter(agent.stream(make_stream(replay, 'train')))
stream_report = iter(agent.stream(make_stream(replay, 'report')))
carry_train = [agent.init_train(args.batch_size)]
carry_report = agent.init_report(args.batch_size)
def trainfn(tran, worker):
if len(replay) < args.batch_size * args.batch_length:
return
for _ in range(should_train(step)):
with elements.timer.section('stream_next'):
batch = next(stream_train)
carry_train[0], outs, mets = agent.train(carry_train[0], batch)
train_fps.step(batch_steps)
if 'replay' in outs:
replay.update(outs['replay'])
train_agg.add(mets, prefix='train')
driver.on_step(trainfn)
cp = elements.Checkpoint(logdir / 'ckpt')
cp.step = step
cp.agent = agent
cp.replay = replay
if args.from_checkpoint:
elements.checkpoint.load(args.from_checkpoint, dict(
agent=bind(agent.load, regex=args.from_checkpoint_regex)))
cp.load_or_save()
print('Start training loop')
policy = lambda *args: agent.policy(*args, mode='train')
driver.reset(agent.init_policy)
while step < args.steps:
driver(policy, steps=10)
if should_report(step) and len(replay):
agg = elements.Agg()
for _ in range(args.consec_report * args.report_batches):
carry_report, mets = agent.report(carry_report, next(stream_report))
agg.add(mets)
logger.add(agg.result(), prefix='report')
if should_log(step):
logger.add(train_agg.result())
logger.add(epstats.result(), prefix='epstats')
logger.add(replay.stats(), prefix='replay')
logger.add(usage.stats(), prefix='usage')
logger.add({'fps/policy': policy_fps.result()})
logger.add({'fps/train': train_fps.result()})
logger.add({'timer': elements.timer.stats()['summary']})
logger.write()
if should_save(step):
cp.save()
logger.close()
|