from typing import Any, ClassVar, TypeVar
import numpy as np
import torch as th
from gymnasium import spaces
from stable_baselines3.common.buffers import ReplayBuffer
from stable_baselines3.common.noise import ActionNoise
from stable_baselines3.common.off_policy_algorithm import OffPolicyAlgorithm
from stable_baselines3.common.policies import BasePolicy
from stable_baselines3.common.type_aliases import GymEnv, MaybeCallback, Schedule
from torch.nn import functional as F
from sb3_contrib.crossq.policies import Actor, CrossQCritic, CrossQPolicy, MlpPolicy
SelfCrossQ = TypeVar("SelfCrossQ", bound="CrossQ")
[docs]
class CrossQ(OffPolicyAlgorithm):
"""
Implementation of Batch Normalization in Deep Reinforcement Learning (CrossQ).
Paper: https://openreview.net/forum?id=PczQtTsTIX
Reference implementation: https://github.com/araffin/sbx
:param policy: The policy model to use (MlpPolicy)
:param env: The environment to learn from (if registered in Gym, can be str)
:param learning_rate: learning rate for adam optimizer,
the same learning rate will be used for all networks (Q-Values, Actor and Value function)
it can be a function of the current progress remaining (from 1 to 0)
:param buffer_size: size of the replay buffer
:param learning_starts: how many steps of the model to collect transitions for before learning starts
:param batch_size: Minibatch size for each gradient update
:param gamma: the discount factor
:param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit
like ``(5, "step")`` or ``(2, "episode")``.
:param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)
Set to ``-1`` means to do as many gradient steps as steps done in the environment
during the rollout.
:param action_noise: the action noise type (None by default), this can help
for hard exploration problem. Cf common.noise for the different action noise type.
:param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).
If ``None``, it will be automatically selected.
:param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.
:param optimize_memory_usage: Enable a memory efficient variant of the replay buffer
at a cost of more complexity.
See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195
:param n_steps: When n_step > 1, uses n-step return (with the NStepReplayBuffer) when updating the Q-value network.
:param ent_coef: Entropy regularization coefficient. (Equivalent to
inverse of reward scale in the original SAC paper.) Controlling exploration/exploitation trade-off.
Set it to 'auto' to learn it automatically (and 'auto_0.1' for using 0.1 as initial value)
:param target_entropy: target entropy when learning ``ent_coef`` (``ent_coef = 'auto'``)
:param use_sde: Whether to use generalized State Dependent Exploration (gSDE)
instead of action noise exploration (default: False)
:param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE
Default: -1 (only sample at the beginning of the rollout)
:param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling
during the warm up phase (before learning starts)
:param stats_window_size: Window size for the rollout logging, specifying the number of episodes to average
the reported success rate, mean episode length, and mean reward over
:param tensorboard_log: the log location for tensorboard (if None, no logging)
:param policy_kwargs: additional arguments to be passed to the policy on creation. See :ref:`crossq_policies`
:param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for
debug messages
:param seed: Seed for the pseudo random generators
:param device: Device (cpu, cuda, ...) on which the code should be run.
Setting it to auto, the code will be run on the GPU if possible.
:param _init_setup_model: Whether or not to build the network at the creation of the instance
"""
policy_aliases: ClassVar[dict[str, type[BasePolicy]]] = {
"MlpPolicy": MlpPolicy,
# TODO: Implement CnnPolicy and MultiInputPolicy
}
policy: CrossQPolicy
actor: Actor
critic: CrossQCritic
def __init__(
self,
policy: str | type[CrossQPolicy],
env: GymEnv | str,
learning_rate: float | Schedule = 1e-3,
buffer_size: int = 1_000_000, # 1e6
learning_starts: int = 100,
batch_size: int = 256,
gamma: float = 0.99,
train_freq: int | tuple[int, str] = 1,
gradient_steps: int = 1,
action_noise: ActionNoise | None = None,
replay_buffer_class: type[ReplayBuffer] | None = None,
replay_buffer_kwargs: dict[str, Any] | None = None,
optimize_memory_usage: bool = False,
n_steps: int = 1,
ent_coef: str | float = "auto",
target_entropy: str | float = "auto",
policy_delay: int = 3,
use_sde: bool = False,
sde_sample_freq: int = -1,
use_sde_at_warmup: bool = False,
stats_window_size: int = 100,
tensorboard_log: str | None = None,
policy_kwargs: dict[str, Any] | None = None,
verbose: int = 0,
seed: int | None = None,
device: th.device | str = "auto",
_init_setup_model: bool = True,
):
super().__init__(
policy,
env,
learning_rate,
buffer_size,
learning_starts,
batch_size,
1.0, # no target networks, tau=1.0
gamma,
train_freq,
gradient_steps,
action_noise,
replay_buffer_class=replay_buffer_class,
replay_buffer_kwargs=replay_buffer_kwargs,
optimize_memory_usage=optimize_memory_usage,
n_steps=n_steps,
policy_kwargs=policy_kwargs,
stats_window_size=stats_window_size,
tensorboard_log=tensorboard_log,
verbose=verbose,
device=device,
seed=seed,
use_sde=use_sde,
sde_sample_freq=sde_sample_freq,
use_sde_at_warmup=use_sde_at_warmup,
supported_action_spaces=(spaces.Box,),
support_multi_env=True,
)
self.target_entropy = target_entropy
self.log_ent_coef = None # type: th.Tensor | None
# Entropy coefficient / Entropy temperature
# Inverse of the reward scale
self.ent_coef = ent_coef
self.ent_coef_optimizer: th.optim.Adam | None = None
self.policy_delay = policy_delay
if _init_setup_model:
self._setup_model()
def _setup_model(self) -> None:
super()._setup_model()
self._create_aliases()
# Target entropy is used when learning the entropy coefficient
if self.target_entropy == "auto":
# automatically set target entropy if needed
self.target_entropy = float(-np.prod(self.env.action_space.shape).astype(np.float32)) # type: ignore
else:
# Force conversion
# this will also throw an error for unexpected string
self.target_entropy = float(self.target_entropy)
# The entropy coefficient or entropy can be learned automatically
# see Automating Entropy Adjustment for Maximum Entropy RL section
# of https://arxiv.org/abs/1812.05905
if isinstance(self.ent_coef, str) and self.ent_coef.startswith("auto"):
# Default initial value of ent_coef when learned
init_value = 1.0
if "_" in self.ent_coef:
init_value = float(self.ent_coef.split("_")[1])
assert init_value > 0.0, "The initial value of ent_coef must be greater than 0"
# Note: we optimize the log of the entropy coeff which is slightly different from the paper
# as discussed in https://github.com/rail-berkeley/softlearning/issues/37
self.log_ent_coef = th.log(th.ones(1, device=self.device) * init_value).requires_grad_(True)
self.ent_coef_optimizer = th.optim.Adam([self.log_ent_coef], lr=self.lr_schedule(1))
else:
# Force conversion to float
# this will throw an error if a malformed string (different from 'auto')
# is passed
self.ent_coef_tensor = th.tensor(float(self.ent_coef), device=self.device)
def _create_aliases(self) -> None:
self.actor = self.policy.actor
self.critic = self.policy.critic
[docs]
def train(self, gradient_steps: int, batch_size: int = 64) -> None:
# Switch to train mode (this affects batch norm / dropout)
self.policy.set_training_mode(True)
# Update optimizers learning rate
optimizers = [self.actor.optimizer, self.critic.optimizer]
if self.ent_coef_optimizer is not None:
optimizers += [self.ent_coef_optimizer]
# Update learning rate according to lr schedule
self._update_learning_rate(optimizers)
ent_coef_losses, ent_coefs = [], []
actor_losses, critic_losses = [], []
for _ in range(gradient_steps):
self._n_updates += 1
# Sample replay buffer
replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env) # type: ignore[union-attr]
# For n-step replay, discount factor is gamma**n_steps (when no early termination)
discounts = replay_data.discounts if replay_data.discounts is not None else self.gamma
# We need to sample because `log_std` may have changed between two gradient steps
if self.use_sde:
self.actor.reset_noise()
# Note: in the following lines we always need to make sure to set train/eval modes
# of actor and critic carefully. This is because of the BatchNorm layers in the networks
# which behave differently in train and eval modes.
if self.log_ent_coef is not None:
# Important: detach the variable from the graph
# so we don't change it with other losses
# see https://github.com/rail-berkeley/softlearning/issues/60
ent_coef = th.exp(self.log_ent_coef.detach())
else:
ent_coef = self.ent_coef_tensor
ent_coefs.append(ent_coef.item())
with th.no_grad():
# Select action according to policy
# Use more precise set_training_mode to allow the use of Dropout
self.actor.set_bn_training_mode(False)
next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)
# Joint forward pass of obs/next_obs and actions/next_state_actions to have only
# one forward pass.
#
# This has two reasons:
# 1. According to the paper obs/actions and next_obs/next_state_actions are differently
# distributed which is the reason why "naively" applying Batch Normalization in SAC fails.
# The batch statistics have to instead be calculated for the mixture distribution of obs/next_obs
# and actions/next_state_actions. Otherwise, next_obs/next_state_actions are perceived as
# out-of-distribution to the Batch Normalization layer, since running statistics are only polyak averaged
# over from the live network and have never seen the next batch which is known to be unstable.
# Without target networks, the joint forward pass is a simple solution to calculate
# the joint batch statistics directly with a single forward pass.
#
# 2. From a computational perspective a single forward pass is simply more efficient than
# two sequential forward passes.
all_obs = th.cat([replay_data.observations, replay_data.next_observations], dim=0)
all_actions = th.cat([replay_data.actions, next_actions], dim=0)
# Update critic BN stats
self.critic.set_bn_training_mode(True)
all_q_values = th.cat(self.critic(all_obs, all_actions), dim=1)
self.critic.set_bn_training_mode(False)
# (2 * batch_size, n_critics) -> (batch_size, n_critics), (batch_size, n_critics)
current_q_values, next_q_values = th.split(all_q_values, batch_size, dim=0)
# (batch_size, n_critics) -> (n_critics, batch_size, 1)
current_q_values = current_q_values.T[..., None]
with th.no_grad():
# Compute the target Q value
next_q_values, _ = th.min(next_q_values.detach(), dim=1, keepdim=True)
# Add entropy term
next_q_values = next_q_values - ent_coef * next_log_prob.reshape(-1, 1)
# td error + entropy term
target_q_values = replay_data.rewards + (1 - replay_data.dones) * discounts * next_q_values
# Compute critic loss
critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values.detach()) for current_q in current_q_values)
assert isinstance(critic_loss, th.Tensor) # for type checker
critic_losses.append(critic_loss.item()) # type: ignore[union-attr]
# Optimize the critic
self.critic.optimizer.zero_grad()
critic_loss.backward()
self.critic.optimizer.step()
# Delayed policy updates
if self._n_updates % self.policy_delay == 0:
# Sample action according to policy and update actor BN stats
self.actor.set_bn_training_mode(True)
actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)
log_prob = log_prob.reshape(-1, 1)
self.actor.set_bn_training_mode(False)
# Optimize entropy coefficient, also called entropy temperature or alpha in the paper
if self.ent_coef_optimizer is not None:
ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean() # type: ignore[operator]
ent_coef_losses.append(ent_coef_loss.item())
self.ent_coef_optimizer.zero_grad()
ent_coef_loss.backward()
self.ent_coef_optimizer.step()
# Compute actor loss
self.critic.set_bn_training_mode(False)
q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)
min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)
actor_loss = (ent_coef * log_prob.reshape(-1, 1) - min_qf_pi).mean()
actor_losses.append(actor_loss.item())
# Optimize the actor
self.actor.optimizer.zero_grad()
actor_loss.backward()
self.actor.optimizer.step()
self.logger.record("train/n_updates", self._n_updates, exclude="tensorboard")
self.logger.record("train/ent_coef", np.mean(ent_coefs))
if len(actor_losses) > 0:
self.logger.record("train/actor_loss", np.mean(actor_losses))
self.logger.record("train/critic_loss", np.mean(critic_losses))
if len(ent_coef_losses) > 0:
self.logger.record("train/ent_coef_loss", np.mean(ent_coef_losses))
[docs]
def learn(
self: SelfCrossQ,
total_timesteps: int,
callback: MaybeCallback = None,
log_interval: int = 4,
tb_log_name: str = "CrossQ",
reset_num_timesteps: bool = True,
progress_bar: bool = False,
) -> SelfCrossQ:
return super().learn(
total_timesteps=total_timesteps,
callback=callback,
log_interval=log_interval,
tb_log_name=tb_log_name,
reset_num_timesteps=reset_num_timesteps,
progress_bar=progress_bar,
)
def _excluded_save_params(self) -> list[str]:
return [*super()._excluded_save_params(), "actor", "critic"]
def _get_torch_save_params(self) -> tuple[list[str], list[str]]:
state_dicts = ["policy", "actor.optimizer", "critic.optimizer"]
if self.ent_coef_optimizer is not None:
saved_pytorch_variables = ["log_ent_coef"]
state_dicts.append("ent_coef_optimizer")
else:
saved_pytorch_variables = ["ent_coef_tensor"]
return state_dicts, saved_pytorch_variables