baselines/lompo/run.py

import argparse
from copy import deepcopy
import functools
import os
import pathlib

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import numpy as np
import random
import tensorflow as tf
from tensorflow.keras.mixed_precision import experimental as prec

tf.get_logger().setLevel('ERROR')

from tensorflow_probability import distributions as tfd

from baselines.lompo import buffer
from baselines.lompo import models
from baselines.lompo import tools
from baselines.lompo import wrappers


def define_config():
    config = tools.AttrDict()
    # General.
    config.logdir = pathlib.Path('.logdir')
    config.loaddir = pathlib.Path('.logdir')
    config.datadir = pathlib.Path('.datadir/walker')
    config.seed = 0
    config.log_every = 1000
    config.save_every = 5000
    config.log_scalars = True
    config.log_images = True
    config.gpu_growth = True

    # Environment.
    config.task = 'dmc_walker_walk'
    config.envs = 1
    config.parallel = 'none'
    config.action_repeat = 2
    config.time_limit = 1000
    config.im_size = 64
    config.eval_noise = 0.0
    config.clip_rewards = 'none'
    config.precision = 32

    # Model.
    config.deter_size = 256
    config.stoch_size = 64
    config.num_models = 7
    config.num_units = 256
    config.proprio = False
    config.penalty_type = 'log_prob'
    config.dense_act = 'elu'
    config.cnn_act = 'relu'
    config.cnn_depth = 32
    config.pcont = False
    config.kl_scale = 1.0
    config.pcont_scale = 10.0
    config.weight_decay = 0.0
    config.weight_decay_pattern = r'.*'

    # Training.
    config.load_model = False
    config.load_agent = False
    config.load_buffer = False
    config.train_steps = 100000
    config.model_train_steps = 25000
    config.model_batch_size = 64
    config.model_batch_length = 50
    config.agent_batch_size = 256
    config.cql_samples = 16
    config.start_training = 50000
    config.agent_train_steps = 150000
    config.agent_iters_per_step = 200
    config.buffer_size = 2e6
    config.model_lr = 6e-4
    config.q_lr = 3e-4
    config.actor_lr = 3e-4
    config.grad_clip = 100.0
    config.tau = 5e-3
    config.target_update_interval = 1
    config.dataset_balance = False

    # Behavior.
    config.lmbd = 5.0
    config.alpha = 0.0
    config.sample = True
    config.discount = 0.99
    config.disclam = 0.95
    config.horizon = 5
    config.done_treshold = 0.5
    config.action_dist = 'tanh_normal'
    config.action_init_std = 5.0
    config.expl = 'additive_gaussian'
    config.expl_amount = 0.2
    config.expl_decay = 0.0
    config.expl_min = 0.0
    return config


