gpudrive-main/gpudrive/integrations/sb3/rollout_buffer.py

"""Module containing regularized PPO algorithm."""
import logging
from typing import Generator, Optional
import gymnasium as gym
import numpy as np
import torch
from typing import Union, NamedTuple
from stable_baselines3.common.vec_env import VecNormalize
from stable_baselines3.common.buffers import BaseBuffer

logging.getLogger(__name__)


class RolloutBufferSamples(NamedTuple):
    observations: torch.Tensor
    actions: torch.Tensor
    old_values: torch.Tensor
    old_log_prob: torch.Tensor
    advantages: torch.Tensor
    returns: torch.Tensor


class MaskedRolloutBuffer(BaseBuffer):
    """Custom SB3 RolloutBuffer class that filters out invalid samples."""

    def __init__(
        self,
        buffer_size: int,
        observation_space: gym.spaces.Space,
        action_space: gym.spaces.Space,
        device: Union[torch.device, str] = "auto",
        storage_device: Union[torch.device, str] = "cpu",
        gae_lambda: float = 1,
        gamma: float = 0.99,
        n_envs: int = 1,
    ):
        super().__init__(
            buffer_size, observation_space, action_space, device, n_envs=n_envs
        )
        self.gae_lambda = gae_lambda
        self.gamma = gamma
        self.generator_ready = False
        self.storage_device = storage_device
        self.reset()

    def reset(self) -> None:
        """Reset the buffer."""
        self.observations = torch.zeros(
            (self.buffer_size, self.n_envs, *self.obs_shape),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.actions = torch.zeros(
            (self.buffer_size, self.n_envs, self.action_dim),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.rewards = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.returns = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.episode_starts = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.values = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.log_probs = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.advantages = torch.zeros(
            (self.buffer_size, self.n_envs),
            device=self.storage_device,
            dtype=torch.float32,
        )
        self.generator_ready = False
        super().reset()

    def add(
        self,
        obs: torch.Tensor,
        action: torch.Tensor,
        reward: torch.Tensor,
        episode_start: torch.Tensor,
        value: torch.Tensor,
        log_prob: torch.Tensor,
    ) -> None:
        """
        EDIT: We do rollouts on the GPU --> convert torch arrays to torch tensors
        """
        if len(log_prob.shape) == 0:
            # Reshape 0-d tensor to avoid error
            log_prob = log_prob.reshape(-1, 1)

        # Reshape needed when using multiple envs with discrete observations
        # as numpy cannot broadcast (n_discrete,) to (n_discrete, 1)
        if isinstance(self.observation_space, gym.spaces.Discrete):
            obs = obs.reshape((self.n_envs, *self.obs_shape))

        # Reshape to handle multi-dim and discrete action spaces, see GH #970 #1392
        action = action.reshape((self.n_envs, self.action_dim))

        self.observations[self.pos] = obs.to(self.storage_device)
        self.actions[self.pos] = action.to(self.storage_device)
        self.rewards[self.pos] = reward.to(self.storage_device)
        self.episode_starts[self.pos] = episode_start.to(self.storage_device)
        self.values[self.pos] = value.flatten().to(self.storage_device)
        self.log_probs[self.pos] = log_prob.clone().to(self.storage_device)
        self.pos += 1
        if self.pos == self.buffer_size:
            self.full = True

    def compute_returns_and_advantage(
        self, last_values: torch.Tensor, dones: torch.Tensor
    ) -> None:
        """GAE (General Advantage Estimation) to compute advantages and returns."""
        # Convert to numpy
        last_values = last_values.clone().flatten().to(self.storage_device)
        dones = dones.clone().flatten().to(self.storage_device)

        last_gae_lam = 0
        for step in reversed(range(self.buffer_size)):
            if step == self.buffer_size - 1:
                # EDIT_1: Map NaNs to 1
                dones = torch.nan_to_num(dones, nan=1.0)

                next_non_terminal = 1.0 - dones
                next_values = last_values

            else:
                # EDIT_1: Map NaNs to 1
                episode_starts = torch.nan_to_num(
                    self.episode_starts[step + 1], nan=1.0
                )

                next_non_terminal = 1.0 - episode_starts
                next_values = self.values[step + 1]

            delta = (
                torch.nan_to_num(
                    self.rewards[step], nan=0
                )  # EDIT_2: Set invalid rewards to zero
                + torch.nan_to_num(
                    self.gamma * next_values * next_non_terminal, nan=0
                )  # EDIT_3: Set invalid rewards to zero
                - torch.nan_to_num(
                    self.values[step], nan=0
                )  # EDIT_4: Set invalid values to zero
            )

            last_gae_lam = (
                delta
                + self.gamma
                * self.gae_lambda
                * next_non_terminal
                * last_gae_lam
            )
            self.advantages[step] = last_gae_lam
        # TD(lambda) estimator, see Github PR #375 or "Telescoping in TD(lambda)"
        # in David Silver Lecture 4: https://www.youtube.com/watch?v=PnHCvfgC_ZA
        self.returns = self.advantages + self.values

        assert not torch.isnan(
            self.advantages
        ).any(), "Advantages arr contains NaN values: Check GAE computation"

    def get(
        self, batch_size: Optional[int] = None
    ) -> Generator[RolloutBufferSamples, None, None]:
        assert self.full, ""

        # Prepare the data
        if not self.generator_ready:
            _tensor_names = [
                "observations",
                "actions",
                "values",
                "log_probs",
                "advantages",
                "returns",
                "rewards",
            ]
            # Create mask
            self.valid_samples_mask = ~torch.isnan(
                self.swap_and_flatten(self.__dict__["rewards"])
            )

            # Flatten data
            # EDIT_5: And mask out invalid samples
            for tensor in _tensor_names:
                if tensor == "observations":
                    self.__dict__[tensor] = self.swap_and_flatten(
                        self.__dict__[tensor]
                    )[self.valid_samples_mask.flatten(), :]
                else:
                    self.__dict__[tensor] = self.swap_and_flatten(
                        self.__dict__[tensor]
                    )[self.valid_samples_mask]

                assert not torch.isnan(
                    self.__dict__[tensor]
                ).any(), f"{tensor} tensor contains NaN values; something went wrong"

            self.generator_ready = True

        # EDIT_6: Compute total number of samples and create indices
        total_num_samples = self.valid_samples_mask.sum()
        indices = torch.randperm(total_num_samples)

        # if self.__dict__["observations"].max() > 1 or self.__dict__["observations"].min() < -1:
        #     print("Observations are out of range")

        # Return everything, don't create minibatches
        if batch_size is None:
            batch_size = total_num_samples

        start_idx = 0
        while start_idx < total_num_samples:
            yield self._get_samples(
                indices[start_idx : start_idx + batch_size]
            )
            start_idx += batch_size

    def _get_samples(
        self,
        batch_inds: np.ndarray,
        env: Optional[VecNormalize] = None,
    ) -> RolloutBufferSamples:  # type: ignore[signature-mismatch]
        data = (
            self.observations[batch_inds],
            self.actions[batch_inds],
            self.values[batch_inds].flatten(),
            self.log_probs[batch_inds].flatten(),
            self.advantages[batch_inds].flatten(),
            self.returns[batch_inds].flatten(),
        )
        return RolloutBufferSamples(*tuple(map(self.to_torch, data)))