| import collections | |
| import functools | |
| import logging | |
| import os | |
| import pathlib | |
| import re | |
| import sys | |
| import warnings | |
| try: | |
| import rich.traceback | |
| rich.traceback.install() | |
| except ImportError: | |
| pass | |
| 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 | |
| def main(): | |
| configs = yaml.safe_load((pathlib.Path(sys.argv[0]).parent / 'configs.yaml').read_text()) | |
| parsed, remaining = common.Flags(configs=['defaults']).parse(known_only=True) | |
| config = common.Config(configs['defaults']) | |
| for name in parsed.configs: | |
| config = config.update(configs[name]) | |
| config = common.Flags(config).parse(remaining) | |
| logdir = pathlib.Path(config.logdir).expanduser() | |
| logdir.mkdir(parents=True, exist_ok=True) | |
| config.save(logdir / 'config.yaml') | |
| print(config, '\n') | |
| print('Logdir', logdir) | |
| import tensorflow as tf | |
| tf.config.experimental_run_functions_eagerly(not config.jit) | |
| message = 'No GPU found. To actually train on CPU remove this assert.' | |
| assert tf.config.experimental.list_physical_devices('GPU'), message | |
| for gpu in tf.config.experimental.list_physical_devices('GPU'): | |
| tf.config.experimental.set_memory_growth(gpu, True) | |
| assert config.precision in (16, 32), config.precision | |
| if config.precision == 16: | |
| from tensorflow.keras.mixed_precision import experimental as prec | |
| prec.set_policy(prec.Policy('mixed_float16')) | |
| train_replay = common.Replay(logdir / 'train_episodes', **config.replay) | |
| eval_replay = common.Replay(logdir / 'eval_episodes', **dict( | |
| capacity=config.replay.capacity // 10, | |
| minlen=config.dataset.length, | |
| maxlen=config.dataset.length)) | |
| step = common.Counter(train_replay.stats['total_steps']) | |
| outputs = [ | |
| common.TerminalOutput(), | |
| common.JSONLOutput(logdir), | |
| common.TensorBoardOutput(logdir), | |
| ] | |
| 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_train = common.Every(config.eval_every) | |
| should_video_eval = common.Every(config.eval_every) | |
| should_expl = common.Until(config.expl_until) | |
| def make_env(mode): | |
| suite, task = config.task.split('_', 1) | |
| if suite == 'dmc': | |
| env = common.DMC( | |
| task, config.action_repeat, config.render_size, config.dmc_camera) | |
| env = common.NormalizeAction(env) | |
| elif suite == 'dmcmt': | |
| env = common.DMCMultitask( | |
| task, config.action_repeat, config.render_size, config.dmc_camera) | |
| env = common.NormalizeAction(env) | |
| elif suite == 'atari': | |
| env = common.Atari( | |
| task, config.action_repeat, config.render_size, | |
| config.atari_grayscale) | |
| env = common.OneHotAction(env) | |
| elif suite == 'crafter': | |
| assert config.action_repeat == 1 | |
| outdir = logdir / 'crafter' if mode == 'train' else None | |
| reward = bool(['noreward', 'reward'].index(task)) or mode == 'eval' | |
| env = common.Crafter(outdir, reward) | |
| env = common.OneHotAction(env) | |
| else: | |
| raise NotImplementedError(suite) | |
| env = common.TimeLimit(env, config.time_limit) | |
| return env | |
| def per_episode(ep, mode): | |
| length = len(ep['reward']) - 1 | |
| score = float(ep['reward'].astype(np.float64).sum()) | |
| print(f'{mode.title()} episode has {length} steps and return {score:.1f}.') | |
| logger.scalar(f'{mode}_return', score) | |
| logger.scalar(f'{mode}_length', length) | |
| for key, value in ep.items(): | |
| if re.match(config.log_keys_sum, key): | |
| logger.scalar(f'sum_{mode}_{key}', ep[key].sum()) | |
| if re.match(config.log_keys_mean, key): | |
| logger.scalar(f'mean_{mode}_{key}', ep[key].mean()) | |
| if re.match(config.log_keys_max, key): | |
| logger.scalar(f'max_{mode}_{key}', ep[key].max(0).mean()) | |
| should = {'train': should_video_train, 'eval': should_video_eval}[mode] | |
| if should(step): | |
| for key in config.log_keys_video: | |
| logger.video(f'{mode}_policy_{key}', ep[key]) | |
| replay = dict(train=train_replay, eval=eval_replay)[mode] | |
| logger.add(replay.stats, prefix=mode) | |
| logger.write() | |
| print('Create envs.') | |
| num_eval_envs = min(config.envs, config.eval_eps) | |
| if config.envs_parallel == 'none': | |
| train_envs = [make_env('train') for _ in range(config.envs)] | |
| eval_envs = [make_env('eval') for _ in range(num_eval_envs)] | |
| else: | |
| make_async_env = lambda mode: common.Async( | |
| functools.partial(make_env, mode), config.envs_parallel) | |
| train_envs = [make_async_env('train') for _ in range(config.envs)] | |
| eval_envs = [make_async_env('eval') for _ in range(num_eval_envs)] | |
| act_space = train_envs[0].act_space | |
| obs_space = train_envs[0].obs_space | |
| train_driver = common.Driver(train_envs) | |
| train_driver.on_episode(lambda ep: per_episode(ep, mode='train')) | |
| train_driver.on_step(lambda tran, worker: step.increment()) | |
| train_driver.on_step(train_replay.add_step) | |
| train_driver.on_reset(train_replay.add_step) | |
| eval_driver = common.Driver(eval_envs) | |
| eval_driver.on_episode(lambda ep: per_episode(ep, mode='eval')) | |
| eval_driver.on_episode(eval_replay.add_episode) | |
| prefill = max(0, config.prefill - train_replay.stats['total_steps']) | |
| if prefill: | |
| print(f'Prefill dataset ({prefill} steps).') | |
| random_agent = common.RandomAgent(act_space) | |
| train_driver(random_agent, steps=prefill, episodes=1) | |
| eval_driver(random_agent, episodes=1) | |
| train_driver.reset() | |
| eval_driver.reset() | |
| print('Create agent.') | |
| train_dataset = iter(train_replay.dataset(**config.dataset)) | |
| report_dataset = iter(train_replay.dataset(**config.dataset)) | |
| eval_dataset = iter(eval_replay.dataset(**config.dataset)) | |
| agnt = agent.Agent(config, obs_space, act_space, step) | |
| train_agent = common.CarryOverState(agnt.train) | |
| train_agent(next(train_dataset)) | |
| if (logdir / 'variables.pkl').exists(): | |
| agnt.load(logdir / 'variables.pkl') | |
| else: | |
| print('Pretrain agent.') | |
| for _ in range(config.pretrain): | |
| train_agent(next(train_dataset)) | |
| train_policy = lambda *args: agnt.policy( | |
| *args, mode='explore' if should_expl(step) else 'train') | |
| eval_policy = lambda *args: agnt.policy(*args, mode='eval') | |
| def train_step(tran, worker): | |
| if should_train(step): | |
| for _ in range(config.train_steps): | |
| mets = train_agent(next(train_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(report_dataset)), prefix='train') | |
| logger.write(fps=True) | |
| train_driver.on_step(train_step) | |
| while step < config.steps: | |
| logger.write() | |
| print('Start evaluation.') | |
| logger.add(agnt.report(next(eval_dataset)), prefix='eval') | |
| eval_driver(eval_policy, episodes=config.eval_eps) | |
| print('Start training.') | |
| train_driver(train_policy, steps=config.eval_every) | |
| agnt.save(logdir / f'variables.pkl') | |
| for env in train_envs + eval_envs: | |
| try: | |
| env.close() | |
| except Exception: | |
| pass | |
| if __name__ == '__main__': | |
| main() | |