class Lompo(tools.Module):

    def __init__(self, config, datadir, actspace, writer):
        self._c = config
        self._actspace = actspace
        self._actdim = actspace.n if hasattr(actspace, 'n') else actspace.shape[0]
        episodes, steps = tools.count_episodes(datadir)
        self.latent_buffer = buffer.LatentReplayBuffer(steps,
                                                       steps,
                                                       self._c.deter_size + self._c.stoch_size,
                                                       self._actdim)
        self.lmbd = config.lmbd
        self.alpha = config.alpha

        self._writer = writer
        tf.summary.experimental.set_step(0)
        self._metrics = dict()

        self._agent_step = 0
        self._model_step = 0

        self._random = np.random.RandomState(config.seed)
        self._float = prec.global_policy().compute_dtype
        self._dataset = iter(load_dataset(datadir, self._c))
        self._episode_iterator = episode_iterator(datadir, self._c)

        self._build_model()
        for _ in range(10):
            self._model_train_step(next(self._dataset), prefix='eval')

    def __call__(self, obs, reset, state=None, training=True):
        if state is not None and reset.any():
            mask = tf.cast(1 - reset, self._float)[:, None]
            state = tf.nest.map_structure(lambda x: x * mask, state)
        action, state = self.policy(obs, state, training)
        return action, state

    def load(self, filename):
        try:
            self.load_model(filename)
        except:
            pass

        try:
            self.load_agent(filename)
        except:
            pass

    def save(self, filename):
        self.save_model(filename)
        self.save_agentl(filename)

    def load_model(self, filename):
        self._encode.load(filename / 'encode.pkl')
        self._dynamics.load(filename / 'dynamic.pkl')
        self._decode.load(filename / 'decode.pkl')
        self._reward.load(filename / 'reward.pkl')
        if self._c.pcont:
            self._pcont.load(filename / 'pcont.pkl')
        if self._c.proprio:
            self._proprio.load(filename / 'proprio.pkl')

    def save_model(self, filename):
        filename.mkdir(parents=True, exist_ok=True)
        self._encode.save(filename / 'encode.pkl')
        self._dynamics.save(filename / 'dynamic.pkl')
        self._decode.save(filename / 'decode.pkl')
        self._reward.save(filename / 'reward.pkl')
        if self._c.pcont:
            self._pcont.save(filename / 'pcont.pkl')
        if self._c.proprio:
            self._proprio.save(filename / 'proprio.pkl')

    def load_agent(self, filename):
        self._qf1.load(filename / 'qf1.pkl')
        self._qf2.load(filename / 'qf2.pkl')
        self._target_qf1.load(filename / 'target_qf1.pkl')
        self._target_qf2.load(filename / 'target_qf2.pkl')
        self._actor.load(filename / 'actor.pkl')

    def save_agent(self, filename):
        filename.mkdir(parents=True, exist_ok=True)
        self._qf1.save(filename / 'qf1.pkl')
        self._qf2.save(filename / 'qf2.pkl')
        self._target_qf1.save(filename / 'target_qf1.pkl')
        self._target_qf2.save(filename / 'target_qf2.pkl')
        self._actor.save(filename / 'actor.pkl')

    def policy(self, obs, state, training):
        if state is None:
            latent = self._dynamics.initial(len(obs['image']))
            action = tf.zeros((len(obs['image']), self._actdim), self._float)
        else:
            latent, action = state

        embed = self._encode(preprocess_raw(obs, self._c))
        latent, _ = self._dynamics.obs_step(latent, action, embed)
        feat = self._dynamics.get_feat(latent)
        action = self._exploration(self._actor(feat), training)
        state = (latent, action)
        return action, state

    def _build_model(self):
        acts = dict(elu=tf.nn.elu, relu=tf.nn.relu,
                    swish=tf.nn.swish, leaky_relu=tf.nn.leaky_relu)
        cnn_act = acts[self._c.cnn_act]
        act = acts[self._c.dense_act]

        # Create encoder based on environment observations
        if self._c.proprio:
            if self._c.im_size == 64:
                self._encode = models.ConvEncoderProprio(self._c.cnn_depth, cnn_act)
            else:
                self._encode = models.ConvEncoderProprioLarge(self._c.cnn_depth, cnn_act)
        else:
            if self._c.im_size == 64:
                self._encode = models.ConvEncoder(self._c.cnn_depth, cnn_act)
            else:
                self._encode = models.ConvEncoderLarge(self._c.cnn_depth, cnn_act)
                # RSSM model with ensembles
        self._dynamics = models.RSSME(self._c.stoch_size, self._c.deter_size,
                                      self._c.deter_size, num_models=self._c.num_models)
        # Create decoder based on image size
        if self._c.im_size == 64:
            self._decode = models.ConvDecoder(self._c.cnn_depth, cnn_act,
                                              shape=(self._c.im_size, self._c.im_size, 3))
        else:
            self._decode = models.ConvDecoderLarge(self._c.cnn_depth, cnn_act,
                                                   shape=(self._c.im_size, self._c.im_size, 3))
        if self._c.proprio:
            self._proprio = models.DenseDecoder((self._propriodim,), 3, self._c.num_units, act=act)
        if self._c.pcont:
            self._pcont = models.DenseDecoder((), 3, self._c.num_units, 'binary', act=act)
        self._reward = models.DenseDecoder((), 2, self._c.num_units, act=act)

        model_modules = [self._encode, self._dynamics, self._decode, self._reward]
        if self._c.proprio:
            model_modules.append(self._proprio)
        if self._c.pcont:
            model_modules.append(self._pcont)

        # Build actor-critic networks
        self._qf1 = models.DenseNetwork(1, 3, self._c.num_units, act=act)
        self._qf2 = models.DenseNetwork(1, 3, self._c.num_units, act=act)
        self._target_qf1 = deepcopy(self._qf2)
        self._target_qf2 = deepcopy(self._qf1)
        self._qf_criterion = tf.keras.losses.Huber()
        self._actor = models.ActorNetwork(self._actdim, 4, self._c.num_units, act=act)

        # Initialize optimizers
        Optimizer = functools.partial(tools.Adam,
                                      wd=self._c.weight_decay,
                                      clip=self._c.grad_clip,
                                      wdpattern=self._c.weight_decay_pattern)

        self._model_opt = Optimizer('model', model_modules, self._c.model_lr)
        self._qf_opt = Optimizer('qf', [self._qf1, self._qf2], self._c.q_lr)
        self._actor_opt = Optimizer('actor', [self._actor], self._c.actor_lr)

    def _exploration(self, action, training):
        if training:
            amount = self._c.expl_amount
            if self._c.expl_decay:
                amount *= 0.5 ** (tf.cast(self._agent_step, tf.float32) / self._c.expl_decay)
            if self._c.expl_min:
                amount = tf.maximum(self._c.expl_min, amount)
            self._metrics['expl_amount'] = amount
        elif self._c.eval_noise:
            amount = self._c.eval_noise
        else:
            return action
        if self._c.expl == 'additive_gaussian':
            return tf.clip_by_value(tfd.Normal(action, amount).sample(), -1, 1)
        if self._c.expl == 'completely_random':
            return tf.random.uniform(action.shape, -1, 1)
        raise NotImplementedError(self._c.expl)

    def fit_model(self, iters):
        for iter in range(iters):
            data = next(self._dataset)
            self._model_train_step(data)
            if iter % self._c.save_every == 0:
                self.save_model(self._c.logdir / 'model_step_{}'.format(iter))
        self.save_model(self._c.logdir / 'final_model')

    def _model_train_step(self, data, prefix='train'):
        with tf.GradientTape() as model_tape:
            embed = self._encode(data)
            post, prior = self._dynamics.observe(embed, data['action'])
            feat = self._dynamics.get_feat(post)
            image_pred = self._decode(feat)
            reward_pred = self._reward(feat)
            likes = tools.AttrDict()
            likes.image = tf.reduce_mean(tf.boolean_mask(image_pred.log_prob(data['image']),
                                                         data['mask']))
            likes.reward = tf.reduce_mean(tf.boolean_mask(reward_pred.log_prob(data['reward']),
                                                          data['mask']))
            if self._c.pcont:
                pcont_pred = self._pcont(feat)
                pcont_target = data['terminal']
                likes.pcont = tf.reduce_mean(tf.boolean_mask(pcont_pred.log_prob(pcont_target),
                                                             data['mask']))
                likes.pcont *= self._c.pcont_scale

            for key in prior.keys():
                prior[key] = tf.boolean_mask(prior[key], data['mask'])
                post[key] = tf.boolean_mask(post[key], data['mask'])

            prior_dist = self._dynamics.get_dist(prior)
            post_dist = self._dynamics.get_dist(post)
            div = tf.reduce_mean(tfd.kl_divergence(post_dist, prior_dist))
            model_loss = self._c.kl_scale * div - sum(likes.values())

        if prefix == 'train':
            model_norm = self._model_opt(model_tape, model_loss)
            self._model_step += 1

        if self._model_step % self._c.log_every == 0:
            self._image_summaries(data, embed, image_pred, self._model_step, prefix)
            model_summaries = dict()
            model_summaries['model_train/KL Divergence'] = tf.reduce_mean(div)
            model_summaries['model_train/image_recon'] = tf.reduce_mean(likes.image)
            model_summaries['model_train/reward_recon'] = tf.reduce_mean(likes.reward)
            model_summaries['model_train/model_loss'] = tf.reduce_mean(model_loss)
            if prefix == 'train':
                model_summaries['model_train/model_norm'] = tf.reduce_mean(model_norm)
            if self._c.pcont:
                model_summaries['model_train/terminal_recon'] = tf.reduce_mean(likes.pcont)
            self._write_summaries(model_summaries, self._model_step)

    def train_agent(self, iters):
        for iter in range(iters):
            data = preprocess_latent(self.latent_buffer.sample(self._c.agent_batch_size))
            self._agent_train_step(data)
            if self._agent_step % self._c.target_update_interval == 0:
                self._update_target_critics()
            if iter % self._c.save_every == 0:
                self.save_agent(self._c.logdir)
        self.save_agent(self._c.logdir / 'final_agent')

    def _agent_train_step(self, data):
        obs = data['obs']
        actions = data['actions']
        next_obs = data['next_obs']
        rewards = data['rewards']
        terminals = data['terminals']

        with tf.GradientTape() as q_tape:
            q1_pred = self._qf1(tf.concat([obs, actions], axis=-1))
            q2_pred = self._qf2(tf.concat([obs, actions], axis=-1))
            # new_next_actions = self._exploration(self._actor(next_obs), True)
            new_actions = self._actor(obs)
            new_next_actions = self._actor(next_obs)

            target_q_values = tf.reduce_min([self._target_qf1(tf.concat([next_obs, new_next_actions], axis=-1)),
                                             self._target_qf2(tf.concat([next_obs, new_next_actions], axis=-1))],
                                            axis=0)
            q_target = rewards + self._c.discount * (1.0 - terminals) * target_q_values

            expanded_actions = tf.expand_dims(actions, 0)
            tilled_actions = tf.tile(expanded_actions, [self._c.cql_samples, 1, 1])
            tilled_actions = tf.random.uniform(tilled_actions.shape, minval=-1, maxval=1)
            tilled_actions = tf.concat([tilled_actions, tf.expand_dims(new_actions, 0)], axis=0)

            expanded_obs = tf.expand_dims(obs, 0)
            tilled_obs = tf.tile(expanded_obs, [self._c.cql_samples + 1, 1, 1])

            q1_values = self._qf1(tf.concat([tilled_obs, tilled_actions], axis=-1))
            q2_values = self._qf2(tf.concat([tilled_obs, tilled_actions], axis=-1))
            q1_penalty = tf.math.reduce_logsumexp(q1_values, axis=0)
            q2_penalty = tf.math.reduce_logsumexp(q2_values, axis=0)

            qf1_loss = self.alpha * (tf.reduce_mean(q1_penalty) - tf.reduce_mean(q1_pred[:self._c.agent_batch_size])) + \
                       tf.reduce_mean((q1_pred - tf.stop_gradient(q_target)) ** 2)
            qf2_loss = self.alpha * (tf.reduce_mean(q2_penalty) - tf.reduce_mean(q2_pred[:self._c.agent_batch_size])) + \
                       tf.reduce_mean((q2_pred - tf.stop_gradient(q_target)) ** 2)

            q_loss = qf1_loss + qf2_loss

        with tf.GradientTape() as actor_tape:
            new_obs_actions = self._actor(obs)
            q_new_actions = tf.reduce_min([self._qf1(tf.concat([obs, new_obs_actions], axis=-1)),
                                           self._qf2(tf.concat([obs, new_obs_actions], axis=-1))], axis=0)
            actor_loss = -tf.reduce_mean(q_new_actions)

        q_norm = self._qf_opt(q_tape, q_loss)
        actor_norm = self._actor_opt(actor_tape, actor_loss)
        self._agent_step += 1

        if self._agent_step % self._c.log_every == 0:
            agent_summaries = dict()
            agent_summaries['agent/Q1_value'] = tf.reduce_mean(q1_pred)
            agent_summaries['agent/Q2_value'] = tf.reduce_mean(q2_pred)
            agent_summaries['agent/Q_target'] = tf.reduce_mean(q_target)
            agent_summaries['agent/Q_loss'] = q_loss
            agent_summaries['agent/actor_loss'] = actor_loss
            agent_summaries['agent/Q_grad_norm'] = q_norm
            agent_summaries['agent/actor_grad_norm'] = actor_norm
            self._write_summaries(agent_summaries, self._agent_step)

    def _update_target_critics(self):
        tau = tf.constant(self._c.tau)
        for source_weight, target_weight in zip(self._qf1.trainable_variables,
                                                self._target_qf1.trainable_variables):
            target_weight.assign(tau * source_weight + (1.0 - tau) * target_weight)
        for source_weight, target_weight in zip(self._qf2.trainable_variables,
                                                self._target_qf2.trainable_variables):
            target_weight.assign(tau * source_weight + (1.0 - tau) * target_weight)

    def _generate_latent_data(self, data):
        embed = self._encode(data)
        post, prior = self._dynamics.observe(embed, data['action'])
        if self._c.pcont:  # Last step could be terminal.
            post = {k: v[:, :-1] for k, v in post.items()}
        for key in post.keys():
            post[key] = tf.boolean_mask(post[key], data['mask'])
        start = post

        policy = lambda state: tf.stop_gradient(
            self._exploration(self._actor(self._dynamics.get_feat(state)), True))

        obs = [[] for _ in tf.nest.flatten(start)]
        next_obs = [[] for _ in tf.nest.flatten(start)]
        actions = []
        full_posts = [[[] for _ in tf.nest.flatten(start)] for _ in range(self._c.num_models)]
        prev = start

        for index in range(self._c.horizon):
            [o.append(l) for o, l in zip(obs, tf.nest.flatten(prev))]
            a = policy(prev)
            actions.append(a)
            for i in range(self._c.num_models):
                p = self._dynamics.img_step(prev, a, k=i)
                [o.append(l) for o, l in zip(full_posts[i], tf.nest.flatten(p))]
            prev = self._dynamics.img_step(prev, a, k=np.random.choice(self._c.num_models, 1)[0])
            [o.append(l) for o, l in zip(next_obs, tf.nest.flatten(prev))]

            obs = self._dynamics.get_feat(tf.nest.pack_sequence_as(start, [tf.stack(x, 0) for x in obs]))
            stoch = tf.nest.pack_sequence_as(start, [tf.stack(x, 0) for x in next_obs])['stoch']
            next_obs = self._dynamics.get_feat(tf.nest.pack_sequence_as(start, [tf.stack(x, 0) for x in next_obs]))
            actions = tf.stack(actions, 0)
            rewards = self._reward(next_obs).mode()
            if self._c.pcont:
                dones = 1.0 * (self._pcont(next_obs).mean().numpy() > self._c.done_treshold)
            else:
                dones = tf.zeros_like(rewards)

            dists = [self._dynamics.get_dist(
                tf.nest.pack_sequence_as(start, [tf.stack(x, 0) for x in full_posts[i]]))
                for i in range(self._c.num_models)]

            # Compute penalty based on specification
            if self._c.penalty_type == 'log_prob':
                log_prob_vars = tf.math.reduce_std(
                    tf.stack([d.log_prob(stoch) for d in dists], 0),
                    axis=0)
                modified_rewards = rewards - self.lmbd * log_prob_vars
            elif self._c.penalty_type == 'max_var':
                max_std = tf.reduce_max(
                    tf.stack([tf.norm(d.stddev(), 2, -1) for d in dists], 0),
                    axis=0)
                modified_rewards = rewards - self.lmbd * max_std
            elif self._c.penalty_type == 'mean':
                mean_prediction = tf.reduce_mean(tf.stack([d.mean() for d in dists], 0), axis=0)
                mean_disagreement = tf.reduce_mean(
                    tf.stack([tf.norm(d.mean() - mean_prediction, 2, -1) for d in dists], 0),
                    axis=0)
                modified_rewards = rewards - self.lmbd * mean_disagreement
            else:
                modified_rewards = rewards

            self.latent_buffer.add_samples(flatten(obs).numpy(),
                                           flatten(actions).numpy(),
                                           flatten(next_obs).numpy(),
                                           flatten(modified_rewards).numpy(),
                                           flatten(dones),
                                           sample_type='latent')

            obs = [[] for _ in tf.nest.flatten(start)]
            next_obs = [[] for _ in tf.nest.flatten(start)]
            actions = []
            full_posts = [[[] for _ in tf.nest.flatten(start)] for _ in range(self._c.num_models)]

            for key in prev.keys():
                prev[key] = tf.boolean_mask(prev[key], flatten(1.0 - dones))

    def _add_data(self, num_episodes=1):
        self._process_data_to_latent(num_episodes=num_episodes)
        self._generate_latent_data(next(self._dataset))

    def _process_data_to_latent(self, num_episodes=None):
        if num_episodes is None:
            num_episodes, _ = tools.count_episodes(self._c.datadir)

        for _ in range(num_episodes):
            filename = next(self._episode_iterator)
            try:
                with filename.open('rb') as f:
                    episode = np.load(f)
                    episode = {k: episode[k] for k in episode.keys()}
            except Exception as e:
                print(f'Could not load episode: {e}')
                continue

            obs = preprocess_raw(episode, self._c)
            if not self._c.pcont:
                obs['terminal'] = tf.zeros_like(obs['reward'])
            with tf.GradientTape(watch_accessed_variables=False) as _:
                embed = self._encode(obs)
                post, prior = self._dynamics.observe(tf.expand_dims(embed, 0),
                                                     tf.expand_dims(obs['action'], 0))
                feat = flatten(self._dynamics.get_feat(post))
                self.latent_buffer.add_samples(feat.numpy()[:-1],
                                               obs['action'].numpy()[1:],
                                               feat.numpy()[1:],
                                               obs['reward'].numpy()[1:],
                                               obs['terminal'].numpy()[1:],
                                               sample_type='real')

    def _image_summaries(self, data, embed, image_pred, step=None, prefix='train'):
        truth = data['image'][:6] + 0.5
        recon = image_pred.mode()[:6]
        init, _ = self._dynamics.observe(embed[:6, :5], data['action'][:6, :5])
        init = {k: v[:, -1] for k, v in init.items()}
        prior = self._dynamics.imagine(data['action'][:6, 5:], init)
        openl = self._decode(self._dynamics.get_feat(prior)).mode()
        model = tf.concat([recon[:, :5] + 0.5, openl + 0.5], 1)
        error_prior = (model - truth + 1) / 2
        error_posterior = (recon + 0.5 - truth + 1) / 2
        openl = tf.concat([truth, recon + 0.5, model, error_prior, error_posterior], 2)
        with self._writer.as_default():
            tools.video_summary('agent/' + prefix, openl.numpy(), step=step)

    def _write_summaries(self, metrics, step=None):
        step = int(step)
        metrics = [(k, float(v)) for k, v in metrics.items()]
        with self._writer.as_default():
            tf.summary.experimental.set_step(step)
            [tf.summary.scalar(k, m, step=step) for k, m in metrics]
        print(f'[{step}]', ' / '.join(f'{k} {v:.1f}' for k, v in metrics))
        self._writer.flush()


