| import collections |
| import logging |
| import os |
| import pathlib |
| import re |
| import sys |
| import warnings |
|
|
| os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' |
| logging.getLogger().setLevel('ERROR') |
| warnings.filterwarnings('ignore', '.*box bound precision lowered.*') |
|
|
| sys.path.append(str(pathlib.Path(__file__).parent)) |
| sys.path.append(str(pathlib.Path(__file__).parent.parent)) |
|
|
| import numpy as np |
| import ruamel.yaml as yaml |
|
|
| from dreamerv2 import agent |
| from dreamerv2 import common |
|
|
| from dreamerv2.common import Config |
| from dreamerv2.common import GymWrapper |
| from dreamerv2.common import RenderImage |
| from dreamerv2.common import TerminalOutput |
| from dreamerv2.common import JSONLOutput |
| from dreamerv2.common import TensorBoardOutput |
|
|
| configs = yaml.safe_load( |
| (pathlib.Path(__file__).parent / 'configs.yaml').read_text()) |
| defaults = common.Config(configs.pop('defaults')) |
|
|
|
|
| def train(env, config, outputs=None): |
| logdir = pathlib.Path(config.logdir).expanduser() |
| logdir.mkdir(parents=True, exist_ok=True) |
| config.save(logdir / 'config.yaml') |
| print(config, '\n') |
| print('Logdir', logdir) |
|
|
| outputs = outputs or [ |
| common.TerminalOutput(), |
| common.JSONLOutput(config.logdir), |
| common.TensorBoardOutput(config.logdir), |
| ] |
| replay = common.Replay(logdir / 'train_episodes', **config.replay) |
| step = common.Counter(replay.stats['total_steps']) |
| logger = common.Logger(step, outputs, multiplier=config.action_repeat) |
| metrics = collections.defaultdict(list) |
|
|
| should_train = common.Every(config.train_every) |
| should_log = common.Every(config.log_every) |
| should_video = common.Every(config.log_every) |
| should_expl = common.Until(config.expl_until) |
|
|
| def per_episode(ep): |
| length = len(ep['reward']) - 1 |
| score = float(ep['reward'].astype(np.float64).sum()) |
| print(f'Episode has {length} steps and return {score:.1f}.') |
| logger.scalar('return', score) |
| logger.scalar('length', length) |
| for key, value in ep.items(): |
| if re.match(config.log_keys_sum, key): |
| logger.scalar(f'sum_{key}', ep[key].sum()) |
| if re.match(config.log_keys_mean, key): |
| logger.scalar(f'mean_{key}', ep[key].mean()) |
| if re.match(config.log_keys_max, key): |
| logger.scalar(f'max_{key}', ep[key].max(0).mean()) |
| if should_video(step): |
| for key in config.log_keys_video: |
| logger.video(f'policy_{key}', ep[key]) |
| logger.add(replay.stats) |
| logger.write() |
|
|
| env = common.GymWrapper(env) |
| env = common.ResizeImage(env) |
| if hasattr(env.act_space['action'], 'n'): |
| env = common.OneHotAction(env) |
| else: |
| env = common.NormalizeAction(env) |
| env = common.TimeLimit(env, config.time_limit) |
|
|
| driver = common.Driver([env]) |
| driver.on_episode(per_episode) |
| driver.on_step(lambda tran, worker: step.increment()) |
| driver.on_step(replay.add_step) |
| driver.on_reset(replay.add_step) |
|
|
| prefill = max(0, config.prefill - replay.stats['total_steps']) |
| if prefill: |
| print(f'Prefill dataset ({prefill} steps).') |
| random_agent = common.RandomAgent(env.act_space) |
| driver(random_agent, steps=prefill, episodes=1) |
| driver.reset() |
|
|
| print('Create agent.') |
| agnt = agent.Agent(config, env.obs_space, env.act_space, step) |
| dataset = iter(replay.dataset(**config.dataset)) |
| train_agent = common.CarryOverState(agnt.train) |
| train_agent(next(dataset)) |
| if (logdir / 'variables.pkl').exists(): |
| agnt.load(logdir / 'variables.pkl') |
| else: |
| print('Pretrain agent.') |
| for _ in range(config.pretrain): |
| train_agent(next(dataset)) |
| policy = lambda *args: agnt.policy( |
| *args, mode='explore' if should_expl(step) else 'train') |
|
|
| def train_step(tran, worker): |
| if should_train(step): |
| for _ in range(config.train_steps): |
| mets = train_agent(next(dataset)) |
| [metrics[key].append(value) for key, value in mets.items()] |
| if should_log(step): |
| for name, values in metrics.items(): |
| logger.scalar(name, np.array(values, np.float64).mean()) |
| metrics[name].clear() |
| logger.add(agnt.report(next(dataset))) |
| logger.write(fps=True) |
|
|
| driver.on_step(train_step) |
|
|
| while step < config.steps: |
| logger.write() |
| driver(policy, steps=config.eval_every) |
| agnt.save(logdir / 'variables.pkl') |
|
|
