upload code

baselines/lompo/buffer.py

@@ -0,0 +1,126 @@
+import h5py
+import numpy as np
+
+
+class Buffer():
+    def __init__(self):
+        self._obs = None
+        self._actions = None
+        self._rewards = None
+        self._next_obs = None
+        self._terminals = None
+
+
+class LatentReplayBuffer(object):
+    def __init__(self,
+                 real_size: int,
+                 latent_size: int,
+                 obs_dim: int,
+                 action_dim: int,
+                 immutable: bool = False,
+                 load_from: str = None,
+                 silent: bool = False,
+                 seed: int = 0):
+
+        self.immutable = immutable
+
+        self.buffers = dict()
+        self.sizes = {'real': real_size, 'latent': latent_size}
+        for key in ['real', 'latent']:
+            self.buffers[key] = Buffer()
+            self.buffers[key]._obs = np.full((self.sizes[key], obs_dim), float('nan'), dtype=np.float32)
+            self.buffers[key]._actions = np.full((self.sizes[key], action_dim), float('nan'), dtype=np.float32)
+            self.buffers[key]._rewards = np.full((self.sizes[key], 1), float('nan'), dtype=np.float32)
+            self.buffers[key]._next_obs = np.full((self.sizes[key], obs_dim), float('nan'), dtype=np.float32)
+            self.buffers[key]._terminals = np.full((self.sizes[key], 1), float('nan'), dtype=np.float32)
+
+        self._real_stored_steps = 0
+        self._real_write_location = 0
+
+        self._latent_stored_steps = 0
+        self._latent_write_location = 0
+
+        self._stored_steps = 0
+        self._random = np.random.RandomState(seed)
+
+    @property
+    def obs_dim(self):
+        return self._obs.shape[-1]
+
+    @property
+    def action_dim(self):
+        return self._actions.shape[-1]
+
+    def __len__(self):
+        return self._stored_steps
+
+    def save(self, location: str):
+        f = h5py.File(location, 'w')
+        f.create_dataset('obs', data=self.buffers['real']._obs[:self._real_stored_steps], compression='lzf')
+        f.create_dataset('actions', data=self.buffers['real']._actions[:self._real_stored_steps], compression='lzf')
+        f.create_dataset('rewards', data=self.buffers['real']._rewards[:self._real_stored_steps], compression='lzf')
+        f.create_dataset('next_obs', data=self.buffers['real']._next_obs[:self._real_stored_steps], compression='lzf')
+        f.create_dataset('terminals', data=self.buffers['real']._terminals[:self._real_stored_steps], compression='lzf')
+        f.close()
+
+    def load(self, location: str):
+        with h5py.File(location, "r") as f:
+            obs = np.array(f['obs'])
+            self._real_stored_steps = obs.shape[0]
+            self._real_write_location = obs.shape[0] % self.sizes['real']
+
+            self.buffers['real']._obs[:self._real_stored_steps] = np.array(f['obs'])
+            self.buffers['real']._actions[:self._real_stored_steps] = np.array(f['actions'])
+            self.buffers['real']._rewards[:self._real_stored_steps] = np.array(f['rewards'])
+            self.buffers['real']._next_obs[:self._real_stored_steps] = np.array(f['next_obs'])
+            self.buffers['real']._terminals[:self._real_stored_steps] = np.array(f['terminals'])
+
+    def add_samples(self, obs_feats, actions, next_obs_feats, rewards, terminals, sample_type='latent'):
+        if sample_type == 'real':
+            for obsi, actsi, nobsi, rewi, termi in zip(obs_feats, actions, next_obs_feats, rewards, terminals):
+                self.buffers['real']._obs[self._real_write_location] = obsi
+                self.buffers['real']._actions[self._real_write_location] = actsi
+                self.buffers['real']._next_obs[self._real_write_location] = nobsi
+                self.buffers['real']._rewards[self._real_write_location] = rewi
+                self.buffers['real']._terminals[self._real_write_location] = termi
+
+                self._real_write_location = (self._real_write_location + 1) % self.sizes['real']
+                self._real_stored_steps = min(self._real_stored_steps + 1, self.sizes['real'])
+
+        else:
+            for obsi, actsi, nobsi, rewi, termi in zip(obs_feats, actions, next_obs_feats, rewards, terminals):
+                self.buffers['latent']._obs[self._latent_write_location] = obsi
+                self.buffers['latent']._actions[self._latent_write_location] = actsi
+                self.buffers['latent']._next_obs[self._latent_write_location] = nobsi
+                self.buffers['latent']._rewards[self._latent_write_location] = rewi
+                self.buffers['latent']._terminals[self._latent_write_location] = termi
+
+                self._latent_write_location = (self._latent_write_location + 1) % self.sizes['latent']
+                self._latent_stored_steps = min(self._latent_stored_steps + 1, self.sizes['latent'])
+
+        self._stored_steps = self._real_stored_steps + self._latent_stored_steps
+
+    def sample(self, batch_size, return_dict: bool = False):
+        real_idxs = self._random.choice(self._real_stored_steps, batch_size)
+        latent_idxs = self._random.choice(self._latent_stored_steps, batch_size)
+
+        obs = np.concatenate([self.buffers['real']._obs[real_idxs],
+                              self.buffers['latent']._obs[latent_idxs]], axis=0)
+        actions = np.concatenate([self.buffers['real']._actions[real_idxs],
+                                  self.buffers['latent']._actions[latent_idxs]], axis=0)
+        next_obs = np.concatenate([self.buffers['real']._next_obs[real_idxs],
+                                   self.buffers['latent']._next_obs[latent_idxs]], axis=0)
+        rewards = np.concatenate([self.buffers['real']._rewards[real_idxs],
+                                  self.buffers['latent']._rewards[latent_idxs]], axis=0)
+        terminals = np.concatenate([self.buffers['real']._terminals[real_idxs],
+                                    self.buffers['latent']._terminals[latent_idxs]], axis=0)
+
+        data = {
+            'obs': obs,
+            'actions': actions,
+            'next_obs': next_obs,
+            'rewards': rewards,
+            'terminals': terminals
+        }
+
+        return data

baselines/lompo/models.py

