sac/replay_buffer.py

# coding=utf-8
# Copyright 2024 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Lightweight in-memory replay buffer. From XIRL by Zakka et al. [1]

Adapted from https://github.com/ikostrikov/jaxrl.
[1]: https://github.com/google-research/google-research/tree/master/xirl
"""

import abc
import collections
from typing import Optional, Tuple

import cv2
import numpy as np
import torch
# from xirl.models import SelfSupervisedModel

Batch = collections.namedtuple(
    "Batch", ["obses", "actions", "rewards", "next_obses", "masks", "subgoals"]
)
TensorType = torch.Tensor
# ModelType = SelfSupervisedModel


class ReplayBuffer:
  """Buffer to store environment transitions."""

  def __init__(
      self,
      obs_shape,
      action_shape,
      capacity,
      device,
  ):
    """Constructor.

    Args:
      obs_shape: The dimensions of the observation space.
      action_shape: The dimensions of the action space
      capacity: The maximum length of the replay buffer.
      device: The torch device wherein to return sampled transitions.
    """
    self.capacity = capacity
    self.device = device

    obs_dtype = np.float32 if len(obs_shape) == 1 else np.uint8
    self.obses = self._empty_arr(obs_shape, obs_dtype)
    self.next_obses = self._empty_arr(obs_shape, obs_dtype)
    self.actions = self._empty_arr(action_shape, np.float32)
    print("In replay buffer, action shape is", action_shape)
    self.rewards = self._empty_arr((1,), np.float32)
    self.masks = self._empty_arr((1,), np.float32)
    self.subgoals = self._empty_arr((256,), np.float32)

    self.idx = 0
    self.size = 0

  def _empty_arr(self, shape, dtype):
    """Creates an empty array of specified shape and type."""
    return np.empty((self.capacity, *shape), dtype=dtype)

  def _to_tensor(self, arr):
    """Convert an ndarray to a torch Tensor and move it to the device."""
    return torch.as_tensor(arr, device=self.device, dtype=torch.float32)

  def insert(
      self,
      obs,
      action,
      reward,
      next_obs,
      mask,
      subgoal,
  ):
    """Insert an episode transition into the buffer."""
    np.copyto(self.obses[self.idx], obs)
    np.copyto(self.actions[self.idx], action)
    np.copyto(self.rewards[self.idx], reward)
    np.copyto(self.next_obses[self.idx], next_obs)
    np.copyto(self.masks[self.idx], mask)
    np.copyto(self.subgoals[self.idx], subgoal)

    self.idx = (self.idx + 1) % self.capacity
    self.size = min(self.size + 1, self.capacity)

  def sample(self, batch_size):
    """Sample an episode transition from the buffer."""
    idxs = np.random.randint(low=0, high=self.size, size=(batch_size,))

    return Batch(
        obses=self._to_tensor(self.obses[idxs]),
        actions=self._to_tensor(self.actions[idxs]),
        rewards=self._to_tensor(self.rewards[idxs]),
        next_obses=self._to_tensor(self.next_obses[idxs]),
        masks=self._to_tensor(self.masks[idxs]),
        subgoals=self._to_tensor(self.subgoals[idxs]),
    )

  def __len__(self):
    return self.size


class ReplayBufferLearnedReward(abc.ABC, ReplayBuffer):
  """Buffer that replaces the environment reward with a learned one.

  Subclasses should implement the `_get_reward_from_image` method.
  """

  def __init__(
      self,
      model,
      res_hw = None,
      batch_size = 64,
      **base_kwargs,
  ):
    """Constructor.

    Args:
      model: A model that ingests RGB frames and returns embeddings. Should be a
        subclass of `xirl.models.SelfSupervisedModel`.
      res_hw: Optional (H, W) to resize the environment image before feeding it
        to the model.
      batch_size: How many samples to forward through the model to compute the
        learned reward. Controls the size of the staging lists.
      **base_kwargs: Base keyword arguments.
    """
    super().__init__(**base_kwargs)

    self.model = model
    self.res_hw = res_hw
    self.batch_size = batch_size

    self._reset_staging()

  def _reset_staging(self):
    self.obses_staging = []
    self.next_obses_staging = []
    self.actions_staging = []
    self.rewards_staging = []
    self.masks_staging = []
    self.pixels_staging = []
    self.subgoal_emb_staging = []

  def _pixel_to_tensor(self, arr):
    arr = torch.from_numpy(arr).permute(2, 0, 1).float()[None, None, Ellipsis]
    arr = arr / 255.0
    arr = arr.to(self.device)
    return arr

  @abc.abstractmethod
  def _get_reward_from_image(self):
    """Forward the pixels through the model and compute the reward."""

  def insert(
      self,
      obs,
      action,
      reward,
      next_obs,
      mask,
      pixels,
      subgoal_emb,
  ):
    if len(self.obses_staging) < self.batch_size:
      self.obses_staging.append(obs)
      self.next_obses_staging.append(next_obs)
      self.actions_staging.append(action)
      self.rewards_staging.append(reward)
      self.masks_staging.append(mask)
      if self.res_hw is not None:
        h, w = self.res_hw
        pixels = cv2.resize(pixels, dsize=(w, h), interpolation=cv2.INTER_CUBIC)
      self.pixels_staging.append(pixels)
      self.subgoal_emb_staging.append(subgoal_emb)
    else:
      for obs_s, action_s, reward_s, next_obs_s, mask_s, subgoal_s, reward_env in zip(
          self.obses_staging,
          self.actions_staging,
          self._get_reward_from_image(),
          self.next_obses_staging,
          self.masks_staging,
          self.subgoal_emb_staging, 
          self.rewards_staging,
      ):
        super().insert(obs_s, action_s, reward_env, next_obs_s, mask_s, subgoal_s)
      self._reset_staging()


class ReplayBufferDistanceToGoal(ReplayBufferLearnedReward):
  """Replace the environment reward with distances in embedding space."""

  def __init__(
      self,
      goal_emb,
      scale_factors, 
      distance_scale = 1.0,
      **base_kwargs,
  ):
    super().__init__(**base_kwargs)

    self.goal_emb = goal_emb[-1]
    self.scale_factors = scale_factors
    self.distance_scale = distance_scale

    print("Using distance to goal reward.")

  def _get_reward_from_image(self):
    image_tensors = [self._pixel_to_tensor(i) for i in self.pixels_staging]
    image_tensors = torch.cat(image_tensors, dim=1)
    embs = self.model.infer(image_tensors, ["assembly"]*len(self.obses_staging)).numpy().embs # TODO automate env name 
    # subgoal_embs = np.stack(self.obses_staging, axis=0)[:, -embs.shape[1]:]
    subgoal_embs = np.array(self.subgoal_emb_staging)

    embs_norm = embs / (np.linalg.norm(embs, axis=-1, keepdims=True) + 1e-8)
    goals_norm = subgoal_embs / (np.linalg.norm(subgoal_embs, axis=-1, keepdims=True) + 1e-8)
    dists = -1.0 * np.linalg.norm(embs_norm - goals_norm, axis=-1)
    return dists

  # def _get_reward_from_image_for_evaluation(self, image_from_evaluation, goal_per_step):
  #   image_tensors = [self._pixel_to_tensor(i) for i in image_from_evaluation]
  #   image_tensors = torch.cat(image_tensors, dim=1)
  #   embs = self.model.infer(image_tensors, ["assembly"]*len(self.obses_staging)).numpy().embs # TODO automate env name 
  #   subgoal_embs = np.array(goal_per_step)[:,:]
  #   dists = -1.0 * np.linalg.norm(embs - subgoal_embs, axis=-1)
  #   print(dists.min(), dists.max(), np.sum(dists > -0.16))
  #   return dists


class ReplayBufferGoalClassifier(ReplayBufferLearnedReward):
  """Replace the environment reward with the output of a goal classifier."""

  def _get_reward_from_image(self):
    print("Using goal classifier reward.")
    image_tensors = [self._pixel_to_tensor(i) for i in self.pixels_staging]
    image_tensors = torch.cat(image_tensors, dim=1)
    prob = torch.sigmoid(self.model.infer(image_tensors).embs)
    return prob.item()