def preprocess_raw(obs, config):
    dtype = prec.global_policy().compute_dtype
    obs = obs.copy()

    with tf.device('cpu:0'):
        obs['image'] = tf.cast(obs['image'], dtype) / 255.0 - 0.5
        if 'image_128' in obs.keys():
            obs['image_128'] = tf.cast(obs['image_128'], dtype) / 255.0 - 0.5
        clip_rewards = dict(none=lambda x: x, tanh=tf.tanh)[config.clip_rewards]
        obs['reward'] = clip_rewards(obs['reward'])
        for k in obs.keys():
            obs[k] = tf.cast(obs[k], dtype)
    return obs


def flatten(x):
    return tf.reshape(x, [-1] + list(x.shape[2:]))


def preprocess_latent(batch):
    dtype = prec.global_policy().compute_dtype
    batch = batch.copy()
    with tf.device('cpu:0'):
        for key in batch.keys():
            batch[key] = tf.cast(batch[key], dtype)
    return batch


def count_steps(datadir, config):
    return tools.count_episodes(datadir)[1] * config.action_repeat


def load_dataset(directory, config):
    episode = next(tools.load_episodes(directory, 1000, load_episodes=1))
    types = {k: v.dtype for k, v in episode.items()}
    shapes = {k: (None,) + v.shape[1:] for k, v in episode.items()}
    generator = lambda: tools.load_episodes(directory, config.train_steps,
                                            config.model_batch_length, config.dataset_balance)
    dataset = tf.data.Dataset.from_generator(generator, types, shapes)
    dataset = dataset.batch(config.model_batch_size, drop_remainder=True)
    dataset = dataset.map(functools.partial(preprocess_raw, config=config))
    dataset = dataset.prefetch(10)
    return dataset