@@ -0,0 +1,250 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import layers as tfkl
+from tensorflow_probability import distributions as tfd
+from tensorflow.keras.mixed_precision import experimental as prec
+
+from . import tools
+
+
+class RSSME(tools.Module):
+    def __init__(self, stoch=30, deter=200, hidden=200, num_models=7, act=tf.nn.elu):
+        super().__init__()
+        self._activation = act
+        self._stoch_size = stoch
+        self._deter_size = deter
+        self._hidden_size = hidden
+        self._cell = tfkl.GRUCell(self._deter_size)
+        self._k = num_models
+
+    def initial(self, batch_size):
+        dtype = prec.global_policy().compute_dtype
+        return dict(
+            mean=tf.zeros([batch_size, self._stoch_size], dtype),
+            std=tf.zeros([batch_size, self._stoch_size], dtype),
+            stoch=tf.zeros([batch_size, self._stoch_size], dtype),
+            deter=self._cell.get_initial_state(None, batch_size, dtype))
+
+    def observe(self, embed, action, state=None):
+        if state is None:
+            state = self.initial(tf.shape(action)[0])
+        embed = tf.transpose(embed, [1, 0, 2])
+        action = tf.transpose(action, [1, 0, 2])
+        post, prior = tools.static_scan(lambda prev, inputs: self.obs_step(prev[0], *inputs),
+                                        (action, embed), (state, state))
+        post = {k: tf.transpose(v, [1, 0, 2]) for k, v in post.items()}
+        prior = {k: tf.transpose(v, [1, 0, 2]) for k, v in prior.items()}
+        return post, prior
+
+    def imagine(self, action, state=None):
+        if state is None:
+            state = self.initial(tf.shape(action)[0])
+        assert isinstance(state, dict), state
+        action = tf.transpose(action, [1, 0, 2])
+        prior = tools.static_scan(self.img_step, action, state)
+        prior = {k: tf.transpose(v, [1, 0, 2]) for k, v in prior.items()}
+        return prior
+
+    def get_feat(self, state):
+        return tf.concat([state['stoch'], state['deter']], -1)
+
+    def get_feat_size(self, state):
+        return self._stoch_size + self._deter_size
+
+    def get_dist(self, state):
+        return tfd.MultivariateNormalDiag(state['mean'], state['std'])
+
+    def obs_step(self, prev_state, prev_action, embed):
+        prior = self.img_step(prev_state, prev_action)
+        x = tf.concat([prior['deter'], embed], -1)
+        x = self.get('obs1', tfkl.Dense, self._hidden_size, self._activation)(x)
+        x = self.get('obs2', tfkl.Dense, 2 * self._stoch_size, None)(x)
+        mean, std = tf.split(x, 2, -1)
+        std = tf.nn.softplus(std) + 0.1
+        stoch = self.get_dist({'mean': mean, 'std': std}).sample()
+        post = {'mean': mean, 'std': std, 'stoch': stoch, 'deter': prior['deter']}
+        return post, prior
+
+    def img_step(self, prev_state, prev_action, k=None):
+        if k is None:
+            k = np.random.choice(self._k)
+        x = tf.concat([prev_state['stoch'], prev_action], -1)
+        x = self.get('img1', tfkl.Dense, self._hidden_size, self._activation)(x)
+        x, deter = self._cell(x, [prev_state['deter']])
+        deter = deter[0]  # Keras wraps the state in a list.
+        x = self.get('img2_{}'.format(k), tfkl.Dense, self._hidden_size, self._activation)(x)
+        x = self.get('img3_{}'.format(k), tfkl.Dense, 2 * self._stoch_size, None)(x)
+        mean, std = tf.split(x, 2, -1)
+        std = tf.nn.softplus(std) + 0.1
+        stoch = self.get_dist({'mean': mean, 'std': std}).sample()
+        prior = {'mean': mean, 'std': std, 'stoch': stoch, 'deter': deter}
+        return prior
+
+
+class MultivariateNormalDiag(tools.Module):
+    def __init__(self, hidden_size, latent_size, scale=None):
+        super().__init__()
+        self.latent_size = latent_size
+        self.scale = scale
+        self.dense1 = tf.keras.layers.Dense(hidden_size, activation=tf.nn.leaky_relu)
+        self.dense2 = tf.keras.layers.Dense(hidden_size, activation=tf.nn.leaky_relu)
+        self.output_layer = tf.keras.layers.Dense(2 * latent_size if self.scale
+                                                                     is None else latent_size)
+
+    def __call__(self, *inputs):
+        if len(inputs) > 1:
+            inputs = tf.concat(inputs, axis=-1)
+        else:
+            inputs, = inputs
+        out = self.dense1(inputs)
+        out = self.dense2(out)
+        out = self.output_layer(out)
+        loc = out[..., :self.latent_size]
+        if self.scale is None:
+            assert out.shape[-1] == 2 * self.latent_size
+            scale_diag = tf.nn.softplus(out[..., self.latent_size:]) + 1e-5
+        else:
+            assert out.shape[-1].value == self.latent_size
+            scale_diag = tf.ones_like(loc) * self.scale
+        return loc, scale_diag
+
+
+class ConstantMultivariateNormalDiag(tools.Module):
+    def __init__(self, latent_size, scale=None):
+        super().__init__()
+        self.latent_size = latent_size
+        self.scale = scale
+
+    def __call__(self, *inputs):
+        # first input should not have any dimensions after the batch_shape, step_type
+        batch_shape = tf.shape(inputs[0])  # input is only used to infer batch_shape
+        shape = tf.concat([batch_shape, [self.latent_size]], axis=0)
+        loc = tf.zeros(shape)
+        if self.scale is None:
+            scale_diag = tf.ones(shape)
+        else:
+            scale_diag = tf.ones(shape) * self.scale
+        return loc, scale_diag
+
+
+class ConvEncoderLarge(tools.Module):
+    def __init__(self, depth=32, act=tf.nn.relu):
+        self._act = act
+        self._depth = depth
+
+    def __call__(self, obs):
+        kwargs = dict(strides=2, activation=self._act)
+        x = tf.reshape(obs['image'], (-1,) + tuple(obs['image'].shape[-3:]))
+        x = self.get('h1', tfkl.Conv2D, 1 * self._depth, 4, **kwargs)(x)
+        x = self.get('h2', tfkl.Conv2D, 2 * self._depth, 4, **kwargs)(x)
+        x = self.get('h3', tfkl.Conv2D, 4 * self._depth, 4, **kwargs)(x)
+        x = self.get('h4', tfkl.Conv2D, 8 * self._depth, 4, **kwargs)(x)
+        x = self.get('h5', tfkl.Conv2D, 8 * self._depth, 4, **kwargs)(x)
+        shape = tf.concat([tf.shape(obs['image'])[:-3], [32 * self._depth]], 0)
+        return tf.reshape(x, shape)
+
+
+class ConvDecoderLarge(tools.Module):
+    def __init__(self, depth=32, act=tf.nn.relu, shape=(128, 128, 3)):
+        self._act = act
+        self._depth = depth
+        self._shape = shape
+
+    def __call__(self, features):
+        kwargs = dict(strides=2, activation=self._act)
+        x = self.get('h1', tfkl.Dense, 32 * self._depth, None)(features)
+        x = tf.reshape(x, [-1, 1, 1, 32 * self._depth])
+        x = self.get('h2', tfkl.Conv2DTranspose, 4 * self._depth, 5, **kwargs)(x)
+        x = self.get('h3', tfkl.Conv2DTranspose, 2 * self._depth, 5, **kwargs)(x)
+        x = self.get('h4', tfkl.Conv2DTranspose, 1 * self._depth, 5, **kwargs)(x)
+        x = self.get('h5', tfkl.Conv2DTranspose, 1 * self._depth, 6, **kwargs)(x)
+        x = self.get('h6', tfkl.Conv2DTranspose, self._shape[-1], 6, strides=2)(x)
+        mean = tf.reshape(x, tf.concat([tf.shape(features)[:-1], self._shape], 0))
+        return tfd.Independent(tfd.Normal(mean, 1), len(self._shape))
+
+
+class ConvEncoder(tools.Module):
+    def __init__(self, depth=32, act=tf.nn.relu):
+        self._act = act
+        self._depth = depth
+
+    def __call__(self, obs):
+        kwargs = dict(strides=2, activation=self._act)
+        x = tf.reshape(obs['image'], (-1,) + tuple(obs['image'].shape[-3:]))
+        x = self.get('h1', tfkl.Conv2D, 1 * self._depth, 4, **kwargs)(x)
+        x = self.get('h2', tfkl.Conv2D, 2 * self._depth, 4, **kwargs)(x)
+        x = self.get('h3', tfkl.Conv2D, 4 * self._depth, 4, **kwargs)(x)
+        x = self.get('h4', tfkl.Conv2D, 8 * self._depth, 4, **kwargs)(x)
+        shape = tf.concat([tf.shape(obs['image'])[:-3], [32 * self._depth]], 0)
+        return tf.reshape(x, shape)
+
+
+class ConvDecoder(tools.Module):
+    def __init__(self, depth=32, act=tf.nn.relu, shape=(64, 64, 3)):
+        self._act = act
+        self._depth = depth
+        self._shape = shape
+
+    def __call__(self, features):
+        kwargs = dict(strides=2, activation=self._act)
+        x = self.get('h1', tfkl.Dense, 32 * self._depth, None)(features)
+        x = tf.reshape(x, [-1, 1, 1, 32 * self._depth])
+        x = self.get('h2', tfkl.Conv2DTranspose, 4 * self._depth, 5, **kwargs)(x)
+        x = self.get('h3', tfkl.Conv2DTranspose, 2 * self._depth, 5, **kwargs)(x)
+        x = self.get('h4', tfkl.Conv2DTranspose, 1 * self._depth, 6, **kwargs)(x)
+        x = self.get('h5', tfkl.Conv2DTranspose, self._shape[-1], 6, strides=2)(x)
+        mean = tf.reshape(x, tf.concat([tf.shape(features)[:-1], self._shape], 0))
+        return tfd.Independent(tfd.Normal(mean, 1), len(self._shape))
+
+
+class DenseDecoder(tools.Module):
+    def __init__(self, shape, layers, units, dist='normal', act=tf.nn.elu):
+        self._shape = shape
+        self._layers = layers
+        self._units = units
+        self._dist = dist
+        self._act = act
+
+    def __call__(self, features):
+        x = features
+        for index in range(self._layers):
+            x = self.get(f'h{index}', tfkl.Dense, self._units, self._act)(x)
+        x = self.get(f'hout', tfkl.Dense, np.prod(self._shape))(x)
+        x = tf.reshape(x, tf.concat([tf.shape(features)[:-1], self._shape], 0))
+        if self._dist == 'normal':
+            return tfd.Independent(tfd.Normal(x, 1), len(self._shape))
+        if self._dist == 'binary':
+            return tfd.Independent(tfd.Bernoulli(x), len(self._shape))
+        raise NotImplementedError(self._dist)
+
+
+class DenseNetwork(tools.Module):
+    def __init__(self, shape, layers, units, act=tf.nn.elu):
+        self._shape = shape
+        self._layers = layers
+        self._units = units
+        self._act = act
+
+    def __call__(self, features):
+        x = features
+        for index in range(self._layers):
+            x = self.get(f'h{index}', tfkl.Dense, self._units, self._act)(x)
+        x = self.get(f'hout', tfkl.Dense, self._shape)(x)
+        return x
+
+
+class ActorNetwork(tools.Module):
+    def __init__(self, shape, layers, units, act=tf.nn.elu, mean_scale=1.0):
+        self._shape = shape
+        self._layers = layers
+        self._units = units
+        self._act = act
+        self._mean_scale = mean_scale
+
+    def __call__(self, features):
+        x = features
+        for index in range(self._layers):
+            x = self.get(f'h{index}', tfkl.Dense, self._units, self._act)(x)
+        x = self.get(f'hout', tfkl.Dense, self._shape)(x)
+        x = self._mean_scale * tf.tanh(x)
+        return x

baselines/lompo/run.py

@@ -0,0 +1,723 @@
+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())

baselines/lompo/tools.py

