baselines/lompo/buffer.py

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