def episode_iterator(datadir, config):
    while True:
        filenames = list(datadir.glob('*.npz'))
        for filename in list(filenames):
            yield filename


def summarize_episode(episode, config, datadir, writer, prefix):
    length = (len(episode['reward']) - 1) * config.action_repeat
    ret = episode['reward'].sum()
    print(f'{prefix.title()} episode of length {length} with return {ret:.1f}.')
    metrics = [
        (f'{prefix}/return', float(episode['reward'].sum())),
        (f'{prefix}/length', len(episode['reward']) - 1)]
    with writer.as_default():  # Env might run in a different thread.
        [tf.summary.scalar('sim/' + k, v) for k, v in metrics]
        if prefix == 'test':
            tools.video_summary(f'sim/{prefix}/video', episode['image'][None])


def make_env(config, writer, prefix, datadir, store):
    suite, task = config.task.split('_', 1)
    if suite == 'dmc':
        env = wrappers.DeepMindControl(task)
        env = wrappers.ActionRepeat(env, config.action_repeat)
        env = wrappers.NormalizeActions(env)
    elif suite == 'gym':
        env = wrappers.Gym(task, config, size=(128, 128))
        env = wrappers.ActionRepeat(env, config.action_repeat)
        env = wrappers.NormalizeActions(env)
    elif task == 'door':
        env = wrappers.DoorOpen(config, size=(128, 128))
        env = wrappers.ActionRepeat(env, config.action_repeat)
        env = wrappers.NormalizeActions(env)
    elif task == 'drawer':
        env = wrappers.DrawerOpen(config, size=(128, 128))
        env = wrappers.ActionRepeat(env, config.action_repeat)
        env = wrappers.NormalizeActions(env)
    else:
        raise NotImplementedError(suite)
    env = wrappers.TimeLimit(env, config.time_limit / config.action_repeat)
    callbacks = []
    if store:
        callbacks.append(lambda ep: tools.save_episodes(datadir, [ep]))
    if prefix == 'test':
        callbacks.append(
            lambda ep: summarize_episode(ep, config, datadir, writer, prefix))
    env = wrappers.Collect(env, callbacks, config.precision)
    env = wrappers.RewardObs(env)
    return env