@@ -0,0 +1,243 @@
+import copy
+import datetime
+import io
+import pathlib
+import pickle
+import uuid
+
+import numpy as np
+import tensorflow as tf
+import tensorflow.compat.v1 as tf1
+from tensorflow_probability import distributions as tfd
+
+
+class AttrDict(dict):
+    __setattr__ = dict.__setitem__
+    __getattr__ = dict.__getitem__
+
+
+class Module(tf.Module):
+    def save(self, filename):
+        values = tf.nest.map_structure(lambda x: x.numpy(), self.variables)
+        with pathlib.Path(filename).open('wb') as f:
+            pickle.dump(values, f)
+
+    def load(self, filename):
+        with pathlib.Path(filename).open('rb') as f:
+            values = pickle.load(f)
+        tf.nest.map_structure(lambda x, y: x.assign(y), self.variables, values)
+
+    def get(self, name, ctor, *args, **kwargs):
+        # Create or get layer by name to avoid mentioning it in the constructor.
+        if not hasattr(self, '_modules'):
+            self._modules = {}
+        if name not in self._modules:
+            self._modules[name] = ctor(*args, **kwargs)
+        return self._modules[name]
+
+
+def video_summary(name, video, step=None, fps=20):
+    name = name if isinstance(name, str) else name.decode('utf-8')
+    if np.issubdtype(video.dtype, np.floating):
+        video = np.clip(255 * video, 0, 255).astype(np.uint8)
+    B, T, H, W, C = video.shape
+    try:
+        frames = video.transpose((1, 2, 0, 3, 4)).reshape((T, H, B * W, C))
+        summary = tf1.Summary()
+        image = tf1.Summary.Image(height=B * H, width=T * W, colorspace=C)
+        image.encoded_image_string = encode_gif(frames, fps)
+        summary.value.add(tag=name + '/gif', image=image)
+        tf.summary.experimental.write_raw_pb(summary.SerializeToString(), step)
+    except (IOError, OSError) as e:
+        print('GIF summaries require ffmpeg in $PATH.', e)
+        frames = video.transpose((0, 2, 1, 3, 4)).reshape((1, B * H, T * W, C))
+        tf.summary.image(name + '/grid', frames, step)
+
+
+def encode_gif(frames, fps):
+    from subprocess import Popen, PIPE
+    h, w, c = frames[0].shape
+    pxfmt = {1: 'gray', 3: 'rgb24'}[c]
+    cmd = ' '.join([
+        f'ffmpeg -y -f rawvideo -vcodec rawvideo',
+        f'-r {fps:.02f} -s {w}x{h} -pix_fmt {pxfmt} -i - -filter_complex',
+        f'[0:v]split[x][z];[z]palettegen[y];[x]fifo[x];[x][y]paletteuse',
+        f'-r {fps:.02f} -f gif -'])
+    proc = Popen(cmd.split(' '), stdin=PIPE, stdout=PIPE, stderr=PIPE)
+    for image in frames:
+        proc.stdin.write(image.tostring())
+    out, err = proc.communicate()
+    if proc.returncode:
+        raise IOError('\n'.join([' '.join(cmd), err.decode('utf8')]))
+    del proc
+    return out
+
+
+def simulate(agent, envs, steps=0, episodes=0, state=None):
+    # Initialize or unpack simulation state.
+    if state is None:
+        step, episode = 0, 0
+        done = np.ones(len(envs), np.bool)
+        length = np.zeros(len(envs), np.int32)
+        obs = [None] * len(envs)
+        agent_state = None
+    else:
+        step, episode, done, length, obs, agent_state = state
+    while (steps and step < steps) or (episodes and episode < episodes):
+        # Reset envs if necessary.
+        if done.any():
+            indices = [index for index, d in enumerate(done) if d]
+            promises = [envs[i].reset(blocking=False) for i in indices]
+            for index, promise in zip(indices, promises):
+                obs[index] = promise()
+        # Step agents.
+        obs = {k: np.stack([o[k] for o in obs]) for k in obs[0]}
+        action, agent_state = agent(obs, done, agent_state)
+        action = np.array(action)
+        assert len(action) == len(envs)
+        # Step envs.
+        promises = [e.step(a, blocking=False) for e, a in zip(envs, action)]
+        obs, _, done = zip(*[p()[:3] for p in promises])
+        obs = list(obs)
+        done = np.stack(done)
+        episode += int(done.sum())
+        length += 1
+        step += (done * length).sum()
+        length *= (1 - done)
+    # Return new state to allow resuming the simulation.
+    return step - steps, episode - episodes, done, length, obs, agent_state
+
+
+def count_episodes(directory):
+    filenames = directory.glob('*.npz')
+    lengths = [int(n.stem.rsplit('-', 1)[-1]) - 1 for n in filenames]
+    episodes, steps = len(lengths), sum(lengths)
+    return episodes, steps
+
+
+def save_episodes(directory, episodes):
+    directory = pathlib.Path(directory).expanduser()
+    directory.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')
+    for episode in episodes:
+        identifier = str(uuid.uuid4().hex)
+        length = len(episode['reward'])
+        filename = directory / f'{timestamp}-{identifier}-{length}.npz'
+        with io.BytesIO() as f1:
+            np.savez_compressed(f1, **episode)
+            f1.seek(0)
+            with filename.open('wb') as f2:
+                f2.write(f1.read())
+
+
+def load_episodes(directory, rescan, length=None, balance=False, seed=0, load_episodes=1000):
+    directory = pathlib.Path(directory).expanduser()
+    random = np.random.RandomState(seed)
+    filenames = list(directory.glob('*.npz'))
+    load_episodes = min(len(filenames), load_episodes)
+    if load_episodes is None:
+        load_episodes = int(count_episodes(directory)[0] / 20)
+
+    while True:
+        cache = {}
+        for filename in random.choice(list(directory.glob('*.npz')),
+                                      load_episodes,
+                                      replace=False):
+            try:
+                with filename.open('rb') as f:
+                    episode = np.load(f)
+                    episode = {k: episode[k] for k in episode.keys() if k not in ['image_128']}
+                    # episode['reward'] = copy.deepcopy(episode['success'])
+                    if 'discount' not in episode:
+                        episode['discount'] = np.where(episode['is_terminal'], 0., 1.)
+            except Exception as e:
+                print(f'Could not load episode: {e}')
+                continue
+            cache[filename] = episode
+
+        keys = list(cache.keys())
+        for index in random.choice(len(keys), rescan):
+            episode = copy.deepcopy(cache[keys[index]])
+            if length:
+                total = len(next(iter(episode.values())))
+                available = total - length
+                if available < 0:
+                    for key in episode.keys():
+                        shape = episode[key].shape
+                        episode[key] = np.concatenate([episode[key],
+                                                       np.zeros([abs(available)] + list(shape[1:]))],
+                                                      axis=0)
+                    episode['mask'] = np.ones(length)
+                    episode['mask'][available:] = 0.0
+                elif available > 0:
+                    if balance:
+                        index = min(random.randint(0, total), available)
+                    else:
+                        index = int(random.randint(0, available))
+                    episode = {k: v[index: index + length] for k, v in episode.items()}
+                    episode['mask'] = np.ones(length)
+                else:
+                    episode['mask'] = np.ones_like(episode['reward'])
+            else:
+                episode['mask'] = np.ones_like(episode['reward'])
+            yield episode
+
+
+class Adam(tf.Module):
+    def __init__(self, name, modules, lr, clip=None, wd=None, wdpattern=r'.*'):
+        self._name = name
+        self._modules = modules
+        self._clip = clip
+        self._wd = wd
+        self._wdpattern = wdpattern
+        self._opt = tf.optimizers.Adam(lr)
+
+    @property
+    def variables(self):
+        return self._opt.variables()
+
+    def __call__(self, tape, loss):
+        variables = [module.variables for module in self._modules]
+        self._variables = tf.nest.flatten(variables)
+        assert len(loss.shape) == 0, loss.shape
+        grads = tape.gradient(loss, self._variables)
+        norm = tf.linalg.global_norm(grads)
+        if self._clip:
+            grads, _ = tf.clip_by_global_norm(grads, self._clip, norm)
+        self._opt.apply_gradients(zip(grads, self._variables))
+        return norm
+
+
+def args_type(default):
+    if isinstance(default, bool):
+        return lambda x: bool(['False', 'True'].index(x))
+    if isinstance(default, int):
+        return lambda x: float(x) if ('e' in x or '.' in x) else int(x)
+    if isinstance(default, pathlib.Path):
+        return lambda x: pathlib.Path(x).expanduser()
+    return type(default)
+
+
+def static_scan(fn, inputs, start, reverse=False):
+    last = start
+    outputs = [[] for _ in tf.nest.flatten(start)]
+    indices = range(len(tf.nest.flatten(inputs)[0]))
+    if reverse:
+        indices = reversed(indices)
+    for index in indices:
+        inp = tf.nest.map_structure(lambda x: x[index], inputs)
+        last = fn(last, inp)
+        [o.append(l) for o, l in zip(outputs, tf.nest.flatten(last))]
+    if reverse:
+        outputs = [list(reversed(x)) for x in outputs]
+    outputs = [tf.stack(x, 0) for x in outputs]
+    return tf.nest.pack_sequence_as(start, outputs)
+
+
+def _mnd_sample(self, sample_shape=(), seed=None, name='sample'):
+    return tf.random.normal(
+        tuple(sample_shape) + tuple(self.event_shape),
+        self.mean(), self.stddev(), self.dtype, seed, name)
+
+
+tfd.MultivariateNormalDiag.sample = _mnd_sample

baselines/lompo/wrappers.py