def main(config):
    print(config)

    # Set random seeds
    os.environ['PYTHONHASHSEED'] = str(config.seed)
    os.environ['TF_CUDNN_DETERMINISTIC'] = '1'
    random.seed(config.seed)
    np.random.seed(config.seed)
    tf.random.set_seed(config.seed)

    if config.gpu_growth:
        for gpu in tf.config.experimental.list_physical_devices('GPU'):
            tf.config.experimental.set_memory_growth(gpu, True)

    config.logdir = config.logdir / config.task
    config.logdir = config.logdir / 'seed_{}'.format(config.seed)
    config.logdir.mkdir(parents=True, exist_ok=True)
    tf_dir = config.logdir / 'tensorboard'
    writer = tf.summary.create_file_writer(str(tf_dir), max_queue=1000, flush_millis=20000)
    writer.set_as_default()

    # Create environments.
    train_envs = [wrappers.Async(lambda: make_env(
        config, writer, 'train', '.', store=False), config.parallel)
                  for _ in range(config.envs)]
    test_envs = [wrappers.Async(lambda: make_env(
        config, writer, 'test', '.', store=False), config.parallel)
                 for _ in range(config.envs)]
    actspace = train_envs[0].action_space

    # Train and regularly evaluate the agent.
    agent = Lompo(config, config.datadir, actspace, writer)

    if agent._c.load_model:
        agent.load_model(config.loaddir / 'final_model')
        print('Load pretrained model')
    else:
        agent.fit_model(agent._c.model_train_steps)
        agent.save_model(config.logdir)

    if agent._c.load_buffer:
        agent.latent_buffer.load(agent._c.loaddir / 'buffer.h5py')
    else:
        agent._process_data_to_latent()
        agent.latent_buffer.save(agent._c.logdir / 'buffer.h5py')

    if agent._c.load_agent:
        agent.load_agent(config.loaddir)
        print('Load pretrained actor')

    while agent.latent_buffer._latent_stored_steps < agent._c.start_training:
        agent._generate_latent_data(next(agent._dataset))

    while agent._agent_step < int(config.agent_train_steps):
        print('Start evaluation.')
        tools.simulate(
            functools.partial(agent, training=False), test_envs, episodes=1)
        writer.flush()
        print('Start collection.')
        agent.train_agent(agent._c.agent_iters_per_step)

        if config.sample:
            agent._add_data(num_episodes=1)
        else:
            agent._process_data_to_latent(num_episodes=1)

    for env in train_envs + test_envs:
        env.close()


if __name__ == '__main__':
    try:
        import colored_traceback

        colored_traceback.add_hook()
    except ImportError:
        pass
    parser = argparse.ArgumentParser()
    for key, value in define_config().items():
        parser.add_argument(f'--{key}', type=tools.args_type(value), default=value)
    main(parser.parse_args())