@@ -0,0 +1,508 @@
+import atexit
+import functools
+import sys
+import traceback
+
+import gym
+import numpy as np
+
+
+class DrawerOpen:
+    def __init__(self, config, size=(128, 128)):
+        import metaworld
+        import mujoco_py
+        self._env = metaworld.envs.mujoco.sawyer_xyz.v2.sawyer_drawer_open_v2.SawyerDrawerOpenEnvV2()
+        self._env._last_rand_vec = np.array([-0.1, 0.9, 0.0])
+        self._env._set_task_called = True
+        self.size = size
+
+        # Setup camera in environment
+        self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
+        self.viewer.cam.elevation = -22.5
+        self.viewer.cam.azimuth = 15
+        self.viewer.cam.distance = 0.75
+        self.viewer.cam.lookat[0] = -0.15
+        self.viewer.cam.lookat[1] = 0.7
+        self.viewer.cam.lookat[2] = 0.10
+
+    def __getattr__(self, attr):
+        if attr == '_wrapped_env':
+            raise AttributeError()
+        return getattr(self._env, attr)
+
+    def step(self, action):
+        state, reward, done, info = self._env.step(action)
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        obs = {'state': state, 'image': img}
+        reward = 1.0 * info['success']
+        return obs, reward, done, info
+
+    def reset(self):
+        state = self._env.reset()
+        state = self._env.reset()
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        if self.use_transform:
+            img = img[self.pad:-self.pad, self.pad:-self.pad, :]
+        obs = {'state': state, 'image': img}
+        return obs
+
+    def render(self, mode, width=128, height=128):
+        self.viewer.render(width=width, height=width)
+        img = self.viewer.read_pixels(self.size[0], self.size[1], depth=False)
+        img = img[::-1]
+        return img
+
+
+class Hammer:
+    def __init__(self, config, size=(128, 128)):
+        import metaworld
+        import mujoco_py
+        self._env = metaworld.envs.mujoco.sawyer_xyz.v2.sawyer_hammer_v2.SawyerHammerEnvV2()
+        self._env._last_rand_vec = np.array([-0.06, 0.4, 0.02])
+        self._env._set_task_called = True
+        self.size = size
+
+        # Setup camera in environment
+        self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
+        self.viewer.cam.elevation = -15
+        self.viewer.cam.azimuth = 137.5
+        self.viewer.cam.distance = 0.9
+        self.viewer.cam.lookat[0] = -0.
+        self.viewer.cam.lookat[1] = 0.6
+        self.viewer.cam.lookat[2] = 0.175
+
+    def __getattr__(self, attr):
+        if attr == '_wrapped_env':
+            raise AttributeError()
+        return getattr(self._env, attr)
+
+    def step(self, action):
+        state, reward, done, info = self._env.step(action)
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        obs = {'state': state, 'image': img}
+        return obs, reward, done, info
+
+    def reset(self):
+        state = self._env.reset()
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        obs = {'state': state, 'image': img}
+        return obs
+
+    def render(self, mode, width=128, height=128):
+        self.viewer.render(width=width, height=width)
+        img = self.viewer.read_pixels(self.size[0], self.size[1], depth=False)
+        img = img[::-1]
+        return img
+
+
+class DoorOpen:
+    def __init__(self, config, size=(128, 128)):
+        import metaworld
+        import mujoco_py
+        self._env = metaworld.envs.mujoco.sawyer_xyz.v2.sawyer_door_v2.SawyerDoorEnvV2()
+        self._env._last_rand_vec = np.array([0.0, 1.0, .1525])
+        self._env._set_task_called = True
+        self.size = size
+
+        # Setup camera in environment
+        self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
+        self.viewer.cam.elevation = -12.5
+        self.viewer.cam.azimuth = 115
+        self.viewer.cam.distance = 1.05
+        self.viewer.cam.lookat[0] = 0.075
+        self.viewer.cam.lookat[1] = 0.75
+        self.viewer.cam.lookat[2] = 0.15
+
+    def __getattr__(self, attr):
+        if attr == '_wrapped_env':
+            raise AttributeError()
+        return getattr(self._env, attr)
+
+    def step(self, action):
+        state, reward, done, info = self._env.step(action)
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        obs = {'state': state, 'image': img}
+        reward = 1.0 * info['success']
+        return obs, reward, done, info
+
+    def reset(self):
+        state = self._env.reset()
+        img = self.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        obs = {'state': state, 'image': img}
+        return obs
+
+    def render(self, mode, width=128, height=128):
+        self.viewer.render(width=width, height=width)
+        img = self.viewer.read_pixels(self.size[0], self.size[1], depth=False)
+        img = img[::-1]
+        return img
+
+
+class Gym:
+    def __init__(self, name, config, size=(64, 64)):
+        self._env = gym.make(name)
+        self.size = size
+        self.use_transform = config.use_transform
+        self.pad = int(config.pad / 2)
+
+    def __getattr__(self, attr):
+        if attr == '_wrapped_env':
+            raise AttributeError()
+        return getattr(self._env, attr)
+
+    def step(self, action):
+        state, reward, done, info = self.env.step(action)
+        img = self._env.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        if self.use_transform:
+            img = img[self.pad:-self.pad, self.pad:-self.pad, :]
+        obs = {'state': state, 'image': img}
+        return obs, reward, done, info
+
+    def reset(self):
+        state = self._env.reset()
+        img = self._env.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+        if self.use_transform:
+            img = img[self.pad:-self.pad, self.pad:-self.pad, :]
+        obs = {'state': state, 'image': img}
+        return obs
+
+    def render(self, *args, **kwargs):
+        if kwargs.get('mode', 'rgb_array') != 'rgb_array':
+            raise ValueError("Only render mode 'rgb_array' is supported.")
+        return self._env.render(mode='rgb_array', width=self.size[0], height=self.size[1])
+
+
+class DeepMindControl:
+    def __init__(self, name, size=(64, 64), camera=None):
+        domain, task = name.split('_', 1)
+        if domain == 'cup':  # Only domain with multiple words.
+            domain = 'ball_in_cup'
+        if isinstance(domain, str):
+            from dm_control import suite
+            self._env = suite.load(domain, task)
+        else:
+            assert task is None
+            self._env = domain()
+        self._size = size
+        if camera is None:
+            camera = dict(quadruped=2).get(domain, 0)
+        self._camera = camera
+
+    @property
+    def observation_space(self):
+        spaces = {}
+        for key, value in self._env.observation_spec().items():
+            spaces[key] = gym.spaces.Box(-np.inf, np.inf, value.shape, dtype=np.float32)
+        spaces['image'] = gym.spaces.Box(0, 255, self._size + (3,), dtype=np.uint8)
+        return gym.spaces.Dict(spaces)
+
+    @property
+    def action_space(self):
+        spec = self._env.action_spec()
+        return gym.spaces.Box(spec.minimum, spec.maximum, dtype=np.float32)
+
+    def step(self, action):
+        time_step = self._env.step(action)
+        obs = dict(time_step.observation)
+        obs['image'] = self.render()
+        reward = time_step.reward or 0
+        done = time_step.last()
+        info = {'discount': np.array(time_step.discount, np.float32)}
+        return obs, reward, done, info
+
+    def reset(self):
+        time_step = self._env.reset()
+        obs = dict(time_step.observation)
+        obs['image'] = self.render()
+        return obs
+
+    def render(self, *args, **kwargs):
+        if kwargs.get('mode', 'rgb_array') != 'rgb_array':
+            raise ValueError("Only render mode 'rgb_array' is supported.")
+        return self._env.physics.render(*self._size, camera_id=self._camera)
+
+
+class Collect:
+    def __init__(self, env, callbacks=None, precision=32):
+        self._env = env
+        self._callbacks = callbacks or ()
+        self._precision = precision
+        self._episode = None
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        obs = {k: self._convert(v) for k, v in obs.items()}
+        transition = obs.copy()
+        transition['action'] = action
+        transition['reward'] = reward
+        transition['discount'] = info.get('discount', np.array(1 - float(done)))
+        self._episode.append(transition)
+        if done:
+            episode = {k: [t[k] for t in self._episode] for k in self._episode[0]}
+            episode = {k: self._convert(v) for k, v in episode.items()}
+            info['episode'] = episode
+            for callback in self._callbacks:
+                callback(episode)
+        return obs, reward, done, info
+
+    def reset(self):
+        obs = self._env.reset()
+        transition = obs.copy()
+        transition['action'] = np.zeros(self._env.action_space.shape)
+        transition['reward'] = 0.0
+        transition['discount'] = 1.0
+        self._episode = [transition]
+        return obs
+
+    def _convert(self, value):
+        value = np.array(value)
+        if np.issubdtype(value.dtype, np.floating):
+            dtype = {16: np.float16, 32: np.float32, 64: np.float64}[self._precision]
+        elif np.issubdtype(value.dtype, np.signedinteger):
+            dtype = {16: np.int16, 32: np.int32, 64: np.int64}[self._precision]
+        elif np.issubdtype(value.dtype, np.uint8):
+            dtype = np.uint8
+        else:
+            raise NotImplementedError(value.dtype)
+        return value.astype(dtype)
+
+
+class TimeLimit:
+    def __init__(self, env, duration):
+        self._env = env
+        self._duration = duration
+        self._step = None
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    def step(self, action):
+        assert self._step is not None, 'Must reset environment.'
+        obs, reward, done, info = self._env.step(action)
+        self._step += 1
+        if self._step >= self._duration:
+            done = True
+            if 'discount' not in info:
+                info['discount'] = np.array(1.0).astype(np.float32)
+            self._step = None
+        return obs, reward, done, info
+
+    def reset(self):
+        self._step = 0
+        return self._env.reset()
+
+
+class ActionRepeat:
+    def __init__(self, env, amount):
+        self._env = env
+        self._amount = amount
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    def step(self, action):
+        done = False
+        total_reward = 0
+        current_step = 0
+        while current_step < self._amount and not done:
+            obs, reward, done, info = self._env.step(action)
+            total_reward += reward
+            current_step += 1
+        return obs, total_reward, done, info
+
+
+class NormalizeActions:
+    def __init__(self, env):
+        self._env = env
+        self._mask = np.logical_and(np.isfinite(env.action_space.low),
+                                    np.isfinite(env.action_space.high))
+        self._low = np.where(self._mask, env.action_space.low, -1)
+        self._high = np.where(self._mask, env.action_space.high, 1)
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    @property
+    def action_space(self):
+        low = np.where(self._mask, -np.ones_like(self._low), self._low)
+        high = np.where(self._mask, np.ones_like(self._low), self._high)
+        return gym.spaces.Box(low, high, dtype=np.float32)
+
+    def step(self, action):
+        original = (action + 1) / 2 * (self._high - self._low) + self._low
+        original = np.where(self._mask, original, action)
+        return self._env.step(original)
+
+
+class ObsDict:
+    def __init__(self, env, key='obs'):
+        self._env = env
+        self._key = key
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    @property
+    def observation_space(self):
+        spaces = {self._key: self._env.observation_space}
+        return gym.spaces.Dict(spaces)
+
+    @property
+    def action_space(self):
+        return self._env.action_space
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        obs = {self._key: np.array(obs)}
+        return obs, reward, done, info
+
+    def reset(self):
+        obs = self._env.reset()
+        obs = {self._key: np.array(obs)}
+        return obs
+
+
+class RewardObs:
+    def __init__(self, env):
+        self._env = env
+
+    def __getattr__(self, name):
+        return getattr(self._env, name)
+
+    @property
+    def observation_space(self):
+        spaces = self._env.observation_space.spaces
+        assert 'reward' not in spaces
+        spaces['reward'] = gym.spaces.Box(-np.inf, np.inf, dtype=np.float32)
+        return gym.spaces.Dict(spaces)
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        obs['reward'] = reward
+        return obs, reward, done, info
+
+    def reset(self):
+        obs = self._env.reset()
+        obs['reward'] = 0.0
+        return obs
+
+
+class Async:
+    _ACCESS = 1
+    _CALL = 2
+    _RESULT = 3
+    _EXCEPTION = 4
+    _CLOSE = 5
+
+    def __init__(self, ctor, strategy='process'):
+        self._strategy = strategy
+        if strategy == 'none':
+            self._env = ctor()
+        elif strategy == 'thread':
+            import multiprocessing.dummy as mp
+        elif strategy == 'process':
+            import multiprocessing as mp
+        else:
+            raise NotImplementedError(strategy)
+        if strategy != 'none':
+            self._conn, conn = mp.Pipe()
+            self._process = mp.Process(target=self._worker, args=(ctor, conn))
+            atexit.register(self.close)
+            self._process.start()
+        self._obs_space = None
+        self._action_space = None
+
+    @property
+    def observation_space(self):
+        if not self._obs_space:
+            self._obs_space = self.__getattr__('observation_space')
+        return self._obs_space
+
+    @property
+    def action_space(self):
+        if not self._action_space:
+            self._action_space = self.__getattr__('action_space')
+        return self._action_space
+
+    def __getattr__(self, name):
+        if self._strategy == 'none':
+            return getattr(self._env, name)
+        self._conn.send((self._ACCESS, name))
+        return self._receive()
+
+    def call(self, name, *args, **kwargs):
+        blocking = kwargs.pop('blocking', True)
+        if self._strategy == 'none':
+            return functools.partial(getattr(self._env, name), *args, **kwargs)
+        payload = name, args, kwargs
+        self._conn.send((self._CALL, payload))
+        promise = self._receive
+        return promise() if blocking else promise
+
+    def close(self):
+        if self._strategy == 'none':
+            try:
+                self._env.close()
+            except AttributeError:
+                pass
+            return
+        try:
+            self._conn.send((self._CLOSE, None))
+            self._conn.close()
+        except IOError:
+            # The connection was already closed.
+            pass
+        self._process.join()
+
+    def step(self, action, blocking=True):
+        return self.call('step', action, blocking=blocking)
+
+    def reset(self, blocking=True):
+        return self.call('reset', blocking=blocking)
+
+    def _receive(self):
+        try:
+            message, payload = self._conn.recv()
+        except ConnectionResetError:
+            raise RuntimeError('Environment worker crashed.')
+        # Re-raise exceptions in the main process.
+        if message == self._EXCEPTION:
+            stacktrace = payload
+            raise Exception(stacktrace)
+        if message == self._RESULT:
+            return payload
+        raise KeyError(f'Received message of unexpected type {message}')
+
+    def _worker(self, ctor, conn):
+        try:
+            env = ctor()
+            while True:
+                try:
+                    # Only block for short times to have keyboard exceptions be raised.
+                    if not conn.poll(0.1):
+                        continue
+                    message, payload = conn.recv()
+                except (EOFError, KeyboardInterrupt):
+                    break
+                if message == self._ACCESS:
+                    name = payload
+                    result = getattr(env, name)
+                    conn.send((self._RESULT, result))
+                    continue
+                if message == self._CALL:
+                    name, args, kwargs = payload
+                    result = getattr(env, name)(*args, **kwargs)
+                    conn.send((self._RESULT, result))
+                    continue
+                if message == self._CLOSE:
+                    assert payload is None
+                    break
+                raise KeyError(f'Received message of unknown type {message}')
+        except Exception:
+            stacktrace = ''.join(traceback.format_exception(*sys.exc_info()))
+            print(f'Error in environment process: {stacktrace}')
+            conn.send((self._EXCEPTION, stacktrace))
+        conn.close()

conversion_scripts/hdf5_to_npz.py

@@ -0,0 +1,66 @@
+import datetime
+import io
+import pathlib
+import uuid
+import numpy as np
+import h5py
+import argparse
+
+
+def save_episode(directory, episode):
+    timestamp = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')
+    identifier = str(uuid.uuid4().hex)
+    length = len(episode['action'])
+    filename = directory / f'{timestamp}-{identifier}-{length}.npz'
+    with io.BytesIO() as f1:
+        np.savez_compressed(f1, **episode)
+        f1.seek(0)
+        with filename.open('wb') as f2:
+            f2.write(f1.read())
+    return filename
+
+
+def main():
+    # Include argument parser
+    parser = argparse.ArgumentParser(description='Convert hdf5 files to npz.')
+    parser.add_argument('--input_dir', type=str, required=True,
+                        help='Path to input files')
+    parser.add_argument('--output_dir', type=str, required=True,
+                        help='Path to output files')
+    args = parser.parse_args()
+
+    is_last = np.zeros(501, dtype=bool)
+    is_last[500] = True
+    is_first = np.zeros(501, dtype=bool)
+    is_first[0] = True
+    is_terminal = np.zeros(501, dtype=bool)
+
+    out_dir = pathlib.Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    filenames = sorted(pathlib.Path(args.input_dir).glob('*.hdf5'))
+    for filename in filenames:
+        with h5py.File(filename, "r") as f:
+            actions = f['action'][:]
+            observations = f['observation'][:]
+            rewards = f['reward'][:]
+            discounts = f['discount'][:]
+            while len(actions) > 0:
+                ep = {
+                    'image': observations[:501].transpose(0, 2, 3, 1),
+                    'action': actions[:501],
+                    'reward': rewards[:501],
+                    'discount': discounts[:501],
+                    'is_last': is_last,
+                    'is_first': is_first,
+                    'is_terminal': is_terminal,
+                }
+                actions = actions[501:]
+                observations = observations[501:]
+                rewards = rewards[501:]
+                discounts = discounts[501:]
+                save_episode(out_dir, ep)
+
+
+if __name__ == '__main__':
+    main()

conversion_scripts/npz_to_hdf5.py

@@ -0,0 +1,81 @@
+import pathlib
+import numpy as np
+import h5py
+import cv2
+import argparse
+
+
+def load_episodes(directory, capacity=None):
+    # The returned directory from filenames to episodes is guaranteed to be in
+    # temporally sorted order.
+    filenames = sorted(directory.glob('*.npz'))
+    if capacity:
+        num_steps = 0
+        num_episodes = 0
+        for filename in reversed(filenames):
+            length = int(str(filename).split('-')[-1][:-4])
+            num_steps += length
+            num_episodes += 1
+            if num_steps >= capacity:
+                break
+        filenames = filenames[-num_episodes:]
+    episodes = {}
+    for filename in filenames:
+        try:
+            with filename.open('rb') as f:
+                episode = np.load(f)
+                episode = {k: episode[k] for k in episode.keys()}
+                # Conversion for older versions of npz files.
+                if 'is_terminal' not in episode:
+                    episode['is_terminal'] = episode['discount'] == 0.
+        except Exception as e:
+            print(f'Could not load episode {str(filename)}: {e}')
+            continue
+        episodes[str(filename)] = episode
+    return episodes
+
+
+def main():
+    # Include argument parser
+    parser = argparse.ArgumentParser(description='Convert npz files to hdf5.')
+    parser.add_argument('--input_dir', type=str, required=True,
+                        help='Path to input files')
+    parser.add_argument('--output_dir', type=str, required=True,
+                        help='Path to output files')
+    args = parser.parse_args()
+
+    step_type = np.ones(501)
+    step_type[0] = 0
+    step_type[500] = 2
+
+    output = {}
+    episodes = load_episodes(pathlib.Path(args.input_dir))
+    episodes = list(episodes.values())
+
+    actions = [e['action'] for e in episodes]
+    discounts = [e['discount'] for e in episodes]
+    observations = []
+    for e in episodes:
+        resized_images = np.empty((501, 84, 84, 3), dtype=e['image'].dtype)
+        for (k, i) in enumerate(e['image']):
+            resized_images[k] = cv2.resize(i, dsize=(84, 84), interpolation=cv2.INTER_CUBIC)
+        observations.append(resized_images.transpose(0, 3, 1, 2))
+    rewards = [e['reward'] for e in episodes]
+    step_types = [step_type for _ in episodes]
+
+    output['action'] = np.concatenate(actions)
+    output['discount'] = np.concatenate(discounts)
+    output['observation'] = np.concatenate(observations)
+    output['reward'] = np.concatenate(rewards)
+    output['step_type'] = np.concatenate(step_types)
+
+    out_dir = pathlib.Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    with h5py.File(out_dir / 'data.hdf5', 'w') as shard_file:
+        for k, v in output.items():
+            shard_file.create_dataset(k, data=v, compression='gzip')
+
+
+if __name__ == '__main__':
+    main()

conversion_scripts/split_hdf5_shards.py

@@ -0,0 +1,40 @@
+import pathlib
+import numpy as np
+import h5py
+import argparse
+
+
+def main():
+    # Include argument parser
+    parser = argparse.ArgumentParser(description='Split hdf5 shards to smaller.')
+    parser.add_argument('--input_dir', type=str, required=True,
+                        help='Path to input files')
+    parser.add_argument('--output_dir', type=str, required=True,
+                        help='Path to output files')
+    parser.add_argument('--split_size', type=int, default=5)
+    args = parser.parse_args()
+
+    in_dir = pathlib.Path(args.input_dir)
+    out_dir = pathlib.Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    counter = 0
+    for filename in in_dir.glob('*.hdf5'):
+        print(filename)
+        with h5py.File(filename, "r") as episodes:
+            episodes = {k: episodes[k][:] for k in episodes.keys()}
+            print(episodes['action'].shape[0])
+
+            split_episodes = {k: np.array_split(v, args.split_size) for k, v in episodes.items()}
+            split_episodes = [{k: v[idx] for k, v in split_episodes.items()} for idx in range(args.split_size)]
+
+            for eps in split_episodes:
+                with h5py.File(out_dir / f'{counter}.hdf5', 'w') as shard_file:
+                    for k, v in eps.items():
+                        shard_file.create_dataset(k, data=v, compression='gzip')
+                print(counter)
+                counter += 1
+
+
+if __name__ == '__main__':
+    main()

dockerfiles/Dockerfile-drqv2

@@ -0,0 +1,74 @@
+# FROM MAIN DIR: docker build -t offline-drqv2 -f dockerfiles/Dockerfile-drqv2 .
+
+FROM nvidia/cuda:11.3.0-cudnn8-devel-ubuntu18.04
+MAINTAINER Anonymous
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+    vim wget unzip \
+    libosmesa6-dev libgl1-mesa-glx libgl1-mesa-dev patchelf libglfw3 build-essential
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+         tzdata \    
+         cmake \
+         git \
+         curl \
+         ca-certificates \
+         libjpeg-dev \
+         libpng-dev \
+         libglib2.0-0
+
+# ZOO PACKAGES
+RUN apt-get -y update \
+    && apt-get -y install \
+    ffmpeg \
+    freeglut3-dev \
+    swig \
+    xvfb \
+    libxrandr2 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# ATARI PACKAGES
+RUN apt-get -y update \
+    && apt-get -y install \
+    tmux \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    unrar \
+    zlib1g \
+    zlib1g-dev \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# mujoco
+RUN mkdir -p /.mujoco \
+    && wget https://mujoco.org/download/mujoco210-linux-x86_64.tar.gz -O mujoco.tar.gz \
+    && tar -xf mujoco.tar.gz -C /.mujoco \
+    && rm mujoco.tar.gz
+ENV MUJOCO_PY_MUJOCO_PATH /.mujoco/mujoco210
+ENV LD_LIBRARY_PATH /.mujoco/mujoco210/bin:${LD_LIBRARY_PATH}
+ENV LD_LIBRARY_PATH /usr/local/cuda/lib64:${LD_LIBRARY_PATH}
+ENV MJLIB_PATH /.mujoco/mujoco210/bin/libmujoco210.so
+
+RUN useradd -u <<USER_ID>> --create-home user
+USER user
+WORKDIR /home/user
+
+RUN wget -q https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
+    bash Miniconda3-latest-Linux-x86_64.sh -b -p miniconda3 && \
+    rm Miniconda3-latest-Linux-x86_64.sh
+ENV PATH /home/user/miniconda3/bin:$PATH
+
+RUN pip install --upgrade pip
+RUN pip install mujoco_py seaborn
+RUN conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
+RUN pip install absl-py 
+RUN pip install dm_control
+RUN pip install tb-nightly termcolor
+RUN pip install imageio imageio-ffmpeg hydra-core hydra-submitit-launcher pandas
+RUN pip install ipdb yapf sklearn matplotlib opencv-python
+
+WORKDIR /vd4rl

dockerfiles/Dockerfile-dv2

@@ -0,0 +1,58 @@
+# FROM MAIN DIR: docker build -t offline-dv2 -f dockerfiles/Dockerfile-dv2 .
+
+FROM tensorflow/tensorflow:2.6.0-gpu
+MAINTAINER Anonymous
+
+# System packages.
+RUN apt-get update && apt-get install -y \
+  ffmpeg \
+  libgl1-mesa-dev \
+  libosmesa6-dev \
+  python3-pip \
+  unrar \
+  wget \
+  && apt-get clean
+
+RUN apt-get update && apt-get install -y \
+  git \
+  && apt-get clean
+
+RUN useradd -u <<USER_ID>> --create-home user
+USER user
+WORKDIR /home/user
+
+RUN wget -q https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \
+    bash Miniconda3-latest-Linux-x86_64.sh -b -p miniconda3 && \
+    rm Miniconda3-latest-Linux-x86_64.sh
+ENV PATH /home/user/miniconda3/bin:$PATH
+
+# MuJoCo
+ENV MUJOCO_GL egl
+ENV MUJOCO_PY_MUJOCO_PATH /home/user/.mujoco/mujoco210
+RUN mkdir -p .mujoco \
+    && wget https://mujoco.org/download/mujoco210-linux-x86_64.tar.gz -O mujoco.tar.gz \
+    && tar -xf mujoco.tar.gz -C .mujoco \
+    && rm mujoco.tar.gz
+ENV LD_LIBRARY_PATH /home/user/.mujoco/mujoco210/bin:${LD_LIBRARY_PATH}
+
+# Python packages.
+RUN pip3 install --no-cache-dir 'gym[atari]'
+RUN pip3 install --no-cache-dir atari_py
+RUN pip3 install --no-cache-dir crafter
+RUN pip3 install --no-cache-dir dm_control
+RUN pip3 install --no-cache-dir ruamel.yaml
+RUN pip3 install --no-cache-dir tensorflow==2.6.0 tensorflow_probability==0.14.1 tensorflow-estimator==2.6.0 tensorboard==2.6.0 keras==2.6.0
+RUN pip3 install --no-cache-dir gym-minigrid sklearn
+
+# Atari ROMS.
+RUN wget -L -nv http://www.atarimania.com/roms/Roms.rar && \
+  unrar x Roms.rar && \
+  unzip ROMS.zip && \
+  python3 -m atari_py.import_roms ROMS && \
+  rm -rf Roms.rar ROMS.zip ROMS
+
+RUN pip3 install -U 'mujoco-py<2.2,>=2.1'
+RUN wget https://www.roboti.us/file/mjkey.txt -O /home/user/.mujoco/mjkey.txt
+RUN conda install patchelf
+
+WORKDIR /vd4rl

drqbc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

drqbc/bcagent.py

@@ -0,0 +1,105 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from drqv2 import Actor, Encoder, RandomShiftsAug
+import utils
+
+
+class BCAgent:
+    def __init__(self, obs_shape, action_shape, device, lr, feature_dim,
+                 hidden_dim, critic_target_tau, num_expl_steps,
+                 update_every_steps, stddev_schedule, stddev_clip, use_tb,
+                 augmentation=RandomShiftsAug(pad=4)):
+        self.device = device
+        self.critic_target_tau = critic_target_tau
+        self.update_every_steps = update_every_steps
+        self.use_tb = use_tb
+        self.num_expl_steps = num_expl_steps
+        self.stddev_schedule = stddev_schedule
+        self.stddev_clip = stddev_clip
+
+        # models
+        self.encoder = Encoder(obs_shape).to(device)
+        self.actor = Actor(self.encoder.repr_dim, action_shape, feature_dim,
+                           hidden_dim).to(device)
+
+        # optimizers
+        self.encoder_opt = torch.optim.Adam(self.encoder.parameters(), lr=lr)
+        self.actor_opt = torch.optim.Adam(self.actor.parameters(), lr=lr)
+
+        # data augmentation
+        self.aug = augmentation
+
+        self.train()
+
+    def train(self, training=True):
+        self.training = training
+        self.encoder.train(training)
+        self.actor.train(training)
+
+    def act(self, obs, step, eval_mode):
+        obs = torch.as_tensor(obs, device=self.device)
+        obs = self.encoder(obs.unsqueeze(0))
+        stddev = utils.schedule(self.stddev_schedule, step)
+        dist = self.actor(obs, stddev)
+        if eval_mode:
+            action = dist.mean
+        else:
+            action = dist.sample(clip=None)
+            if step < self.num_expl_steps:
+                action.uniform_(-1.0, 1.0)
+        return action.cpu().numpy()[0]
+
+    def update_actor(self, obs, step, behavioural_action=None):
+        metrics = dict()
+
+        stddev = utils.schedule(self.stddev_schedule, step)
+        dist = self.actor(obs, stddev)
+        action = dist.sample(clip=self.stddev_clip)
+        log_prob = dist.log_prob(action).sum(-1, keepdim=True)
+
+        # offline BC Loss
+        actor_loss = F.mse_loss(action, behavioural_action)
+
+        # optimize actor and encoder
+        self.encoder_opt.zero_grad(set_to_none=True)
+        self.actor_opt.zero_grad(set_to_none=True)
+        actor_loss.backward()
+        self.actor_opt.step()
+        self.encoder_opt.step()
+
+        if self.use_tb:
+            metrics['actor_logprob'] = log_prob.mean().item()
+            metrics['actor_ent'] = dist.entropy().sum(dim=-1).mean().item()
+            metrics['actor_bc_loss'] = actor_loss.item()
+
+        return metrics
+
+    def update(self, replay_buffer, step):
+        metrics = dict()
+
+        if step % self.update_every_steps != 0:
+            return metrics
+
+        batch = next(replay_buffer)
+        obs, action, reward, _, _ = utils.to_torch(
+            batch, self.device)
+
+        # augment
+        obs = self.aug(obs.float())
+        # encode
+        obs = self.encoder(obs)
+
+        if self.use_tb:
+            metrics['batch_reward'] = reward.mean().item()
+
+        # update actor
+        metrics.update(self.update_actor(obs, step, action.detach()))
+
+        return metrics

drqbc/cfgs/algo/bc.yaml

@@ -0,0 +1,20 @@
+defaults:
+  - _self_
+
+# experiment
+experiment: bc
+
+agent:
+  _target_: bcagent.BCAgent
+  obs_shape: ??? # to be specified later
+  action_shape: ??? # to be specified later
+  device: ${device}
+  lr: ${lr}
+  critic_target_tau: 0.01
+  update_every_steps: 2
+  use_tb: ${use_tb}
+  num_expl_steps: 2000
+  hidden_dim: 1024
+  feature_dim: ${feature_dim}
+  stddev_schedule: ${stddev_schedule}
+  stddev_clip: 0.3

drqbc/cfgs/algo/cql.yaml

@@ -0,0 +1,27 @@
+defaults:
+  - _self_
+
+# experiment
+experiment: cql
+
+agent:
+  _target_: cql.CQLAgent
+  obs_shape: ??? # to be specified later
+  action_shape: ??? # to be specified later
+  device: ${device}
+  lr: ${lr}
+  critic_target_tau: 0.01
+  update_every_steps: 2
+  use_tb: ${use_tb}
+  num_expl_steps: 2000
+  hidden_dim: 1024
+  feature_dim: ${feature_dim}
+  stddev_schedule: ${stddev_schedule}
+  stddev_clip: 0.3
+  offline: ${offline}
+  cql_importance_sample: ${cql_importance_sample}
+  temp: ${temp}
+  min_q_weight: ${min_q_weight}
+  num_random: ${num_random}
+  with_lagrange: ${with_lagrange}
+  lagrange_thresh: ${lagrange_thresh}

drqbc/cfgs/algo/drqv2.yaml

@@ -0,0 +1,23 @@
+defaults:
+  - _self_
+
+# experiment
+experiment: drqv2
+
+agent:
+  _target_: drqv2.DrQV2Agent
+  obs_shape: ??? # to be specified later
+  action_shape: ??? # to be specified later
+  device: ${device}
+  lr: ${lr}
+  critic_target_tau: 0.01
+  update_every_steps: 2
+  use_tb: ${use_tb}
+  num_expl_steps: 2000
+  hidden_dim: 1024
+  feature_dim: ${feature_dim}
+  stddev_schedule: ${stddev_schedule}
+  stddev_clip: 0.3
+  offline: ${offline}
+  bc_weight: ${bc_weight}
+  use_bc: ${use_bc}

drqbc/cfgs/algo/noaug_bc.yaml

@@ -0,0 +1,10 @@
+defaults:
+  - bc
+  - _self_
+  
+# experiment
+experiment: noaug_bc
+
+agent:
+  augmentation:
+    _target_: drqv2.NoShiftAug

drqbc/cfgs/algo/noaug_drqv2.yaml

@@ -0,0 +1,10 @@
+defaults:
+  - drqv2
+  - _self_
+
+# experiment
+experiment: noaug_drqv2
+
+agent:
+  augmentation:
+    _target_: drqv2.NoShiftAug

drqbc/cfgs/config.yaml

@@ -0,0 +1,63 @@
+defaults:
+  - _self_
+  - task@_global_: offline_dmc
+  - algo@_global_: drqv2
+  - override hydra/launcher: submitit_local
+
+# task settings
+frame_stack: 3
+action_repeat: 2
+discount: 0.99
+distracting_mode: null
+# train settings
+num_seed_frames: 4000
+# eval
+eval_every_frames: 10000
+num_eval_episodes: 10
+eval_on_distracting: False
+eval_on_multitask: False
+eval_save_vid_every_step: 100000
+# snapshot
+save_snapshot: False
+# replay buffer
+replay_buffer_size: 1_000_000
+replay_buffer_num_workers: 1
+nstep: 3
+batch_size: 256
+# misc
+seed: 1
+device: cuda
+save_video: True
+save_train_video: False
+use_tb: True
+# experiment
+experiment: exp
+# agent
+lr: 1e-4
+feature_dim: 50
+# offline
+offline: False
+bc_weight: 2.5
+use_bc: True
+# cql
+cql_importance_sample: False
+temp: 1.0
+min_q_weight: 1.0
+num_random: 10
+with_lagrange: False
+lagrange_thresh: 0.0
+
+hydra:
+  run:
+     dir: drqv2_data/${experiment}/${task_name}/${now:%Y.%m.%d}/${now:%H%M%S}`
+  sweep:
+    dir: ./exp/${now:%Y.%m.%d}/${now:%H%M}_${agent_cfg.experiment}
+    subdir: ${hydra.job.num}
+  launcher:
+    timeout_min: 4300
+    cpus_per_task: 10
+    gpus_per_node: 1
+    tasks_per_node: 1
+    mem_gb: 160
+    nodes: 1
+    submitit_folder: ./exp/${now:%Y.%m.%d}/${now:%H%M%S}_${agent_cfg.experiment}/.slurm

drqbc/cfgs/task/offline_dmc.yaml

@@ -0,0 +1,12 @@
+defaults:
+  - _self_
+
+num_train_frames: 1100000
+stddev_schedule: 'linear(1.0,0.1,250000)'
+nstep: 1
+show_train_stats_every_frames: 2000
+lr: 3e-4
+replay_buffer_size: 1_000_000
+offline: True
+task_name: offline_walker_walk_random
+offline_dir: ...

drqbc/cfgs/task/online/acrobot_swingup.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: acrobot_swingup

drqbc/cfgs/task/online/cartpole_balance.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: cartpole_balance

drqbc/cfgs/task/online/cartpole_balance_sparse.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: cartpole_balance_sparse

drqbc/cfgs/task/online/cartpole_swingup.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: cartpole_swingup

drqbc/cfgs/task/online/cartpole_swingup_sparse.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: cartpole_swingup_sparse

drqbc/cfgs/task/online/cheetah_run.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: cheetah_run

drqbc/cfgs/task/online/cup_catch.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: cup_catch

drqbc/cfgs/task/online/easy.yaml

@@ -0,0 +1,2 @@
+num_train_frames: 1100000
+stddev_schedule: 'linear(1.0,0.1,100000)'

drqbc/cfgs/task/online/finger_spin.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: finger_spin

drqbc/cfgs/task/online/finger_turn_easy.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: finger_turn_easy

drqbc/cfgs/task/online/finger_turn_hard.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: finger_turn_hard

drqbc/cfgs/task/online/hard.yaml

@@ -0,0 +1,2 @@
+num_train_frames: 30100000
+stddev_schedule: 'linear(1.0,0.1,2000000)'

drqbc/cfgs/task/online/hopper_hop.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: hopper_hop

drqbc/cfgs/task/online/hopper_stand.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: hopper_stand

drqbc/cfgs/task/online/humanoid_run.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - hard
+  - _self_
+
+task_name: humanoid_run
+lr: 8e-5
+feature_dim: 100

drqbc/cfgs/task/online/humanoid_stand.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - hard
+  - _self_
+
+task_name: humanoid_stand
+lr: 8e-5
+feature_dim: 100

drqbc/cfgs/task/online/humanoid_walk.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - hard
+  - _self_
+
+task_name: humanoid_walk
+lr: 8e-5
+feature_dim: 100

drqbc/cfgs/task/online/medium.yaml

@@ -0,0 +1,2 @@
+num_train_frames: 3100000
+stddev_schedule: 'linear(1.0,0.1,500000)'

drqbc/cfgs/task/online/pendulum_swingup.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: pendulum_swingup

drqbc/cfgs/task/online/quadruped_run.yaml

@@ -0,0 +1,6 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: quadruped_run
+replay_buffer_size: 100000

drqbc/cfgs/task/online/quadruped_walk.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: quadruped_walk

drqbc/cfgs/task/online/reach_duplo.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: reach_duplo

drqbc/cfgs/task/online/reacher_easy.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: reacher_easy

drqbc/cfgs/task/online/reacher_hard.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: reacher_hard

drqbc/cfgs/task/online/walker_run.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - medium
+  - _self_
+
+task_name: walker_run
+nstep: 1
+batch_size: 512

drqbc/cfgs/task/online/walker_stand.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: walker_stand
+nstep: 1
+batch_size: 512

drqbc/cfgs/task/online/walker_walk.yaml

@@ -0,0 +1,7 @@
+defaults:
+  - easy
+  - _self_
+
+task_name: walker_walk
+nstep: 1
+batch_size: 512

drqbc/conda_env.yml

@@ -0,0 +1,245 @@
+name: drqv2
+channels:
+  - pytorch
+  - nvidia
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1
+  - _openmp_mutex=4.5
+  - absl-py=0.13.0
+  - anyio=2.2.0
+  - argon2-cffi=20.1.0
+  - async_generator=1.10
+  - attrs=21.2.0
+  - babel=2.9.1
+  - backcall=0.2.0
+  - blas=1.0
+  - bleach=4.1.0
+  - blosc=1.21.0
+  - brotli=1.0.9
+  - brotlipy=0.7.0
+  - brunsli=0.1
+  - bzip2=1.0.8
+  - c-ares=1.18.1
+  - ca-certificates=2021.10.26
+  - certifi=2021.10.8
+  - cffi=1.14.6
+  - cfitsio=3.470
+  - charls=2.2.0
+  - charset-normalizer=2.0.4
+  - cloudpickle=2.0.0
+  - cryptography=36.0.0
+  - cudatoolkit=11.1.74
+  - cycler=0.11.0
+  - cytoolz=0.11.0
+  - dask-core=2021.10.0
+  - debugpy=1.5.1
+  - defusedxml=0.7.1
+  - entrypoints=0.3
+  - ffmpeg=4.2.2
+  - fonttools=4.25.0
+  - freetype=2.11.0
+  - fsspec=2021.10.1
+  - giflib=5.2.1
+  - gmp=6.2.1
+  - gnutls=3.6.15
+  - idna=3.3
+  - imagecodecs=2021.8.26
+  - imageio=2.9.0
+  - importlib-metadata=4.8.2
+  - importlib_metadata=4.8.2
+  - intel-openmp=2021.4.0
+  - ipykernel=6.4.1
+  - ipython=7.29.0
+  - ipython_genutils=0.2.0
+  - jedi=0.18.0
+  - jinja2=3.0.2
+  - jpeg=9d
+  - json5=0.9.6
+  - jsonschema=3.2.0
+  - jupyter-packaging=0.7.12
+  - jupyter_client=7.1.0
+  - jupyter_core=4.9.1
+  - jupyter_server=1.4.1
+  - jupyterlab=3.0.14
+  - jupyterlab_pygments=0.1.2
+  - jupyterlab_server=2.10.2
+  - jxrlib=1.1
+  - kiwisolver=1.3.1
+  - krb5=1.19.2
+  - lame=3.100
+  - lcms2=2.12
+  - ld_impl_linux-64=2.35.1
+  - lerc=3.0
+  - libaec=1.0.4
+  - libcurl=7.80.0
+  - libdeflate=1.8
+  - libedit=3.1.20210910
+  - libev=4.33
+  - libffi=3.3
+  - libgcc-ng=9.3.0
+  - libgfortran-ng=7.5.0
+  - libgfortran4=7.5.0
+  - libgomp=9.3.0
+  - libidn2=2.3.2
+  - libnghttp2=1.46.0
+  - libopus=1.3.1
+  - libpng=1.6.37
+  - libsodium=1.0.18
+  - libssh2=1.9.0
+  - libstdcxx-ng=9.3.0
+  - libtasn1=4.16.0
+  - libtiff=4.2.0
+  - libunistring=0.9.10
+  - libuv=1.40.0
+  - libvpx=1.7.0
+  - libwebp=1.2.0
+  - libwebp-base=1.2.0
+  - libzopfli=1.0.3
+  - locket=0.2.1
+  - lz4-c=1.9.3
+  - markupsafe=2.0.1
+  - matplotlib-inline=0.1.2
+  - mistune=0.8.4
+  - mkl=2020.2
+  - mkl-service=2.3.0
+  - mkl_fft=1.3.0
+  - mkl_random=1.1.1
+  - munkres=1.1.4
+  - nbclassic=0.2.6
+  - nbclient=0.5.3
+  - nbconvert=6.3.0
+  - nbformat=5.1.3
+  - ncurses=6.3
+  - nest-asyncio=1.5.1
+  - nettle=3.7.3
+  - networkx=2.6.3
+  - notebook=6.4.6
+  - numpy=1.19.2
+  - numpy-base=1.19.2
+  - olefile=0.46
+  - openh264=2.1.1
+  - openjpeg=2.4.0
+  - openssl=1.1.1m
+  - packaging=21.3
+  - pandocfilters=1.4.3
+  - parso=0.8.3
+  - partd=1.2.0
+  - pexpect=4.8.0
+  - pickleshare=0.7.5
+  - pillow=8.4.0
+  - pip=21.1.3
+  - prometheus_client=0.12.0
+  - prompt-toolkit=3.0.20
+  - ptyprocess=0.7.0
+  - pycparser=2.21
+  - pygments=2.10.0
+  - pyopenssl=21.0.0
+  - pyparsing=2.4.7
+  - pyrsistent=0.18.0
+  - pysocks=1.7.1
+  - python=3.8.12
+  - python-dateutil=2.8.2
+  - pytorch=1.10.1
+  - pytorch-mutex=1.0
+  - pytz=2021.3
+  - pywavelets=1.1.1
+  - pyyaml=6.0
+  - pyzmq=22.3.0
+  - readline=8.1.2
+  - requests=2.27.1
+  - scikit-image=0.18.1
+  - scipy=1.6.2
+  - send2trash=1.8.0
+  - setuptools=58.0.4
+  - six=1.16.0
+  - snappy=1.1.8
+  - sniffio=1.2.0
+  - sqlite=3.37.0
+  - terminado=0.9.4
+  - testpath=0.5.0
+  - tifffile=2021.7.2
+  - tk=8.6.11
+  - toolz=0.11.2
+  - torchaudio=0.10.1
+  - torchvision=0.11.2
+  - tornado=6.1
+  - traitlets=5.1.1
+  - typing_extensions=3.10.0.2
+  - urllib3=1.26.7
+  - wcwidth=0.2.5
+  - webencodings=0.5.1
+  - wheel=0.37.1
+  - x264=1!157.20191217
+  - xz=5.2.5
+  - yaml=0.2.5
+  - zeromq=4.3.4
+  - zfp=0.5.5
+  - zipp=3.7.0
+  - zlib=1.2.11
+  - zstd=1.4.9
+  - pip:
+    - antlr4-python3-runtime==4.8
+    - astunparse==1.6.3
+    - cachetools==4.2.4
+    - cython==0.29.26
+    - decorator==4.4.2
+    - dm-control==0.0.403778684
+    - dm-env==1.5
+    - dm-tree==0.1.6
+    - dmc2gym==1.0.0
+    - fasteners==0.16.3
+    - flatbuffers==2.0
+    - future==0.18.2
+    - gast==0.4.0
+    - glfw==2.5.0
+    - google-auth==2.3.3
+    - google-auth-oauthlib==0.4.6
+    - google-pasta==0.2.0
+    - grpcio==1.43.0
+    - gym==0.21.0
+    - h5py==3.6.0
+    - hydra-core==1.1.0
+    - hydra-submitit-launcher==1.1.5
+    - imageio-ffmpeg==0.4.4
+    - importlib-resources==5.4.0
+    - ipdb==0.13.9
+    - joblib==1.1.0
+    - keras==2.7.0
+    - keras-preprocessing==1.1.2
+    - labmaze==1.0.5
+    - libclang==12.0.0
+    - lxml==4.7.1
+    - markdown==3.3.6
+    - matplotlib==3.4.2
+    - moviepy==1.0.3
+    - mujoco-py==2.1.2.14
+    - oauthlib==3.1.1
+    - omegaconf==2.1.1
+    - opencv-python==4.5.3.56
+    - opt-einsum==3.3.0
+    - pandas==1.3.0
+    - proglog==0.1.9
+    - protobuf==3.19.3
+    - pyasn1==0.4.8
+    - pyasn1-modules==0.2.8
+    - pyopengl==3.1.5
+    - requests-oauthlib==1.3.0
+    - rsa==4.8
+    - scikit-learn==1.0.2
+    - sklearn==0.0
+    - submitit==1.4.1
+    - tb-nightly==2.8.0a20220114
+    - tensorboard==2.7.0
+    - tensorboard-data-server==0.6.1
+    - tensorboard-plugin-wit==1.8.1
+    - tensorflow==2.7.0
+    - tensorflow-estimator==2.7.0
+    - tensorflow-io-gcs-filesystem==0.23.1
+    - termcolor==1.1.0
+    - threadpoolctl==3.0.0
+    - toml==0.10.2
+    - tqdm==4.62.3
+    - werkzeug==2.0.2
+    - wrapt==1.13.3
+    - yapf==0.31.0