Add files using upload-large-folder tool

.gitattributes

@@ -1418,3 +1418,4 @@ evalkit_tf433/lib/libasan.so filter=lfs diff=lfs merge=lfs -text
 evalkit_tf433/lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 deepseek/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 deepseek/lib/python3.10/site-packages/pyarrow/_acero.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseek/lib/libtinfow.so.6 filter=lfs diff=lfs merge=lfs -text

deepseek/lib/libtinfow.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fa5905616132c8011f70288c40108dec369707481d75643646e9040878a958a
+size 287080

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/__init__.py

@@ -0,0 +1,11 @@
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.models.tf.fcnet import FullyConnectedNetwork
+from ray.rllib.models.tf.recurrent_net import RecurrentNetwork
+from ray.rllib.models.tf.visionnet import VisionNetwork
+
+__all__ = [
+    "FullyConnectedNetwork",
+    "RecurrentNetwork",
+    "TFModelV2",
+    "VisionNetwork",
+]

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/attention_net.py

@@ -0,0 +1,573 @@
+"""
+[1] - Attention Is All You Need - Vaswani, Jones, Shazeer, Parmar,
+      Uszkoreit, Gomez, Kaiser - Google Brain/Research, U Toronto - 2017.
+      https://arxiv.org/pdf/1706.03762.pdf
+[2] - Stabilizing Transformers for Reinforcement Learning - E. Parisotto
+      et al. - DeepMind - 2019. https://arxiv.org/pdf/1910.06764.pdf
+[3] - Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context.
+      Z. Dai, Z. Yang, et al. - Carnegie Mellon U - 2019.
+      https://www.aclweb.org/anthology/P19-1285.pdf
+"""
+import gymnasium as gym
+from gymnasium.spaces import Box, Discrete, MultiDiscrete
+import numpy as np
+import tree  # pip install dm_tree
+from typing import Any, Dict, Optional, Union
+
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.models.tf.layers import (
+    GRUGate,
+    RelativeMultiHeadAttention,
+    SkipConnection,
+)
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.models.tf.recurrent_net import RecurrentNetwork
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.policy.view_requirement import ViewRequirement
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.tf_utils import flatten_inputs_to_1d_tensor, one_hot
+from ray.rllib.utils.typing import ModelConfigDict, TensorType, List
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+@OldAPIStack
+class PositionwiseFeedforward(tf.keras.layers.Layer if tf else object):
+    """A 2x linear layer with ReLU activation in between described in [1].
+
+    Each timestep coming from the attention head will be passed through this
+    layer separately.
+    """
+
+    def __init__(
+        self,
+        out_dim: int,
+        hidden_dim: int,
+        output_activation: Optional[Any] = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self._hidden_layer = tf.keras.layers.Dense(
+            hidden_dim,
+            activation=tf.nn.relu,
+        )
+
+        self._output_layer = tf.keras.layers.Dense(
+            out_dim, activation=output_activation
+        )
+        if log_once("positionwise_feedforward_tf"):
+            deprecation_warning(
+                old="rllib.models.tf.attention_net.PositionwiseFeedforward",
+            )
+
+    def call(self, inputs: TensorType, **kwargs) -> TensorType:
+        del kwargs
+        output = self._hidden_layer(inputs)
+        return self._output_layer(output)
+
+
+@OldAPIStack
+class TrXLNet(RecurrentNetwork):
+    """A TrXL net Model described in [1]."""
+
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+        num_transformer_units: int,
+        attention_dim: int,
+        num_heads: int,
+        head_dim: int,
+        position_wise_mlp_dim: int,
+    ):
+        """Initializes a TrXLNet object.
+
+        Args:
+            num_transformer_units: The number of Transformer repeats to
+                use (denoted L in [2]).
+            attention_dim: The input and output dimensions of one
+                Transformer unit.
+            num_heads: The number of attention heads to use in parallel.
+                Denoted as `H` in [3].
+            head_dim: The dimension of a single(!) attention head within
+                a multi-head attention unit. Denoted as `d` in [3].
+            position_wise_mlp_dim: The dimension of the hidden layer
+                within the position-wise MLP (after the multi-head attention
+                block within one Transformer unit). This is the size of the
+                first of the two layers within the PositionwiseFeedforward. The
+                second layer always has size=`attention_dim`.
+        """
+        if log_once("trxl_net_tf"):
+            deprecation_warning(
+                old="rllib.models.tf.attention_net.TrXLNet",
+            )
+        super().__init__(
+            observation_space, action_space, num_outputs, model_config, name
+        )
+
+        self.num_transformer_units = num_transformer_units
+        self.attention_dim = attention_dim
+        self.num_heads = num_heads
+        self.head_dim = head_dim
+        self.max_seq_len = model_config["max_seq_len"]
+        self.obs_dim = observation_space.shape[0]
+
+        inputs = tf.keras.layers.Input(
+            shape=(self.max_seq_len, self.obs_dim), name="inputs"
+        )
+        E_out = tf.keras.layers.Dense(attention_dim)(inputs)
+
+        for _ in range(self.num_transformer_units):
+            MHA_out = SkipConnection(
+                RelativeMultiHeadAttention(
+                    out_dim=attention_dim,
+                    num_heads=num_heads,
+                    head_dim=head_dim,
+                    input_layernorm=False,
+                    output_activation=None,
+                ),
+                fan_in_layer=None,
+            )(E_out)
+            E_out = SkipConnection(
+                PositionwiseFeedforward(attention_dim, position_wise_mlp_dim)
+            )(MHA_out)
+            E_out = tf.keras.layers.LayerNormalization(axis=-1)(E_out)
+
+        # Postprocess TrXL output with another hidden layer and compute values.
+        logits = tf.keras.layers.Dense(
+            self.num_outputs, activation=tf.keras.activations.linear, name="logits"
+        )(E_out)
+
+        self.base_model = tf.keras.models.Model([inputs], [logits])
+
+    @override(RecurrentNetwork)
+    def forward_rnn(
+        self, inputs: TensorType, state: List[TensorType], seq_lens: TensorType
+    ) -> (TensorType, List[TensorType]):
+        # To make Attention work with current RLlib's ModelV2 API:
+        # We assume `state` is the history of L recent observations (all
+        # concatenated into one tensor) and append the current inputs to the
+        # end and only keep the most recent (up to `max_seq_len`). This allows
+        # us to deal with timestep-wise inference and full sequence training
+        # within the same logic.
+        observations = state[0]
+        observations = tf.concat((observations, inputs), axis=1)[:, -self.max_seq_len :]
+        logits = self.base_model([observations])
+        T = tf.shape(inputs)[1]  # Length of input segment (time).
+        logits = logits[:, -T:]
+
+        return logits, [observations]
+
+    @override(RecurrentNetwork)
+    def get_initial_state(self) -> List[np.ndarray]:
+        # State is the T last observations concat'd together into one Tensor.
+        # Plus all Transformer blocks' E(l) outputs concat'd together (up to
+        # tau timesteps).
+        return [np.zeros((self.max_seq_len, self.obs_dim), np.float32)]
+
+
+class GTrXLNet(RecurrentNetwork):
+    """A GTrXL net Model described in [2].
+
+    This is still in an experimental phase.
+    Can be used as a drop-in replacement for LSTMs in PPO and IMPALA.
+
+    To use this network as a replacement for an RNN, configure your Algorithm
+    as follows:
+
+    Examples:
+        >> config["model"]["custom_model"] = GTrXLNet
+        >> config["model"]["max_seq_len"] = 10
+        >> config["model"]["custom_model_config"] = {
+        >>     num_transformer_units=1,
+        >>     attention_dim=32,
+        >>     num_heads=2,
+        >>     memory_inference=100,
+        >>     memory_training=50,
+        >>     etc..
+        >> }
+    """
+
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: Optional[int],
+        model_config: ModelConfigDict,
+        name: str,
+        *,
+        num_transformer_units: int = 1,
+        attention_dim: int = 64,
+        num_heads: int = 2,
+        memory_inference: int = 50,
+        memory_training: int = 50,
+        head_dim: int = 32,
+        position_wise_mlp_dim: int = 32,
+        init_gru_gate_bias: float = 2.0,
+    ):
+        """Initializes a GTrXLNet instance.
+
+        Args:
+            num_transformer_units: The number of Transformer repeats to
+                use (denoted L in [2]).
+            attention_dim: The input and output dimensions of one
+                Transformer unit.
+            num_heads: The number of attention heads to use in parallel.
+                Denoted as `H` in [3].
+            memory_inference: The number of timesteps to concat (time
+                axis) and feed into the next transformer unit as inference
+                input. The first transformer unit will receive this number of
+                past observations (plus the current one), instead.
+            memory_training: The number of timesteps to concat (time
+                axis) and feed into the next transformer unit as training
+                input (plus the actual input sequence of len=max_seq_len).
+                The first transformer unit will receive this number of
+                past observations (plus the input sequence), instead.
+            head_dim: The dimension of a single(!) attention head within
+                a multi-head attention unit. Denoted as `d` in [3].
+            position_wise_mlp_dim: The dimension of the hidden layer
+                within the position-wise MLP (after the multi-head attention
+                block within one Transformer unit). This is the size of the
+                first of the two layers within the PositionwiseFeedforward. The
+                second layer always has size=`attention_dim`.
+            init_gru_gate_bias: Initial bias values for the GRU gates
+                (two GRUs per Transformer unit, one after the MHA, one after
+                the position-wise MLP).
+        """
+        super().__init__(
+            observation_space, action_space, num_outputs, model_config, name
+        )
+
+        self.num_transformer_units = num_transformer_units
+        self.attention_dim = attention_dim
+        self.num_heads = num_heads
+        self.memory_inference = memory_inference
+        self.memory_training = memory_training
+        self.head_dim = head_dim
+        self.max_seq_len = model_config["max_seq_len"]
+        self.obs_dim = observation_space.shape[0]
+
+        # Raw observation input (plus (None) time axis).
+        input_layer = tf.keras.layers.Input(shape=(None, self.obs_dim), name="inputs")
+        memory_ins = [
+            tf.keras.layers.Input(
+                shape=(None, self.attention_dim),
+                dtype=tf.float32,
+                name="memory_in_{}".format(i),
+            )
+            for i in range(self.num_transformer_units)
+        ]
+
+        # Map observation dim to input/output transformer (attention) dim.
+        E_out = tf.keras.layers.Dense(self.attention_dim)(input_layer)
+        # Output, collected and concat'd to build the internal, tau-len
+        # Memory units used for additional contextual information.
+        memory_outs = [E_out]
+
+        # 2) Create L Transformer blocks according to [2].
+        for i in range(self.num_transformer_units):
+            # RelativeMultiHeadAttention part.
+            MHA_out = SkipConnection(
+                RelativeMultiHeadAttention(
+                    out_dim=self.attention_dim,
+                    num_heads=num_heads,
+                    head_dim=head_dim,
+                    input_layernorm=True,
+                    output_activation=tf.nn.relu,
+                ),
+                fan_in_layer=GRUGate(init_gru_gate_bias),
+                name="mha_{}".format(i + 1),
+            )(E_out, memory=memory_ins[i])
+            # Position-wise MLP part.
+            E_out = SkipConnection(
+                tf.keras.Sequential(
+                    (
+                        tf.keras.layers.LayerNormalization(axis=-1),
+                        PositionwiseFeedforward(
+                            out_dim=self.attention_dim,
+                            hidden_dim=position_wise_mlp_dim,
+                            output_activation=tf.nn.relu,
+                        ),
+                    )
+                ),
+                fan_in_layer=GRUGate(init_gru_gate_bias),
+                name="pos_wise_mlp_{}".format(i + 1),
+            )(MHA_out)
+            # Output of position-wise MLP == E(l-1), which is concat'd
+            # to the current Mem block (M(l-1)) to yield E~(l-1), which is then
+            # used by the next transformer block.
+            memory_outs.append(E_out)
+
+        self._logits = None
+        self._value_out = None
+
+        # Postprocess TrXL output with another hidden layer and compute values.
+        if num_outputs is not None:
+            self._logits = tf.keras.layers.Dense(
+                self.num_outputs, activation=None, name="logits"
+            )(E_out)
+            values_out = tf.keras.layers.Dense(1, activation=None, name="values")(E_out)
+            outs = [self._logits, values_out]
+        else:
+            outs = [E_out]
+            self.num_outputs = self.attention_dim
+
+        self.trxl_model = tf.keras.Model(
+            inputs=[input_layer] + memory_ins, outputs=outs + memory_outs[:-1]
+        )
+
+        self.trxl_model.summary()
+
+        # __sphinx_doc_begin__
+        # Setup trajectory views (`memory-inference` x past memory outs).
+        for i in range(self.num_transformer_units):
+            space = Box(-1.0, 1.0, shape=(self.attention_dim,))
+            self.view_requirements["state_in_{}".format(i)] = ViewRequirement(
+                "state_out_{}".format(i),
+                shift="-{}:-1".format(self.memory_inference),
+                # Repeat the incoming state every max-seq-len times.
+                batch_repeat_value=self.max_seq_len,
+                space=space,
+            )
+            self.view_requirements["state_out_{}".format(i)] = ViewRequirement(
+                space=space, used_for_training=False
+            )
+        # __sphinx_doc_end__
+
+    @override(ModelV2)
+    def forward(
+        self, input_dict, state: List[TensorType], seq_lens: TensorType
+    ) -> (TensorType, List[TensorType]):
+        assert seq_lens is not None
+
+        # Add the time dim to observations.
+        B = tf.shape(seq_lens)[0]
+        observations = input_dict[SampleBatch.OBS]
+
+        shape = tf.shape(observations)
+        T = shape[0] // B
+        observations = tf.reshape(observations, tf.concat([[-1, T], shape[1:]], axis=0))
+
+        all_out = self.trxl_model([observations] + state)
+
+        if self._logits is not None:
+            out = tf.reshape(all_out[0], [-1, self.num_outputs])
+            self._value_out = all_out[1]
+            memory_outs = all_out[2:]
+        else:
+            out = tf.reshape(all_out[0], [-1, self.attention_dim])
+            memory_outs = all_out[1:]
+
+        return out, [tf.reshape(m, [-1, self.attention_dim]) for m in memory_outs]
+
+    @override(RecurrentNetwork)
+    def get_initial_state(self) -> List[np.ndarray]:
+        return [
+            tf.zeros(self.view_requirements["state_in_{}".format(i)].space.shape)
+            for i in range(self.num_transformer_units)
+        ]
+
+    @override(ModelV2)
+    def value_function(self) -> TensorType:
+        return tf.reshape(self._value_out, [-1])
+
+
+class AttentionWrapper(TFModelV2):
+    """GTrXL wrapper serving as interface for ModelV2s that set use_attention."""
+
+    def __init__(
+        self,
+        obs_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+    ):
+        if log_once("attention_wrapper_tf_deprecation"):
+            deprecation_warning(
+                old="ray.rllib.models.tf.attention_net.AttentionWrapper"
+            )
+        super().__init__(obs_space, action_space, None, model_config, name)
+
+        self.use_n_prev_actions = model_config["attention_use_n_prev_actions"]
+        self.use_n_prev_rewards = model_config["attention_use_n_prev_rewards"]
+
+        self.action_space_struct = get_base_struct_from_space(self.action_space)
+        self.action_dim = 0
+
+        for space in tree.flatten(self.action_space_struct):
+            if isinstance(space, Discrete):
+                self.action_dim += space.n
+            elif isinstance(space, MultiDiscrete):
+                self.action_dim += np.sum(space.nvec)
+            elif space.shape is not None:
+                self.action_dim += int(np.prod(space.shape))
+            else:
+                self.action_dim += int(len(space))
+
+        # Add prev-action/reward nodes to input to LSTM.
+        if self.use_n_prev_actions:
+            self.num_outputs += self.use_n_prev_actions * self.action_dim
+        if self.use_n_prev_rewards:
+            self.num_outputs += self.use_n_prev_rewards
+
+        cfg = model_config
+
+        self.attention_dim = cfg["attention_dim"]
+
+        if self.num_outputs is not None:
+            in_space = gym.spaces.Box(
+                float("-inf"), float("inf"), shape=(self.num_outputs,), dtype=np.float32
+            )
+        else:
+            in_space = obs_space
+
+        # Construct GTrXL sub-module w/ num_outputs=None (so it does not
+        # create a logits/value output; we'll do this ourselves in this wrapper
+        # here).
+        self.gtrxl = GTrXLNet(
+            in_space,
+            action_space,
+            None,
+            model_config,
+            "gtrxl",
+            num_transformer_units=cfg["attention_num_transformer_units"],
+            attention_dim=self.attention_dim,
+            num_heads=cfg["attention_num_heads"],
+            head_dim=cfg["attention_head_dim"],
+            memory_inference=cfg["attention_memory_inference"],
+            memory_training=cfg["attention_memory_training"],
+            position_wise_mlp_dim=cfg["attention_position_wise_mlp_dim"],
+            init_gru_gate_bias=cfg["attention_init_gru_gate_bias"],
+        )
+
+        # `self.num_outputs` right now is the number of nodes coming from the
+        # attention net.
+        input_ = tf.keras.layers.Input(shape=(self.gtrxl.num_outputs,))
+
+        # Set final num_outputs to correct value (depending on action space).
+        self.num_outputs = num_outputs
+
+        # Postprocess GTrXL output with another hidden layer and compute
+        # values.
+        out = tf.keras.layers.Dense(self.num_outputs, activation=None)(input_)
+        self._logits_branch = tf.keras.models.Model([input_], [out])
+
+        out = tf.keras.layers.Dense(1, activation=None)(input_)
+        self._value_branch = tf.keras.models.Model([input_], [out])
+
+        self.view_requirements = self.gtrxl.view_requirements
+        self.view_requirements["obs"].space = self.obs_space
+
+        # Add prev-a/r to this model's view, if required.
+        if self.use_n_prev_actions:
+            self.view_requirements[SampleBatch.PREV_ACTIONS] = ViewRequirement(
+                SampleBatch.ACTIONS,
+                space=self.action_space,
+                shift="-{}:-1".format(self.use_n_prev_actions),
+            )
+        if self.use_n_prev_rewards:
+            self.view_requirements[SampleBatch.PREV_REWARDS] = ViewRequirement(
+                SampleBatch.REWARDS, shift="-{}:-1".format(self.use_n_prev_rewards)
+            )
+
+    @override(RecurrentNetwork)
+    def forward(
+        self,
+        input_dict: Dict[str, TensorType],
+        state: List[TensorType],
+        seq_lens: TensorType,
+    ) -> (TensorType, List[TensorType]):
+        assert seq_lens is not None
+        # Push obs through "unwrapped" net's `forward()` first.
+        wrapped_out, _ = self._wrapped_forward(input_dict, [], None)
+
+        # Concat. prev-action/reward if required.
+        prev_a_r = []
+
+        # Prev actions.
+        if self.use_n_prev_actions:
+            prev_n_actions = input_dict[SampleBatch.PREV_ACTIONS]
+            # If actions are not processed yet (in their original form as
+            # have been sent to environment):
+            # Flatten/one-hot into 1D array.
+            if self.model_config["_disable_action_flattening"]:
+                # Merge prev n actions into flat tensor.
+                flat = flatten_inputs_to_1d_tensor(
+                    prev_n_actions,
+                    spaces_struct=self.action_space_struct,
+                    time_axis=True,
+                )
+                # Fold time-axis into flattened data.
+                flat = tf.reshape(flat, [tf.shape(flat)[0], -1])
+                prev_a_r.append(flat)
+            # If actions are already flattened (but not one-hot'd yet!),
+            # one-hot discrete/multi-discrete actions here and concatenate the
+            # n most recent actions together.
+            else:
+                if isinstance(self.action_space, Discrete):
+                    for i in range(self.use_n_prev_actions):
+                        prev_a_r.append(
+                            one_hot(prev_n_actions[:, i], self.action_space)
+                        )
+                elif isinstance(self.action_space, MultiDiscrete):
+                    for i in range(
+                        0, self.use_n_prev_actions, self.action_space.shape[0]
+                    ):
+                        prev_a_r.append(
+                            one_hot(
+                                tf.cast(
+                                    prev_n_actions[
+                                        :, i : i + self.action_space.shape[0]
+                                    ],
+                                    tf.float32,
+                                ),
+                                space=self.action_space,
+                            )
+                        )
+                else:
+                    prev_a_r.append(
+                        tf.reshape(
+                            tf.cast(prev_n_actions, tf.float32),
+                            [-1, self.use_n_prev_actions * self.action_dim],
+                        )
+                    )
+        # Prev rewards.
+        if self.use_n_prev_rewards:
+            prev_a_r.append(
+                tf.reshape(
+                    tf.cast(input_dict[SampleBatch.PREV_REWARDS], tf.float32),
+                    [-1, self.use_n_prev_rewards],
+                )
+            )
+
+        # Concat prev. actions + rewards to the "main" input.
+        if prev_a_r:
+            wrapped_out = tf.concat([wrapped_out] + prev_a_r, axis=1)
+
+        # Then through our GTrXL.
+        input_dict["obs_flat"] = input_dict["obs"] = wrapped_out
+
+        self._features, memory_outs = self.gtrxl(input_dict, state, seq_lens)
+        model_out = self._logits_branch(self._features)
+        return model_out, memory_outs
+
+    @override(ModelV2)
+    def value_function(self) -> TensorType:
+        assert self._features is not None, "Must call forward() first!"
+        return tf.reshape(self._value_branch(self._features), [-1])
+
+    @override(ModelV2)
+    def get_initial_state(self) -> Union[List[np.ndarray], List[TensorType]]:
+        return [
+            np.zeros(self.gtrxl.view_requirements["state_in_{}".format(i)].space.shape)
+            for i in range(self.gtrxl.num_transformer_units)
+        ]

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/complex_input_net.py

@@ -0,0 +1,214 @@
+from gymnasium.spaces import Box, Discrete, MultiDiscrete
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.models.catalog import ModelCatalog
+from ray.rllib.models.modelv2 import ModelV2, restore_original_dimensions
+from ray.rllib.models.tf.misc import normc_initializer
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.models.utils import get_filter_config
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.spaces.space_utils import flatten_space
+from ray.rllib.utils.tf_utils import one_hot
+
+tf1, tf, tfv = try_import_tf()
+
+
+# __sphinx_doc_begin__
+@OldAPIStack
+class ComplexInputNetwork(TFModelV2):
+    """TFModelV2 concat'ing CNN outputs to flat input(s), followed by FC(s).
+
+    Note: This model should be used for complex (Dict or Tuple) observation
+    spaces that have one or more image components.
+
+    The data flow is as follows:
+
+    `obs` (e.g. Tuple[img0, img1, discrete0]) -> `CNN0 + CNN1 + ONE-HOT`
+    `CNN0 + CNN1 + ONE-HOT` -> concat all flat outputs -> `out`
+    `out` -> (optional) FC-stack -> `out2`
+    `out2` -> action (logits) and vaulue heads.
+    """
+
+    def __init__(self, obs_space, action_space, num_outputs, model_config, name):
+
+        self.original_space = (
+            obs_space.original_space
+            if hasattr(obs_space, "original_space")
+            else obs_space
+        )
+
+        self.processed_obs_space = (
+            self.original_space
+            if model_config.get("_disable_preprocessor_api")
+            else obs_space
+        )
+        super().__init__(
+            self.original_space, action_space, num_outputs, model_config, name
+        )
+
+        self.flattened_input_space = flatten_space(self.original_space)
+
+        # Build the CNN(s) given obs_space's image components.
+        self.cnns = {}
+        self.one_hot = {}
+        self.flatten_dims = {}
+        self.flatten = {}
+        concat_size = 0
+        for i, component in enumerate(self.flattened_input_space):
+            # Image space.
+            if len(component.shape) == 3 and isinstance(component, Box):
+                config = {
+                    "conv_filters": model_config["conv_filters"]
+                    if "conv_filters" in model_config
+                    else get_filter_config(component.shape),
+                    "conv_activation": model_config.get("conv_activation"),
+                    "post_fcnet_hiddens": [],
+                }
+                self.cnns[i] = ModelCatalog.get_model_v2(
+                    component,
+                    action_space,
+                    num_outputs=None,
+                    model_config=config,
+                    framework="tf",
+                    name="cnn_{}".format(i),
+                )
+                concat_size += int(self.cnns[i].num_outputs)
+            # Discrete|MultiDiscrete inputs -> One-hot encode.
+            elif isinstance(component, (Discrete, MultiDiscrete)):
+                if isinstance(component, Discrete):
+                    size = component.n
+                else:
+                    size = np.sum(component.nvec)
+                config = {
+                    "fcnet_hiddens": model_config["fcnet_hiddens"],
+                    "fcnet_activation": model_config.get("fcnet_activation"),
+                    "post_fcnet_hiddens": [],
+                }
+                self.one_hot[i] = ModelCatalog.get_model_v2(
+                    Box(-1.0, 1.0, (size,), np.float32),
+                    action_space,
+                    num_outputs=None,
+                    model_config=config,
+                    framework="tf",
+                    name="one_hot_{}".format(i),
+                )
+                concat_size += int(self.one_hot[i].num_outputs)
+            # Everything else (1D Box).
+            else:
+                size = int(np.prod(component.shape))
+                config = {
+                    "fcnet_hiddens": model_config["fcnet_hiddens"],
+                    "fcnet_activation": model_config.get("fcnet_activation"),
+                    "post_fcnet_hiddens": [],
+                }
+                self.flatten[i] = ModelCatalog.get_model_v2(
+                    Box(-1.0, 1.0, (size,), np.float32),
+                    action_space,
+                    num_outputs=None,
+                    model_config=config,
+                    framework="tf",
+                    name="flatten_{}".format(i),
+                )
+                self.flatten_dims[i] = size
+                concat_size += int(self.flatten[i].num_outputs)
+
+        # Optional post-concat FC-stack.
+        post_fc_stack_config = {
+            "fcnet_hiddens": model_config.get("post_fcnet_hiddens", []),
+            "fcnet_activation": model_config.get("post_fcnet_activation", "relu"),
+        }
+        self.post_fc_stack = ModelCatalog.get_model_v2(
+            Box(float("-inf"), float("inf"), shape=(concat_size,), dtype=np.float32),
+            self.action_space,
+            None,
+            post_fc_stack_config,
+            framework="tf",
+            name="post_fc_stack",
+        )
+
+        # Actions and value heads.
+        self.logits_and_value_model = None
+        self._value_out = None
+        if num_outputs:
+            # Action-distribution head.
+            concat_layer = tf.keras.layers.Input((self.post_fc_stack.num_outputs,))
+            logits_layer = tf.keras.layers.Dense(
+                num_outputs,
+                activation=None,
+                kernel_initializer=normc_initializer(0.01),
+                name="logits",
+            )(concat_layer)
+
+            # Create the value branch model.
+            value_layer = tf.keras.layers.Dense(
+                1,
+                activation=None,
+                kernel_initializer=normc_initializer(0.01),
+                name="value_out",
+            )(concat_layer)
+            self.logits_and_value_model = tf.keras.models.Model(
+                concat_layer, [logits_layer, value_layer]
+            )
+        else:
+            self.num_outputs = self.post_fc_stack.num_outputs
+
+    @override(ModelV2)
+    def forward(self, input_dict, state, seq_lens):
+        if SampleBatch.OBS in input_dict and "obs_flat" in input_dict:
+            orig_obs = input_dict[SampleBatch.OBS]
+        else:
+            orig_obs = restore_original_dimensions(
+                input_dict[SampleBatch.OBS], self.processed_obs_space, tensorlib="tf"
+            )
+        # Push image observations through our CNNs.
+        outs = []
+        for i, component in enumerate(tree.flatten(orig_obs)):
+            if i in self.cnns:
+                cnn_out, _ = self.cnns[i](SampleBatch({SampleBatch.OBS: component}))
+                outs.append(cnn_out)
+            elif i in self.one_hot:
+                if "int" in component.dtype.name:
+                    one_hot_in = {
+                        SampleBatch.OBS: one_hot(
+                            component, self.flattened_input_space[i]
+                        )
+                    }
+                else:
+                    one_hot_in = {SampleBatch.OBS: component}
+                one_hot_out, _ = self.one_hot[i](SampleBatch(one_hot_in))
+                outs.append(one_hot_out)
+            else:
+                nn_out, _ = self.flatten[i](
+                    SampleBatch(
+                        {
+                            SampleBatch.OBS: tf.cast(
+                                tf.reshape(component, [-1, self.flatten_dims[i]]),
+                                tf.float32,
+                            )
+                        }
+                    )
+                )
+                outs.append(nn_out)
+        # Concat all outputs and the non-image inputs.
+        out = tf.concat(outs, axis=1)
+        # Push through (optional) FC-stack (this may be an empty stack).
+        out, _ = self.post_fc_stack(SampleBatch({SampleBatch.OBS: out}))
+
+        # No logits/value branches.
+        if not self.logits_and_value_model:
+            return out, []
+
+        # Logits- and value branches.
+        logits, values = self.logits_and_value_model(out)
+        self._value_out = tf.reshape(values, [-1])
+        return logits, []
+
+    @override(ModelV2)
+    def value_function(self):
+        return self._value_out
+
+
+# __sphinx_doc_end__

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/fcnet.py

@@ -0,0 +1,148 @@
+import numpy as np
+import gymnasium as gym
+from typing import Dict
+
+from ray.rllib.models.tf.misc import normc_initializer
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.models.utils import get_activation_fn
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType, List, ModelConfigDict
+
+tf1, tf, tfv = try_import_tf()
+
+
+@OldAPIStack
+class FullyConnectedNetwork(TFModelV2):
+    """Generic fully connected network implemented in ModelV2 API."""
+
+    def __init__(
+        self,
+        obs_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+    ):
+        super(FullyConnectedNetwork, self).__init__(
+            obs_space, action_space, num_outputs, model_config, name
+        )
+
+        hiddens = list(model_config.get("fcnet_hiddens", [])) + list(
+            model_config.get("post_fcnet_hiddens", [])
+        )
+        activation = model_config.get("fcnet_activation")
+        if not model_config.get("fcnet_hiddens", []):
+            activation = model_config.get("post_fcnet_activation")
+        activation = get_activation_fn(activation)
+        no_final_linear = model_config.get("no_final_linear")
+        vf_share_layers = model_config.get("vf_share_layers")
+        free_log_std = model_config.get("free_log_std")
+
+        # Generate free-floating bias variables for the second half of
+        # the outputs.
+        if free_log_std:
+            assert num_outputs % 2 == 0, (
+                "num_outputs must be divisible by two",
+                num_outputs,
+            )
+            num_outputs = num_outputs // 2
+            self.log_std_var = tf.Variable(
+                [0.0] * num_outputs, dtype=tf.float32, name="log_std"
+            )
+
+        # We are using obs_flat, so take the flattened shape as input.
+        inputs = tf.keras.layers.Input(
+            shape=(int(np.prod(obs_space.shape)),), name="observations"
+        )
+        # Last hidden layer output (before logits outputs).
+        last_layer = inputs
+        # The action distribution outputs.
+        logits_out = None
+        i = 1
+
+        # Create layers 0 to second-last.
+        for size in hiddens[:-1]:
+            last_layer = tf.keras.layers.Dense(
+                size,
+                name="fc_{}".format(i),
+                activation=activation,
+                kernel_initializer=normc_initializer(1.0),
+            )(last_layer)
+            i += 1
+
+        # The last layer is adjusted to be of size num_outputs, but it's a
+        # layer with activation.
+        if no_final_linear and num_outputs:
+            logits_out = tf.keras.layers.Dense(
+                num_outputs,
+                name="fc_out",
+                activation=activation,
+                kernel_initializer=normc_initializer(1.0),
+            )(last_layer)
+        # Finish the layers with the provided sizes (`hiddens`), plus -
+        # iff num_outputs > 0 - a last linear layer of size num_outputs.
+        else:
+            if len(hiddens) > 0:
+                last_layer = tf.keras.layers.Dense(
+                    hiddens[-1],
+                    name="fc_{}".format(i),
+                    activation=activation,
+                    kernel_initializer=normc_initializer(1.0),
+                )(last_layer)
+            if num_outputs:
+                logits_out = tf.keras.layers.Dense(
+                    num_outputs,
+                    name="fc_out",
+                    activation=None,
+                    kernel_initializer=normc_initializer(0.01),
+                )(last_layer)
+            # Adjust num_outputs to be the number of nodes in the last layer.
+            else:
+                self.num_outputs = ([int(np.prod(obs_space.shape))] + hiddens[-1:])[-1]
+
+        # Concat the log std vars to the end of the state-dependent means.
+        if free_log_std and logits_out is not None:
+
+            def tiled_log_std(x):
+                return tf.tile(tf.expand_dims(self.log_std_var, 0), [tf.shape(x)[0], 1])
+
+            log_std_out = tf.keras.layers.Lambda(tiled_log_std)(inputs)
+            logits_out = tf.keras.layers.Concatenate(axis=1)([logits_out, log_std_out])
+
+        last_vf_layer = None
+        if not vf_share_layers:
+            # Build a parallel set of hidden layers for the value net.
+            last_vf_layer = inputs
+            i = 1
+            for size in hiddens:
+                last_vf_layer = tf.keras.layers.Dense(
+                    size,
+                    name="fc_value_{}".format(i),
+                    activation=activation,
+                    kernel_initializer=normc_initializer(1.0),
+                )(last_vf_layer)
+                i += 1
+
+        value_out = tf.keras.layers.Dense(
+            1,
+            name="value_out",
+            activation=None,
+            kernel_initializer=normc_initializer(0.01),
+        )(last_vf_layer if last_vf_layer is not None else last_layer)
+
+        self.base_model = tf.keras.Model(
+            inputs, [(logits_out if logits_out is not None else last_layer), value_out]
+        )
+
+    def forward(
+        self,
+        input_dict: Dict[str, TensorType],
+        state: List[TensorType],
+        seq_lens: TensorType,
+    ) -> (TensorType, List[TensorType]):
+        model_out, self._value_out = self.base_model(input_dict["obs_flat"])
+        return model_out, state
+
+    def value_function(self) -> TensorType:
+        return tf.reshape(self._value_out, [-1])

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/__init__.py

@@ -0,0 +1,17 @@
+from ray.rllib.models.tf.layers.gru_gate import GRUGate
+from ray.rllib.models.tf.layers.noisy_layer import NoisyLayer
+from ray.rllib.models.tf.layers.relative_multi_head_attention import (
+    PositionalEmbedding,
+    RelativeMultiHeadAttention,
+)
+from ray.rllib.models.tf.layers.skip_connection import SkipConnection
+from ray.rllib.models.tf.layers.multi_head_attention import MultiHeadAttention
+
+__all__ = [
+    "GRUGate",
+    "MultiHeadAttention",
+    "NoisyLayer",
+    "PositionalEmbedding",
+    "RelativeMultiHeadAttention",
+    "SkipConnection",
+]

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/gru_gate.py

@@ -0,0 +1,58 @@
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType, TensorShape
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+class GRUGate(tf.keras.layers.Layer if tf else object):
+    def __init__(self, init_bias: float = 0.0, **kwargs):
+        super().__init__(**kwargs)
+        self._init_bias = init_bias
+        if log_once("gru_gate"):
+            deprecation_warning(
+                old="rllib.models.tf.layers.GRUGate",
+            )
+
+    def build(self, input_shape: TensorShape):
+        h_shape, x_shape = input_shape
+        if x_shape[-1] != h_shape[-1]:
+            raise ValueError(
+                "Both inputs to GRUGate must have equal size in last axis!"
+            )
+
+        dim = int(h_shape[-1])
+        self._w_r = self.add_weight(shape=(dim, dim))
+        self._w_z = self.add_weight(shape=(dim, dim))
+        self._w_h = self.add_weight(shape=(dim, dim))
+
+        self._u_r = self.add_weight(shape=(dim, dim))
+        self._u_z = self.add_weight(shape=(dim, dim))
+        self._u_h = self.add_weight(shape=(dim, dim))
+
+        def bias_initializer(shape, dtype):
+            return tf.fill(shape, tf.cast(self._init_bias, dtype=dtype))
+
+        self._bias_z = self.add_weight(shape=(dim,), initializer=bias_initializer)
+
+    def call(self, inputs: TensorType, **kwargs) -> TensorType:
+        # Pass in internal state first.
+        h, X = inputs
+
+        r = tf.tensordot(X, self._w_r, axes=1) + tf.tensordot(h, self._u_r, axes=1)
+        r = tf.nn.sigmoid(r)
+
+        z = (
+            tf.tensordot(X, self._w_z, axes=1)
+            + tf.tensordot(h, self._u_z, axes=1)
+            - self._bias_z
+        )
+        z = tf.nn.sigmoid(z)
+
+        h_next = tf.tensordot(X, self._w_h, axes=1) + tf.tensordot(
+            (h * r), self._u_h, axes=1
+        )
+        h_next = tf.nn.tanh(h_next)
+
+        return (1 - z) * h + z * h_next

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/multi_head_attention.py

@@ -0,0 +1,61 @@
+"""
+[1] - Attention Is All You Need - Vaswani, Jones, Shazeer, Parmar,
+      Uszkoreit, Gomez, Kaiser - Google Brain/Research, U Toronto - 2017.
+      https://arxiv.org/pdf/1706.03762.pdf
+"""
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+class MultiHeadAttention(tf.keras.layers.Layer if tf else object):
+    """A multi-head attention layer described in [1]."""
+
+    def __init__(self, out_dim: int, num_heads: int, head_dim: int, **kwargs):
+        super().__init__(**kwargs)
+
+        # No bias or non-linearity.
+        self._num_heads = num_heads
+        self._head_dim = head_dim
+        self._qkv_layer = tf.keras.layers.Dense(
+            3 * num_heads * head_dim, use_bias=False
+        )
+        self._linear_layer = tf.keras.layers.TimeDistributed(
+            tf.keras.layers.Dense(out_dim, use_bias=False)
+        )
+        if log_once("multi_head_attention"):
+            deprecation_warning(
+                old="rllib.models.tf.layers.MultiHeadAttention",
+            )
+
+    def call(self, inputs: TensorType) -> TensorType:
+        L = tf.shape(inputs)[1]  # length of segment
+        H = self._num_heads  # number of attention heads
+        D = self._head_dim  # attention head dimension
+
+        qkv = self._qkv_layer(inputs)
+
+        queries, keys, values = tf.split(qkv, 3, -1)
+        queries = queries[:, -L:]  # only query based on the segment
+
+        queries = tf.reshape(queries, [-1, L, H, D])
+        keys = tf.reshape(keys, [-1, L, H, D])
+        values = tf.reshape(values, [-1, L, H, D])
+
+        score = tf.einsum("bihd,bjhd->bijh", queries, keys)
+        score = score / D**0.5
+
+        # causal mask of the same length as the sequence
+        mask = tf.sequence_mask(tf.range(1, L + 1), dtype=score.dtype)
+        mask = mask[None, :, :, None]
+
+        masked_score = score * mask + 1e30 * (mask - 1.0)
+        wmat = tf.nn.softmax(masked_score, axis=2)
+
+        out = tf.einsum("bijh,bjhd->bihd", wmat, values)
+        shape = tf.concat([tf.shape(out)[:2], [H * D]], axis=0)
+        out = tf.reshape(out, shape)
+        return self._linear_layer(out)

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/noisy_layer.py

@@ -0,0 +1,118 @@
+import numpy as np
+
+from ray.rllib.models.utils import get_activation_fn
+from ray.rllib.utils.framework import (
+    get_variable,
+    try_import_tf,
+    TensorType,
+    TensorShape,
+)
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+class NoisyLayer(tf.keras.layers.Layer if tf else object):
+    r"""A Layer that adds learnable Noise to some previous layer's outputs.
+
+    Consists of:
+    - a common dense layer: y = w^{T}x + b
+    - a noisy layer: y = (w + \epsilon_w*\sigma_w)^{T}x +
+        (b+\epsilon_b*\sigma_b)
+    , where \epsilon are random variables sampled from factorized normal
+    distributions and \sigma are trainable variables which are expected to
+    vanish along the training procedure.
+    """
+
+    def __init__(
+        self, prefix: str, out_size: int, sigma0: float, activation: str = "relu"
+    ):
+        """Initializes a NoisyLayer object.
+
+        Args:
+            prefix:
+            out_size: Output size for Noisy Layer
+            sigma0: Initialization value for sigma_b (bias noise)
+            non_linear: Non-linear activation for Noisy Layer
+        """
+        super().__init__()
+        self.prefix = prefix
+        self.out_size = out_size
+        # TF noise generation can be unreliable on GPU
+        # If generating the noise on the CPU,
+        # lowering sigma0 to 0.1 may be helpful
+        self.sigma0 = sigma0  # 0.5~GPU, 0.1~CPU
+        self.activation = activation
+        # Variables.
+        self.w = None  # Weight matrix.
+        self.b = None  # Biases.
+        self.sigma_w = None  # Noise for weight matrix
+        self.sigma_b = None  # Noise for biases.
+        if log_once("noisy_layer"):
+            deprecation_warning(
+                old="rllib.models.tf.layers.NoisyLayer",
+            )
+
+    def build(self, input_shape: TensorShape):
+        in_size = int(input_shape[1])
+
+        self.sigma_w = get_variable(
+            value=tf.keras.initializers.RandomUniform(
+                minval=-1.0 / np.sqrt(float(in_size)),
+                maxval=1.0 / np.sqrt(float(in_size)),
+            ),
+            trainable=True,
+            tf_name=self.prefix + "_sigma_w",
+            shape=[in_size, self.out_size],
+            dtype=tf.float32,
+        )
+
+        self.sigma_b = get_variable(
+            value=tf.keras.initializers.Constant(self.sigma0 / np.sqrt(float(in_size))),
+            trainable=True,
+            tf_name=self.prefix + "_sigma_b",
+            shape=[self.out_size],
+            dtype=tf.float32,
+        )
+
+        self.w = get_variable(
+            value=tf.keras.initializers.GlorotUniform(),
+            tf_name=self.prefix + "_fc_w",
+            trainable=True,
+            shape=[in_size, self.out_size],
+            dtype=tf.float32,
+        )
+
+        self.b = get_variable(
+            value=tf.keras.initializers.Zeros(),
+            tf_name=self.prefix + "_fc_b",
+            trainable=True,
+            shape=[self.out_size],
+            dtype=tf.float32,
+        )
+
+    def call(self, inputs: TensorType) -> TensorType:
+        in_size = int(inputs.shape[1])
+        epsilon_in = tf.random.normal(shape=[in_size])
+        epsilon_out = tf.random.normal(shape=[self.out_size])
+        epsilon_in = self._f_epsilon(epsilon_in)
+        epsilon_out = self._f_epsilon(epsilon_out)
+        epsilon_w = tf.matmul(
+            a=tf.expand_dims(epsilon_in, -1), b=tf.expand_dims(epsilon_out, 0)
+        )
+        epsilon_b = epsilon_out
+
+        action_activation = (
+            tf.matmul(inputs, self.w + self.sigma_w * epsilon_w)
+            + self.b
+            + self.sigma_b * epsilon_b
+        )
+
+        fn = get_activation_fn(self.activation, framework="tf")
+        if fn is not None:
+            action_activation = fn(action_activation)
+        return action_activation
+
+    def _f_epsilon(self, x: TensorType) -> TensorType:
+        return tf.math.sign(x) * tf.math.sqrt(tf.math.abs(x))

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/relative_multi_head_attention.py

@@ -0,0 +1,147 @@
+from typing import Optional
+
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+class RelativeMultiHeadAttention(tf.keras.layers.Layer if tf else object):
+    """A RelativeMultiHeadAttention layer as described in [3].
+
+    Uses segment level recurrence with state reuse.
+    """
+
+    def __init__(
+        self,
+        out_dim: int,
+        num_heads: int,
+        head_dim: int,
+        input_layernorm: bool = False,
+        output_activation: Optional["tf.nn.activation"] = None,
+        **kwargs
+    ):
+        """Initializes a RelativeMultiHeadAttention keras Layer object.
+
+        Args:
+            out_dim: The output dimensions of the multi-head attention
+                unit.
+            num_heads: The number of attention heads to use.
+                Denoted `H` in [2].
+            head_dim: The dimension of a single(!) attention head within
+                a multi-head attention unit. Denoted as `d` in [3].
+            input_layernorm: Whether to prepend a LayerNorm before
+                everything else. Should be True for building a GTrXL.
+            output_activation (Optional[tf.nn.activation]): Optional tf.nn
+                activation function. Should be relu for GTrXL.
+            **kwargs:
+        """
+        if log_once("relative_multi_head_attention"):
+            deprecation_warning(
+                old="rllib.models.tf.layers.RelativeMultiHeadAttention",
+            )
+        super().__init__(**kwargs)
+
+        # No bias or non-linearity.
+        self._num_heads = num_heads
+        self._head_dim = head_dim
+        # 3=Query, key, and value inputs.
+        self._qkv_layer = tf.keras.layers.Dense(
+            3 * num_heads * head_dim, use_bias=False
+        )
+        self._linear_layer = tf.keras.layers.TimeDistributed(
+            tf.keras.layers.Dense(out_dim, use_bias=False, activation=output_activation)
+        )
+
+        self._uvar = self.add_weight(shape=(num_heads, head_dim))
+        self._vvar = self.add_weight(shape=(num_heads, head_dim))
+
+        # Constant (non-trainable) sinusoid rel pos encoding matrix, which
+        # depends on this incoming time dimension.
+        # For inference, we prepend the memory to the current timestep's
+        # input: Tau + 1. For training, we prepend the memory to the input
+        # sequence: Tau + T.
+        self._pos_embedding = PositionalEmbedding(out_dim)
+        self._pos_proj = tf.keras.layers.Dense(num_heads * head_dim, use_bias=False)
+
+        self._input_layernorm = None
+        if input_layernorm:
+            self._input_layernorm = tf.keras.layers.LayerNormalization(axis=-1)
+
+    def call(
+        self, inputs: TensorType, memory: Optional[TensorType] = None
+    ) -> TensorType:
+        T = tf.shape(inputs)[1]  # length of segment (time)
+        H = self._num_heads  # number of attention heads
+        d = self._head_dim  # attention head dimension
+
+        # Add previous memory chunk (as const, w/o gradient) to input.
+        # Tau (number of (prev) time slices in each memory chunk).
+        Tau = tf.shape(memory)[1]
+        inputs = tf.concat([tf.stop_gradient(memory), inputs], axis=1)
+
+        # Apply the Layer-Norm.
+        if self._input_layernorm is not None:
+            inputs = self._input_layernorm(inputs)
+
+        qkv = self._qkv_layer(inputs)
+
+        queries, keys, values = tf.split(qkv, 3, -1)
+        # Cut out memory timesteps from query.
+        queries = queries[:, -T:]
+
+        # Splitting up queries into per-head dims (d).
+        queries = tf.reshape(queries, [-1, T, H, d])
+        keys = tf.reshape(keys, [-1, Tau + T, H, d])
+        values = tf.reshape(values, [-1, Tau + T, H, d])
+
+        R = self._pos_embedding(Tau + T)
+        R = self._pos_proj(R)
+        R = tf.reshape(R, [Tau + T, H, d])
+
+        # b=batch
+        # i and j=time indices (i=max-timesteps (inputs); j=Tau memory space)
+        # h=head
+        # d=head-dim (over which we will reduce-sum)
+        score = tf.einsum("bihd,bjhd->bijh", queries + self._uvar, keys)
+        pos_score = tf.einsum("bihd,jhd->bijh", queries + self._vvar, R)
+        score = score + self.rel_shift(pos_score)
+        score = score / d**0.5
+
+        # Causal mask of the same length as the sequence.
+        mask = tf.sequence_mask(tf.range(Tau + 1, Tau + T + 1), dtype=score.dtype)
+        mask = mask[None, :, :, None]
+
+        masked_score = score * mask + 1e30 * (mask - 1.0)
+        wmat = tf.nn.softmax(masked_score, axis=2)
+
+        out = tf.einsum("bijh,bjhd->bihd", wmat, values)
+        out = tf.reshape(out, tf.concat((tf.shape(out)[:2], [H * d]), axis=0))
+        return self._linear_layer(out)
+
+    @staticmethod
+    def rel_shift(x: TensorType) -> TensorType:
+        # Transposed version of the shift approach described in [3].
+        # https://github.com/kimiyoung/transformer-xl/blob/
+        # 44781ed21dbaec88b280f74d9ae2877f52b492a5/tf/model.py#L31
+        x_size = tf.shape(x)
+
+        x = tf.pad(x, [[0, 0], [0, 0], [1, 0], [0, 0]])
+        x = tf.reshape(x, [x_size[0], x_size[2] + 1, x_size[1], x_size[3]])
+        x = x[:, 1:, :, :]
+        x = tf.reshape(x, x_size)
+
+        return x
+
+
+class PositionalEmbedding(tf.keras.layers.Layer if tf else object):
+    def __init__(self, out_dim, **kwargs):
+        super().__init__(**kwargs)
+        self.inverse_freq = 1 / (10000 ** (tf.range(0, out_dim, 2.0) / out_dim))
+
+    def call(self, seq_length):
+        pos_offsets = tf.cast(tf.range(seq_length - 1, -1, -1), tf.float32)
+        inputs = pos_offsets[:, None] * self.inverse_freq[None, :]
+        return tf.concat((tf.sin(inputs), tf.cos(inputs)), axis=-1)

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/layers/skip_connection.py

@@ -0,0 +1,46 @@
+from typing import Optional, Any
+
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util import log_once
+
+tf1, tf, tfv = try_import_tf()
+
+
+class SkipConnection(tf.keras.layers.Layer if tf else object):
+    """Skip connection layer.
+
+    Adds the original input to the output (regular residual layer) OR uses
+    input as hidden state input to a given fan_in_layer.
+    """
+
+    def __init__(self, layer: Any, fan_in_layer: Optional[Any] = None, **kwargs):
+        """Initializes a SkipConnection keras layer object.
+
+        Args:
+            layer (tf.keras.layers.Layer): Any layer processing inputs.
+            fan_in_layer (Optional[tf.keras.layers.Layer]): An optional
+                layer taking two inputs: The original input and the output
+                of `layer`.
+        """
+        if log_once("skip_connection"):
+            deprecation_warning(
+                old="rllib.models.tf.layers.SkipConnection",
+            )
+        super().__init__(**kwargs)
+        self._layer = layer
+        self._fan_in_layer = fan_in_layer
+
+    def call(self, inputs: TensorType, **kwargs) -> TensorType:
+        # del kwargs
+        outputs = self._layer(inputs, **kwargs)
+        # Residual case, just add inputs to outputs.
+        if self._fan_in_layer is None:
+            outputs = outputs + inputs
+        # Fan-in e.g. RNN: Call fan-in with `inputs` and `outputs`.
+        else:
+            # NOTE: In the GRU case, `inputs` is the state input.
+            outputs = self._fan_in_layer((inputs, outputs))
+
+        return outputs

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/misc.py

@@ -0,0 +1,90 @@
+import numpy as np
+from typing import Tuple, Any, Optional
+
+from ray.rllib.utils.annotations import DeveloperAPI
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import TensorType
+
+tf1, tf, tfv = try_import_tf()
+
+
+# TODO: (sven) obsolete this class.
+@DeveloperAPI
+def normc_initializer(std: float = 1.0) -> Any:
+    def _initializer(shape, dtype=None, partition_info=None):
+        out = np.random.randn(*shape).astype(
+            dtype.name if hasattr(dtype, "name") else dtype or np.float32
+        )
+        out *= std / np.sqrt(np.square(out).sum(axis=0, keepdims=True))
+        return tf.constant(out)
+
+    return _initializer
+
+
+@DeveloperAPI
+def conv2d(
+    x: TensorType,
+    num_filters: int,
+    name: str,
+    filter_size: Tuple[int, int] = (3, 3),
+    stride: Tuple[int, int] = (1, 1),
+    pad: str = "SAME",
+    dtype: Optional[Any] = None,
+    collections: Optional[Any] = None,
+) -> TensorType:
+
+    if dtype is None:
+        dtype = tf.float32
+
+    with tf1.variable_scope(name):
+        stride_shape = [1, stride[0], stride[1], 1]
+        filter_shape = [
+            filter_size[0],
+            filter_size[1],
+            int(x.get_shape()[3]),
+            num_filters,
+        ]
+
+        # There are "num input feature maps * filter height * filter width"
+        # inputs to each hidden unit.
+        fan_in = np.prod(filter_shape[:3])
+        # Each unit in the lower layer receives a gradient from: "num output
+        # feature maps * filter height * filter width" / pooling size.
+        fan_out = np.prod(filter_shape[:2]) * num_filters
+        # Initialize weights with random weights.
+        w_bound = np.sqrt(6 / (fan_in + fan_out))
+
+        w = tf1.get_variable(
+            "W",
+            filter_shape,
+            dtype,
+            tf1.random_uniform_initializer(-w_bound, w_bound),
+            collections=collections,
+        )
+        b = tf1.get_variable(
+            "b",
+            [1, 1, 1, num_filters],
+            initializer=tf1.constant_initializer(0.0),
+            collections=collections,
+        )
+        return tf1.nn.conv2d(x, w, stride_shape, pad) + b
+
+
+@DeveloperAPI
+def linear(
+    x: TensorType,
+    size: int,
+    name: str,
+    initializer: Optional[Any] = None,
+    bias_init: float = 0.0,
+) -> TensorType:
+    w = tf1.get_variable(name + "/w", [x.get_shape()[1], size], initializer=initializer)
+    b = tf1.get_variable(
+        name + "/b", [size], initializer=tf1.constant_initializer(bias_init)
+    )
+    return tf.matmul(x, w) + b
+
+
+@DeveloperAPI
+def flatten(x: TensorType) -> TensorType:
+    return tf.reshape(x, [-1, np.prod(x.get_shape().as_list()[1:])])

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/recurrent_net.py

@@ -0,0 +1,292 @@
+import numpy as np
+import gymnasium as gym
+from gymnasium.spaces import Discrete, MultiDiscrete
+import logging
+import tree  # pip install dm_tree
+from typing import Dict, List, Tuple
+
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.policy.rnn_sequencing import add_time_dimension
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.policy.view_requirement import ViewRequirement
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.tf_utils import flatten_inputs_to_1d_tensor, one_hot
+from ray.rllib.utils.typing import ModelConfigDict, TensorType
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.util.debug import log_once
+
+tf1, tf, tfv = try_import_tf()
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class RecurrentNetwork(TFModelV2):
+    """Helper class to simplify implementing RNN models with TFModelV2.
+
+    Instead of implementing forward(), you can implement forward_rnn() which
+    takes batches with the time dimension added already.
+
+    Here is an example implementation for a subclass
+    ``MyRNNClass(RecurrentNetwork)``::
+
+        def __init__(self, *args, **kwargs):
+            super(MyModelClass, self).__init__(*args, **kwargs)
+            cell_size = 256
+
+            # Define input layers
+            input_layer = tf.keras.layers.Input(
+                shape=(None, obs_space.shape[0]))
+            state_in_h = tf.keras.layers.Input(shape=(256, ))
+            state_in_c = tf.keras.layers.Input(shape=(256, ))
+            seq_in = tf.keras.layers.Input(shape=(), dtype=tf.int32)
+
+            # Send to LSTM cell
+            lstm_out, state_h, state_c = tf.keras.layers.LSTM(
+                cell_size, return_sequences=True, return_state=True,
+                name="lstm")(
+                    inputs=input_layer,
+                    mask=tf.sequence_mask(seq_in),
+                    initial_state=[state_in_h, state_in_c])
+            output_layer = tf.keras.layers.Dense(...)(lstm_out)
+
+            # Create the RNN model
+            self.rnn_model = tf.keras.Model(
+                inputs=[input_layer, seq_in, state_in_h, state_in_c],
+                outputs=[output_layer, state_h, state_c])
+            self.rnn_model.summary()
+    """
+
+    @override(ModelV2)
+    def forward(
+        self,
+        input_dict: Dict[str, TensorType],
+        state: List[TensorType],
+        seq_lens: TensorType,
+    ) -> Tuple[TensorType, List[TensorType]]:
+        """Adds time dimension to batch before sending inputs to forward_rnn().
+
+        You should implement forward_rnn() in your subclass."""
+        # Creating a __init__ function that acts as a passthrough and adding the warning
+        # there led to errors probably due to the multiple inheritance. We encountered
+        # the same error if we add the Deprecated decorator. We therefore add the
+        # deprecation warning here.
+        if log_once("recurrent_network_tf"):
+            deprecation_warning(
+                old="ray.rllib.models.tf.recurrent_net.RecurrentNetwork"
+            )
+        assert seq_lens is not None
+        flat_inputs = input_dict["obs_flat"]
+        inputs = add_time_dimension(
+            padded_inputs=flat_inputs, seq_lens=seq_lens, framework="tf"
+        )
+        output, new_state = self.forward_rnn(
+            inputs,
+            state,
+            seq_lens,
+        )
+        return tf.reshape(output, [-1, self.num_outputs]), new_state
+
+    def forward_rnn(
+        self, inputs: TensorType, state: List[TensorType], seq_lens: TensorType
+    ) -> Tuple[TensorType, List[TensorType]]:
+        """Call the model with the given input tensors and state.
+
+        Args:
+            inputs: observation tensor with shape [B, T, obs_size].
+            state: list of state tensors, each with shape [B, T, size].
+            seq_lens: 1d tensor holding input sequence lengths.
+
+        Returns:
+            (outputs, new_state): The model output tensor of shape
+                [B, T, num_outputs] and the list of new state tensors each with
+                shape [B, size].
+
+        Sample implementation for the ``MyRNNClass`` example::
+
+            def forward_rnn(self, inputs, state, seq_lens):
+                model_out, h, c = self.rnn_model([inputs, seq_lens] + state)
+                return model_out, [h, c]
+        """
+        raise NotImplementedError("You must implement this for a RNN model")
+
+    def get_initial_state(self) -> List[TensorType]:
+        """Get the initial recurrent state values for the model.
+
+        Returns:
+            list of np.array objects, if any
+
+        Sample implementation for the ``MyRNNClass`` example::
+
+            def get_initial_state(self):
+                return [
+                    np.zeros(self.cell_size, np.float32),
+                    np.zeros(self.cell_size, np.float32),
+                ]
+        """
+        raise NotImplementedError("You must implement this for a RNN model")
+
+
+@OldAPIStack
+class LSTMWrapper(RecurrentNetwork):
+    """An LSTM wrapper serving as an interface for ModelV2s that set use_lstm."""
+
+    def __init__(
+        self,
+        obs_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+    ):
+        super(LSTMWrapper, self).__init__(
+            obs_space, action_space, None, model_config, name
+        )
+        # At this point, self.num_outputs is the number of nodes coming
+        # from the wrapped (underlying) model. In other words, self.num_outputs
+        # is the input size for the LSTM layer.
+        # If None, set it to the observation space.
+        if self.num_outputs is None:
+            self.num_outputs = int(np.prod(self.obs_space.shape))
+
+        self.cell_size = model_config["lstm_cell_size"]
+        self.use_prev_action = model_config["lstm_use_prev_action"]
+        self.use_prev_reward = model_config["lstm_use_prev_reward"]
+
+        self.action_space_struct = get_base_struct_from_space(self.action_space)
+        self.action_dim = 0
+
+        for space in tree.flatten(self.action_space_struct):
+            if isinstance(space, Discrete):
+                self.action_dim += space.n
+            elif isinstance(space, MultiDiscrete):
+                self.action_dim += np.sum(space.nvec)
+            elif space.shape is not None:
+                self.action_dim += int(np.prod(space.shape))
+            else:
+                self.action_dim += int(len(space))
+
+        # Add prev-action/reward nodes to input to LSTM.
+        if self.use_prev_action:
+            self.num_outputs += self.action_dim
+        if self.use_prev_reward:
+            self.num_outputs += 1
+
+        # Define input layers.
+        input_layer = tf.keras.layers.Input(
+            shape=(None, self.num_outputs), name="inputs"
+        )
+
+        # Set self.num_outputs to the number of output nodes desired by the
+        # caller of this constructor.
+        self.num_outputs = num_outputs
+
+        state_in_h = tf.keras.layers.Input(shape=(self.cell_size,), name="h")
+        state_in_c = tf.keras.layers.Input(shape=(self.cell_size,), name="c")
+        seq_in = tf.keras.layers.Input(shape=(), name="seq_in", dtype=tf.int32)
+
+        # Preprocess observation with a hidden layer and send to LSTM cell
+        lstm_out, state_h, state_c = tf.keras.layers.LSTM(
+            self.cell_size, return_sequences=True, return_state=True, name="lstm"
+        )(
+            inputs=input_layer,
+            mask=tf.sequence_mask(seq_in),
+            initial_state=[state_in_h, state_in_c],
+        )
+
+        # Postprocess LSTM output with another hidden layer and compute values
+        logits = tf.keras.layers.Dense(
+            self.num_outputs, activation=tf.keras.activations.linear, name="logits"
+        )(lstm_out)
+        values = tf.keras.layers.Dense(1, activation=None, name="values")(lstm_out)
+
+        # Create the RNN model
+        self._rnn_model = tf.keras.Model(
+            inputs=[input_layer, seq_in, state_in_h, state_in_c],
+            outputs=[logits, values, state_h, state_c],
+        )
+        # Print out model summary in INFO logging mode.
+        if logger.isEnabledFor(logging.INFO):
+            self._rnn_model.summary()
+
+        # Add prev-a/r to this model's view, if required.
+        if model_config["lstm_use_prev_action"]:
+            self.view_requirements[SampleBatch.PREV_ACTIONS] = ViewRequirement(
+                SampleBatch.ACTIONS, space=self.action_space, shift=-1
+            )
+        if model_config["lstm_use_prev_reward"]:
+            self.view_requirements[SampleBatch.PREV_REWARDS] = ViewRequirement(
+                SampleBatch.REWARDS, shift=-1
+            )
+
+    @override(RecurrentNetwork)
+    def forward(
+        self,
+        input_dict: Dict[str, TensorType],
+        state: List[TensorType],
+        seq_lens: TensorType,
+    ) -> Tuple[TensorType, List[TensorType]]:
+        assert seq_lens is not None
+        # Push obs through "unwrapped" net's `forward()` first.
+        wrapped_out, _ = self._wrapped_forward(input_dict, [], None)
+
+        # Concat. prev-action/reward if required.
+        prev_a_r = []
+
+        # Prev actions.
+        if self.model_config["lstm_use_prev_action"]:
+            prev_a = input_dict[SampleBatch.PREV_ACTIONS]
+            # If actions are not processed yet (in their original form as
+            # have been sent to environment):
+            # Flatten/one-hot into 1D array.
+            if self.model_config["_disable_action_flattening"]:
+                prev_a_r.append(
+                    flatten_inputs_to_1d_tensor(
+                        prev_a,
+                        spaces_struct=self.action_space_struct,
+                        time_axis=False,
+                    )
+                )
+            # If actions are already flattened (but not one-hot'd yet!),
+            # one-hot discrete/multi-discrete actions here.
+            else:
+                if isinstance(self.action_space, (Discrete, MultiDiscrete)):
+                    prev_a = one_hot(prev_a, self.action_space)
+                prev_a_r.append(
+                    tf.reshape(tf.cast(prev_a, tf.float32), [-1, self.action_dim])
+                )
+        # Prev rewards.
+        if self.model_config["lstm_use_prev_reward"]:
+            prev_a_r.append(
+                tf.reshape(
+                    tf.cast(input_dict[SampleBatch.PREV_REWARDS], tf.float32), [-1, 1]
+                )
+            )
+
+        # Concat prev. actions + rewards to the "main" input.
+        if prev_a_r:
+            wrapped_out = tf.concat([wrapped_out] + prev_a_r, axis=1)
+
+        # Push everything through our LSTM.
+        input_dict["obs_flat"] = wrapped_out
+        return super().forward(input_dict, state, seq_lens)
+
+    @override(RecurrentNetwork)
+    def forward_rnn(
+        self, inputs: TensorType, state: List[TensorType], seq_lens: TensorType
+    ) -> Tuple[TensorType, List[TensorType]]:
+        model_out, self._value_out, h, c = self._rnn_model([inputs, seq_lens] + state)
+        return model_out, [h, c]
+
+    @override(ModelV2)
+    def get_initial_state(self) -> List[np.ndarray]:
+        return [
+            np.zeros(self.cell_size, np.float32),
+            np.zeros(self.cell_size, np.float32),
+        ]
+
+    @override(ModelV2)
+    def value_function(self) -> TensorType:
+        return tf.reshape(self._value_out, [-1])

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/tf_action_dist.py

@@ -0,0 +1,735 @@
+import functools
+import gymnasium as gym
+from math import log
+import numpy as np
+import tree  # pip install dm_tree
+from typing import Optional
+
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.utils import MIN_LOG_NN_OUTPUT, MAX_LOG_NN_OUTPUT, SMALL_NUMBER
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf, try_import_tfp
+from ray.rllib.utils.spaces.space_utils import get_base_struct_from_space
+from ray.rllib.utils.typing import TensorType, List, Union, Tuple, ModelConfigDict
+
+tf1, tf, tfv = try_import_tf()
+tfp = try_import_tfp()
+
+
+@OldAPIStack
+class TFActionDistribution(ActionDistribution):
+    """TF-specific extensions for building action distributions."""
+
+    @override(ActionDistribution)
+    def __init__(self, inputs: List[TensorType], model: ModelV2):
+        super().__init__(inputs, model)
+        self.sample_op = self._build_sample_op()
+        self.sampled_action_logp_op = self.logp(self.sample_op)
+
+    def _build_sample_op(self) -> TensorType:
+        """Implement this instead of sample(), to enable op reuse.
+
+        This is needed since the sample op is non-deterministic and is shared
+        between sample() and sampled_action_logp().
+        """
+        raise NotImplementedError
+
+    @override(ActionDistribution)
+    def sample(self) -> TensorType:
+        """Draw a sample from the action distribution."""
+        return self.sample_op
+
+    @override(ActionDistribution)
+    def sampled_action_logp(self) -> TensorType:
+        """Returns the log probability of the sampled action."""
+        return self.sampled_action_logp_op
+
+
+@OldAPIStack
+class Categorical(TFActionDistribution):
+    """Categorical distribution for discrete action spaces."""
+
+    def __init__(
+        self, inputs: List[TensorType], model: ModelV2 = None, temperature: float = 1.0
+    ):
+        assert temperature > 0.0, "Categorical `temperature` must be > 0.0!"
+        # Allow softmax formula w/ temperature != 1.0:
+        # Divide inputs by temperature.
+        super().__init__(inputs / temperature, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        return tf.math.argmax(self.inputs, axis=1)
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        return -tf.nn.sparse_softmax_cross_entropy_with_logits(
+            logits=self.inputs, labels=tf.cast(x, tf.int32)
+        )
+
+    @override(ActionDistribution)
+    def entropy(self) -> TensorType:
+        a0 = self.inputs - tf.reduce_max(self.inputs, axis=1, keepdims=True)
+        ea0 = tf.exp(a0)
+        z0 = tf.reduce_sum(ea0, axis=1, keepdims=True)
+        p0 = ea0 / z0
+        return tf.reduce_sum(p0 * (tf.math.log(z0) - a0), axis=1)
+
+    @override(ActionDistribution)
+    def kl(self, other: ActionDistribution) -> TensorType:
+        a0 = self.inputs - tf.reduce_max(self.inputs, axis=1, keepdims=True)
+        a1 = other.inputs - tf.reduce_max(other.inputs, axis=1, keepdims=True)
+        ea0 = tf.exp(a0)
+        ea1 = tf.exp(a1)
+        z0 = tf.reduce_sum(ea0, axis=1, keepdims=True)
+        z1 = tf.reduce_sum(ea1, axis=1, keepdims=True)
+        p0 = ea0 / z0
+        return tf.reduce_sum(p0 * (a0 - tf.math.log(z0) - a1 + tf.math.log(z1)), axis=1)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return tf.squeeze(tf.random.categorical(self.inputs, 1), axis=1)
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(action_space, model_config):
+        return action_space.n
+
+
+@OldAPIStack
+def get_categorical_class_with_temperature(t: float):
+    """Categorical distribution class that has customized default temperature."""
+
+    class CategoricalWithTemperature(Categorical):
+        def __init__(self, inputs, model=None, temperature=t):
+            super().__init__(inputs, model, temperature)
+
+    return CategoricalWithTemperature
+
+
+@OldAPIStack
+class MultiCategorical(TFActionDistribution):
+    """MultiCategorical distribution for MultiDiscrete action spaces."""
+
+    def __init__(
+        self,
+        inputs: List[TensorType],
+        model: ModelV2,
+        input_lens: Union[List[int], np.ndarray, Tuple[int, ...]],
+        action_space=None,
+    ):
+        # skip TFActionDistribution init
+        ActionDistribution.__init__(self, inputs, model)
+        self.cats = [
+            Categorical(input_, model)
+            for input_ in tf.split(inputs, input_lens, axis=1)
+        ]
+        self.action_space = action_space
+        if self.action_space is None:
+            self.action_space = gym.spaces.MultiDiscrete(
+                [c.inputs.shape[1] for c in self.cats]
+            )
+        self.sample_op = self._build_sample_op()
+        self.sampled_action_logp_op = self.logp(self.sample_op)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        sample_ = tf.stack([cat.deterministic_sample() for cat in self.cats], axis=1)
+        if isinstance(self.action_space, gym.spaces.Box):
+            return tf.cast(
+                tf.reshape(sample_, [-1] + list(self.action_space.shape)),
+                self.action_space.dtype,
+            )
+        return sample_
+
+    @override(ActionDistribution)
+    def logp(self, actions: TensorType) -> TensorType:
+        # If tensor is provided, unstack it into list.
+        if isinstance(actions, tf.Tensor):
+            if isinstance(self.action_space, gym.spaces.Box):
+                actions = tf.reshape(
+                    actions, [-1, int(np.prod(self.action_space.shape))]
+                )
+            elif isinstance(self.action_space, gym.spaces.MultiDiscrete):
+                actions.set_shape((None, len(self.cats)))
+            actions = tf.unstack(tf.cast(actions, tf.int32), axis=1)
+        logps = tf.stack([cat.logp(act) for cat, act in zip(self.cats, actions)])
+        return tf.reduce_sum(logps, axis=0)
+
+    @override(ActionDistribution)
+    def multi_entropy(self) -> TensorType:
+        return tf.stack([cat.entropy() for cat in self.cats], axis=1)
+
+    @override(ActionDistribution)
+    def entropy(self) -> TensorType:
+        return tf.reduce_sum(self.multi_entropy(), axis=1)
+
+    @override(ActionDistribution)
+    def multi_kl(self, other: ActionDistribution) -> TensorType:
+        return tf.stack(
+            [cat.kl(oth_cat) for cat, oth_cat in zip(self.cats, other.cats)], axis=1
+        )
+
+    @override(ActionDistribution)
+    def kl(self, other: ActionDistribution) -> TensorType:
+        return tf.reduce_sum(self.multi_kl(other), axis=1)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        sample_op = tf.stack([cat.sample() for cat in self.cats], axis=1)
+        if isinstance(self.action_space, gym.spaces.Box):
+            return tf.cast(
+                tf.reshape(sample_op, [-1] + list(self.action_space.shape)),
+                dtype=self.action_space.dtype,
+            )
+        return sample_op
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        # Int Box.
+        if isinstance(action_space, gym.spaces.Box):
+            assert action_space.dtype.name.startswith("int")
+            low_ = np.min(action_space.low)
+            high_ = np.max(action_space.high)
+            assert np.all(action_space.low == low_)
+            assert np.all(action_space.high == high_)
+            return np.prod(action_space.shape, dtype=np.int32) * (high_ - low_ + 1)
+        # MultiDiscrete space.
+        else:
+            # nvec is already integer, so no casting needed.
+            return np.sum(action_space.nvec)
+
+
+@OldAPIStack
+class SlateMultiCategorical(Categorical):
+    """MultiCategorical distribution for MultiDiscrete action spaces.
+
+    The action space must be uniform, meaning all nvec items have the same size, e.g.
+    MultiDiscrete([10, 10, 10]), where 10 is the number of candidates to pick from
+    and 3 is the slate size (pick 3 out of 10). When picking candidates, no candidate
+    must be picked more than once.
+    """
+
+    def __init__(
+        self,
+        inputs: List[TensorType],
+        model: ModelV2 = None,
+        temperature: float = 1.0,
+        action_space: Optional[gym.spaces.MultiDiscrete] = None,
+        all_slates=None,
+    ):
+        assert temperature > 0.0, "Categorical `temperature` must be > 0.0!"
+        # Allow softmax formula w/ temperature != 1.0:
+        # Divide inputs by temperature.
+        super().__init__(inputs / temperature, model)
+        self.action_space = action_space
+        # Assert uniformness of the action space (all discrete buckets have the same
+        # size).
+        assert isinstance(self.action_space, gym.spaces.MultiDiscrete) and all(
+            n == self.action_space.nvec[0] for n in self.action_space.nvec
+        )
+        self.all_slates = all_slates
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        # Get a sample from the underlying Categorical (batch of ints).
+        sample = super().deterministic_sample()
+        # Use the sampled ints to pick the actual slates.
+        return tf.gather(self.all_slates, sample)
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        # TODO: Implement.
+        return tf.ones_like(self.inputs[:, 0])
+
+
+@OldAPIStack
+class GumbelSoftmax(TFActionDistribution):
+    """GumbelSoftmax distr. (for differentiable sampling in discr. actions
+
+    The Gumbel Softmax distribution [1] (also known as the Concrete [2]
+    distribution) is a close cousin of the relaxed one-hot categorical
+    distribution, whose tfp implementation we will use here plus
+    adjusted `sample_...` and `log_prob` methods. See discussion at [0].
+
+    [0] https://stackoverflow.com/questions/56226133/
+    soft-actor-critic-with-discrete-action-space
+
+    [1] Categorical Reparametrization with Gumbel-Softmax (Jang et al, 2017):
+    https://arxiv.org/abs/1611.01144
+    [2] The Concrete Distribution: A Continuous Relaxation of Discrete Random
+    Variables (Maddison et al, 2017) https://arxiv.org/abs/1611.00712
+    """
+
+    def __init__(
+        self, inputs: List[TensorType], model: ModelV2 = None, temperature: float = 1.0
+    ):
+        """Initializes a GumbelSoftmax distribution.
+
+        Args:
+            temperature: Temperature parameter. For low temperatures,
+                the expected value approaches a categorical random variable.
+                For high temperatures, the expected value approaches a uniform
+                distribution.
+        """
+        assert temperature >= 0.0
+        self.dist = tfp.distributions.RelaxedOneHotCategorical(
+            temperature=temperature, logits=inputs
+        )
+        self.probs = tf.nn.softmax(self.dist._distribution.logits)
+        super().__init__(inputs, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        # Return the dist object's prob values.
+        return self.probs
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        # Override since the implementation of tfp.RelaxedOneHotCategorical
+        # yields positive values.
+        if x.shape != self.dist.logits.shape:
+            values = tf.one_hot(
+                x, self.dist.logits.shape.as_list()[-1], dtype=tf.float32
+            )
+            assert values.shape == self.dist.logits.shape, (
+                values.shape,
+                self.dist.logits.shape,
+            )
+
+        # [0]'s implementation (see line below) seems to be an approximation
+        # to the actual Gumbel Softmax density.
+        return -tf.reduce_sum(
+            -x * tf.nn.log_softmax(self.dist.logits, axis=-1), axis=-1
+        )
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return self.dist.sample()
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return action_space.n
+
+
+@OldAPIStack
+class DiagGaussian(TFActionDistribution):
+    """Action distribution where each vector element is a gaussian.
+
+    The first half of the input vector defines the gaussian means, and the
+    second half the gaussian standard deviations.
+    """
+
+    def __init__(
+        self,
+        inputs: List[TensorType],
+        model: ModelV2,
+        *,
+        action_space: Optional[gym.spaces.Space] = None
+    ):
+        mean, log_std = tf.split(inputs, 2, axis=1)
+        self.mean = mean
+        self.log_std = log_std
+        self.std = tf.exp(log_std)
+        # Remember to squeeze action samples in case action space is Box(shape)
+        self.zero_action_dim = action_space and action_space.shape == ()
+        super().__init__(inputs, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        return self.mean
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        # Cover case where action space is Box(shape=()).
+        if int(tf.shape(x).shape[0]) == 1:
+            x = tf.expand_dims(x, axis=1)
+        return (
+            -0.5
+            * tf.reduce_sum(
+                tf.math.square((tf.cast(x, tf.float32) - self.mean) / self.std), axis=1
+            )
+            - 0.5 * np.log(2.0 * np.pi) * tf.cast(tf.shape(x)[1], tf.float32)
+            - tf.reduce_sum(self.log_std, axis=1)
+        )
+
+    @override(ActionDistribution)
+    def kl(self, other: ActionDistribution) -> TensorType:
+        assert isinstance(other, DiagGaussian)
+        return tf.reduce_sum(
+            other.log_std
+            - self.log_std
+            + (tf.math.square(self.std) + tf.math.square(self.mean - other.mean))
+            / (2.0 * tf.math.square(other.std))
+            - 0.5,
+            axis=1,
+        )
+
+    @override(ActionDistribution)
+    def entropy(self) -> TensorType:
+        return tf.reduce_sum(self.log_std + 0.5 * np.log(2.0 * np.pi * np.e), axis=1)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        sample = self.mean + self.std * tf.random.normal(tf.shape(self.mean))
+        if self.zero_action_dim:
+            return tf.squeeze(sample, axis=-1)
+        return sample
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return np.prod(action_space.shape, dtype=np.int32) * 2
+
+
+@OldAPIStack
+class SquashedGaussian(TFActionDistribution):
+    """A tanh-squashed Gaussian distribution defined by: mean, std, low, high.
+
+    The distribution will never return low or high exactly, but
+    `low`+SMALL_NUMBER or `high`-SMALL_NUMBER respectively.
+    """
+
+    def __init__(
+        self,
+        inputs: List[TensorType],
+        model: ModelV2,
+        low: float = -1.0,
+        high: float = 1.0,
+    ):
+        """Parameterizes the distribution via `inputs`.
+
+        Args:
+            low: The lowest possible sampling value
+                (excluding this value).
+            high: The highest possible sampling value
+                (excluding this value).
+        """
+        assert tfp is not None
+        mean, log_std = tf.split(inputs, 2, axis=-1)
+        # Clip `scale` values (coming from NN) to reasonable values.
+        log_std = tf.clip_by_value(log_std, MIN_LOG_NN_OUTPUT, MAX_LOG_NN_OUTPUT)
+        std = tf.exp(log_std)
+        self.distr = tfp.distributions.Normal(loc=mean, scale=std)
+        assert np.all(np.less(low, high))
+        self.low = low
+        self.high = high
+        super().__init__(inputs, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        mean = self.distr.mean()
+        return self._squash(mean)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return self._squash(self.distr.sample())
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        # Unsquash values (from [low,high] to ]-inf,inf[)
+        unsquashed_values = tf.cast(self._unsquash(x), self.inputs.dtype)
+        # Get log prob of unsquashed values from our Normal.
+        log_prob_gaussian = self.distr.log_prob(unsquashed_values)
+        # For safety reasons, clamp somehow, only then sum up.
+        log_prob_gaussian = tf.clip_by_value(log_prob_gaussian, -100, 100)
+        log_prob_gaussian = tf.reduce_sum(log_prob_gaussian, axis=-1)
+        # Get log-prob for squashed Gaussian.
+        unsquashed_values_tanhd = tf.math.tanh(unsquashed_values)
+        log_prob = log_prob_gaussian - tf.reduce_sum(
+            tf.math.log(1 - unsquashed_values_tanhd**2 + SMALL_NUMBER), axis=-1
+        )
+        return log_prob
+
+    def sample_logp(self):
+        z = self.distr.sample()
+        actions = self._squash(z)
+        return actions, tf.reduce_sum(
+            self.distr.log_prob(z) - tf.math.log(1 - actions * actions + SMALL_NUMBER),
+            axis=-1,
+        )
+
+    @override(ActionDistribution)
+    def entropy(self) -> TensorType:
+        raise ValueError("Entropy not defined for SquashedGaussian!")
+
+    @override(ActionDistribution)
+    def kl(self, other: ActionDistribution) -> TensorType:
+        raise ValueError("KL not defined for SquashedGaussian!")
+
+    def _squash(self, raw_values: TensorType) -> TensorType:
+        # Returned values are within [low, high] (including `low` and `high`).
+        squashed = ((tf.math.tanh(raw_values) + 1.0) / 2.0) * (
+            self.high - self.low
+        ) + self.low
+        return tf.clip_by_value(squashed, self.low, self.high)
+
+    def _unsquash(self, values: TensorType) -> TensorType:
+        normed_values = (values - self.low) / (self.high - self.low) * 2.0 - 1.0
+        # Stabilize input to atanh.
+        save_normed_values = tf.clip_by_value(
+            normed_values, -1.0 + SMALL_NUMBER, 1.0 - SMALL_NUMBER
+        )
+        unsquashed = tf.math.atanh(save_normed_values)
+        return unsquashed
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return np.prod(action_space.shape, dtype=np.int32) * 2
+
+
+@OldAPIStack
+class Beta(TFActionDistribution):
+    """
+    A Beta distribution is defined on the interval [0, 1] and parameterized by
+    shape parameters alpha and beta (also called concentration parameters).
+
+    PDF(x; alpha, beta) = x**(alpha - 1) (1 - x)**(beta - 1) / Z
+        with Z = Gamma(alpha) Gamma(beta) / Gamma(alpha + beta)
+        and Gamma(n) = (n - 1)!
+    """
+
+    def __init__(
+        self,
+        inputs: List[TensorType],
+        model: ModelV2,
+        low: float = 0.0,
+        high: float = 1.0,
+    ):
+        # Stabilize input parameters (possibly coming from a linear layer).
+        inputs = tf.clip_by_value(inputs, log(SMALL_NUMBER), -log(SMALL_NUMBER))
+        inputs = tf.math.log(tf.math.exp(inputs) + 1.0) + 1.0
+        self.low = low
+        self.high = high
+        alpha, beta = tf.split(inputs, 2, axis=-1)
+        # Note: concentration0==beta, concentration1=alpha (!)
+        self.dist = tfp.distributions.Beta(concentration1=alpha, concentration0=beta)
+        super().__init__(inputs, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        mean = self.dist.mean()
+        return self._squash(mean)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return self._squash(self.dist.sample())
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        unsquashed_values = self._unsquash(x)
+        return tf.math.reduce_sum(self.dist.log_prob(unsquashed_values), axis=-1)
+
+    def _squash(self, raw_values: TensorType) -> TensorType:
+        return raw_values * (self.high - self.low) + self.low
+
+    def _unsquash(self, values: TensorType) -> TensorType:
+        return (values - self.low) / (self.high - self.low)
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return np.prod(action_space.shape, dtype=np.int32) * 2
+
+
+@OldAPIStack
+class Deterministic(TFActionDistribution):
+    """Action distribution that returns the input values directly.
+
+    This is similar to DiagGaussian with standard deviation zero (thus only
+    requiring the "mean" values as NN output).
+    """
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        return self.inputs
+
+    @override(TFActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        return tf.zeros_like(self.inputs)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return self.inputs
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return np.prod(action_space.shape, dtype=np.int32)
+
+
+@OldAPIStack
+class MultiActionDistribution(TFActionDistribution):
+    """Action distribution that operates on a set of actions.
+
+    Args:
+        inputs (Tensor list): A list of tensors from which to compute samples.
+    """
+
+    def __init__(
+        self, inputs, model, *, child_distributions, input_lens, action_space, **kwargs
+    ):
+        ActionDistribution.__init__(self, inputs, model)
+
+        self.action_space_struct = get_base_struct_from_space(action_space)
+
+        self.input_lens = np.array(input_lens, dtype=np.int32)
+        split_inputs = tf.split(inputs, self.input_lens, axis=1)
+        self.flat_child_distributions = tree.map_structure(
+            lambda dist, input_: dist(input_, model, **kwargs),
+            child_distributions,
+            split_inputs,
+        )
+
+    @override(ActionDistribution)
+    def logp(self, x):
+        # Single tensor input (all merged).
+        if isinstance(x, (tf.Tensor, np.ndarray)):
+            split_indices = []
+            for dist in self.flat_child_distributions:
+                if isinstance(dist, Categorical):
+                    split_indices.append(1)
+                elif (
+                    isinstance(dist, MultiCategorical) and dist.action_space is not None
+                ):
+                    split_indices.append(np.prod(dist.action_space.shape))
+                else:
+                    sample = dist.sample()
+                    # Cover Box(shape=()) case.
+                    if len(sample.shape) == 1:
+                        split_indices.append(1)
+                    else:
+                        split_indices.append(tf.shape(sample)[1])
+            split_x = tf.split(x, split_indices, axis=1)
+        # Structured or flattened (by single action component) input.
+        else:
+            split_x = tree.flatten(x)
+
+        def map_(val, dist):
+            # Remove extra categorical dimension.
+            if isinstance(dist, Categorical):
+                val = tf.cast(
+                    tf.squeeze(val, axis=-1) if len(val.shape) > 1 else val, tf.int32
+                )
+            return dist.logp(val)
+
+        # Remove extra categorical dimension and take the logp of each
+        # component.
+        flat_logps = tree.map_structure(map_, split_x, self.flat_child_distributions)
+
+        return functools.reduce(lambda a, b: a + b, flat_logps)
+
+    @override(ActionDistribution)
+    def kl(self, other):
+        kl_list = [
+            d.kl(o)
+            for d, o in zip(
+                self.flat_child_distributions, other.flat_child_distributions
+            )
+        ]
+        return functools.reduce(lambda a, b: a + b, kl_list)
+
+    @override(ActionDistribution)
+    def entropy(self):
+        entropy_list = [d.entropy() for d in self.flat_child_distributions]
+        return functools.reduce(lambda a, b: a + b, entropy_list)
+
+    @override(ActionDistribution)
+    def sample(self):
+        child_distributions = tree.unflatten_as(
+            self.action_space_struct, self.flat_child_distributions
+        )
+        return tree.map_structure(lambda s: s.sample(), child_distributions)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self):
+        child_distributions = tree.unflatten_as(
+            self.action_space_struct, self.flat_child_distributions
+        )
+        return tree.map_structure(
+            lambda s: s.deterministic_sample(), child_distributions
+        )
+
+    @override(TFActionDistribution)
+    def sampled_action_logp(self):
+        p = self.flat_child_distributions[0].sampled_action_logp()
+        for c in self.flat_child_distributions[1:]:
+            p += c.sampled_action_logp()
+        return p
+
+    @override(ActionDistribution)
+    def required_model_output_shape(self, action_space, model_config):
+        return np.sum(self.input_lens, dtype=np.int32)
+
+
+@OldAPIStack
+class Dirichlet(TFActionDistribution):
+    """Dirichlet distribution for continuous actions that are between
+    [0,1] and sum to 1.
+
+    e.g. actions that represent resource allocation."""
+
+    def __init__(self, inputs: List[TensorType], model: ModelV2):
+        """Input is a tensor of logits. The exponential of logits is used to
+        parametrize the Dirichlet distribution as all parameters need to be
+        positive. An arbitrary small epsilon is added to the concentration
+        parameters to be zero due to numerical error.
+
+        See issue #4440 for more details.
+        """
+        self.epsilon = 1e-7
+        concentration = tf.exp(inputs) + self.epsilon
+        self.dist = tf1.distributions.Dirichlet(
+            concentration=concentration,
+            validate_args=True,
+            allow_nan_stats=False,
+        )
+        super().__init__(concentration, model)
+
+    @override(ActionDistribution)
+    def deterministic_sample(self) -> TensorType:
+        return tf.nn.softmax(self.dist.concentration)
+
+    @override(ActionDistribution)
+    def logp(self, x: TensorType) -> TensorType:
+        # Support of Dirichlet are positive real numbers. x is already
+        # an array of positive numbers, but we clip to avoid zeros due to
+        # numerical errors.
+        x = tf.maximum(x, self.epsilon)
+        x = x / tf.reduce_sum(x, axis=-1, keepdims=True)
+        return self.dist.log_prob(x)
+
+    @override(ActionDistribution)
+    def entropy(self) -> TensorType:
+        return self.dist.entropy()
+
+    @override(ActionDistribution)
+    def kl(self, other: ActionDistribution) -> TensorType:
+        return self.dist.kl_divergence(other.dist)
+
+    @override(TFActionDistribution)
+    def _build_sample_op(self) -> TensorType:
+        return self.dist.sample()
+
+    @staticmethod
+    @override(ActionDistribution)
+    def required_model_output_shape(
+        action_space: gym.Space, model_config: ModelConfigDict
+    ) -> Union[int, np.ndarray]:
+        return np.prod(action_space.shape, dtype=np.int32)

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/tf_distributions.py

@@ -0,0 +1,552 @@
+"""The main difference between this and the old ActionDistribution is that this one
+has more explicit input args. So that the input format does not have to be guessed from
+the code. This matches the design pattern of torch distribution which developers may
+already be familiar with.
+"""
+import gymnasium as gym
+import tree
+import numpy as np
+from typing import Dict, Iterable, List, Optional
+import abc
+
+
+from ray.rllib.models.distributions import Distribution
+from ray.rllib.utils.annotations import override, DeveloperAPI
+from ray.rllib.utils.framework import try_import_tf, try_import_tfp
+from ray.rllib.utils.typing import TensorType, Union, Tuple
+
+
+_, tf, _ = try_import_tf()
+tfp = try_import_tfp()
+
+# TODO (Kourosh) Write unittest for this class similar to torch distributions.
+
+
+@DeveloperAPI
+class TfDistribution(Distribution, abc.ABC):
+    """Wrapper class for tfp.distributions."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self._dist = self._get_tf_distribution(*args, **kwargs)
+
+    @abc.abstractmethod
+    def _get_tf_distribution(self, *args, **kwargs) -> "tfp.distributions.Distribution":
+        """Returns the tfp.distributions.Distribution object to use."""
+
+    @override(Distribution)
+    def logp(self, value: TensorType, **kwargs) -> TensorType:
+        return self._dist.log_prob(value, **kwargs)
+
+    @override(Distribution)
+    def entropy(self) -> TensorType:
+        return self._dist.entropy()
+
+    @override(Distribution)
+    def kl(self, other: "Distribution") -> TensorType:
+        return self._dist.kl_divergence(other._dist)
+
+    @override(Distribution)
+    def sample(
+        self, *, sample_shape=()
+    ) -> Union[TensorType, Tuple[TensorType, TensorType]]:
+        sample = self._dist.sample(sample_shape)
+        return sample
+
+    @override(Distribution)
+    def rsample(
+        self, *, sample_shape=()
+    ) -> Union[TensorType, Tuple[TensorType, TensorType]]:
+        raise NotImplementedError
+
+
+@DeveloperAPI
+class TfCategorical(TfDistribution):
+    """Wrapper class for Categorical distribution.
+
+    Creates a categorical distribution parameterized by either :attr:`probs` or
+    :attr:`logits` (but not both).
+
+    Samples are integers from :math:`\{0, \ldots, K-1\}` where `K` is
+    ``probs.size(-1)``.
+
+    If `probs` is 1-dimensional with length-`K`, each element is the relative
+    probability of sampling the class at that index.
+
+    If `probs` is N-dimensional, the first N-1 dimensions are treated as a batch of
+    relative probability vectors.
+
+    .. testcode::
+        :skipif: True
+
+        m = TfCategorical([ 0.25, 0.25, 0.25, 0.25 ])
+        m.sample(sample_shape=(2,))  # equal probability of 0, 1, 2, 3
+
+    .. testoutput::
+
+        tf.Tensor([2 3], shape=(2,), dtype=int32)
+
+    Args:
+        probs: The probablities of each event.
+        logits: Event log probabilities (unnormalized)
+        temperature: In case of using logits, this parameter can be used to determine
+            the sharpness of the distribution. i.e.
+            ``probs = softmax(logits / temperature)``. The temperature must be strictly
+            positive. A low value (e.g. 1e-10) will result in argmax sampling while a
+            larger value will result in uniform sampling.
+    """
+
+    @override(TfDistribution)
+    def __init__(
+        self,
+        probs: "tf.Tensor" = None,
+        logits: "tf.Tensor" = None,
+    ) -> None:
+        # We assert this here because to_deterministic makes this assumption.
+        assert (probs is None) != (
+            logits is None
+        ), "Exactly one out of `probs` and `logits` must be set!"
+
+        self.probs = probs
+        self.logits = logits
+        self.one_hot = tfp.distributions.OneHotCategorical(logits=logits, probs=probs)
+        super().__init__(logits=logits, probs=probs)
+
+    @override(Distribution)
+    def logp(self, value: TensorType, **kwargs) -> TensorType:
+        # This prevents an error in which float values at the boundaries of the range
+        # of the distribution are passed to this function.
+        return -tf.nn.sparse_softmax_cross_entropy_with_logits(
+            logits=self.logits if self.logits is not None else tf.log(self.probs),
+            labels=tf.cast(value, tf.int32),
+        )
+
+    @override(TfDistribution)
+    def _get_tf_distribution(
+        self,
+        probs: "tf.Tensor" = None,
+        logits: "tf.Tensor" = None,
+    ) -> "tfp.distributions.Distribution":
+        return tfp.distributions.Categorical(probs=probs, logits=logits)
+
+    @staticmethod
+    @override(Distribution)
+    def required_input_dim(space: gym.Space, **kwargs) -> int:
+        assert isinstance(space, gym.spaces.Discrete)
+        return int(space.n)
+
+    @override(Distribution)
+    def rsample(self, sample_shape=()):
+        one_hot_sample = self.one_hot.sample(sample_shape)
+        return tf.stop_gradients(one_hot_sample - self.probs) + self.probs
+
+    @classmethod
+    @override(Distribution)
+    def from_logits(cls, logits: TensorType, **kwargs) -> "TfCategorical":
+        return TfCategorical(logits=logits, **kwargs)
+
+    def to_deterministic(self) -> "TfDeterministic":
+        if self.probs is not None:
+            probs_or_logits = self.probs
+        else:
+            probs_or_logits = self.logits
+
+        return TfDeterministic(loc=tf.math.argmax(probs_or_logits, axis=-1))
+
+
+@DeveloperAPI
+class TfDiagGaussian(TfDistribution):
+    """Wrapper class for Normal distribution.
+
+    Creates a normal distribution parameterized by :attr:`loc` and :attr:`scale`. In
+    case of multi-dimensional distribution, the variance is assumed to be diagonal.
+
+    .. testcode::
+        :skipif: True
+
+        m = TfDiagGaussian(loc=[0.0, 0.0], scale=[1.0, 1.0])
+        m.sample(sample_shape=(2,))  # 2d normal dist with loc=0 and scale=1
+
+    .. testoutput::
+
+        tensor([[ 0.1046, -0.6120], [ 0.234, 0.556]])
+
+    .. testcode::
+        :skipif: True
+
+        # scale is None
+        m = TfDiagGaussian(loc=[0.0, 1.0])
+        m.sample(sample_shape=(2,))  # normally distributed with loc=0 and scale=1
+
+    .. testoutput::
+
+        tensor([0.1046, 0.6120])
+
+
+    Args:
+        loc: mean of the distribution (often referred to as mu). If scale is None, the
+            second half of the `loc` will be used as the log of scale.
+        scale: standard deviation of the distribution (often referred to as sigma).
+            Has to be positive.
+    """
+
+    @override(TfDistribution)
+    def __init__(
+        self,
+        loc: Union[float, TensorType],
+        scale: Optional[Union[float, TensorType]] = None,
+    ):
+        self.loc = loc
+        super().__init__(loc=loc, scale=scale)
+
+    @override(TfDistribution)
+    def _get_tf_distribution(self, loc, scale) -> "tfp.distributions.Distribution":
+        return tfp.distributions.Normal(loc=loc, scale=scale)
+
+    @override(TfDistribution)
+    def logp(self, value: TensorType) -> TensorType:
+        return tf.math.reduce_sum(super().logp(value), axis=-1)
+
+    @override(TfDistribution)
+    def entropy(self) -> TensorType:
+        return tf.math.reduce_sum(super().entropy(), axis=-1)
+
+    @override(TfDistribution)
+    def kl(self, other: "TfDistribution") -> TensorType:
+        return tf.math.reduce_sum(super().kl(other), axis=-1)
+
+    @staticmethod
+    @override(Distribution)
+    def required_input_dim(space: gym.Space, **kwargs) -> int:
+        assert isinstance(space, gym.spaces.Box)
+        return int(np.prod(space.shape, dtype=np.int32) * 2)
+
+    @override(Distribution)
+    def rsample(self, sample_shape=()):
+        eps = tf.random.normal(sample_shape)
+        return self._dist.loc + eps * self._dist.scale
+
+    @classmethod
+    @override(Distribution)
+    def from_logits(cls, logits: TensorType, **kwargs) -> "TfDiagGaussian":
+        loc, log_std = tf.split(logits, num_or_size_splits=2, axis=-1)
+        scale = tf.math.exp(log_std)
+        return TfDiagGaussian(loc=loc, scale=scale)
+
+    def to_deterministic(self) -> "TfDeterministic":
+        return TfDeterministic(loc=self.loc)
+
+
+@DeveloperAPI
+class TfDeterministic(Distribution):
+    """The distribution that returns the input values directly.
+
+    This is similar to DiagGaussian with standard deviation zero (thus only
+    requiring the "mean" values as NN output).
+
+    Note: entropy is always zero, ang logp and kl are not implemented.
+
+    .. testcode::
+        :skipif: True
+
+        m = TfDeterministic(loc=tf.constant([0.0, 0.0]))
+        m.sample(sample_shape=(2,))
+
+    .. testoutput::
+
+        Tensor([[ 0.0, 0.0], [ 0.0, 0.0]])
+
+    Args:
+        loc: the determinsitic value to return
+    """
+
+    @override(Distribution)
+    def __init__(self, loc: "tf.Tensor") -> None:
+        super().__init__()
+        self.loc = loc
+
+    @override(Distribution)
+    def sample(
+        self,
+        *,
+        sample_shape: Tuple[int, ...] = (),
+        **kwargs,
+    ) -> Union[TensorType, Tuple[TensorType, TensorType]]:
+        shape = sample_shape + self.loc.shape
+        return tf.ones(shape, dtype=self.loc.dtype) * self.loc
+
+    @override(Distribution)
+    def rsample(
+        self,
+        *,
+        sample_shape: Tuple[int, ...] = None,
+        **kwargs,
+    ) -> Union[TensorType, Tuple[TensorType, TensorType]]:
+        raise NotImplementedError
+
+    @override(Distribution)
+    def logp(self, value: TensorType, **kwargs) -> TensorType:
+        return tf.zeros_like(self.loc)
+
+    @override(Distribution)
+    def entropy(self, **kwargs) -> TensorType:
+        raise RuntimeError(f"`entropy()` not supported for {self.__class__.__name__}.")
+
+    @override(Distribution)
+    def kl(self, other: "Distribution", **kwargs) -> TensorType:
+        raise RuntimeError(f"`kl()` not supported for {self.__class__.__name__}.")
+
+    @staticmethod
+    @override(Distribution)
+    def required_input_dim(space: gym.Space, **kwargs) -> int:
+        assert isinstance(space, gym.spaces.Box)
+        return int(np.prod(space.shape, dtype=np.int32))
+
+    @classmethod
+    @override(Distribution)
+    def from_logits(cls, logits: TensorType, **kwargs) -> "TfDeterministic":
+        return TfDeterministic(loc=logits)
+
+    def to_deterministic(self) -> "TfDeterministic":
+        return self
+
+
+@DeveloperAPI
+class TfMultiCategorical(Distribution):
+    """MultiCategorical distribution for MultiDiscrete action spaces."""
+
+    @override(Distribution)
+    def __init__(
+        self,
+        categoricals: List[TfCategorical],
+    ):
+        super().__init__()
+        self._cats = categoricals
+
+    @override(Distribution)
+    def sample(self) -> TensorType:
+        arr = [cat.sample() for cat in self._cats]
+        sample_ = tf.stack(arr, axis=-1)
+        return sample_
+
+    @override(Distribution)
+    def rsample(self, sample_shape=()):
+        arr = [cat.rsample() for cat in self._cats]
+        sample_ = tf.stack(arr, axis=-1)
+        return sample_
+
+    @override(Distribution)
+    def logp(self, value: tf.Tensor) -> TensorType:
+        actions = tf.unstack(tf.cast(value, tf.int32), axis=-1)
+        logps = tf.stack([cat.logp(act) for cat, act in zip(self._cats, actions)])
+        return tf.reduce_sum(logps, axis=0)
+
+    @override(Distribution)
+    def entropy(self) -> TensorType:
+        return tf.reduce_sum(
+            tf.stack([cat.entropy() for cat in self._cats], axis=-1), axis=-1
+        )
+
+    @override(Distribution)
+    def kl(self, other: Distribution) -> TensorType:
+        kls = tf.stack(
+            [cat.kl(oth_cat) for cat, oth_cat in zip(self._cats, other._cats)], axis=-1
+        )
+        return tf.reduce_sum(kls, axis=-1)
+
+    @staticmethod
+    @override(Distribution)
+    def required_input_dim(space: gym.Space, **kwargs) -> int:
+        assert isinstance(space, gym.spaces.MultiDiscrete)
+        return int(np.sum(space.nvec))
+
+    @classmethod
+    @override(Distribution)
+    def from_logits(
+        cls,
+        logits: tf.Tensor,
+        input_lens: List[int],
+        **kwargs,
+    ) -> "TfMultiCategorical":
+        """Creates this Distribution from logits (and additional arguments).
+
+        If you wish to create this distribution from logits only, please refer to
+        `Distribution.get_partial_dist_cls()`.
+
+        Args:
+            logits: The tensor containing logits to be separated by logit_lens.
+                child_distribution_cls_struct: A struct of Distribution classes that can
+                be instantiated from the given logits.
+            input_lens: A list of integers that indicate the length of the logits
+                vectors to be passed into each child distribution.
+            **kwargs: Forward compatibility kwargs.
+        """
+        categoricals = [
+            TfCategorical(logits=logits)
+            for logits in tf.split(logits, input_lens, axis=-1)
+        ]
+
+        return TfMultiCategorical(categoricals=categoricals)
+
+    def to_deterministic(self) -> "TfMultiDistribution":
+        return TfMultiDistribution([cat.to_deterministic() for cat in self._cats])
+
+
+@DeveloperAPI
+class TfMultiDistribution(Distribution):
+    """Action distribution that operates on multiple, possibly nested actions."""
+
+    def __init__(
+        self,
+        child_distribution_struct: Union[Tuple, List, Dict],
+    ):
+        """Initializes a TfMultiDistribution object.
+
+        Args:
+            child_distribution_struct: Any struct
+                that contains the child distribution classes to use to
+                instantiate the child distributions from `logits`.
+        """
+        super().__init__()
+        self._original_struct = child_distribution_struct
+        self._flat_child_distributions = tree.flatten(child_distribution_struct)
+
+    @override(Distribution)
+    def rsample(
+        self,
+        *,
+        sample_shape: Tuple[int, ...] = None,
+        **kwargs,
+    ) -> Union[TensorType, Tuple[TensorType, TensorType]]:
+        rsamples = []
+        for dist in self._flat_child_distributions:
+            rsample = dist.rsample(sample_shape=sample_shape, **kwargs)
+            rsamples.append(rsample)
+
+        rsamples = tree.unflatten_as(self._original_struct, rsamples)
+        return rsamples
+
+    @override(Distribution)
+    def logp(self, value):
+        # Single tensor input (all merged).
+        if isinstance(value, (tf.Tensor, np.ndarray)):
+            split_indices = []
+            for dist in self._flat_child_distributions:
+                if isinstance(dist, TfCategorical):
+                    split_indices.append(1)
+                elif isinstance(dist, TfMultiCategorical):
+                    split_indices.append(len(dist._cats))
+                else:
+                    sample = dist.sample()
+                    # Cover Box(shape=()) case.
+                    if len(sample.shape) == 1:
+                        split_indices.append(1)
+                    else:
+                        split_indices.append(tf.shape(sample)[1])
+            split_value = tf.split(value, split_indices, axis=1)
+        # Structured or flattened (by single action component) input.
+        else:
+            split_value = tree.flatten(value)
+
+        def map_(val, dist):
+            # Remove extra dimension if present.
+            if (
+                isinstance(dist, TfCategorical)
+                and len(val.shape) > 1
+                and val.shape[-1] == 1
+            ):
+                val = tf.squeeze(val, axis=-1)
+
+            return dist.logp(val)
+
+        # Remove extra categorical dimension and take the logp of each
+        # component.
+        flat_logps = tree.map_structure(
+            map_, split_value, self._flat_child_distributions
+        )
+
+        return sum(flat_logps)
+
+    @override(Distribution)
+    def kl(self, other):
+        kl_list = [
+            d.kl(o)
+            for d, o in zip(
+                self._flat_child_distributions, other._flat_child_distributions
+            )
+        ]
+        return sum(kl_list)
+
+    @override(Distribution)
+    def entropy(self):
+        entropy_list = [d.entropy() for d in self._flat_child_distributions]
+        return sum(entropy_list)
+
+    @override(Distribution)
+    def sample(self):
+        child_distributions_struct = tree.unflatten_as(
+            self._original_struct, self._flat_child_distributions
+        )
+        return tree.map_structure(lambda s: s.sample(), child_distributions_struct)
+
+    @staticmethod
+    @override(Distribution)
+    def required_input_dim(space: gym.Space, input_lens: List[int], **kwargs) -> int:
+        return sum(input_lens)
+
+    @classmethod
+    @override(Distribution)
+    def from_logits(
+        cls,
+        logits: tf.Tensor,
+        child_distribution_cls_struct: Union[Dict, Iterable],
+        input_lens: Union[Dict, List[int]],
+        space: gym.Space,
+        **kwargs,
+    ) -> "TfMultiDistribution":
+        """Creates this Distribution from logits (and additional arguments).
+
+        If you wish to create this distribution from logits only, please refer to
+        `Distribution.get_partial_dist_cls()`.
+
+        Args:
+            logits: The tensor containing logits to be separated by `input_lens`.
+                child_distribution_cls_struct: A struct of Distribution classes that can
+                be instantiated from the given logits.
+            child_distribution_cls_struct: A struct of Distribution classes that can
+                be instantiated from the given logits.
+            input_lens: A list or dict of integers that indicate the length of each
+                logit. If this is given as a dict, the structure should match the
+                structure of child_distribution_cls_struct.
+            space: The possibly nested output space.
+            **kwargs: Forward compatibility kwargs.
+
+        Returns:
+            A TfMultiDistribution object.
+        """
+        logit_lens = tree.flatten(input_lens)
+        child_distribution_cls_list = tree.flatten(child_distribution_cls_struct)
+        split_logits = tf.split(logits, logit_lens, axis=1)
+
+        child_distribution_list = tree.map_structure(
+            lambda dist, input_: dist.from_logits(input_),
+            child_distribution_cls_list,
+            list(split_logits),
+        )
+
+        child_distribution_struct = tree.unflatten_as(
+            child_distribution_cls_struct, child_distribution_list
+        )
+
+        return TfMultiDistribution(
+            child_distribution_struct=child_distribution_struct,
+        )
+
+    def to_deterministic(self) -> "TfMultiDistribution":
+        flat_deterministic_dists = [
+            dist.to_deterministic for dist in self._flat_child_distributions
+        ]
+        deterministic_dists = tree.unflatten_as(
+            self._original_struct, flat_deterministic_dists
+        )
+        return TfMultiDistribution(deterministic_dists)

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/tf_modelv2.py

@@ -0,0 +1,142 @@
+import contextlib
+import gymnasium as gym
+import re
+from typing import Dict, List, Union
+
+from ray.util import log_once
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.deprecation import deprecation_warning
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import ModelConfigDict, TensorType
+
+tf1, tf, tfv = try_import_tf()
+
+
+@OldAPIStack
+class TFModelV2(ModelV2):
+    """TF version of ModelV2, which should contain a tf keras Model.
+
+    Note that this class by itself is not a valid model unless you
+    implement forward() in a subclass."""
+
+    def __init__(
+        self,
+        obs_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+    ):
+        """Initializes a TFModelV2 instance.
+
+        Here is an example implementation for a subclass
+        ``MyModelClass(TFModelV2)``::
+
+            def __init__(self, *args, **kwargs):
+                super(MyModelClass, self).__init__(*args, **kwargs)
+                input_layer = tf.keras.layers.Input(...)
+                hidden_layer = tf.keras.layers.Dense(...)(input_layer)
+                output_layer = tf.keras.layers.Dense(...)(hidden_layer)
+                value_layer = tf.keras.layers.Dense(...)(hidden_layer)
+                self.base_model = tf.keras.Model(
+                    input_layer, [output_layer, value_layer])
+        """
+        super().__init__(
+            obs_space, action_space, num_outputs, model_config, name, framework="tf"
+        )
+
+        # Deprecated: TFModelV2 now automatically track their variables.
+        self.var_list = []
+
+        if tf1.executing_eagerly():
+            self.graph = None
+        else:
+            self.graph = tf1.get_default_graph()
+
+    def context(self) -> contextlib.AbstractContextManager:
+        """Returns a contextmanager for the current TF graph."""
+        if self.graph:
+            return self.graph.as_default()
+        else:
+            return ModelV2.context(self)
+
+    def update_ops(self) -> List[TensorType]:
+        """Return the list of update ops for this model.
+
+        For example, this should include any BatchNorm update ops."""
+        return []
+
+    def register_variables(self, variables: List[TensorType]) -> None:
+        """Register the given list of variables with this model."""
+        if log_once("deprecated_tfmodelv2_register_variables"):
+            deprecation_warning(old="TFModelV2.register_variables", error=False)
+        self.var_list.extend(variables)
+
+    @override(ModelV2)
+    def variables(
+        self, as_dict: bool = False
+    ) -> Union[List[TensorType], Dict[str, TensorType]]:
+        if as_dict:
+            # Old way using `register_variables`.
+            if self.var_list:
+                return {v.name: v for v in self.var_list}
+            # New way: Automatically determine the var tree.
+            else:
+                return self._find_sub_modules("", self.__dict__)
+
+        # Old way using `register_variables`.
+        if self.var_list:
+            return list(self.var_list)
+        # New way: Automatically determine the var tree.
+        else:
+            return list(self.variables(as_dict=True).values())
+
+    @override(ModelV2)
+    def trainable_variables(
+        self, as_dict: bool = False
+    ) -> Union[List[TensorType], Dict[str, TensorType]]:
+        if as_dict:
+            return {
+                k: v for k, v in self.variables(as_dict=True).items() if v.trainable
+            }
+        return [v for v in self.variables() if v.trainable]
+
+    @staticmethod
+    def _find_sub_modules(current_key, struct):
+        # Keras Model: key=k + "." + var-name (replace '/' by '.').
+        if isinstance(struct, tf.keras.models.Model) or isinstance(struct, tf.Module):
+            ret = {}
+            for var in struct.variables:
+                name = re.sub("/", ".", var.name)
+                key = current_key + "." + name
+                ret[key] = var
+            return ret
+        # Other TFModelV2: Include its vars into ours.
+        elif isinstance(struct, TFModelV2):
+            return {
+                current_key + "." + key: var
+                for key, var in struct.variables(as_dict=True).items()
+            }
+        # tf.Variable
+        elif isinstance(struct, tf.Variable):
+            return {current_key: struct}
+        # List/Tuple.
+        elif isinstance(struct, (tuple, list)):
+            ret = {}
+            for i, value in enumerate(struct):
+                sub_vars = TFModelV2._find_sub_modules(
+                    current_key + "_{}".format(i), value
+                )
+                ret.update(sub_vars)
+            return ret
+        # Dict.
+        elif isinstance(struct, dict):
+            if current_key:
+                current_key += "_"
+            ret = {}
+            for key, value in struct.items():
+                sub_vars = TFModelV2._find_sub_modules(current_key + str(key), value)
+                ret.update(sub_vars)
+            return ret
+        return {}

deepseek/lib/python3.10/site-packages/ray/rllib/models/tf/visionnet.py

@@ -0,0 +1,264 @@
+import gymnasium as gym
+from typing import Dict, List
+
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.models.tf.misc import normc_initializer
+from ray.rllib.models.utils import get_activation_fn, get_filter_config
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.framework import try_import_tf
+from ray.rllib.utils.typing import ModelConfigDict, TensorType
+
+tf1, tf, tfv = try_import_tf()
+
+
+@OldAPIStack
+class VisionNetwork(TFModelV2):
+    """Generic vision network implemented in ModelV2 API.
+
+    An additional post-conv fully connected stack can be added and configured
+    via the config keys:
+    `post_fcnet_hiddens`: Dense layer sizes after the Conv2D stack.
+    `post_fcnet_activation`: Activation function to use for this FC stack.
+    """
+
+    def __init__(
+        self,
+        obs_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        num_outputs: int,
+        model_config: ModelConfigDict,
+        name: str,
+    ):
+        if not model_config.get("conv_filters"):
+            model_config["conv_filters"] = get_filter_config(obs_space.shape)
+
+        super(VisionNetwork, self).__init__(
+            obs_space, action_space, num_outputs, model_config, name
+        )
+
+        activation = get_activation_fn(
+            self.model_config.get("conv_activation"), framework="tf"
+        )
+        filters = self.model_config["conv_filters"]
+        assert len(filters) > 0, "Must provide at least 1 entry in `conv_filters`!"
+
+        # Post FC net config.
+        post_fcnet_hiddens = model_config.get("post_fcnet_hiddens", [])
+        post_fcnet_activation = get_activation_fn(
+            model_config.get("post_fcnet_activation"), framework="tf"
+        )
+
+        no_final_linear = self.model_config.get("no_final_linear")
+        vf_share_layers = self.model_config.get("vf_share_layers")
+
+        input_shape = obs_space.shape
+        self.data_format = "channels_last"
+
+        inputs = tf.keras.layers.Input(shape=input_shape, name="observations")
+        last_layer = inputs
+        # Whether the last layer is the output of a Flattened (rather than
+        # a n x (1,1) Conv2D).
+        self.last_layer_is_flattened = False
+
+        # Build the action layers
+        for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
+            last_layer = tf.keras.layers.Conv2D(
+                out_size,
+                kernel,
+                strides=stride
+                if isinstance(stride, (list, tuple))
+                else (stride, stride),
+                activation=activation,
+                padding="same",
+                data_format="channels_last",
+                name="conv{}".format(i),
+            )(last_layer)
+
+        out_size, kernel, stride = filters[-1]
+
+        # No final linear: Last layer has activation function and exits with
+        # num_outputs nodes (this could be a 1x1 conv or a FC layer, depending
+        # on `post_fcnet_...` settings).
+        if no_final_linear and num_outputs:
+            last_layer = tf.keras.layers.Conv2D(
+                out_size if post_fcnet_hiddens else num_outputs,
+                kernel,
+                strides=stride
+                if isinstance(stride, (list, tuple))
+                else (stride, stride),
+                activation=activation,
+                padding="valid",
+                data_format="channels_last",
+                name="conv_out",
+            )(last_layer)
+            # Add (optional) post-fc-stack after last Conv2D layer.
+            layer_sizes = post_fcnet_hiddens[:-1] + (
+                [num_outputs] if post_fcnet_hiddens else []
+            )
+            feature_out = last_layer
+
+            for i, out_size in enumerate(layer_sizes):
+                feature_out = last_layer
+                last_layer = tf.keras.layers.Dense(
+                    out_size,
+                    name="post_fcnet_{}".format(i),
+                    activation=post_fcnet_activation,
+                    kernel_initializer=normc_initializer(1.0),
+                )(last_layer)
+
+        # Finish network normally (w/o overriding last layer size with
+        # `num_outputs`), then add another linear one of size `num_outputs`.
+        else:
+            last_layer = tf.keras.layers.Conv2D(
+                out_size,
+                kernel,
+                strides=stride
+                if isinstance(stride, (list, tuple))
+                else (stride, stride),
+                activation=activation,
+                padding="valid",
+                data_format="channels_last",
+                name="conv{}".format(len(filters)),
+            )(last_layer)
+
+            # num_outputs defined. Use that to create an exact
+            # `num_output`-sized (1,1)-Conv2D.
+            if num_outputs:
+                if post_fcnet_hiddens:
+                    last_cnn = last_layer = tf.keras.layers.Conv2D(
+                        post_fcnet_hiddens[0],
+                        [1, 1],
+                        activation=post_fcnet_activation,
+                        padding="same",
+                        data_format="channels_last",
+                        name="conv_out",
+                    )(last_layer)
+                    # Add (optional) post-fc-stack after last Conv2D layer.
+                    for i, out_size in enumerate(
+                        post_fcnet_hiddens[1:] + [num_outputs]
+                    ):
+                        feature_out = last_layer
+                        last_layer = tf.keras.layers.Dense(
+                            out_size,
+                            name="post_fcnet_{}".format(i + 1),
+                            activation=post_fcnet_activation
+                            if i < len(post_fcnet_hiddens) - 1
+                            else None,
+                            kernel_initializer=normc_initializer(1.0),
+                        )(last_layer)
+                else:
+                    feature_out = last_layer
+                    last_cnn = last_layer = tf.keras.layers.Conv2D(
+                        num_outputs,
+                        [1, 1],
+                        activation=None,
+                        padding="same",
+                        data_format="channels_last",
+                        name="conv_out",
+                    )(last_layer)
+
+                if last_cnn.shape[1] != 1 or last_cnn.shape[2] != 1:
+                    raise ValueError(
+                        "Given `conv_filters` ({}) do not result in a [B, 1, "
+                        "1, {} (`num_outputs`)] shape (but in {})! Please "
+                        "adjust your Conv2D stack such that the dims 1 and 2 "
+                        "are both 1.".format(
+                            self.model_config["conv_filters"],
+                            self.num_outputs,
+                            list(last_cnn.shape),
+                        )
+                    )
+
+            # num_outputs not known -> Flatten, then set self.num_outputs
+            # to the resulting number of nodes.
+            else:
+                self.last_layer_is_flattened = True
+                last_layer = tf.keras.layers.Flatten(data_format="channels_last")(
+                    last_layer
+                )
+
+                # Add (optional) post-fc-stack after last Conv2D layer.
+                for i, out_size in enumerate(post_fcnet_hiddens):
+                    last_layer = tf.keras.layers.Dense(
+                        out_size,
+                        name="post_fcnet_{}".format(i),
+                        activation=post_fcnet_activation,
+                        kernel_initializer=normc_initializer(1.0),
+                    )(last_layer)
+                feature_out = last_layer
+                self.num_outputs = last_layer.shape[1]
+        logits_out = last_layer
+
+        # Build the value layers
+        if vf_share_layers:
+            if not self.last_layer_is_flattened:
+                feature_out = tf.keras.layers.Lambda(
+                    lambda x: tf.squeeze(x, axis=[1, 2])
+                )(feature_out)
+            value_out = tf.keras.layers.Dense(
+                1,
+                name="value_out",
+                activation=None,
+                kernel_initializer=normc_initializer(0.01),
+            )(feature_out)
+        else:
+            # build a parallel set of hidden layers for the value net
+            last_layer = inputs
+            for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
+                last_layer = tf.keras.layers.Conv2D(
+                    out_size,
+                    kernel,
+                    strides=stride
+                    if isinstance(stride, (list, tuple))
+                    else (stride, stride),
+                    activation=activation,
+                    padding="same",
+                    data_format="channels_last",
+                    name="conv_value_{}".format(i),
+                )(last_layer)
+            out_size, kernel, stride = filters[-1]
+            last_layer = tf.keras.layers.Conv2D(
+                out_size,
+                kernel,
+                strides=stride
+                if isinstance(stride, (list, tuple))
+                else (stride, stride),
+                activation=activation,
+                padding="valid",
+                data_format="channels_last",
+                name="conv_value_{}".format(len(filters)),
+            )(last_layer)
+            last_layer = tf.keras.layers.Conv2D(
+                1,
+                [1, 1],
+                activation=None,
+                padding="same",
+                data_format="channels_last",
+                name="conv_value_out",
+            )(last_layer)
+            value_out = tf.keras.layers.Lambda(lambda x: tf.squeeze(x, axis=[1, 2]))(
+                last_layer
+            )
+
+        self.base_model = tf.keras.Model(inputs, [logits_out, value_out])
+
+    def forward(
+        self,
+        input_dict: Dict[str, TensorType],
+        state: List[TensorType],
+        seq_lens: TensorType,
+    ) -> (TensorType, List[TensorType]):
+        obs = input_dict["obs"]
+        if self.data_format == "channels_first":
+            obs = tf.transpose(obs, [0, 2, 3, 1])
+        # Explicit cast to float32 needed in eager.
+        model_out, self._value_out = self.base_model(tf.cast(obs, tf.float32))
+        # Our last layer is already flat.
+        if self.last_layer_is_flattened:
+            return model_out, state
+        # Last layer is a n x [1,1] Conv2D -> Flatten.
+        else:
+            return tf.squeeze(model_out, axis=[1, 2]), state
+
+    def value_function(self) -> TensorType:
+        return tf.reshape(self._value_out, [-1])

deepseek/lib/python3.10/site-packages/ray/rllib/models/utils.py

@@ -0,0 +1,280 @@
+from typing import Callable, Optional, Union
+
+from ray.rllib.utils.annotations import DeveloperAPI
+from ray.rllib.utils.framework import try_import_jax, try_import_tf, try_import_torch
+
+
+@DeveloperAPI
+def get_activation_fn(
+    name: Optional[Union[Callable, str]] = None,
+    framework: str = "tf",
+):
+    """Returns a framework specific activation function, given a name string.
+
+    Args:
+        name: One of "relu" (default), "tanh", "elu",
+            "swish" (or "silu", which is the same), or "linear" (same as None).
+        framework: One of "jax", "tf|tf2" or "torch".
+
+    Returns:
+        A framework-specific activtion function. e.g. tf.nn.tanh or
+            torch.nn.ReLU. None if name in ["linear", None].
+
+    Raises:
+        ValueError: If name is an unknown activation function.
+    """
+    # Already a callable, return as-is.
+    if callable(name):
+        return name
+
+    name_lower = name.lower() if isinstance(name, str) else name
+
+    # Infer the correct activation function from the string specifier.
+    if framework == "torch":
+        if name_lower in ["linear", None]:
+            return None
+
+        _, nn = try_import_torch()
+        # First try getting the correct activation function from nn directly.
+        # Note that torch activation functions are not all lower case.
+        fn = getattr(nn, name, None)
+        if fn is not None:
+            return fn
+
+        if name_lower in ["swish", "silu"]:
+            return nn.SiLU
+        elif name_lower == "relu":
+            return nn.ReLU
+        elif name_lower == "tanh":
+            return nn.Tanh
+        elif name_lower == "elu":
+            return nn.ELU
+    elif framework == "jax":
+        if name_lower in ["linear", None]:
+            return None
+        jax, _ = try_import_jax()
+        if name_lower in ["swish", "silu"]:
+            return jax.nn.swish
+        if name_lower == "relu":
+            return jax.nn.relu
+        elif name_lower == "tanh":
+            return jax.nn.hard_tanh
+        elif name_lower == "elu":
+            return jax.nn.elu
+    else:
+        assert framework in ["tf", "tf2"], "Unsupported framework `{}`!".format(
+            framework
+        )
+        if name_lower in ["linear", None]:
+            return None
+
+        tf1, tf, tfv = try_import_tf()
+        # Try getting the correct activation function from tf.nn directly.
+        # Note that tf activation functions are all lower case, so this should always
+        # work.
+        fn = getattr(tf.nn, name_lower, None)
+
+        if fn is not None:
+            return fn
+
+    raise ValueError(
+        "Unknown activation ({}) for framework={}!".format(name, framework)
+    )
+
+
+@DeveloperAPI
+def get_initializer_fn(name: Optional[Union[str, Callable]], framework: str = "torch"):
+    """Returns the framework-specific initializer class or function.
+
+    This function relies fully on the specified initializer classes and
+    functions in the frameworks `torch` and `tf2` (see for `torch`
+    https://pytorch.org/docs/stable/nn.init.html and for `tf2` see
+    https://www.tensorflow.org/api_docs/python/tf/keras/initializers).
+
+    Note, for framework `torch` the in-place initializers are needed, i.e. names
+    should end with an underscore `_`, e.g. `glorot_uniform_`.
+
+    Args:
+        name: Name of the initializer class or function in one of the two
+            supported frameworks, i.e. `torch` or `tf2`.
+        framework: The framework string, either `torch  or `tf2`.
+
+    Returns:
+        A framework-specific function or class defining an initializer to be used
+        for network initialization,
+
+    Raises:
+        `ValueError` if the `name` is neither class or function in the specified
+        `framework`. Raises also a `ValueError`, if `name` does not define an
+        in-place initializer for framework `torch`.
+    """
+    # Already a callable or `None` return as is. If `None` we use the default
+    # initializer defined in the framework-specific layers themselves.
+    if callable(name) or name is None:
+        return name
+
+    if framework == "torch":
+        name_lower = name.lower() if isinstance(name, str) else name
+
+        _, nn = try_import_torch()
+
+        # Check, if the name includes an underscore. We must use the
+        # in-place initialization from Torch.
+        if not name_lower.endswith("_"):
+            raise ValueError(
+                "Not an in-place initializer: Torch weight initializers "
+                "need to be provided as their in-place version, i.e. "
+                "<initializaer_name> + '_'. See "
+                "https://pytorch.org/docs/stable/nn.init.html. "
+                f"User provided {name}."
+            )
+
+        # First, try to get the initialization directly from `nn.init`.
+        # Note, that all initialization methods in `nn.init` are lower
+        # case and that `<method>_` defines the "in-place" method.
+        fn = getattr(nn.init, name_lower, None)
+        if fn is not None:
+            # TODO (simon): Raise a warning if not "in-place" method.
+            return fn
+        # Unknown initializer.
+        else:
+            # Inform the user that this initializer does not exist.
+            raise ValueError(
+                f"Unknown initializer name: {name_lower} is not a method in "
+                "`torch.nn.init`!"
+            )
+    elif framework == "tf2":
+        # Note, as initializer classes in TensorFlow can be either given by their
+        # name in camel toe typing or by their shortcut we use the `name` as it is.
+        # See https://www.tensorflow.org/api_docs/python/tf/keras/initializers.
+
+        _, tf, _ = try_import_tf()
+
+        # Try to get the initialization function directly from `tf.keras.initializers`.
+        fn = getattr(tf.keras.initializers, name, None)
+        if fn is not None:
+            return fn
+        # Unknown initializer.
+        else:
+            # Inform the user that this initializer does not exist.
+            raise ValueError(
+                f"Unknown initializer: {name} is not a initializer in "
+                "`tf.keras.initializers`!"
+            )
+
+
+@DeveloperAPI
+def get_filter_config(shape):
+    """Returns a default Conv2D filter config (list) for a given image shape.
+
+    Args:
+        shape (Tuple[int]): The input (image) shape, e.g. (84,84,3).
+
+    Returns:
+        List[list]: The Conv2D filter configuration usable as `conv_filters`
+            inside a model config dict.
+    """
+    # 96x96x3 (e.g. CarRacing-v0).
+    filters_96x96 = [
+        [16, [8, 8], 4],
+        [32, [4, 4], 2],
+        [256, [11, 11], 2],
+    ]
+    # Atari.
+    filters_84x84 = [
+        [16, [8, 8], 4],
+        [32, [4, 4], 2],
+        [256, [11, 11], 1],
+    ]
+    # Dreamer-style (S-sized model) Atari or DM Control Suite.
+    filters_64x64 = [
+        [32, [4, 4], 2],
+        [64, [4, 4], 2],
+        [128, [4, 4], 2],
+        [256, [4, 4], 2],
+    ]
+    # Small (1/2) Atari.
+    filters_42x42 = [
+        [16, [4, 4], 2],
+        [32, [4, 4], 2],
+        [256, [11, 11], 1],
+    ]
+    # Test image (10x10).
+    filters_10x10 = [
+        [16, [5, 5], 2],
+        [32, [5, 5], 2],
+    ]
+
+    shape = list(shape)
+    if len(shape) in [2, 3] and (shape[:2] == [96, 96] or shape[1:] == [96, 96]):
+        return filters_96x96
+    elif len(shape) in [2, 3] and (shape[:2] == [84, 84] or shape[1:] == [84, 84]):
+        return filters_84x84
+    elif len(shape) in [2, 3] and (shape[:2] == [64, 64] or shape[1:] == [64, 64]):
+        return filters_64x64
+    elif len(shape) in [2, 3] and (shape[:2] == [42, 42] or shape[1:] == [42, 42]):
+        return filters_42x42
+    elif len(shape) in [2, 3] and (shape[:2] == [10, 10] or shape[1:] == [10, 10]):
+        return filters_10x10
+    else:
+        raise ValueError(
+            "No default configuration for obs shape {}".format(shape)
+            + ", you must specify `conv_filters` manually as a model option. "
+            "Default configurations are only available for inputs of the following "
+            "shapes: [42, 42, K], [84, 84, K], [64, 64, K], [10, 10, K]. You may "
+            "alternatively want to use a custom model or preprocessor."
+        )
+
+
+@DeveloperAPI
+def get_initializer(name, framework="tf"):
+    """Returns a framework specific initializer, given a name string.
+
+    Args:
+        name: One of "xavier_uniform" (default), "xavier_normal".
+        framework: One of "jax", "tf|tf2" or "torch".
+
+    Returns:
+        A framework-specific initializer function, e.g.
+            tf.keras.initializers.GlorotUniform or
+            torch.nn.init.xavier_uniform_.
+
+    Raises:
+        ValueError: If name is an unknown initializer.
+    """
+    # Already a callable, return as-is.
+    if callable(name):
+        return name
+
+    if framework == "jax":
+        _, flax = try_import_jax()
+        assert flax is not None, "`flax` not installed. Try `pip install jax flax`."
+        import flax.linen as nn
+
+        if name in [None, "default", "xavier_uniform"]:
+            return nn.initializers.xavier_uniform()
+        elif name == "xavier_normal":
+            return nn.initializers.xavier_normal()
+    if framework == "torch":
+        _, nn = try_import_torch()
+        assert nn is not None, "`torch` not installed. Try `pip install torch`."
+        if name in [None, "default", "xavier_uniform"]:
+            return nn.init.xavier_uniform_
+        elif name == "xavier_normal":
+            return nn.init.xavier_normal_
+    else:
+        assert framework in ["tf", "tf2"], "Unsupported framework `{}`!".format(
+            framework
+        )
+        tf1, tf, tfv = try_import_tf()
+        assert (
+            tf is not None
+        ), "`tensorflow` not installed. Try `pip install tensorflow`."
+        if name in [None, "default", "xavier_uniform"]:
+            return tf.keras.initializers.GlorotUniform
+        elif name == "xavier_normal":
+            return tf.keras.initializers.GlorotNormal
+
+    raise ValueError(
+        "Unknown activation ({}) for framework={}!".format(name, framework)
+    )

deepseek/lib/python3.10/site-packages/ray/rllib/utils/actors.py

@@ -0,0 +1,258 @@
+from collections import defaultdict, deque
+import logging
+import platform
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Type
+
+import ray
+from ray.actor import ActorClass, ActorHandle
+
+logger = logging.getLogger(__name__)
+
+
+class TaskPool:
+    """Helper class for tracking the status of many in-flight actor tasks."""
+
+    def __init__(self):
+        self._tasks = {}
+        self._objects = {}
+        self._fetching = deque()
+
+    def add(self, worker, all_obj_refs):
+        if isinstance(all_obj_refs, list):
+            obj_ref = all_obj_refs[0]
+        else:
+            obj_ref = all_obj_refs
+        self._tasks[obj_ref] = worker
+        self._objects[obj_ref] = all_obj_refs
+
+    def completed(self, blocking_wait=False):
+        pending = list(self._tasks)
+        if pending:
+            ready, _ = ray.wait(pending, num_returns=len(pending), timeout=0)
+            if not ready and blocking_wait:
+                ready, _ = ray.wait(pending, num_returns=1, timeout=10.0)
+            for obj_ref in ready:
+                yield (self._tasks.pop(obj_ref), self._objects.pop(obj_ref))
+
+    def completed_prefetch(self, blocking_wait=False, max_yield=999):
+        """Similar to completed but only returns once the object is local.
+
+        Assumes obj_ref only is one id."""
+
+        for worker, obj_ref in self.completed(blocking_wait=blocking_wait):
+            self._fetching.append((worker, obj_ref))
+
+        for _ in range(max_yield):
+            if not self._fetching:
+                break
+
+            yield self._fetching.popleft()
+
+    def reset_workers(self, workers):
+        """Notify that some workers may be removed."""
+        for obj_ref, ev in self._tasks.copy().items():
+            if ev not in workers:
+                del self._tasks[obj_ref]
+                del self._objects[obj_ref]
+
+        # We want to keep the same deque reference so that we don't suffer from
+        # stale references in generators that are still in flight
+        for _ in range(len(self._fetching)):
+            ev, obj_ref = self._fetching.popleft()
+            if ev in workers:
+                # Re-queue items that are still valid
+                self._fetching.append((ev, obj_ref))
+
+    @property
+    def count(self):
+        return len(self._tasks)
+
+
+def create_colocated_actors(
+    actor_specs: Sequence[Tuple[Type, Any, Any, int]],
+    node: Optional[str] = "localhost",
+    max_attempts: int = 10,
+) -> Dict[Type, List[ActorHandle]]:
+    """Create co-located actors of any type(s) on any node.
+
+    Args:
+        actor_specs: Tuple/list with tuples consisting of: 1) The
+            (already @ray.remote) class(es) to construct, 2) c'tor args,
+            3) c'tor kwargs, and 4) the number of actors of that class with
+            given args/kwargs to construct.
+        node: The node to co-locate the actors on. By default ("localhost"),
+            place the actors on the node the caller of this function is
+            located on. Use None for indicating that any (resource fulfilling)
+            node in the cluster may be used.
+        max_attempts: The maximum number of co-location attempts to
+            perform before throwing an error.
+
+    Returns:
+        A dict mapping the created types to the list of n ActorHandles
+        created (and co-located) for that type.
+    """
+    if node == "localhost":
+        node = platform.node()
+
+    # Maps each entry in `actor_specs` to lists of already co-located actors.
+    ok = [[] for _ in range(len(actor_specs))]
+
+    # Try n times to co-locate all given actor types (`actor_specs`).
+    # With each (failed) attempt, increase the number of actors we try to
+    # create (on the same node), then kill the ones that have been created in
+    # excess.
+    for attempt in range(max_attempts):
+        # If any attempt to co-locate fails, set this to False and we'll do
+        # another attempt.
+        all_good = True
+        # Process all `actor_specs` in sequence.
+        for i, (typ, args, kwargs, count) in enumerate(actor_specs):
+            args = args or []  # Allow None.
+            kwargs = kwargs or {}  # Allow None.
+            # We don't have enough actors yet of this spec co-located on
+            # the desired node.
+            if len(ok[i]) < count:
+                co_located = try_create_colocated(
+                    cls=typ,
+                    args=args,
+                    kwargs=kwargs,
+                    count=count * (attempt + 1),
+                    node=node,
+                )
+                # If node did not matter (None), from here on, use the host
+                # that the first actor(s) are already co-located on.
+                if node is None:
+                    node = ray.get(co_located[0].get_host.remote())
+                # Add the newly co-located actors to the `ok` list.
+                ok[i].extend(co_located)
+                # If we still don't have enough -> We'll have to do another
+                # attempt.
+                if len(ok[i]) < count:
+                    all_good = False
+            # We created too many actors for this spec -> Kill/truncate
+            # the excess ones.
+            if len(ok[i]) > count:
+                for a in ok[i][count:]:
+                    a.__ray_terminate__.remote()
+                ok[i] = ok[i][:count]
+
+        # All `actor_specs` have been fulfilled, return lists of
+        # co-located actors.
+        if all_good:
+            return ok
+
+    raise Exception("Unable to create enough colocated actors -> aborting.")
+
+
+def try_create_colocated(
+    cls: Type[ActorClass],
+    args: List[Any],
+    count: int,
+    kwargs: Optional[List[Any]] = None,
+    node: Optional[str] = "localhost",
+) -> List[ActorHandle]:
+    """Tries to co-locate (same node) a set of Actors of the same type.
+
+    Returns a list of successfully co-located actors. All actors that could
+    not be co-located (with the others on the given node) will not be in this
+    list.
+
+    Creates each actor via it's remote() constructor and then checks, whether
+    it has been co-located (on the same node) with the other (already created)
+    ones. If not, terminates the just created actor.
+
+    Args:
+        cls: The Actor class to use (already @ray.remote "converted").
+        args: List of args to pass to the Actor's constructor. One item
+            per to-be-created actor (`count`).
+        count: Number of actors of the given `cls` to construct.
+        kwargs: Optional list of kwargs to pass to the Actor's constructor.
+            One item per to-be-created actor (`count`).
+        node: The node to co-locate the actors on. By default ("localhost"),
+            place the actors on the node the caller of this function is
+            located on. If None, will try to co-locate all actors on
+            any available node.
+
+    Returns:
+        List containing all successfully co-located actor handles.
+    """
+    if node == "localhost":
+        node = platform.node()
+
+    kwargs = kwargs or {}
+    actors = [cls.remote(*args, **kwargs) for _ in range(count)]
+    co_located, non_co_located = split_colocated(actors, node=node)
+    logger.info("Got {} colocated actors of {}".format(len(co_located), count))
+    for a in non_co_located:
+        a.__ray_terminate__.remote()
+    return co_located
+
+
+def split_colocated(
+    actors: List[ActorHandle],
+    node: Optional[str] = "localhost",
+) -> Tuple[List[ActorHandle], List[ActorHandle]]:
+    """Splits up given actors into colocated (on same node) and non colocated.
+
+    The co-location criterion depends on the `node` given:
+    If given (or default: platform.node()): Consider all actors that are on
+    that node "colocated".
+    If None: Consider the largest sub-set of actors that are all located on
+    the same node (whatever that node is) as "colocated".
+
+    Args:
+        actors: The list of actor handles to split into "colocated" and
+            "non colocated".
+        node: The node defining "colocation" criterion. If provided, consider
+            thos actors "colocated" that sit on this node. If None, use the
+            largest subset within `actors` that are sitting on the same
+            (any) node.
+
+    Returns:
+        Tuple of two lists: 1) Co-located ActorHandles, 2) non co-located
+        ActorHandles.
+    """
+    if node == "localhost":
+        node = platform.node()
+
+    # Get nodes of all created actors.
+    hosts = ray.get([a.get_host.remote() for a in actors])
+
+    # If `node` not provided, use the largest group of actors that sit on the
+    # same node, regardless of what that node is.
+    if node is None:
+        node_groups = defaultdict(set)
+        for host, actor in zip(hosts, actors):
+            node_groups[host].add(actor)
+        max_ = -1
+        largest_group = None
+        for host in node_groups:
+            if max_ < len(node_groups[host]):
+                max_ = len(node_groups[host])
+                largest_group = host
+        non_co_located = []
+        for host in node_groups:
+            if host != largest_group:
+                non_co_located.extend(list(node_groups[host]))
+        return list(node_groups[largest_group]), non_co_located
+    # Node provided (or default: localhost): Consider those actors "colocated"
+    # that were placed on `node`.
+    else:
+        # Split into co-located (on `node) and non-co-located (not on `node`).
+        co_located = []
+        non_co_located = []
+        for host, a in zip(hosts, actors):
+            # This actor has been placed on the correct node.
+            if host == node:
+                co_located.append(a)
+            # This actor has been placed on a different node.
+            else:
+                non_co_located.append(a)
+        return co_located, non_co_located
+
+
+def drop_colocated(actors: List[ActorHandle]) -> List[ActorHandle]:
+    colocated, non_colocated = split_colocated(actors)
+    for a in colocated:
+        a.__ray_terminate__.remote()
+    return non_colocated

deepseek/lib/python3.10/site-packages/ray/rllib/utils/annotations.py

@@ -0,0 +1,213 @@
+from ray.rllib.utils.deprecation import Deprecated
+from ray.util.annotations import _mark_annotated
+
+
+def override(parent_cls):
+    """Decorator for documenting method overrides.
+
+    Args:
+        parent_cls: The superclass that provides the overridden method. If
+            `parent_class` does not actually have the method or the class, in which
+            method is defined is not a subclass of `parent_class`, an error is raised.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy import Policy
+        class TorchPolicy(Policy):
+            ...
+            # Indicates that `TorchPolicy.loss()` overrides the parent
+            # Policy class' own `loss method. Leads to an error if Policy
+            # does not have a `loss` method.
+
+            @override(Policy)
+            def loss(self, model, action_dist, train_batch):
+                ...
+
+    """
+
+    class OverrideCheck:
+        def __init__(self, func, expected_parent_cls):
+            self.func = func
+            self.expected_parent_cls = expected_parent_cls
+
+        def __set_name__(self, owner, name):
+            # Check if the owner (the class) is a subclass of the expected base class
+            if not issubclass(owner, self.expected_parent_cls):
+                raise TypeError(
+                    f"When using the @override decorator, {owner.__name__} must be a "
+                    f"subclass of {parent_cls.__name__}!"
+                )
+            # Set the function as a regular method on the class.
+            setattr(owner, name, self.func)
+
+    def decorator(method):
+        # Check, whether `method` is actually defined by the parent class.
+        if method.__name__ not in dir(parent_cls):
+            raise NameError(
+                f"When using the @override decorator, {method.__name__} must override "
+                f"the respective method (with the same name) of {parent_cls.__name__}!"
+            )
+
+        # Check if the class is a subclass of the expected base class
+        OverrideCheck(method, parent_cls)
+        return method
+
+    return decorator
+
+
+def PublicAPI(obj):
+    """Decorator for documenting public APIs.
+
+    Public APIs are classes and methods exposed to end users of RLlib. You
+    can expect these APIs to remain stable across RLlib releases.
+
+    Subclasses that inherit from a ``@PublicAPI`` base class can be
+    assumed part of the RLlib public API as well (e.g., all Algorithm classes
+    are in public API because Algorithm is ``@PublicAPI``).
+
+    In addition, you can assume all algo configurations are part of their
+    public API as well.
+
+    .. testcode::
+        :skipif: True
+
+        # Indicates that the `Algorithm` class is exposed to end users
+        # of RLlib and will remain stable across RLlib releases.
+        from ray import tune
+        @PublicAPI
+        class Algorithm(tune.Trainable):
+            ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def DeveloperAPI(obj):
+    """Decorator for documenting developer APIs.
+
+    Developer APIs are classes and methods explicitly exposed to developers
+    for the purposes of building custom algorithms or advanced training
+    strategies on top of RLlib internals. You can generally expect these APIs
+    to be stable sans minor changes (but less stable than public APIs).
+
+    Subclasses that inherit from a ``@DeveloperAPI`` base class can be
+    assumed part of the RLlib developer API as well.
+
+    .. testcode::
+        :skipif: True
+
+        # Indicates that the `TorchPolicy` class is exposed to end users
+        # of RLlib and will remain (relatively) stable across RLlib
+        # releases.
+        from ray.rllib.policy import Policy
+        @DeveloperAPI
+        class TorchPolicy(Policy):
+            ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def ExperimentalAPI(obj):
+    """Decorator for documenting experimental APIs.
+
+    Experimental APIs are classes and methods that are in development and may
+    change at any time in their development process. You should not expect
+    these APIs to be stable until their tag is changed to `DeveloperAPI` or
+    `PublicAPI`.
+
+    Subclasses that inherit from a ``@ExperimentalAPI`` base class can be
+    assumed experimental as well.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy import Policy
+        class TorchPolicy(Policy):
+            ...
+            # Indicates that the `TorchPolicy.loss` method is a new and
+            # experimental API and may change frequently in future
+            # releases.
+            @ExperimentalAPI
+            def loss(self, model, action_dist, train_batch):
+                ...
+    """
+
+    _mark_annotated(obj)
+    return obj
+
+
+def OldAPIStack(obj):
+    """Decorator for classes/methods/functions belonging to the old API stack.
+
+    These should be deprecated at some point after Ray 3.0 (RLlib GA).
+    It is recommended for users to start exploring (and coding against) the new API
+    stack instead.
+    """
+    # No effect yet.
+
+    _mark_annotated(obj)
+    return obj
+
+
+def OverrideToImplementCustomLogic(obj):
+    """Users should override this in their sub-classes to implement custom logic.
+
+    Used in Algorithm and Policy to tag methods that need overriding, e.g.
+    `Policy.loss()`.
+
+    .. testcode::
+        :skipif: True
+
+        from ray.rllib.policy.torch_policy import TorchPolicy
+        @overrides(TorchPolicy)
+        @OverrideToImplementCustomLogic
+        def loss(self, ...):
+            # implement custom loss function here ...
+            # ... w/o calling the corresponding `super().loss()` method.
+            ...
+
+    """
+    obj.__is_overridden__ = False
+    return obj
+
+
+def OverrideToImplementCustomLogic_CallToSuperRecommended(obj):
+    """Users should override this in their sub-classes to implement custom logic.
+
+    Thereby, it is recommended (but not required) to call the super-class'
+    corresponding method.
+
+    Used in Algorithm and Policy to tag methods that need overriding, but the
+    super class' method should still be called, e.g.
+    `Algorithm.setup()`.
+
+    .. testcode::
+        :skipif: True
+
+        from ray import tune
+        @overrides(tune.Trainable)
+        @OverrideToImplementCustomLogic_CallToSuperRecommended
+        def setup(self, config):
+            # implement custom setup logic here ...
+            super().setup(config)
+            # ... or here (after having called super()'s setup method.
+    """
+    obj.__is_overridden__ = False
+    return obj
+
+
+def is_overridden(obj):
+    """Check whether a function has been overridden.
+
+    Note, this only works for API calls decorated with OverrideToImplementCustomLogic
+    or OverrideToImplementCustomLogic_CallToSuperRecommended.
+    """
+    return getattr(obj, "__is_overridden__", True)
+
+
+# Backward compatibility.
+Deprecated = Deprecated

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/exploration.py

@@ -0,0 +1,209 @@
+from gymnasium.spaces import Space
+from typing import Dict, List, Optional, Union, TYPE_CHECKING
+
+from ray.rllib.env.base_env import BaseEnv
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.framework import try_import_torch, TensorType
+from ray.rllib.utils.typing import LocalOptimizer, AlgorithmConfigDict
+
+if TYPE_CHECKING:
+    from ray.rllib.policy.policy import Policy
+    from ray.rllib.utils import try_import_tf
+
+    _, tf, _ = try_import_tf()
+
+_, nn = try_import_torch()
+
+
+@OldAPIStack
+class Exploration:
+    """Implements an exploration strategy for Policies.
+
+    An Exploration takes model outputs, a distribution, and a timestep from
+    the agent and computes an action to apply to the environment using an
+    implemented exploration schema.
+    """
+
+    def __init__(
+        self,
+        action_space: Space,
+        *,
+        framework: str,
+        policy_config: AlgorithmConfigDict,
+        model: ModelV2,
+        num_workers: int,
+        worker_index: int
+    ):
+        """
+        Args:
+            action_space: The action space in which to explore.
+            framework: One of "tf" or "torch".
+            policy_config: The Policy's config dict.
+            model: The Policy's model.
+            num_workers: The overall number of workers used.
+            worker_index: The index of the worker using this class.
+        """
+        self.action_space = action_space
+        self.policy_config = policy_config
+        self.model = model
+        self.num_workers = num_workers
+        self.worker_index = worker_index
+        self.framework = framework
+        # The device on which the Model has been placed.
+        # This Exploration will be on the same device.
+        self.device = None
+        if isinstance(self.model, nn.Module):
+            params = list(self.model.parameters())
+            if params:
+                self.device = params[0].device
+
+    def before_compute_actions(
+        self,
+        *,
+        timestep: Optional[Union[TensorType, int]] = None,
+        explore: Optional[Union[TensorType, bool]] = None,
+        tf_sess: Optional["tf.Session"] = None,
+        **kwargs
+    ):
+        """Hook for preparations before policy.compute_actions() is called.
+
+        Args:
+            timestep: An optional timestep tensor.
+            explore: An optional explore boolean flag.
+            tf_sess: The tf-session object to use.
+            **kwargs: Forward compatibility kwargs.
+        """
+        pass
+
+    # fmt: off
+    # __sphinx_doc_begin_get_exploration_action__
+
+    def get_exploration_action(self,
+                               *,
+                               action_distribution: ActionDistribution,
+                               timestep: Union[TensorType, int],
+                               explore: bool = True):
+        """Returns a (possibly) exploratory action and its log-likelihood.
+
+        Given the Model's logits outputs and action distribution, returns an
+        exploratory action.
+
+        Args:
+            action_distribution: The instantiated
+                ActionDistribution object to work with when creating
+                exploration actions.
+            timestep: The current sampling time step. It can be a tensor
+                for TF graph mode, otherwise an integer.
+            explore: True: "Normal" exploration behavior.
+                False: Suppress all exploratory behavior and return
+                a deterministic action.
+
+        Returns:
+            A tuple consisting of 1) the chosen exploration action or a
+            tf-op to fetch the exploration action from the graph and
+            2) the log-likelihood of the exploration action.
+        """
+        pass
+
+    # __sphinx_doc_end_get_exploration_action__
+    # fmt: on
+
+    def on_episode_start(
+        self,
+        policy: "Policy",
+        *,
+        environment: BaseEnv = None,
+        episode: int = None,
+        tf_sess: Optional["tf.Session"] = None
+    ):
+        """Handles necessary exploration logic at the beginning of an episode.
+
+        Args:
+            policy: The Policy object that holds this Exploration.
+            environment: The environment object we are acting in.
+            episode: The number of the episode that is starting.
+            tf_sess: In case of tf, the session object.
+        """
+        pass
+
+    def on_episode_end(
+        self,
+        policy: "Policy",
+        *,
+        environment: BaseEnv = None,
+        episode: int = None,
+        tf_sess: Optional["tf.Session"] = None
+    ):
+        """Handles necessary exploration logic at the end of an episode.
+
+        Args:
+            policy: The Policy object that holds this Exploration.
+            environment: The environment object we are acting in.
+            episode: The number of the episode that is starting.
+            tf_sess: In case of tf, the session object.
+        """
+        pass
+
+    def postprocess_trajectory(
+        self,
+        policy: "Policy",
+        sample_batch: SampleBatch,
+        tf_sess: Optional["tf.Session"] = None,
+    ):
+        """Handles post-processing of done episode trajectories.
+
+        Changes the given batch in place. This callback is invoked by the
+        sampler after policy.postprocess_trajectory() is called.
+
+        Args:
+            policy: The owning policy object.
+            sample_batch: The SampleBatch object to post-process.
+            tf_sess: An optional tf.Session object.
+        """
+        return sample_batch
+
+    def get_exploration_optimizer(
+        self, optimizers: List[LocalOptimizer]
+    ) -> List[LocalOptimizer]:
+        """May add optimizer(s) to the Policy's own `optimizers`.
+
+        The number of optimizers (Policy's plus Exploration's optimizers) must
+        match the number of loss terms produced by the Policy's loss function
+        and the Exploration component's loss terms.
+
+        Args:
+            optimizers: The list of the Policy's local optimizers.
+
+        Returns:
+            The updated list of local optimizers to use on the different
+            loss terms.
+        """
+        return optimizers
+
+    def get_state(self, sess: Optional["tf.Session"] = None) -> Dict[str, TensorType]:
+        """Returns the current exploration state.
+
+        Args:
+            sess: An optional tf Session object to use.
+
+        Returns:
+            The Exploration object's current state.
+        """
+        return {}
+
+    def set_state(self, state: object, sess: Optional["tf.Session"] = None) -> None:
+        """Sets the Exploration object's state to the given values.
+
+        Note that some exploration components are stateless, even though they
+        decay some values over time (e.g. EpsilonGreedy). However the decay is
+        only dependent on the current global timestep of the policy and we
+        therefore don't need to keep track of it.
+
+        Args:
+            state: The state to set this Exploration to.
+            sess: An optional tf Session object to use.
+        """
+        pass

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/gaussian_noise.py

@@ -0,0 +1,247 @@
+from gymnasium.spaces import Space
+import numpy as np
+from typing import Union, Optional
+
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.exploration.exploration import Exploration
+from ray.rllib.utils.exploration.random import Random
+from ray.rllib.utils.framework import (
+    try_import_tf,
+    try_import_torch,
+    get_variable,
+    TensorType,
+)
+from ray.rllib.utils.numpy import convert_to_numpy
+from ray.rllib.utils.schedules import Schedule
+from ray.rllib.utils.schedules.piecewise_schedule import PiecewiseSchedule
+from ray.rllib.utils.tf_utils import zero_logps_from_actions
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class GaussianNoise(Exploration):
+    """An exploration that adds white noise to continuous actions.
+
+    If explore=True, returns actions plus scale (annealed over time) x
+    Gaussian noise. Also, some completely random period is possible at the
+    beginning.
+
+    If explore=False, returns the deterministic action.
+    """
+
+    def __init__(
+        self,
+        action_space: Space,
+        *,
+        framework: str,
+        model: ModelV2,
+        random_timesteps: int = 1000,
+        stddev: float = 0.1,
+        initial_scale: float = 1.0,
+        final_scale: float = 0.02,
+        scale_timesteps: int = 10000,
+        scale_schedule: Optional[Schedule] = None,
+        **kwargs
+    ):
+        """Initializes a GaussianNoise instance.
+
+        Args:
+            random_timesteps: The number of timesteps for which to act
+                completely randomly. Only after this number of timesteps, the
+                `self.scale` annealing process will start (see below).
+            stddev: The stddev (sigma) to use for the
+                Gaussian noise to be added to the actions.
+            initial_scale: The initial scaling weight to multiply
+                the noise with.
+            final_scale: The final scaling weight to multiply
+                the noise with.
+            scale_timesteps: The timesteps over which to linearly anneal
+                the scaling factor (after(!) having used random actions for
+                `random_timesteps` steps).
+            scale_schedule: An optional Schedule object
+                to use (instead of constructing one from the given parameters).
+        """
+        assert framework is not None
+        super().__init__(action_space, model=model, framework=framework, **kwargs)
+
+        # Create the Random exploration module (used for the first n
+        # timesteps).
+        self.random_timesteps = random_timesteps
+        self.random_exploration = Random(
+            action_space, model=self.model, framework=self.framework, **kwargs
+        )
+
+        self.stddev = stddev
+        # The `scale` annealing schedule.
+        self.scale_schedule = scale_schedule or PiecewiseSchedule(
+            endpoints=[
+                (random_timesteps, initial_scale),
+                (random_timesteps + scale_timesteps, final_scale),
+            ],
+            outside_value=final_scale,
+            framework=self.framework,
+        )
+
+        # The current timestep value (tf-var or python int).
+        self.last_timestep = get_variable(
+            np.array(0, np.int64),
+            framework=self.framework,
+            tf_name="timestep",
+            dtype=np.int64,
+        )
+
+        # Build the tf-info-op.
+        if self.framework == "tf":
+            self._tf_state_op = self.get_state()
+
+    @override(Exploration)
+    def get_exploration_action(
+        self,
+        *,
+        action_distribution: ActionDistribution,
+        timestep: Union[int, TensorType],
+        explore: bool = True
+    ):
+        # Adds IID Gaussian noise for exploration, TD3-style.
+        if self.framework == "torch":
+            return self._get_torch_exploration_action(
+                action_distribution, explore, timestep
+            )
+        else:
+            return self._get_tf_exploration_action_op(
+                action_distribution, explore, timestep
+            )
+
+    def _get_tf_exploration_action_op(
+        self,
+        action_dist: ActionDistribution,
+        explore: bool,
+        timestep: Union[int, TensorType],
+    ):
+        ts = timestep if timestep is not None else self.last_timestep
+
+        # The deterministic actions (if explore=False).
+        deterministic_actions = action_dist.deterministic_sample()
+
+        # Take a Gaussian sample with our stddev (mean=0.0) and scale it.
+        gaussian_sample = self.scale_schedule(ts) * tf.random.normal(
+            tf.shape(deterministic_actions), stddev=self.stddev
+        )
+
+        # Stochastic actions could either be: random OR action + noise.
+        random_actions, _ = self.random_exploration.get_tf_exploration_action_op(
+            action_dist, explore
+        )
+        stochastic_actions = tf.cond(
+            pred=tf.convert_to_tensor(ts < self.random_timesteps),
+            true_fn=lambda: random_actions,
+            false_fn=lambda: tf.clip_by_value(
+                deterministic_actions + gaussian_sample,
+                self.action_space.low * tf.ones_like(deterministic_actions),
+                self.action_space.high * tf.ones_like(deterministic_actions),
+            ),
+        )
+
+        # Chose by `explore` (main exploration switch).
+        action = tf.cond(
+            pred=tf.constant(explore, dtype=tf.bool)
+            if isinstance(explore, bool)
+            else explore,
+            true_fn=lambda: stochastic_actions,
+            false_fn=lambda: deterministic_actions,
+        )
+        # Logp=always zero.
+        logp = zero_logps_from_actions(deterministic_actions)
+
+        # Increment `last_timestep` by 1 (or set to `timestep`).
+        if self.framework == "tf2":
+            if timestep is None:
+                self.last_timestep.assign_add(1)
+            else:
+                self.last_timestep.assign(tf.cast(timestep, tf.int64))
+            return action, logp
+        else:
+            assign_op = (
+                tf1.assign_add(self.last_timestep, 1)
+                if timestep is None
+                else tf1.assign(self.last_timestep, timestep)
+            )
+            with tf1.control_dependencies([assign_op]):
+                return action, logp
+
+    def _get_torch_exploration_action(
+        self,
+        action_dist: ActionDistribution,
+        explore: bool,
+        timestep: Union[int, TensorType],
+    ):
+        # Set last timestep or (if not given) increase by one.
+        self.last_timestep = (
+            timestep if timestep is not None else self.last_timestep + 1
+        )
+
+        # Apply exploration.
+        if explore:
+            # Random exploration phase.
+            if self.last_timestep < self.random_timesteps:
+                action, _ = self.random_exploration.get_torch_exploration_action(
+                    action_dist, explore=True
+                )
+            # Take a Gaussian sample with our stddev (mean=0.0) and scale it.
+            else:
+                det_actions = action_dist.deterministic_sample()
+                scale = self.scale_schedule(self.last_timestep)
+                gaussian_sample = scale * torch.normal(
+                    mean=torch.zeros(det_actions.size()), std=self.stddev
+                ).to(self.device)
+                action = torch.min(
+                    torch.max(
+                        det_actions + gaussian_sample,
+                        torch.tensor(
+                            self.action_space.low,
+                            dtype=torch.float32,
+                            device=self.device,
+                        ),
+                    ),
+                    torch.tensor(
+                        self.action_space.high, dtype=torch.float32, device=self.device
+                    ),
+                )
+        # No exploration -> Return deterministic actions.
+        else:
+            action = action_dist.deterministic_sample()
+
+        # Logp=always zero.
+        logp = torch.zeros((action.size()[0],), dtype=torch.float32, device=self.device)
+
+        return action, logp
+
+    @override(Exploration)
+    def get_state(self, sess: Optional["tf.Session"] = None):
+        """Returns the current scale value.
+
+        Returns:
+            Union[float,tf.Tensor[float]]: The current scale value.
+        """
+        if sess:
+            return sess.run(self._tf_state_op)
+        scale = self.scale_schedule(self.last_timestep)
+        return {
+            "cur_scale": convert_to_numpy(scale) if self.framework != "tf" else scale,
+            "last_timestep": convert_to_numpy(self.last_timestep)
+            if self.framework != "tf"
+            else self.last_timestep,
+        }
+
+    @override(Exploration)
+    def set_state(self, state: dict, sess: Optional["tf.Session"] = None) -> None:
+        if self.framework == "tf":
+            self.last_timestep.load(state["last_timestep"], session=sess)
+        elif isinstance(self.last_timestep, int):
+            self.last_timestep = state["last_timestep"]
+        else:
+            self.last_timestep.assign(state["last_timestep"])

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/ornstein_uhlenbeck_noise.py

@@ -0,0 +1,273 @@
+import numpy as np
+from typing import Optional, Union
+
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.exploration.gaussian_noise import GaussianNoise
+from ray.rllib.utils.framework import (
+    try_import_tf,
+    try_import_torch,
+    get_variable,
+    TensorType,
+)
+from ray.rllib.utils.numpy import convert_to_numpy
+from ray.rllib.utils.schedules import Schedule
+from ray.rllib.utils.tf_utils import zero_logps_from_actions
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class OrnsteinUhlenbeckNoise(GaussianNoise):
+    """An exploration that adds Ornstein-Uhlenbeck noise to continuous actions.
+
+    If explore=True, returns sampled actions plus a noise term X,
+    which changes according to this formula:
+    Xt+1 = -theta*Xt + sigma*N[0,stddev], where theta, sigma and stddev are
+    constants. Also, some completely random period is possible at the
+    beginning.
+    If explore=False, returns the deterministic action.
+    """
+
+    def __init__(
+        self,
+        action_space,
+        *,
+        framework: str,
+        ou_theta: float = 0.15,
+        ou_sigma: float = 0.2,
+        ou_base_scale: float = 0.1,
+        random_timesteps: int = 1000,
+        initial_scale: float = 1.0,
+        final_scale: float = 0.02,
+        scale_timesteps: int = 10000,
+        scale_schedule: Optional[Schedule] = None,
+        **kwargs
+    ):
+        """Initializes an Ornstein-Uhlenbeck Exploration object.
+
+        Args:
+            action_space: The gym action space used by the environment.
+            ou_theta: The theta parameter of the Ornstein-Uhlenbeck process.
+            ou_sigma: The sigma parameter of the Ornstein-Uhlenbeck process.
+            ou_base_scale: A fixed scaling factor, by which all OU-
+                noise is multiplied. NOTE: This is on top of the parent
+                GaussianNoise's scaling.
+            random_timesteps: The number of timesteps for which to act
+                completely randomly. Only after this number of timesteps, the
+                `self.scale` annealing process will start (see below).
+            initial_scale: The initial scaling weight to multiply the
+                noise with.
+            final_scale: The final scaling weight to multiply the noise with.
+            scale_timesteps: The timesteps over which to linearly anneal the
+                scaling factor (after(!) having used random actions for
+                `random_timesteps` steps.
+            scale_schedule: An optional Schedule object to use (instead
+                of constructing one from the given parameters).
+            framework: One of None, "tf", "torch".
+        """
+        # The current OU-state value (gets updated each time, an eploration
+        # action is computed).
+        self.ou_state = get_variable(
+            np.array(action_space.low.size * [0.0], dtype=np.float32),
+            framework=framework,
+            tf_name="ou_state",
+            torch_tensor=True,
+            device=None,
+        )
+
+        super().__init__(
+            action_space,
+            framework=framework,
+            random_timesteps=random_timesteps,
+            initial_scale=initial_scale,
+            final_scale=final_scale,
+            scale_timesteps=scale_timesteps,
+            scale_schedule=scale_schedule,
+            stddev=1.0,  # Force `self.stddev` to 1.0.
+            **kwargs
+        )
+        self.ou_theta = ou_theta
+        self.ou_sigma = ou_sigma
+        self.ou_base_scale = ou_base_scale
+        # Now that we know the device, move ou_state there, in case of PyTorch.
+        if self.framework == "torch" and self.device is not None:
+            self.ou_state = self.ou_state.to(self.device)
+
+    @override(GaussianNoise)
+    def _get_tf_exploration_action_op(
+        self,
+        action_dist: ActionDistribution,
+        explore: Union[bool, TensorType],
+        timestep: Union[int, TensorType],
+    ):
+        ts = timestep if timestep is not None else self.last_timestep
+        scale = self.scale_schedule(ts)
+
+        # The deterministic actions (if explore=False).
+        deterministic_actions = action_dist.deterministic_sample()
+
+        # Apply base-scaled and time-annealed scaled OU-noise to
+        # deterministic actions.
+        gaussian_sample = tf.random.normal(
+            shape=[self.action_space.low.size], stddev=self.stddev
+        )
+        ou_new = self.ou_theta * -self.ou_state + self.ou_sigma * gaussian_sample
+        if self.framework == "tf2":
+            self.ou_state.assign_add(ou_new)
+            ou_state_new = self.ou_state
+        else:
+            ou_state_new = tf1.assign_add(self.ou_state, ou_new)
+        high_m_low = self.action_space.high - self.action_space.low
+        high_m_low = tf.where(
+            tf.math.is_inf(high_m_low), tf.ones_like(high_m_low), high_m_low
+        )
+        noise = scale * self.ou_base_scale * ou_state_new * high_m_low
+        stochastic_actions = tf.clip_by_value(
+            deterministic_actions + noise,
+            self.action_space.low * tf.ones_like(deterministic_actions),
+            self.action_space.high * tf.ones_like(deterministic_actions),
+        )
+
+        # Stochastic actions could either be: random OR action + noise.
+        random_actions, _ = self.random_exploration.get_tf_exploration_action_op(
+            action_dist, explore
+        )
+        exploration_actions = tf.cond(
+            pred=tf.convert_to_tensor(ts < self.random_timesteps),
+            true_fn=lambda: random_actions,
+            false_fn=lambda: stochastic_actions,
+        )
+
+        # Chose by `explore` (main exploration switch).
+        action = tf.cond(
+            pred=tf.constant(explore, dtype=tf.bool)
+            if isinstance(explore, bool)
+            else explore,
+            true_fn=lambda: exploration_actions,
+            false_fn=lambda: deterministic_actions,
+        )
+        # Logp=always zero.
+        logp = zero_logps_from_actions(deterministic_actions)
+
+        # Increment `last_timestep` by 1 (or set to `timestep`).
+        if self.framework == "tf2":
+            if timestep is None:
+                self.last_timestep.assign_add(1)
+            else:
+                self.last_timestep.assign(tf.cast(timestep, tf.int64))
+        else:
+            assign_op = (
+                tf1.assign_add(self.last_timestep, 1)
+                if timestep is None
+                else tf1.assign(self.last_timestep, timestep)
+            )
+            with tf1.control_dependencies([assign_op, ou_state_new]):
+                action = tf.identity(action)
+                logp = tf.identity(logp)
+
+        return action, logp
+
+    @override(GaussianNoise)
+    def _get_torch_exploration_action(
+        self,
+        action_dist: ActionDistribution,
+        explore: bool,
+        timestep: Union[int, TensorType],
+    ):
+        # Set last timestep or (if not given) increase by one.
+        self.last_timestep = (
+            timestep if timestep is not None else self.last_timestep + 1
+        )
+
+        # Apply exploration.
+        if explore:
+            # Random exploration phase.
+            if self.last_timestep < self.random_timesteps:
+                action, _ = self.random_exploration.get_torch_exploration_action(
+                    action_dist, explore=True
+                )
+            # Apply base-scaled and time-annealed scaled OU-noise to
+            # deterministic actions.
+            else:
+                det_actions = action_dist.deterministic_sample()
+                scale = self.scale_schedule(self.last_timestep)
+                gaussian_sample = scale * torch.normal(
+                    mean=torch.zeros(self.ou_state.size()), std=1.0
+                ).to(self.device)
+                ou_new = (
+                    self.ou_theta * -self.ou_state + self.ou_sigma * gaussian_sample
+                )
+                self.ou_state += ou_new
+                high_m_low = torch.from_numpy(
+                    self.action_space.high - self.action_space.low
+                ).to(self.device)
+                high_m_low = torch.where(
+                    torch.isinf(high_m_low),
+                    torch.ones_like(high_m_low).to(self.device),
+                    high_m_low,
+                )
+                noise = scale * self.ou_base_scale * self.ou_state * high_m_low
+
+                action = torch.min(
+                    torch.max(
+                        det_actions + noise,
+                        torch.tensor(
+                            self.action_space.low,
+                            dtype=torch.float32,
+                            device=self.device,
+                        ),
+                    ),
+                    torch.tensor(
+                        self.action_space.high, dtype=torch.float32, device=self.device
+                    ),
+                )
+
+        # No exploration -> Return deterministic actions.
+        else:
+            action = action_dist.deterministic_sample()
+
+        # Logp=always zero.
+        logp = torch.zeros((action.size()[0],), dtype=torch.float32, device=self.device)
+
+        return action, logp
+
+    @override(GaussianNoise)
+    def get_state(self, sess: Optional["tf.Session"] = None):
+        """Returns the current scale value.
+
+        Returns:
+            Union[float,tf.Tensor[float]]: The current scale value.
+        """
+        if sess:
+            return sess.run(
+                dict(
+                    self._tf_state_op,
+                    **{
+                        "ou_state": self.ou_state,
+                    }
+                )
+            )
+
+        state = super().get_state()
+        return dict(
+            state,
+            **{
+                "ou_state": convert_to_numpy(self.ou_state)
+                if self.framework != "tf"
+                else self.ou_state,
+            }
+        )
+
+    @override(GaussianNoise)
+    def set_state(self, state: dict, sess: Optional["tf.Session"] = None) -> None:
+        if self.framework == "tf":
+            self.ou_state.load(state["ou_state"], session=sess)
+        elif isinstance(self.ou_state, np.ndarray):
+            self.ou_state = state["ou_state"]
+        elif torch and torch.is_tensor(self.ou_state):
+            self.ou_state = torch.from_numpy(state["ou_state"])
+        else:
+            self.ou_state.assign(state["ou_state"])
+        super().set_state(state, sess=sess)

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/parameter_noise.py

@@ -0,0 +1,440 @@
+from gymnasium.spaces import Box, Discrete
+import numpy as np
+from typing import Optional, TYPE_CHECKING, Union
+
+from ray.rllib.env.base_env import BaseEnv
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.models.tf.tf_action_dist import Categorical, Deterministic
+from ray.rllib.models.torch.torch_action_dist import (
+    TorchCategorical,
+    TorchDeterministic,
+)
+from ray.rllib.policy.sample_batch import SampleBatch
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.exploration.exploration import Exploration
+from ray.rllib.utils.framework import get_variable, try_import_tf, try_import_torch
+from ray.rllib.utils.from_config import from_config
+from ray.rllib.utils.numpy import softmax, SMALL_NUMBER
+from ray.rllib.utils.typing import TensorType
+
+if TYPE_CHECKING:
+    from ray.rllib.policy.policy import Policy
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class ParameterNoise(Exploration):
+    """An exploration that changes a Model's parameters.
+
+    Implemented based on:
+    [1] https://openai.com/research/better-exploration-with-parameter-noise
+    [2] https://arxiv.org/pdf/1706.01905.pdf
+
+    At the beginning of an episode, Gaussian noise is added to all weights
+    of the model. At the end of the episode, the noise is undone and an action
+    diff (pi-delta) is calculated, from which we determine the changes in the
+    noise's stddev for the next episode.
+    """
+
+    def __init__(
+        self,
+        action_space,
+        *,
+        framework: str,
+        policy_config: dict,
+        model: ModelV2,
+        initial_stddev: float = 1.0,
+        random_timesteps: int = 10000,
+        sub_exploration: Optional[dict] = None,
+        **kwargs
+    ):
+        """Initializes a ParameterNoise Exploration object.
+
+        Args:
+            initial_stddev: The initial stddev to use for the noise.
+            random_timesteps: The number of timesteps to act completely
+                randomly (see [1]).
+            sub_exploration: Optional sub-exploration config.
+                None for auto-detection/setup.
+        """
+        assert framework is not None
+        super().__init__(
+            action_space,
+            policy_config=policy_config,
+            model=model,
+            framework=framework,
+            **kwargs
+        )
+
+        self.stddev = get_variable(
+            initial_stddev, framework=self.framework, tf_name="stddev"
+        )
+        self.stddev_val = initial_stddev  # Out-of-graph tf value holder.
+
+        # The weight variables of the Model where noise should be applied to.
+        # This excludes any variable, whose name contains "LayerNorm" (those
+        # are BatchNormalization layers, which should not be perturbed).
+        self.model_variables = [
+            v
+            for k, v in self.model.trainable_variables(as_dict=True).items()
+            if "LayerNorm" not in k
+        ]
+        # Our noise to be added to the weights. Each item in `self.noise`
+        # corresponds to one Model variable and holding the Gaussian noise to
+        # be added to that variable (weight).
+        self.noise = []
+        for var in self.model_variables:
+            name_ = var.name.split(":")[0] + "_noisy" if var.name else ""
+            self.noise.append(
+                get_variable(
+                    np.zeros(var.shape, dtype=np.float32),
+                    framework=self.framework,
+                    tf_name=name_,
+                    torch_tensor=True,
+                    device=self.device,
+                )
+            )
+
+        # tf-specific ops to sample, assign and remove noise.
+        if self.framework == "tf" and not tf.executing_eagerly():
+            self.tf_sample_new_noise_op = self._tf_sample_new_noise_op()
+            self.tf_add_stored_noise_op = self._tf_add_stored_noise_op()
+            self.tf_remove_noise_op = self._tf_remove_noise_op()
+            # Create convenience sample+add op for tf.
+            with tf1.control_dependencies([self.tf_sample_new_noise_op]):
+                add_op = self._tf_add_stored_noise_op()
+            with tf1.control_dependencies([add_op]):
+                self.tf_sample_new_noise_and_add_op = tf.no_op()
+
+        # Whether the Model's weights currently have noise added or not.
+        self.weights_are_currently_noisy = False
+
+        # Auto-detection of underlying exploration functionality.
+        if sub_exploration is None:
+            # For discrete action spaces, use an underlying EpsilonGreedy with
+            # a special schedule.
+            if isinstance(self.action_space, Discrete):
+                sub_exploration = {
+                    "type": "EpsilonGreedy",
+                    "epsilon_schedule": {
+                        "type": "PiecewiseSchedule",
+                        # Step function (see [2]).
+                        "endpoints": [
+                            (0, 1.0),
+                            (random_timesteps + 1, 1.0),
+                            (random_timesteps + 2, 0.01),
+                        ],
+                        "outside_value": 0.01,
+                    },
+                }
+            elif isinstance(self.action_space, Box):
+                sub_exploration = {
+                    "type": "OrnsteinUhlenbeckNoise",
+                    "random_timesteps": random_timesteps,
+                }
+            # TODO(sven): Implement for any action space.
+            else:
+                raise NotImplementedError
+
+        self.sub_exploration = from_config(
+            Exploration,
+            sub_exploration,
+            framework=self.framework,
+            action_space=self.action_space,
+            policy_config=self.policy_config,
+            model=self.model,
+            **kwargs
+        )
+
+        # Whether we need to call `self._delayed_on_episode_start` before
+        # the forward pass.
+        self.episode_started = False
+
+    @override(Exploration)
+    def before_compute_actions(
+        self,
+        *,
+        timestep: Optional[int] = None,
+        explore: Optional[bool] = None,
+        tf_sess: Optional["tf.Session"] = None
+    ):
+        explore = explore if explore is not None else self.policy_config["explore"]
+
+        # Is this the first forward pass in the new episode? If yes, do the
+        # noise re-sampling and add to weights.
+        if self.episode_started:
+            self._delayed_on_episode_start(explore, tf_sess)
+
+        # Add noise if necessary.
+        if explore and not self.weights_are_currently_noisy:
+            self._add_stored_noise(tf_sess=tf_sess)
+        # Remove noise if necessary.
+        elif not explore and self.weights_are_currently_noisy:
+            self._remove_noise(tf_sess=tf_sess)
+
+    @override(Exploration)
+    def get_exploration_action(
+        self,
+        *,
+        action_distribution: ActionDistribution,
+        timestep: Union[TensorType, int],
+        explore: Union[TensorType, bool]
+    ):
+        # Use our sub-exploration object to handle the final exploration
+        # action (depends on the algo-type/action-space/etc..).
+        return self.sub_exploration.get_exploration_action(
+            action_distribution=action_distribution, timestep=timestep, explore=explore
+        )
+
+    @override(Exploration)
+    def on_episode_start(
+        self,
+        policy: "Policy",
+        *,
+        environment: BaseEnv = None,
+        episode: int = None,
+        tf_sess: Optional["tf.Session"] = None
+    ):
+        # We have to delay the noise-adding step by one forward call.
+        # This is due to the fact that the optimizer does it's step right
+        # after the episode was reset (and hence the noise was already added!).
+        # We don't want to update into a noisy net.
+        self.episode_started = True
+
+    def _delayed_on_episode_start(self, explore, tf_sess):
+        # Sample fresh noise and add to weights.
+        if explore:
+            self._sample_new_noise_and_add(tf_sess=tf_sess, override=True)
+        # Only sample, don't apply anything to the weights.
+        else:
+            self._sample_new_noise(tf_sess=tf_sess)
+        self.episode_started = False
+
+    @override(Exploration)
+    def on_episode_end(self, policy, *, environment=None, episode=None, tf_sess=None):
+        # Remove stored noise from weights (only if currently noisy).
+        if self.weights_are_currently_noisy:
+            self._remove_noise(tf_sess=tf_sess)
+
+    @override(Exploration)
+    def postprocess_trajectory(
+        self,
+        policy: "Policy",
+        sample_batch: SampleBatch,
+        tf_sess: Optional["tf.Session"] = None,
+    ):
+        noisy_action_dist = noise_free_action_dist = None
+        # Adjust the stddev depending on the action (pi)-distance.
+        # Also see [1] for details.
+        # TODO(sven): Find out whether this can be scrapped by simply using
+        #  the `sample_batch` to get the noisy/noise-free action dist.
+        _, _, fetches = policy.compute_actions_from_input_dict(
+            input_dict=sample_batch, explore=self.weights_are_currently_noisy
+        )
+
+        # Categorical case (e.g. DQN).
+        if issubclass(policy.dist_class, (Categorical, TorchCategorical)):
+            action_dist = softmax(fetches[SampleBatch.ACTION_DIST_INPUTS])
+        # Deterministic (Gaussian actions, e.g. DDPG).
+        elif issubclass(policy.dist_class, (Deterministic, TorchDeterministic)):
+            action_dist = fetches[SampleBatch.ACTION_DIST_INPUTS]
+        else:
+            raise NotImplementedError  # TODO(sven): Other action-dist cases.
+
+        if self.weights_are_currently_noisy:
+            noisy_action_dist = action_dist
+        else:
+            noise_free_action_dist = action_dist
+
+        _, _, fetches = policy.compute_actions_from_input_dict(
+            input_dict=sample_batch, explore=not self.weights_are_currently_noisy
+        )
+
+        # Categorical case (e.g. DQN).
+        if issubclass(policy.dist_class, (Categorical, TorchCategorical)):
+            action_dist = softmax(fetches[SampleBatch.ACTION_DIST_INPUTS])
+            # Deterministic (Gaussian actions, e.g. DDPG).
+        elif issubclass(policy.dist_class, (Deterministic, TorchDeterministic)):
+            action_dist = fetches[SampleBatch.ACTION_DIST_INPUTS]
+
+        if noisy_action_dist is None:
+            noisy_action_dist = action_dist
+        else:
+            noise_free_action_dist = action_dist
+
+        delta = distance = None
+        # Categorical case (e.g. DQN).
+        if issubclass(policy.dist_class, (Categorical, TorchCategorical)):
+            # Calculate KL-divergence (DKL(clean||noisy)) according to [2].
+            # TODO(sven): Allow KL-divergence to be calculated by our
+            #  Distribution classes (don't support off-graph/numpy yet).
+            distance = np.nanmean(
+                np.sum(
+                    noise_free_action_dist
+                    * np.log(
+                        noise_free_action_dist / (noisy_action_dist + SMALL_NUMBER)
+                    ),
+                    1,
+                )
+            )
+            current_epsilon = self.sub_exploration.get_state(sess=tf_sess)[
+                "cur_epsilon"
+            ]
+            delta = -np.log(1 - current_epsilon + current_epsilon / self.action_space.n)
+        elif issubclass(policy.dist_class, (Deterministic, TorchDeterministic)):
+            # Calculate MSE between noisy and non-noisy output (see [2]).
+            distance = np.sqrt(
+                np.mean(np.square(noise_free_action_dist - noisy_action_dist))
+            )
+            current_scale = self.sub_exploration.get_state(sess=tf_sess)["cur_scale"]
+            delta = getattr(self.sub_exploration, "ou_sigma", 0.2) * current_scale
+
+        # Adjust stddev according to the calculated action-distance.
+        if distance <= delta:
+            self.stddev_val *= 1.01
+        else:
+            self.stddev_val /= 1.01
+
+        # Update our state (self.stddev and self.stddev_val).
+        self.set_state(self.get_state(), sess=tf_sess)
+
+        return sample_batch
+
+    def _sample_new_noise(self, *, tf_sess=None):
+        """Samples new noise and stores it in `self.noise`."""
+        if self.framework == "tf":
+            tf_sess.run(self.tf_sample_new_noise_op)
+        elif self.framework == "tf2":
+            self._tf_sample_new_noise_op()
+        else:
+            for i in range(len(self.noise)):
+                self.noise[i] = torch.normal(
+                    mean=torch.zeros(self.noise[i].size()), std=self.stddev
+                ).to(self.device)
+
+    def _tf_sample_new_noise_op(self):
+        added_noises = []
+        for noise in self.noise:
+            added_noises.append(
+                tf1.assign(
+                    noise,
+                    tf.random.normal(
+                        shape=noise.shape, stddev=self.stddev, dtype=tf.float32
+                    ),
+                )
+            )
+        return tf.group(*added_noises)
+
+    def _sample_new_noise_and_add(self, *, tf_sess=None, override=False):
+        if self.framework == "tf":
+            if override and self.weights_are_currently_noisy:
+                tf_sess.run(self.tf_remove_noise_op)
+            tf_sess.run(self.tf_sample_new_noise_and_add_op)
+        else:
+            if override and self.weights_are_currently_noisy:
+                self._remove_noise()
+            self._sample_new_noise()
+            self._add_stored_noise()
+
+        self.weights_are_currently_noisy = True
+
+    def _add_stored_noise(self, *, tf_sess=None):
+        """Adds the stored `self.noise` to the model's parameters.
+
+        Note: No new sampling of noise here.
+
+        Args:
+            tf_sess (Optional[tf.Session]): The tf-session to use to add the
+                stored noise to the (currently noise-free) weights.
+            override: If True, undo any currently applied noise first,
+                then add the currently stored noise.
+        """
+        # Make sure we only add noise to currently noise-free weights.
+        assert self.weights_are_currently_noisy is False
+
+        # Add stored noise to the model's parameters.
+        if self.framework == "tf":
+            tf_sess.run(self.tf_add_stored_noise_op)
+        elif self.framework == "tf2":
+            self._tf_add_stored_noise_op()
+        else:
+            for var, noise in zip(self.model_variables, self.noise):
+                # Add noise to weights in-place.
+                var.requires_grad = False
+                var.add_(noise)
+                var.requires_grad = True
+
+        self.weights_are_currently_noisy = True
+
+    def _tf_add_stored_noise_op(self):
+        """Generates tf-op that assigns the stored noise to weights.
+
+        Also used by tf-eager.
+
+        Returns:
+            tf.op: The tf op to apply the already stored noise to the NN.
+        """
+        add_noise_ops = list()
+        for var, noise in zip(self.model_variables, self.noise):
+            add_noise_ops.append(tf1.assign_add(var, noise))
+        ret = tf.group(*tuple(add_noise_ops))
+        with tf1.control_dependencies([ret]):
+            return tf.no_op()
+
+    def _remove_noise(self, *, tf_sess=None):
+        """
+        Removes the current action noise from the model parameters.
+
+        Args:
+            tf_sess (Optional[tf.Session]): The tf-session to use to remove
+                the noise from the (currently noisy) weights.
+        """
+        # Make sure we only remove noise iff currently noisy.
+        assert self.weights_are_currently_noisy is True
+
+        # Removes the stored noise from the model's parameters.
+        if self.framework == "tf":
+            tf_sess.run(self.tf_remove_noise_op)
+        elif self.framework == "tf2":
+            self._tf_remove_noise_op()
+        else:
+            for var, noise in zip(self.model_variables, self.noise):
+                # Remove noise from weights in-place.
+                var.requires_grad = False
+                var.add_(-noise)
+                var.requires_grad = True
+
+        self.weights_are_currently_noisy = False
+
+    def _tf_remove_noise_op(self):
+        """Generates a tf-op for removing noise from the model's weights.
+
+        Also used by tf-eager.
+
+        Returns:
+            tf.op: The tf op to remve the currently stored noise from the NN.
+        """
+        remove_noise_ops = list()
+        for var, noise in zip(self.model_variables, self.noise):
+            remove_noise_ops.append(tf1.assign_add(var, -noise))
+        ret = tf.group(*tuple(remove_noise_ops))
+        with tf1.control_dependencies([ret]):
+            return tf.no_op()
+
+    @override(Exploration)
+    def get_state(self, sess=None):
+        return {"cur_stddev": self.stddev_val}
+
+    @override(Exploration)
+    def set_state(self, state: dict, sess: Optional["tf.Session"] = None) -> None:
+        self.stddev_val = state["cur_stddev"]
+        # Set self.stddev to calculated value.
+        if self.framework == "tf":
+            self.stddev.load(self.stddev_val, session=sess)
+        elif isinstance(self.stddev, float):
+            self.stddev = self.stddev_val
+        else:
+            self.stddev.assign(self.stddev_val)

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/per_worker_gaussian_noise.py

@@ -0,0 +1,49 @@
+from gymnasium.spaces import Space
+from typing import Optional
+
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.exploration.gaussian_noise import GaussianNoise
+from ray.rllib.utils.schedules import ConstantSchedule
+
+
+@OldAPIStack
+class PerWorkerGaussianNoise(GaussianNoise):
+    """A per-worker Gaussian noise class for distributed algorithms.
+
+    Sets the `scale` schedules of individual workers to a constant:
+    0.4 ^ (1 + [worker-index] / float([num-workers] - 1) * 7)
+    See Ape-X paper.
+    """
+
+    def __init__(
+        self,
+        action_space: Space,
+        *,
+        framework: Optional[str],
+        num_workers: Optional[int],
+        worker_index: Optional[int],
+        **kwargs
+    ):
+        """
+        Args:
+            action_space: The gym action space used by the environment.
+            num_workers: The overall number of workers used.
+            worker_index: The index of the Worker using this
+                Exploration.
+            framework: One of None, "tf", "torch".
+        """
+        scale_schedule = None
+        # Use a fixed, different epsilon per worker. See: Ape-X paper.
+        if num_workers > 0:
+            if worker_index > 0:
+                num_workers_minus_1 = float(num_workers - 1) if num_workers > 1 else 1.0
+                exponent = 1 + (worker_index / num_workers_minus_1) * 7
+                scale_schedule = ConstantSchedule(0.4**exponent, framework=framework)
+            # Local worker should have zero exploration so that eval
+            # rollouts run properly.
+            else:
+                scale_schedule = ConstantSchedule(0.0, framework=framework)
+
+        super().__init__(
+            action_space, scale_schedule=scale_schedule, framework=framework, **kwargs
+        )

deepseek/lib/python3.10/site-packages/ray/rllib/utils/exploration/slate_soft_q.py

@@ -0,0 +1,46 @@
+from typing import Union
+
+from ray.rllib.models.action_dist import ActionDistribution
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.exploration.exploration import TensorType
+from ray.rllib.utils.exploration.soft_q import SoftQ
+from ray.rllib.utils.framework import try_import_tf, try_import_torch
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+
+@OldAPIStack
+class SlateSoftQ(SoftQ):
+    @override(SoftQ)
+    def get_exploration_action(
+        self,
+        action_distribution: ActionDistribution,
+        timestep: Union[int, TensorType],
+        explore: bool = True,
+    ):
+        assert (
+            self.framework == "torch"
+        ), "ERROR: SlateSoftQ only supports torch so far!"
+
+        cls = type(action_distribution)
+
+        # Re-create the action distribution with the correct temperature
+        # applied.
+        action_distribution = cls(
+            action_distribution.inputs, self.model, temperature=self.temperature
+        )
+        batch_size = action_distribution.inputs.size()[0]
+        action_logp = torch.zeros(batch_size, dtype=torch.float)
+
+        self.last_timestep = timestep
+
+        # Explore.
+        if explore:
+            # Return stochastic sample over (q-value) logits.
+            action = action_distribution.sample()
+        # Return the deterministic "sample" (argmax) over (q-value) logits.
+        else:
+            action = action_distribution.deterministic_sample()
+
+        return action, action_logp

deepseek/lib/python3.10/site-packages/ray/rllib/utils/filter.py

@@ -0,0 +1,420 @@
+import logging
+import threading
+
+import numpy as np
+import tree  # pip install dm_tree
+
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.numpy import SMALL_NUMBER
+from ray.rllib.utils.typing import TensorStructType
+from ray.rllib.utils.serialization import _serialize_ndarray, _deserialize_ndarray
+from ray.rllib.utils.deprecation import deprecation_warning
+
+logger = logging.getLogger(__name__)
+
+
+@OldAPIStack
+class Filter:
+    """Processes input, possibly statefully."""
+
+    def apply_changes(self, other: "Filter", *args, **kwargs) -> None:
+        """Updates self with "new state" from other filter."""
+        raise NotImplementedError
+
+    def copy(self) -> "Filter":
+        """Creates a new object with same state as self.
+
+        Returns:
+            A copy of self.
+        """
+        raise NotImplementedError
+
+    def sync(self, other: "Filter") -> None:
+        """Copies all state from other filter to self."""
+        raise NotImplementedError
+
+    def reset_buffer(self) -> None:
+        """Creates copy of current state and resets accumulated state"""
+        raise NotImplementedError
+
+    def as_serializable(self) -> "Filter":
+        raise NotImplementedError
+
+    @Deprecated(new="Filter.reset_buffer()", error=True)
+    def clear_buffer(self):
+        pass
+
+
+@OldAPIStack
+class NoFilter(Filter):
+    is_concurrent = True
+
+    def __call__(self, x: TensorStructType, update=True):
+        # Process no further if already np.ndarray, dict, or tuple.
+        if isinstance(x, (np.ndarray, dict, tuple)):
+            return x
+
+        try:
+            return np.asarray(x)
+        except Exception:
+            raise ValueError("Failed to convert to array", x)
+
+    def apply_changes(self, other: "NoFilter", *args, **kwargs) -> None:
+        pass
+
+    def copy(self) -> "NoFilter":
+        return self
+
+    def sync(self, other: "NoFilter") -> None:
+        pass
+
+    def reset_buffer(self) -> None:
+        pass
+
+    def as_serializable(self) -> "NoFilter":
+        return self
+
+
+# http://www.johndcook.com/blog/standard_deviation/
+@OldAPIStack
+class RunningStat:
+    def __init__(self, shape=()):
+        self.num_pushes = 0
+        self.mean_array = np.zeros(shape)
+        self.std_array = np.zeros(shape)
+
+    def copy(self):
+        other = RunningStat()
+        # TODO: Remove these safe-guards if not needed anymore.
+        other.num_pushes = self.num_pushes if hasattr(self, "num_pushes") else self._n
+        other.mean_array = (
+            np.copy(self.mean_array)
+            if hasattr(self, "mean_array")
+            else np.copy(self._M)
+        )
+        other.std_array = (
+            np.copy(self.std_array) if hasattr(self, "std_array") else np.copy(self._S)
+        )
+        return other
+
+    def push(self, x):
+        x = np.asarray(x)
+        # Unvectorized update of the running statistics.
+        if x.shape != self.mean_array.shape:
+            raise ValueError(
+                "Unexpected input shape {}, expected {}, value = {}".format(
+                    x.shape, self.mean_array.shape, x
+                )
+            )
+        self.num_pushes += 1
+        if self.num_pushes == 1:
+            self.mean_array[...] = x
+        else:
+            delta = x - self.mean_array
+            self.mean_array[...] += delta / self.num_pushes
+            self.std_array[...] += (
+                (delta / self.num_pushes) * delta * (self.num_pushes - 1)
+            )
+
+    def update(self, other):
+        n1 = float(self.num_pushes)
+        n2 = float(other.num_pushes)
+        n = n1 + n2
+        if n == 0:
+            # Avoid divide by zero, which creates nans
+            return
+        delta = self.mean_array - other.mean_array
+        delta2 = delta * delta
+        m = (n1 * self.mean_array + n2 * other.mean_array) / n
+        s = self.std_array + other.std_array + (delta2 / n) * n1 * n2
+        self.num_pushes = n
+        self.mean_array = m
+        self.std_array = s
+
+    def __repr__(self):
+        return "(n={}, mean_mean={}, mean_std={})".format(
+            self.n, np.mean(self.mean), np.mean(self.std)
+        )
+
+    @property
+    def n(self):
+        return self.num_pushes
+
+    @property
+    def mean(self):
+        return self.mean_array
+
+    @property
+    def var(self):
+        return (
+            self.std_array / (self.num_pushes - 1)
+            if self.num_pushes > 1
+            else np.square(self.mean_array)
+        ).astype(np.float32)
+
+    @property
+    def std(self):
+        return np.sqrt(self.var)
+
+    @property
+    def shape(self):
+        return self.mean_array.shape
+
+    def to_state(self):
+        return {
+            "num_pushes": self.num_pushes,
+            "mean_array": _serialize_ndarray(self.mean_array),
+            "std_array": _serialize_ndarray(self.std_array),
+        }
+
+    @staticmethod
+    def from_state(state):
+        running_stats = RunningStat()
+        running_stats.num_pushes = state["num_pushes"]
+        running_stats.mean_array = _deserialize_ndarray(state["mean_array"])
+        running_stats.std_array = _deserialize_ndarray(state["std_array"])
+        return running_stats
+
+
+@OldAPIStack
+class MeanStdFilter(Filter):
+    """Keeps track of a running mean for seen states"""
+
+    is_concurrent = False
+
+    def __init__(self, shape, demean=True, destd=True, clip=10.0):
+        self.shape = shape
+        # We don't have a preprocessor, if shape is None (Discrete) or
+        # flat_shape is Tuple[np.ndarray] or Dict[str, np.ndarray]
+        # (complex inputs).
+        flat_shape = tree.flatten(self.shape)
+        self.no_preprocessor = shape is None or (
+            isinstance(self.shape, (dict, tuple))
+            and len(flat_shape) > 0
+            and isinstance(flat_shape[0], np.ndarray)
+        )
+        # If preprocessing (flattening dicts/tuples), make sure shape
+        # is an np.ndarray, so we don't confuse it with a complex Tuple
+        # space's shape structure (which is a Tuple[np.ndarray]).
+        if not self.no_preprocessor:
+            self.shape = np.array(self.shape)
+        self.demean = demean
+        self.destd = destd
+        self.clip = clip
+        # Running stats.
+        self.running_stats = tree.map_structure(lambda s: RunningStat(s), self.shape)
+
+        # In distributed rollouts, each worker sees different states.
+        # The buffer is used to keep track of deltas amongst all the
+        # observation filters.
+        self.buffer = None
+        self.reset_buffer()
+
+    def reset_buffer(self) -> None:
+        self.buffer = tree.map_structure(lambda s: RunningStat(s), self.shape)
+
+    def apply_changes(
+        self, other: "MeanStdFilter", with_buffer: bool = False, *args, **kwargs
+    ) -> None:
+        """Applies updates from the buffer of another filter.
+
+        Args:
+            other: Other filter to apply info from
+            with_buffer: Flag for specifying if the buffer should be
+                copied from other.
+
+        .. testcode::
+            :skipif: True
+
+            a = MeanStdFilter(())
+            a(1)
+            a(2)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [2, 1.5, 2]
+
+        .. testcode::
+            :skipif: True
+
+            b = MeanStdFilter(())
+            b(10)
+            a.apply_changes(b, with_buffer=False)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [3, 4.333333333333333, 2]
+
+        .. testcode::
+            :skipif: True
+
+            a.apply_changes(b, with_buffer=True)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [4, 5.75, 1]
+        """
+        tree.map_structure(
+            lambda rs, other_rs: rs.update(other_rs), self.running_stats, other.buffer
+        )
+        if with_buffer:
+            self.buffer = tree.map_structure(lambda b: b.copy(), other.buffer)
+
+    def copy(self) -> "MeanStdFilter":
+        """Returns a copy of `self`."""
+        other = MeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def as_serializable(self) -> "MeanStdFilter":
+        return self.copy()
+
+    def sync(self, other: "MeanStdFilter") -> None:
+        """Syncs all fields together from other filter.
+
+        .. testcode::
+            :skipif: True
+
+            a = MeanStdFilter(())
+            a(1)
+            a(2)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [2, array(1.5), 2]
+
+        .. testcode::
+            :skipif: True
+
+            b = MeanStdFilter(())
+            b(10)
+            print([b.running_stats.n, b.running_stats.mean, b.buffer.n])
+
+        .. testoutput::
+
+            [1, array(10.0), 1]
+
+        .. testcode::
+            :skipif: True
+
+            a.sync(b)
+            print([a.running_stats.n, a.running_stats.mean, a.buffer.n])
+
+        .. testoutput::
+
+            [1, array(10.0), 1]
+        """
+        self.demean = other.demean
+        self.destd = other.destd
+        self.clip = other.clip
+        self.running_stats = tree.map_structure(
+            lambda rs: rs.copy(), other.running_stats
+        )
+        self.buffer = tree.map_structure(lambda b: b.copy(), other.buffer)
+
+    def __call__(self, x: TensorStructType, update: bool = True) -> TensorStructType:
+        if self.no_preprocessor:
+            x = tree.map_structure(lambda x_: np.asarray(x_), x)
+        else:
+            x = np.asarray(x)
+
+        def _helper(x, rs, buffer, shape):
+            # Discrete|MultiDiscrete spaces -> No normalization.
+            if shape is None:
+                return x
+
+            # Keep dtype as is througout this filter.
+            orig_dtype = x.dtype
+
+            if update:
+                if len(x.shape) == len(rs.shape) + 1:
+                    # The vectorized case.
+                    for i in range(x.shape[0]):
+                        rs.push(x[i])
+                        buffer.push(x[i])
+                else:
+                    # The unvectorized case.
+                    rs.push(x)
+                    buffer.push(x)
+            if self.demean:
+                x = x - rs.mean
+            if self.destd:
+                x = x / (rs.std + SMALL_NUMBER)
+            if self.clip:
+                x = np.clip(x, -self.clip, self.clip)
+            return x.astype(orig_dtype)
+
+        if self.no_preprocessor:
+            return tree.map_structure_up_to(
+                x, _helper, x, self.running_stats, self.buffer, self.shape
+            )
+        else:
+            return _helper(x, self.running_stats, self.buffer, self.shape)
+
+
+@OldAPIStack
+class ConcurrentMeanStdFilter(MeanStdFilter):
+    is_concurrent = True
+
+    def __init__(self, *args, **kwargs):
+        super(ConcurrentMeanStdFilter, self).__init__(*args, **kwargs)
+        deprecation_warning(
+            old="ConcurrentMeanStdFilter",
+            error=False,
+            help="ConcurrentMeanStd filters are only used for testing and will "
+            "therefore be deprecated in the course of moving to the "
+            "Connetors API, where testing of filters will be done by other "
+            "means.",
+        )
+
+        self._lock = threading.RLock()
+
+        def lock_wrap(func):
+            def wrapper(*args, **kwargs):
+                with self._lock:
+                    return func(*args, **kwargs)
+
+            return wrapper
+
+        self.__getattribute__ = lock_wrap(self.__getattribute__)
+
+    def as_serializable(self) -> "MeanStdFilter":
+        """Returns non-concurrent version of current class"""
+        other = MeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def copy(self) -> "ConcurrentMeanStdFilter":
+        """Returns a copy of Filter."""
+        other = ConcurrentMeanStdFilter(self.shape)
+        other.sync(self)
+        return other
+
+    def __repr__(self) -> str:
+        return "ConcurrentMeanStdFilter({}, {}, {}, {}, {}, {})".format(
+            self.shape,
+            self.demean,
+            self.destd,
+            self.clip,
+            self.running_stats,
+            self.buffer,
+        )
+
+
+@OldAPIStack
+def get_filter(filter_config, shape):
+    if filter_config == "MeanStdFilter":
+        return MeanStdFilter(shape, clip=None)
+    elif filter_config == "ConcurrentMeanStdFilter":
+        return ConcurrentMeanStdFilter(shape, clip=None)
+    elif filter_config == "NoFilter":
+        return NoFilter()
+    elif callable(filter_config):
+        return filter_config(shape)
+    else:
+        raise Exception("Unknown observation_filter: " + str(filter_config))

deepseek/lib/python3.10/site-packages/ray/rllib/utils/images.py

@@ -0,0 +1,60 @@
+import logging
+import importlib
+
+import numpy as np
+
+from ray.rllib.utils.annotations import DeveloperAPI
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+def is_package_installed(package_name):
+    try:
+        importlib.metadata.version(package_name)
+        return True
+    except importlib.metadata.PackageNotFoundError:
+        return False
+
+
+try:
+    import cv2
+
+    cv2.ocl.setUseOpenCL(False)
+
+    logger.debug("CV2 found for image processing.")
+except ImportError as e:
+    if is_package_installed("opencv-python"):
+        raise ImportError(
+            f"OpenCV is installed, but we failed to import it. This may be because "
+            f"you need to install `opencv-python-headless` instead of "
+            f"`opencv-python`. Error message: {e}",
+        )
+    cv2 = None
+
+
+@DeveloperAPI
+def resize(img: np.ndarray, height: int, width: int) -> np.ndarray:
+    if not cv2:
+        raise ModuleNotFoundError(
+            "`opencv` not installed! Do `pip install opencv-python`"
+        )
+    return cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)
+
+
+@DeveloperAPI
+def rgb2gray(img: np.ndarray) -> np.ndarray:
+    if not cv2:
+        raise ModuleNotFoundError(
+            "`opencv` not installed! Do `pip install opencv-python`"
+        )
+    return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+
+
+@DeveloperAPI
+def imread(img_file: str) -> np.ndarray:
+    if not cv2:
+        raise ModuleNotFoundError(
+            "`opencv` not installed! Do `pip install opencv-python`"
+        )
+    return cv2.imread(img_file).astype(np.float32)

deepseek/lib/python3.10/site-packages/ray/rllib/utils/numpy.py

@@ -0,0 +1,606 @@
+from collections import OrderedDict
+from gymnasium.spaces import Discrete, MultiDiscrete
+import numpy as np
+import tree  # pip install dm_tree
+from types import MappingProxyType
+from typing import List, Optional
+
+
+from ray.rllib.utils.annotations import PublicAPI
+from ray.rllib.utils.deprecation import Deprecated
+from ray.rllib.utils.framework import try_import_tf, try_import_torch
+from ray.rllib.utils.typing import SpaceStruct, TensorType, TensorStructType, Union
+
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+SMALL_NUMBER = 1e-6
+# Some large int number. May be increased here, if needed.
+LARGE_INTEGER = 100000000
+# Min and Max outputs (clipped) from an NN-output layer interpreted as the
+# log(x) of some x (e.g. a stddev of a normal
+# distribution).
+MIN_LOG_NN_OUTPUT = -5
+MAX_LOG_NN_OUTPUT = 2
+
+
+@PublicAPI
+@Deprecated(
+    help="RLlib itself has no use for this anymore.",
+    error=False,
+)
+def aligned_array(size: int, dtype, align: int = 64) -> np.ndarray:
+    """Returns an array of a given size that is 64-byte aligned.
+
+    The returned array can be efficiently copied into GPU memory by TensorFlow.
+
+    Args:
+        size: The size (total number of items) of the array. For example,
+            array([[0.0, 1.0], [2.0, 3.0]]) would have size=4.
+        dtype: The numpy dtype of the array.
+        align: The alignment to use.
+
+    Returns:
+        A np.ndarray with the given specifications.
+    """
+    n = size * dtype.itemsize
+    empty = np.empty(n + (align - 1), dtype=np.uint8)
+    data_align = empty.ctypes.data % align
+    offset = 0 if data_align == 0 else (align - data_align)
+    if n == 0:
+        # stop np from optimising out empty slice reference
+        output = empty[offset : offset + 1][0:0].view(dtype)
+    else:
+        output = empty[offset : offset + n].view(dtype)
+
+    assert len(output) == size, len(output)
+    assert output.ctypes.data % align == 0, output.ctypes.data
+    return output
+
+
+@PublicAPI
+@Deprecated(
+    help="RLlib itself has no use for this anymore.",
+    error=False,
+)
+def concat_aligned(
+    items: List[np.ndarray], time_major: Optional[bool] = None
+) -> np.ndarray:
+    """Concatenate arrays, ensuring the output is 64-byte aligned.
+
+    We only align float arrays; other arrays are concatenated as normal.
+
+    This should be used instead of np.concatenate() to improve performance
+    when the output array is likely to be fed into TensorFlow.
+
+    Args:
+        items: The list of items to concatenate and align.
+        time_major: Whether the data in items is time-major, in which
+            case, we will concatenate along axis=1.
+
+    Returns:
+        The concat'd and aligned array.
+    """
+
+    if len(items) == 0:
+        return []
+    elif len(items) == 1:
+        # we assume the input is aligned. In any case, it doesn't help
+        # performance to force align it since that incurs a needless copy.
+        return items[0]
+    elif isinstance(items[0], np.ndarray) and items[0].dtype in [
+        np.float32,
+        np.float64,
+        np.uint8,
+    ]:
+        dtype = items[0].dtype
+        flat = aligned_array(sum(s.size for s in items), dtype)
+        if time_major is not None:
+            if time_major is True:
+                batch_dim = sum(s.shape[1] for s in items)
+                new_shape = (items[0].shape[0], batch_dim,) + items[
+                    0
+                ].shape[2:]
+            else:
+                batch_dim = sum(s.shape[0] for s in items)
+                new_shape = (batch_dim, items[0].shape[1],) + items[
+                    0
+                ].shape[2:]
+        else:
+            batch_dim = sum(s.shape[0] for s in items)
+            new_shape = (batch_dim,) + items[0].shape[1:]
+        output = flat.reshape(new_shape)
+        assert output.ctypes.data % 64 == 0, output.ctypes.data
+        np.concatenate(items, out=output, axis=1 if time_major else 0)
+        return output
+    else:
+        return np.concatenate(items, axis=1 if time_major else 0)
+
+
+@PublicAPI
+def convert_to_numpy(x: TensorStructType, reduce_type: bool = True) -> TensorStructType:
+    """Converts values in `stats` to non-Tensor numpy or python types.
+
+    Args:
+        x: Any (possibly nested) struct, the values in which will be
+            converted and returned as a new struct with all torch/tf tensors
+            being converted to numpy types.
+        reduce_type: Whether to automatically reduce all float64 and int64 data
+            into float32 and int32 data, respectively.
+
+    Returns:
+        A new struct with the same structure as `x`, but with all
+        values converted to numpy arrays (on CPU).
+    """
+
+    # The mapping function used to numpyize torch/tf Tensors (and move them
+    # to the CPU beforehand).
+    def mapping(item):
+        if torch and isinstance(item, torch.Tensor):
+            ret = (
+                item.cpu().item()
+                if len(item.size()) == 0
+                else item.detach().cpu().numpy()
+            )
+        elif (
+            tf and isinstance(item, (tf.Tensor, tf.Variable)) and hasattr(item, "numpy")
+        ):
+            assert tf.executing_eagerly()
+            ret = item.numpy()
+        else:
+            ret = item
+        if reduce_type and isinstance(ret, np.ndarray):
+            if np.issubdtype(ret.dtype, np.floating):
+                ret = ret.astype(np.float32)
+            elif np.issubdtype(ret.dtype, int):
+                ret = ret.astype(np.int32)
+            return ret
+        return ret
+
+    return tree.map_structure(mapping, x)
+
+
+@PublicAPI
+def fc(
+    x: np.ndarray,
+    weights: np.ndarray,
+    biases: Optional[np.ndarray] = None,
+    framework: Optional[str] = None,
+) -> np.ndarray:
+    """Calculates FC (dense) layer outputs given weights/biases and input.
+
+    Args:
+        x: The input to the dense layer.
+        weights: The weights matrix.
+        biases: The biases vector. All 0s if None.
+        framework: An optional framework hint (to figure out,
+            e.g. whether to transpose torch weight matrices).
+
+    Returns:
+        The dense layer's output.
+    """
+
+    def map_(data, transpose=False):
+        if torch:
+            if isinstance(data, torch.Tensor):
+                data = data.cpu().detach().numpy()
+        if tf and tf.executing_eagerly():
+            if isinstance(data, tf.Variable):
+                data = data.numpy()
+        if transpose:
+            data = np.transpose(data)
+        return data
+
+    x = map_(x)
+    # Torch stores matrices in transpose (faster for backprop).
+    transpose = framework == "torch" and (
+        x.shape[1] != weights.shape[0] and x.shape[1] == weights.shape[1]
+    )
+    weights = map_(weights, transpose=transpose)
+    biases = map_(biases)
+
+    return np.matmul(x, weights) + (0.0 if biases is None else biases)
+
+
+@PublicAPI
+def flatten_inputs_to_1d_tensor(
+    inputs: TensorStructType,
+    spaces_struct: Optional[SpaceStruct] = None,
+    time_axis: bool = False,
+    batch_axis: bool = True,
+) -> TensorType:
+    """Flattens arbitrary input structs according to the given spaces struct.
+
+    Returns a single 1D tensor resulting from the different input
+    components' values.
+
+    Thereby:
+    - Boxes (any shape) get flattened to (B, [T]?, -1). Note that image boxes
+    are not treated differently from other types of Boxes and get
+    flattened as well.
+    - Discrete (int) values are one-hot'd, e.g. a batch of [1, 0, 3] (B=3 with
+    Discrete(4) space) results in [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]].
+    - MultiDiscrete values are multi-one-hot'd, e.g. a batch of
+    [[0, 2], [1, 4]] (B=2 with MultiDiscrete([2, 5]) space) results in
+    [[1, 0,  0, 0, 1, 0, 0], [0, 1,  0, 0, 0, 0, 1]].
+
+    Args:
+        inputs: The inputs to be flattened.
+        spaces_struct: The (possibly nested) structure of the spaces that `inputs`
+            belongs to.
+        time_axis: Whether all inputs have a time-axis (after the batch axis).
+            If True, will keep not only the batch axis (0th), but the time axis
+            (1st) as-is and flatten everything from the 2nd axis up.
+        batch_axis: Whether all inputs have a batch axis.
+            If True, will keep that batch axis as-is and flatten everything from the
+            other dims up.
+
+    Returns:
+        A single 1D tensor resulting from concatenating all
+        flattened/one-hot'd input components. Depending on the time_axis flag,
+        the shape is (B, n) or (B, T, n).
+
+    .. testcode::
+        :skipif: True
+
+        # B=2
+        from ray.rllib.utils.tf_utils import flatten_inputs_to_1d_tensor
+        from gymnasium.spaces import Discrete, Box
+        out = flatten_inputs_to_1d_tensor(
+            {"a": [1, 0], "b": [[[0.0], [0.1]], [1.0], [1.1]]},
+            spaces_struct=dict(a=Discrete(2), b=Box(shape=(2, 1)))
+        )
+        print(out)
+
+        # B=2; T=2
+        out = flatten_inputs_to_1d_tensor(
+            ([[1, 0], [0, 1]],
+             [[[0.0, 0.1], [1.0, 1.1]], [[2.0, 2.1], [3.0, 3.1]]]),
+            spaces_struct=tuple([Discrete(2), Box(shape=(2, ))]),
+            time_axis=True
+        )
+        print(out)
+
+    .. testoutput::
+
+        [[0.0, 1.0,  0.0, 0.1], [1.0, 0.0,  1.0, 1.1]]  # B=2 n=4
+        [[[0.0, 1.0, 0.0, 0.1], [1.0, 0.0, 1.0, 1.1]],
+        [[1.0, 0.0, 2.0, 2.1], [0.0, 1.0, 3.0, 3.1]]]  # B=2 T=2 n=4
+    """
+    # `time_axis` must not be True if `batch_axis` is False.
+    assert not (time_axis and not batch_axis)
+
+    flat_inputs = tree.flatten(inputs)
+    flat_spaces = (
+        tree.flatten(spaces_struct)
+        if spaces_struct is not None
+        else [None] * len(flat_inputs)
+    )
+
+    B = None
+    T = None
+    out = []
+    for input_, space in zip(flat_inputs, flat_spaces):
+        # Store batch and (if applicable) time dimension.
+        if B is None and batch_axis:
+            B = input_.shape[0]
+            if time_axis:
+                T = input_.shape[1]
+
+        # One-hot encoding.
+        if isinstance(space, Discrete):
+            if time_axis:
+                input_ = np.reshape(input_, [B * T])
+            out.append(one_hot(input_, depth=space.n).astype(np.float32))
+        # Multi one-hot encoding.
+        elif isinstance(space, MultiDiscrete):
+            if time_axis:
+                input_ = np.reshape(input_, [B * T, -1])
+            if batch_axis:
+                out.append(
+                    np.concatenate(
+                        [
+                            one_hot(input_[:, i], depth=n).astype(np.float32)
+                            for i, n in enumerate(space.nvec)
+                        ],
+                        axis=-1,
+                    )
+                )
+            else:
+                out.append(
+                    np.concatenate(
+                        [
+                            one_hot(input_[i], depth=n).astype(np.float32)
+                            for i, n in enumerate(space.nvec)
+                        ],
+                        axis=-1,
+                    )
+                )
+        # Box: Flatten.
+        else:
+            # Special case for spaces: Box(.., shape=(), ..)
+            if isinstance(input_, float):
+                input_ = np.array([input_])
+
+            if time_axis:
+                input_ = np.reshape(input_, [B * T, -1])
+            elif batch_axis:
+                input_ = np.reshape(input_, [B, -1])
+            else:
+                input_ = np.reshape(input_, [-1])
+            out.append(input_.astype(np.float32))
+
+    merged = np.concatenate(out, axis=-1)
+    # Restore the time-dimension, if applicable.
+    if time_axis:
+        merged = np.reshape(merged, [B, T, -1])
+    return merged
+
+
+@PublicAPI
+def make_action_immutable(obj):
+    """Flags actions immutable to notify users when trying to change them.
+
+    Can also be used with any tree-like structure containing either
+    dictionaries, numpy arrays or already immutable objects per se.
+    Note, however that `tree.map_structure()` will in general not
+    include the shallow object containing all others and therefore
+    immutability will hold only for all objects contained in it.
+    Use `tree.traverse(fun, action, top_down=False)` to include
+    also the containing object.
+
+    Args:
+        obj: The object to be made immutable.
+
+    Returns:
+        The immutable object.
+
+    .. testcode::
+        :skipif: True
+
+        import tree
+        import numpy as np
+        from ray.rllib.utils.numpy import make_action_immutable
+        arr = np.arange(1,10)
+        d = dict(a = 1, b = (arr, arr))
+        tree.traverse(make_action_immutable, d, top_down=False)
+    """
+    if isinstance(obj, np.ndarray):
+        obj.setflags(write=False)
+        return obj
+    elif isinstance(obj, OrderedDict):
+        return MappingProxyType(dict(obj))
+    elif isinstance(obj, dict):
+        return MappingProxyType(obj)
+    else:
+        return obj
+
+
+@PublicAPI
+def huber_loss(x: np.ndarray, delta: float = 1.0) -> np.ndarray:
+    """Reference: https://en.wikipedia.org/wiki/Huber_loss."""
+    return np.where(
+        np.abs(x) < delta, np.power(x, 2.0) * 0.5, delta * (np.abs(x) - 0.5 * delta)
+    )
+
+
+@PublicAPI
+def l2_loss(x: np.ndarray) -> np.ndarray:
+    """Computes half the L2 norm of a tensor (w/o the sqrt): sum(x**2) / 2.
+
+    Args:
+        x: The input tensor.
+
+    Returns:
+        The l2-loss output according to the above formula given `x`.
+    """
+    return np.sum(np.square(x)) / 2.0
+
+
+@PublicAPI
+def lstm(
+    x,
+    weights: np.ndarray,
+    biases: Optional[np.ndarray] = None,
+    initial_internal_states: Optional[np.ndarray] = None,
+    time_major: bool = False,
+    forget_bias: float = 1.0,
+):
+    """Calculates LSTM layer output given weights/biases, states, and input.
+
+    Args:
+        x: The inputs to the LSTM layer including time-rank
+            (0th if time-major, else 1st) and the batch-rank
+            (1st if time-major, else 0th).
+        weights: The weights matrix.
+        biases: The biases vector. All 0s if None.
+        initial_internal_states: The initial internal
+            states to pass into the layer. All 0s if None.
+        time_major: Whether to use time-major or not. Default: False.
+        forget_bias: Gets added to first sigmoid (forget gate) output.
+            Default: 1.0.
+
+    Returns:
+        Tuple consisting of 1) The LSTM layer's output and
+        2) Tuple: Last (c-state, h-state).
+    """
+    sequence_length = x.shape[0 if time_major else 1]
+    batch_size = x.shape[1 if time_major else 0]
+    units = weights.shape[1] // 4  # 4 internal layers (3x sigmoid, 1x tanh)
+
+    if initial_internal_states is None:
+        c_states = np.zeros(shape=(batch_size, units))
+        h_states = np.zeros(shape=(batch_size, units))
+    else:
+        c_states = initial_internal_states[0]
+        h_states = initial_internal_states[1]
+
+    # Create a placeholder for all n-time step outputs.
+    if time_major:
+        unrolled_outputs = np.zeros(shape=(sequence_length, batch_size, units))
+    else:
+        unrolled_outputs = np.zeros(shape=(batch_size, sequence_length, units))
+
+    # Push the batch 4 times through the LSTM cell and capture the outputs plus
+    # the final h- and c-states.
+    for t in range(sequence_length):
+        input_matrix = x[t, :, :] if time_major else x[:, t, :]
+        input_matrix = np.concatenate((input_matrix, h_states), axis=1)
+        input_matmul_matrix = np.matmul(input_matrix, weights) + biases
+        # Forget gate (3rd slot in tf output matrix). Add static forget bias.
+        sigmoid_1 = sigmoid(input_matmul_matrix[:, units * 2 : units * 3] + forget_bias)
+        c_states = np.multiply(c_states, sigmoid_1)
+        # Add gate (1st and 2nd slots in tf output matrix).
+        sigmoid_2 = sigmoid(input_matmul_matrix[:, 0:units])
+        tanh_3 = np.tanh(input_matmul_matrix[:, units : units * 2])
+        c_states = np.add(c_states, np.multiply(sigmoid_2, tanh_3))
+        # Output gate (last slot in tf output matrix).
+        sigmoid_4 = sigmoid(input_matmul_matrix[:, units * 3 : units * 4])
+        h_states = np.multiply(sigmoid_4, np.tanh(c_states))
+
+        # Store this output time-slice.
+        if time_major:
+            unrolled_outputs[t, :, :] = h_states
+        else:
+            unrolled_outputs[:, t, :] = h_states
+
+    return unrolled_outputs, (c_states, h_states)
+
+
+@PublicAPI
+def one_hot(
+    x: Union[TensorType, int],
+    depth: int = 0,
+    on_value: float = 1.0,
+    off_value: float = 0.0,
+    dtype: type = np.float32,
+) -> np.ndarray:
+    """One-hot utility function for numpy.
+
+    Thanks to qianyizhang:
+    https://gist.github.com/qianyizhang/07ee1c15cad08afb03f5de69349efc30.
+
+    Args:
+        x: The input to be one-hot encoded.
+        depth: The max. number to be one-hot encoded (size of last rank).
+        on_value: The value to use for on. Default: 1.0.
+        off_value: The value to use for off. Default: 0.0.
+
+    Returns:
+        The one-hot encoded equivalent of the input array.
+    """
+
+    # Handle simple ints properly.
+    if isinstance(x, int):
+        x = np.array(x, dtype=np.int32)
+    # Handle torch arrays properly.
+    elif torch and isinstance(x, torch.Tensor):
+        x = x.numpy()
+
+    # Handle bool arrays correctly.
+    if x.dtype == np.bool_:
+        x = x.astype(np.int_)
+        depth = 2
+
+    # If depth is not given, try to infer it from the values in the array.
+    if depth == 0:
+        depth = np.max(x) + 1
+    assert (
+        np.max(x) < depth
+    ), "ERROR: The max. index of `x` ({}) is larger than depth ({})!".format(
+        np.max(x), depth
+    )
+    shape = x.shape
+
+    out = np.ones(shape=(*shape, depth)) * off_value
+    indices = []
+    for i in range(x.ndim):
+        tiles = [1] * x.ndim
+        s = [1] * x.ndim
+        s[i] = -1
+        r = np.arange(shape[i]).reshape(s)
+        if i > 0:
+            tiles[i - 1] = shape[i - 1]
+            r = np.tile(r, tiles)
+        indices.append(r)
+    indices.append(x)
+    out[tuple(indices)] = on_value
+    return out.astype(dtype)
+
+
+@PublicAPI
+def one_hot_multidiscrete(x, depths=List[int]):
+    # Handle torch arrays properly.
+    if torch and isinstance(x, torch.Tensor):
+        x = x.numpy()
+
+    shape = x.shape
+    return np.concatenate(
+        [
+            one_hot(x[i] if len(shape) == 1 else x[:, i], depth=n).astype(np.float32)
+            for i, n in enumerate(depths)
+        ],
+        axis=-1,
+    )
+
+
+@PublicAPI
+def relu(x: np.ndarray, alpha: float = 0.0) -> np.ndarray:
+    """Implementation of the leaky ReLU function.
+
+    y = x * alpha if x < 0 else x
+
+    Args:
+        x: The input values.
+        alpha: A scaling ("leak") factor to use for negative x.
+
+    Returns:
+        The leaky ReLU output for x.
+    """
+    return np.maximum(x, x * alpha, x)
+
+
+@PublicAPI
+def sigmoid(x: np.ndarray, derivative: bool = False) -> np.ndarray:
+    """
+    Returns the sigmoid function applied to x.
+    Alternatively, can return the derivative or the sigmoid function.
+
+    Args:
+        x: The input to the sigmoid function.
+        derivative: Whether to return the derivative or not.
+            Default: False.
+
+    Returns:
+        The sigmoid function (or its derivative) applied to x.
+    """
+    if derivative:
+        return x * (1 - x)
+    else:
+        return 1 / (1 + np.exp(-x))
+
+
+@PublicAPI
+def softmax(
+    x: Union[np.ndarray, list], axis: int = -1, epsilon: Optional[float] = None
+) -> np.ndarray:
+    """Returns the softmax values for x.
+
+    The exact formula used is:
+    S(xi) = e^xi / SUMj(e^xj), where j goes over all elements in x.
+
+    Args:
+        x: The input to the softmax function.
+        axis: The axis along which to softmax.
+        epsilon: Optional epsilon as a minimum value. If None, use
+            `SMALL_NUMBER`.
+
+    Returns:
+        The softmax over x.
+    """
+    epsilon = epsilon or SMALL_NUMBER
+    # x_exp = np.maximum(np.exp(x), SMALL_NUMBER)
+    x_exp = np.exp(x)
+    # return x_exp /
+    #   np.maximum(np.sum(x_exp, axis, keepdims=True), SMALL_NUMBER)
+    return np.maximum(x_exp / np.sum(x_exp, axis, keepdims=True), epsilon)

deepseek/lib/python3.10/site-packages/ray/rllib/utils/replay_buffers/__init__.py

@@ -0,0 +1,44 @@
+from ray.rllib.utils.replay_buffers.episode_replay_buffer import EpisodeReplayBuffer
+from ray.rllib.utils.replay_buffers.fifo_replay_buffer import FifoReplayBuffer
+from ray.rllib.utils.replay_buffers.multi_agent_mixin_replay_buffer import (
+    MultiAgentMixInReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_episode_buffer import (
+    MultiAgentEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_prioritized_episode_buffer import (
+    MultiAgentPrioritizedEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_prioritized_replay_buffer import (
+    MultiAgentPrioritizedReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.multi_agent_replay_buffer import (
+    MultiAgentReplayBuffer,
+    ReplayMode,
+)
+from ray.rllib.utils.replay_buffers.prioritized_episode_buffer import (
+    PrioritizedEpisodeReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.prioritized_replay_buffer import (
+    PrioritizedReplayBuffer,
+)
+from ray.rllib.utils.replay_buffers.replay_buffer import ReplayBuffer, StorageUnit
+from ray.rllib.utils.replay_buffers.reservoir_replay_buffer import ReservoirReplayBuffer
+from ray.rllib.utils.replay_buffers import utils
+
+__all__ = [
+    "EpisodeReplayBuffer",
+    "FifoReplayBuffer",
+    "MultiAgentEpisodeReplayBuffer",
+    "MultiAgentMixInReplayBuffer",
+    "MultiAgentPrioritizedEpisodeReplayBuffer",
+    "MultiAgentPrioritizedReplayBuffer",
+    "MultiAgentReplayBuffer",
+    "PrioritizedEpisodeReplayBuffer",
+    "PrioritizedReplayBuffer",
+    "ReplayMode",
+    "ReplayBuffer",
+    "ReservoirReplayBuffer",
+    "StorageUnit",
+    "utils",
+]

deepseek/lib/python3.10/site-packages/ray/rllib/utils/serialization.py

@@ -0,0 +1,418 @@
+import base64
+from collections import OrderedDict
+import importlib
+import io
+import zlib
+from typing import Any, Dict, Optional, Sequence, Type, Union
+
+import gymnasium as gym
+import numpy as np
+
+import ray
+from ray.rllib.utils.annotations import DeveloperAPI
+from ray.rllib.utils.error import NotSerializable
+from ray.rllib.utils.spaces.flexdict import FlexDict
+from ray.rllib.utils.spaces.repeated import Repeated
+from ray.rllib.utils.spaces.simplex import Simplex
+
+NOT_SERIALIZABLE = "__not_serializable__"
+
+
+@DeveloperAPI
+def convert_numpy_to_python_primitives(obj: Any):
+    """Convert an object that is a numpy type to a python type.
+
+    If the object is not a numpy type, it is returned unchanged.
+
+    Args:
+        obj: The object to convert.
+    """
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.bool_):
+        return bool(obj)
+    elif isinstance(obj, np.str_):
+        return str(obj)
+    elif isinstance(obj, np.ndarray):
+        ret = obj.tolist()
+        for i, v in enumerate(ret):
+            ret[i] = convert_numpy_to_python_primitives(v)
+        return ret
+    else:
+        return obj
+
+
+def _serialize_ndarray(array: np.ndarray) -> str:
+    """Pack numpy ndarray into Base64 encoded strings for serialization.
+
+    This function uses numpy.save() instead of pickling to ensure
+    compatibility.
+
+    Args:
+        array: numpy ndarray.
+
+    Returns:
+        b64 escaped string.
+    """
+    buf = io.BytesIO()
+    np.save(buf, array)
+    return base64.b64encode(zlib.compress(buf.getvalue())).decode("ascii")
+
+
+def _deserialize_ndarray(b64_string: str) -> np.ndarray:
+    """Unpack b64 escaped string into numpy ndarray.
+
+    This function assumes the unescaped bytes are of npy format.
+
+    Args:
+        b64_string: Base64 escaped string.
+
+    Returns:
+        numpy ndarray.
+    """
+    return np.load(
+        io.BytesIO(zlib.decompress(base64.b64decode(b64_string))), allow_pickle=True
+    )
+
+
+@DeveloperAPI
+def gym_space_to_dict(space: gym.spaces.Space) -> Dict:
+    """Serialize a gym Space into a JSON-serializable dict.
+
+    Args:
+        space: gym.spaces.Space
+
+    Returns:
+        Serialized JSON string.
+    """
+    if space is None:
+        return None
+
+    def _box(sp: gym.spaces.Box) -> Dict:
+        return {
+            "space": "box",
+            "low": _serialize_ndarray(sp.low),
+            "high": _serialize_ndarray(sp.high),
+            "shape": sp._shape,  # shape is a tuple.
+            "dtype": sp.dtype.str,
+        }
+
+    def _discrete(sp: gym.spaces.Discrete) -> Dict:
+        d = {
+            "space": "discrete",
+            "n": int(sp.n),
+        }
+        # Offset is a relatively new Discrete space feature.
+        if hasattr(sp, "start"):
+            d["start"] = int(sp.start)
+        return d
+
+    def _multi_binary(sp: gym.spaces.MultiBinary) -> Dict:
+        return {
+            "space": "multi-binary",
+            "n": sp.n,
+        }
+
+    def _multi_discrete(sp: gym.spaces.MultiDiscrete) -> Dict:
+        return {
+            "space": "multi-discrete",
+            "nvec": _serialize_ndarray(sp.nvec),
+            "dtype": sp.dtype.str,
+        }
+
+    def _tuple(sp: gym.spaces.Tuple) -> Dict:
+        return {
+            "space": "tuple",
+            "spaces": [gym_space_to_dict(sp) for sp in sp.spaces],
+        }
+
+    def _dict(sp: gym.spaces.Dict) -> Dict:
+        return {
+            "space": "dict",
+            "spaces": {k: gym_space_to_dict(sp) for k, sp in sp.spaces.items()},
+        }
+
+    def _simplex(sp: Simplex) -> Dict:
+        return {
+            "space": "simplex",
+            "shape": sp._shape,  # shape is a tuple.
+            "concentration": sp.concentration,
+            "dtype": sp.dtype.str,
+        }
+
+    def _repeated(sp: Repeated) -> Dict:
+        return {
+            "space": "repeated",
+            "child_space": gym_space_to_dict(sp.child_space),
+            "max_len": sp.max_len,
+        }
+
+    def _flex_dict(sp: FlexDict) -> Dict:
+        d = {
+            "space": "flex_dict",
+        }
+        for k, s in sp.spaces:
+            d[k] = gym_space_to_dict(s)
+        return d
+
+    def _text(sp: "gym.spaces.Text") -> Dict:
+        # Note (Kourosh): This only works in gym >= 0.25.0
+        charset = getattr(sp, "character_set", None)
+        if charset is None:
+            charset = getattr(sp, "charset", None)
+        if charset is None:
+            raise ValueError(
+                "Text space must have a character_set or charset attribute"
+            )
+        return {
+            "space": "text",
+            "min_length": sp.min_length,
+            "max_length": sp.max_length,
+            "charset": charset,
+        }
+
+    if isinstance(space, gym.spaces.Box):
+        return _box(space)
+    elif isinstance(space, gym.spaces.Discrete):
+        return _discrete(space)
+    elif isinstance(space, gym.spaces.MultiBinary):
+        return _multi_binary(space)
+    elif isinstance(space, gym.spaces.MultiDiscrete):
+        return _multi_discrete(space)
+    elif isinstance(space, gym.spaces.Tuple):
+        return _tuple(space)
+    elif isinstance(space, gym.spaces.Dict):
+        return _dict(space)
+    elif isinstance(space, gym.spaces.Text):
+        return _text(space)
+    elif isinstance(space, Simplex):
+        return _simplex(space)
+    elif isinstance(space, Repeated):
+        return _repeated(space)
+    elif isinstance(space, FlexDict):
+        return _flex_dict(space)
+    else:
+        raise ValueError("Unknown space type for serialization, ", type(space))
+
+
+@DeveloperAPI
+def space_to_dict(space: gym.spaces.Space) -> Dict:
+    d = {"space": gym_space_to_dict(space)}
+    if "original_space" in space.__dict__:
+        d["original_space"] = space_to_dict(space.original_space)
+    return d
+
+
+@DeveloperAPI
+def gym_space_from_dict(d: Dict) -> gym.spaces.Space:
+    """De-serialize a dict into gym Space.
+
+    Args:
+        str: serialized JSON str.
+
+    Returns:
+        De-serialized gym space.
+    """
+    if d is None:
+        return None
+
+    def __common(d: Dict):
+        """Common updates to the dict before we use it to construct spaces"""
+        ret = d.copy()
+        del ret["space"]
+        if "dtype" in ret:
+            ret["dtype"] = np.dtype(ret["dtype"])
+        return ret
+
+    def _box(d: Dict) -> gym.spaces.Box:
+        ret = d.copy()
+        ret.update(
+            {
+                "low": _deserialize_ndarray(d["low"]),
+                "high": _deserialize_ndarray(d["high"]),
+            }
+        )
+        return gym.spaces.Box(**__common(ret))
+
+    def _discrete(d: Dict) -> gym.spaces.Discrete:
+        return gym.spaces.Discrete(**__common(d))
+
+    def _multi_binary(d: Dict) -> gym.spaces.MultiBinary:
+        return gym.spaces.MultiBinary(**__common(d))
+
+    def _multi_discrete(d: Dict) -> gym.spaces.MultiDiscrete:
+        ret = d.copy()
+        ret.update(
+            {
+                "nvec": _deserialize_ndarray(ret["nvec"]),
+            }
+        )
+        return gym.spaces.MultiDiscrete(**__common(ret))
+
+    def _tuple(d: Dict) -> gym.spaces.Discrete:
+        spaces = [gym_space_from_dict(sp) for sp in d["spaces"]]
+        return gym.spaces.Tuple(spaces=spaces)
+
+    def _dict(d: Dict) -> gym.spaces.Discrete:
+        # We need to always use an OrderedDict here to cover the following two ways, by
+        # which a user might construct a Dict space originally. We need to restore this
+        # original Dict space with the exact order of keys the user intended to.
+        # - User provides an OrderedDict inside the gym.spaces.Dict constructor ->
+        #  gymnasium should NOT further sort the keys. The same (user-provided) order
+        #  must be restored.
+        # - User provides a simple dict inside the gym.spaces.Dict constructor ->
+        #  By its API definition, gymnasium automatically sorts all keys alphabetically.
+        #  The same (alphabetical) order must thus be restored.
+        spaces = OrderedDict(
+            {k: gym_space_from_dict(sp) for k, sp in d["spaces"].items()}
+        )
+        return gym.spaces.Dict(spaces=spaces)
+
+    def _simplex(d: Dict) -> Simplex:
+        return Simplex(**__common(d))
+
+    def _repeated(d: Dict) -> Repeated:
+        child_space = gym_space_from_dict(d["child_space"])
+        return Repeated(child_space=child_space, max_len=d["max_len"])
+
+    def _flex_dict(d: Dict) -> FlexDict:
+        spaces = {k: gym_space_from_dict(s) for k, s in d.items() if k != "space"}
+        return FlexDict(spaces=spaces)
+
+    def _text(d: Dict) -> "gym.spaces.Text":
+        return gym.spaces.Text(**__common(d))
+
+    space_map = {
+        "box": _box,
+        "discrete": _discrete,
+        "multi-binary": _multi_binary,
+        "multi-discrete": _multi_discrete,
+        "tuple": _tuple,
+        "dict": _dict,
+        "simplex": _simplex,
+        "repeated": _repeated,
+        "flex_dict": _flex_dict,
+        "text": _text,
+    }
+
+    space_type = d["space"]
+    if space_type not in space_map:
+        raise ValueError("Unknown space type for de-serialization, ", space_type)
+
+    return space_map[space_type](d)
+
+
+@DeveloperAPI
+def space_from_dict(d: Dict) -> gym.spaces.Space:
+    space = gym_space_from_dict(d["space"])
+    if "original_space" in d:
+        assert "space" in d["original_space"]
+        if isinstance(d["original_space"]["space"], str):
+            # For backward compatibility reasons, if d["original_space"]["space"]
+            # is a string, this original space was serialized by gym_space_to_dict.
+            space.original_space = gym_space_from_dict(d["original_space"])
+        else:
+            # Otherwise, this original space was serialized by space_to_dict.
+            space.original_space = space_from_dict(d["original_space"])
+    return space
+
+
+@DeveloperAPI
+def check_if_args_kwargs_serializable(args: Sequence[Any], kwargs: Dict[str, Any]):
+    """Check if parameters to a function are serializable by ray.
+
+    Args:
+        args: arguments to be checked.
+        kwargs: keyword arguments to be checked.
+
+    Raises:
+        NoteSerializable if either args are kwargs are not serializable
+            by ray.
+    """
+    for arg in args:
+        try:
+            # if the object is truly serializable we should be able to
+            # ray.put and ray.get it.
+            ray.get(ray.put(arg))
+        except TypeError as e:
+            raise NotSerializable(
+                "RLModule constructor arguments must be serializable. "
+                f"Found non-serializable argument: {arg}.\n"
+                f"Original serialization error: {e}"
+            )
+    for k, v in kwargs.items():
+        try:
+            # if the object is truly serializable we should be able to
+            # ray.put and ray.get it.
+            ray.get(ray.put(v))
+        except TypeError as e:
+            raise NotSerializable(
+                "RLModule constructor arguments must be serializable. "
+                f"Found non-serializable keyword argument: {k} = {v}.\n"
+                f"Original serialization error: {e}"
+            )
+
+
+@DeveloperAPI
+def serialize_type(type_: Union[Type, str]) -> str:
+    """Converts a type into its full classpath ([module file] + "." + [class name]).
+
+    Args:
+        type_: The type to convert.
+
+    Returns:
+        The full classpath of the given type, e.g. "ray.rllib.algorithms.ppo.PPOConfig".
+    """
+    # TODO (avnishn): find a way to incorporate the tune registry here.
+    # Already serialized.
+    if isinstance(type_, str):
+        return type_
+
+    return type_.__module__ + "." + type_.__qualname__
+
+
+@DeveloperAPI
+def deserialize_type(
+    module: Union[str, Type], error: bool = False
+) -> Optional[Union[str, Type]]:
+    """Resolves a class path to a class.
+    If the given module is already a class, it is returned as is.
+    If the given module is a string, it is imported and the class is returned.
+
+    Args:
+        module: The classpath (str) or type to resolve.
+        error: Whether to throw a ValueError if `module` could not be resolved into
+            a class. If False and `module` is not resolvable, returns None.
+
+    Returns:
+        The resolved class or `module` (if `error` is False and no resolution possible).
+
+    Raises:
+        ValueError: If `error` is True and `module` cannot be resolved.
+    """
+    # Already a class, return as-is.
+    if isinstance(module, type):
+        return module
+    # A string.
+    elif isinstance(module, str):
+        # Try interpreting (as classpath) and importing the given module.
+        try:
+            module_path, class_name = module.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            return getattr(module, class_name)
+        # Module not found OR not a module (but a registered string?).
+        except (ModuleNotFoundError, ImportError, AttributeError, ValueError) as e:
+            # Ignore if error=False.
+            if error:
+                raise ValueError(
+                    f"Could not deserialize the given classpath `module={module}` into "
+                    "a valid python class! Make sure you have all necessary pip "
+                    "packages installed and all custom modules are in your "
+                    "`PYTHONPATH` env variable."
+                ) from e
+    else:
+        raise ValueError(f"`module` ({module} must be type or string (classpath)!")
+
+    return module

deepseek/lib/python3.10/site-packages/ray/rllib/utils/tensor_dtype.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from ray.rllib.utils.typing import TensorType
+from ray.rllib.utils.framework import try_import_torch, try_import_tf
+from ray.util.annotations import PublicAPI
+
+torch, _ = try_import_torch()
+_, tf, _ = try_import_tf()
+
+
+# Dict of NumPy dtype -> torch dtype
+if torch:
+    numpy_to_torch_dtype_dict = {
+        np.bool_: torch.bool,
+        np.uint8: torch.uint8,
+        np.int8: torch.int8,
+        np.int16: torch.int16,
+        np.int32: torch.int32,
+        np.int64: torch.int64,
+        np.float16: torch.float16,
+        np.float32: torch.float32,
+        np.float64: torch.float64,
+        np.complex64: torch.complex64,
+        np.complex128: torch.complex128,
+    }
+else:
+    numpy_to_torch_dtype_dict = {}
+
+# Dict of NumPy dtype -> tf dtype
+if tf:
+    numpy_to_tf_dtype_dict = {
+        np.bool_: tf.bool,
+        np.uint8: tf.uint8,
+        np.int8: tf.int8,
+        np.int16: tf.int16,
+        np.int32: tf.int32,
+        np.int64: tf.int64,
+        np.float16: tf.float16,
+        np.float32: tf.float32,
+        np.float64: tf.float64,
+        np.complex64: tf.complex64,
+        np.complex128: tf.complex128,
+    }
+else:
+    numpy_to_tf_dtype_dict = {}
+
+# Dict of torch dtype -> NumPy dtype
+torch_to_numpy_dtype_dict = {
+    value: key for (key, value) in numpy_to_torch_dtype_dict.items()
+}
+# Dict of tf dtype -> NumPy dtype
+tf_to_numpy_dtype_dict = {value: key for (key, value) in numpy_to_tf_dtype_dict.items()}
+
+
+@PublicAPI(stability="alpha")
+def get_np_dtype(x: TensorType) -> np.dtype:
+    """Returns the NumPy dtype of the given tensor or array."""
+    if torch and isinstance(x, torch.Tensor):
+        return torch_to_numpy_dtype_dict[x.dtype]
+    if tf and isinstance(x, tf.Tensor):
+        return tf_to_numpy_dtype_dict[x.dtype]
+    elif isinstance(x, np.ndarray):
+        return x.dtype
+    else:
+        raise TypeError("Unsupported type: {}".format(type(x)))

deepseek/lib/python3.10/site-packages/ray/rllib/utils/test_utils.py

@@ -0,0 +1,1817 @@
+import argparse
+import json
+import logging
+import os
+import pprint
+import random
+import re
+import time
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+import gymnasium as gym
+from gymnasium.spaces import Box, Discrete, MultiDiscrete, MultiBinary
+from gymnasium.spaces import Dict as GymDict
+from gymnasium.spaces import Tuple as GymTuple
+import numpy as np
+import tree  # pip install dm_tree
+
+import ray
+from ray import air, tune
+from ray.air.constants import TRAINING_ITERATION
+from ray.air.integrations.wandb import WandbLoggerCallback, WANDB_ENV_VAR
+from ray.rllib.core import DEFAULT_MODULE_ID, Columns
+from ray.rllib.env.wrappers.atari_wrappers import is_atari, wrap_deepmind
+from ray.rllib.utils.annotations import OldAPIStack
+from ray.rllib.utils.framework import try_import_jax, try_import_tf, try_import_torch
+from ray.rllib.utils.metrics import (
+    DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY,
+    ENV_RUNNER_RESULTS,
+    EPISODE_RETURN_MEAN,
+    EVALUATION_RESULTS,
+    NUM_ENV_STEPS_TRAINED,
+    NUM_ENV_STEPS_SAMPLED_LIFETIME,
+)
+from ray.rllib.utils.typing import ResultDict
+from ray.rllib.utils.error import UnsupportedSpaceException
+
+
+from ray.tune import CLIReporter
+
+
+if TYPE_CHECKING:
+    from ray.rllib.algorithms import Algorithm, AlgorithmConfig
+    from ray.rllib.offline.dataset_reader import DatasetReader
+
+jax, _ = try_import_jax()
+tf1, tf, tfv = try_import_tf()
+torch, _ = try_import_torch()
+
+logger = logging.getLogger(__name__)
+
+
+def add_rllib_example_script_args(
+    parser: Optional[argparse.ArgumentParser] = None,
+    default_reward: float = 100.0,
+    default_iters: int = 200,
+    default_timesteps: int = 100000,
+) -> argparse.ArgumentParser:
+    """Adds RLlib-typical (and common) examples scripts command line args to a parser.
+
+    TODO (sven): This function should be used by most of our examples scripts, which
+     already mostly have this logic in them (but written out).
+
+    Args:
+        parser: The parser to add the arguments to. If None, create a new one.
+        default_reward: The default value for the --stop-reward option.
+        default_iters: The default value for the --stop-iters option.
+        default_timesteps: The default value for the --stop-timesteps option.
+
+    Returns:
+        The altered (or newly created) parser object.
+    """
+    if parser is None:
+        parser = argparse.ArgumentParser()
+
+    # Algo and Algo config options.
+    parser.add_argument(
+        "--algo", type=str, default="PPO", help="The RLlib-registered algorithm to use."
+    )
+    parser.add_argument(
+        "--enable-new-api-stack",
+        action="store_true",
+        help="Whether to use the `enable_rl_module_and_learner` config setting.",
+    )
+    parser.add_argument(
+        "--framework",
+        choices=["tf", "tf2", "torch"],
+        default="torch",
+        help="The DL framework specifier.",
+    )
+    parser.add_argument(
+        "--env",
+        type=str,
+        default=None,
+        help="The gym.Env identifier to run the experiment with.",
+    )
+    parser.add_argument(
+        "--num-env-runners",
+        type=int,
+        default=None,
+        help="The number of (remote) EnvRunners to use for the experiment.",
+    )
+    parser.add_argument(
+        "--num-envs-per-env-runner",
+        type=int,
+        default=None,
+        help="The number of (vectorized) environments per EnvRunner. Note that "
+        "this is identical to the batch size for (inference) action computations.",
+    )
+    parser.add_argument(
+        "--num-agents",
+        type=int,
+        default=0,
+        help="If 0 (default), will run as single-agent. If > 0, will run as "
+        "multi-agent with the environment simply cloned n times and each agent acting "
+        "independently at every single timestep. The overall reward for this "
+        "experiment is then the sum over all individual agents' rewards.",
+    )
+
+    # Evaluation options.
+    parser.add_argument(
+        "--evaluation-num-env-runners",
+        type=int,
+        default=0,
+        help="The number of evaluation (remote) EnvRunners to use for the experiment.",
+    )
+    parser.add_argument(
+        "--evaluation-interval",
+        type=int,
+        default=0,
+        help="Every how many iterations to run one round of evaluation. "
+        "Use 0 (default) to disable evaluation.",
+    )
+    parser.add_argument(
+        "--evaluation-duration",
+        type=lambda v: v if v == "auto" else int(v),
+        default=10,
+        help="The number of evaluation units to run each evaluation round. "
+        "Use `--evaluation-duration-unit` to count either in 'episodes' "
+        "or 'timesteps'. If 'auto', will run as many as possible during train pass ("
+        "`--evaluation-parallel-to-training` must be set then).",
+    )
+    parser.add_argument(
+        "--evaluation-duration-unit",
+        type=str,
+        default="episodes",
+        choices=["episodes", "timesteps"],
+        help="The evaluation duration unit to count by. One of 'episodes' or "
+        "'timesteps'. This unit will be run `--evaluation-duration` times in each "
+        "evaluation round. If `--evaluation-duration=auto`, this setting does not "
+        "matter.",
+    )
+    parser.add_argument(
+        "--evaluation-parallel-to-training",
+        action="store_true",
+        help="Whether to run evaluation parallel to training. This might help speed up "
+        "your overall iteration time. Be aware that when using this option, your "
+        "reported evaluation results are referring to one iteration before the current "
+        "one.",
+    )
+
+    # RLlib logging options.
+    parser.add_argument(
+        "--output",
+        type=str,
+        default=None,
+        help="The output directory to write trajectories to, which are collected by "
+        "the algo's EnvRunners.",
+    )
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        default=None,  # None -> use default
+        choices=["INFO", "DEBUG", "WARN", "ERROR"],
+        help="The log-level to be used by the RLlib logger.",
+    )
+
+    # tune.Tuner options.
+    parser.add_argument(
+        "--no-tune",
+        action="store_true",
+        help="Whether to NOT use tune.Tuner(), but rather a simple for-loop calling "
+        "`algo.train()` repeatedly until one of the stop criteria is met.",
+    )
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=1,
+        help="How many (tune.Tuner.fit()) experiments to execute - if possible in "
+        "parallel.",
+    )
+    parser.add_argument(
+        "--max-concurrent-trials",
+        type=int,
+        default=None,
+        help="How many (tune.Tuner) trials to run concurrently.",
+    )
+    parser.add_argument(
+        "--verbose",
+        type=int,
+        default=2,
+        help="The verbosity level for the `tune.Tuner()` running the experiment.",
+    )
+    parser.add_argument(
+        "--checkpoint-freq",
+        type=int,
+        default=0,
+        help=(
+            "The frequency (in training iterations) with which to create checkpoints. "
+            "Note that if --wandb-key is provided, all checkpoints will "
+            "automatically be uploaded to WandB."
+        ),
+    )
+    parser.add_argument(
+        "--checkpoint-at-end",
+        action="store_true",
+        help=(
+            "Whether to create a checkpoint at the very end of the experiment. "
+            "Note that if --wandb-key is provided, all checkpoints will "
+            "automatically be uploaded to WandB."
+        ),
+    )
+
+    # WandB logging options.
+    parser.add_argument(
+        "--wandb-key",
+        type=str,
+        default=None,
+        help="The WandB API key to use for uploading results.",
+    )
+    parser.add_argument(
+        "--wandb-project",
+        type=str,
+        default=None,
+        help="The WandB project name to use.",
+    )
+    parser.add_argument(
+        "--wandb-run-name",
+        type=str,
+        default=None,
+        help="The WandB run name to use.",
+    )
+
+    # Experiment stopping and testing criteria.
+    parser.add_argument(
+        "--stop-reward",
+        type=float,
+        default=default_reward,
+        help="Reward at which the script should stop training.",
+    )
+    parser.add_argument(
+        "--stop-iters",
+        type=int,
+        default=default_iters,
+        help="The number of iterations to train.",
+    )
+    parser.add_argument(
+        "--stop-timesteps",
+        type=int,
+        default=default_timesteps,
+        help="The number of (environment sampling) timesteps to train.",
+    )
+    parser.add_argument(
+        "--as-test",
+        action="store_true",
+        help="Whether this script should be run as a test. If set, --stop-reward must "
+        "be achieved within --stop-timesteps AND --stop-iters, otherwise this "
+        "script will throw an exception at the end.",
+    )
+    parser.add_argument(
+        "--as-release-test",
+        action="store_true",
+        help="Whether this script should be run as a release test. If set, "
+        "all that applies to the --as-test option is true, plus, a short JSON summary "
+        "will be written into a results file whose location is given by the ENV "
+        "variable `TEST_OUTPUT_JSON`.",
+    )
+
+    # Learner scaling options.
+    parser.add_argument(
+        "--num-learners",
+        type=int,
+        default=None,
+        help="The number of Learners to use. If none, use the algorithm's default "
+        "value.",
+    )
+    parser.add_argument(
+        "--num-gpus-per-learner",
+        type=float,
+        default=None,
+        help="The number of GPUs per Learner to use. If none and there are enough GPUs "
+        "for all required Learners (--num-learners), use a value of 1, otherwise 0.",
+    )
+
+    # Ray init options.
+    parser.add_argument("--num-cpus", type=int, default=0)
+    parser.add_argument(
+        "--local-mode",
+        action="store_true",
+        help="Init Ray in local mode for easier debugging.",
+    )
+
+    # Old API stack: config.num_gpus.
+    parser.add_argument(
+        "--num-gpus",
+        type=int,
+        default=0,
+        help="The number of GPUs to use (if on the old API stack).",
+    )
+
+    return parser
+
+
+def check(x, y, decimals=5, atol=None, rtol=None, false=False):
+    """
+    Checks two structures (dict, tuple, list,
+    np.array, float, int, etc..) for (almost) numeric identity.
+    All numbers in the two structures have to match up to `decimal` digits
+    after the floating point. Uses assertions.
+
+    Args:
+        x: The value to be compared (to the expectation: `y`). This
+            may be a Tensor.
+        y: The expected value to be compared to `x`. This must not
+            be a tf-Tensor, but may be a tf/torch-Tensor.
+        decimals: The number of digits after the floating point up to
+            which all numeric values have to match.
+        atol: Absolute tolerance of the difference between x and y
+            (overrides `decimals` if given).
+        rtol: Relative tolerance of the difference between x and y
+            (overrides `decimals` if given).
+        false: Whether to check that x and y are NOT the same.
+    """
+    # A dict type.
+    if isinstance(x, dict):
+        assert isinstance(y, dict), "ERROR: If x is dict, y needs to be a dict as well!"
+        y_keys = set(x.keys())
+        for key, value in x.items():
+            assert key in y, f"ERROR: y does not have x's key='{key}'! y={y}"
+            check(value, y[key], decimals=decimals, atol=atol, rtol=rtol, false=false)
+            y_keys.remove(key)
+        assert not y_keys, "ERROR: y contains keys ({}) that are not in x! y={}".format(
+            list(y_keys), y
+        )
+    # A tuple type.
+    elif isinstance(x, (tuple, list)):
+        assert isinstance(
+            y, (tuple, list)
+        ), "ERROR: If x is tuple/list, y needs to be a tuple/list as well!"
+        assert len(y) == len(
+            x
+        ), "ERROR: y does not have the same length as x ({} vs {})!".format(
+            len(y), len(x)
+        )
+        for i, value in enumerate(x):
+            check(value, y[i], decimals=decimals, atol=atol, rtol=rtol, false=false)
+    # Boolean comparison.
+    elif isinstance(x, (np.bool_, bool)):
+        if false is True:
+            assert bool(x) is not bool(y), f"ERROR: x ({x}) is y ({y})!"
+        else:
+            assert bool(x) is bool(y), f"ERROR: x ({x}) is not y ({y})!"
+    # Nones or primitives (excluding int vs float, which should be compared with
+    # tolerance/decimals as well).
+    elif (
+        x is None
+        or y is None
+        or isinstance(x, str)
+        or (isinstance(x, int) and isinstance(y, int))
+    ):
+        if false is True:
+            assert x != y, f"ERROR: x ({x}) is the same as y ({y})!"
+        else:
+            assert x == y, f"ERROR: x ({x}) is not the same as y ({y})!"
+    # String/byte comparisons.
+    elif (
+        hasattr(x, "dtype") and (x.dtype == object or str(x.dtype).startswith("<U"))
+    ) or isinstance(x, bytes):
+        try:
+            np.testing.assert_array_equal(x, y)
+            if false is True:
+                assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+        except AssertionError as e:
+            if false is False:
+                raise e
+    # Everything else (assume numeric or tf/torch.Tensor).
+    # Also includes int vs float comparison, which is performed with tolerance/decimals.
+    else:
+        if tf1 is not None:
+            # y should never be a Tensor (y=expected value).
+            if isinstance(y, (tf1.Tensor, tf1.Variable)):
+                # In eager mode, numpyize tensors.
+                if tf.executing_eagerly():
+                    y = y.numpy()
+                else:
+                    raise ValueError(
+                        "`y` (expected value) must not be a Tensor. "
+                        "Use numpy.ndarray instead"
+                    )
+            if isinstance(x, (tf1.Tensor, tf1.Variable)):
+                # In eager mode, numpyize tensors.
+                if tf1.executing_eagerly():
+                    x = x.numpy()
+                # Otherwise, use a new tf-session.
+                else:
+                    with tf1.Session() as sess:
+                        x = sess.run(x)
+                        return check(
+                            x, y, decimals=decimals, atol=atol, rtol=rtol, false=false
+                        )
+        if torch is not None:
+            if isinstance(x, torch.Tensor):
+                x = x.detach().cpu().numpy()
+            if isinstance(y, torch.Tensor):
+                y = y.detach().cpu().numpy()
+
+        # Stats objects.
+        from ray.rllib.utils.metrics.stats import Stats
+
+        if isinstance(x, Stats):
+            x = x.peek()
+        if isinstance(y, Stats):
+            y = y.peek()
+
+        # Using decimals.
+        if atol is None and rtol is None:
+            # Assert equality of both values.
+            try:
+                np.testing.assert_almost_equal(x, y, decimal=decimals)
+            # Both values are not equal.
+            except AssertionError as e:
+                # Raise error in normal case.
+                if false is False:
+                    raise e
+            # Both values are equal.
+            else:
+                # If false is set -> raise error (not expected to be equal).
+                if false is True:
+                    assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+
+        # Using atol/rtol.
+        else:
+            # Provide defaults for either one of atol/rtol.
+            if atol is None:
+                atol = 0
+            if rtol is None:
+                rtol = 1e-7
+            try:
+                np.testing.assert_allclose(x, y, atol=atol, rtol=rtol)
+            except AssertionError as e:
+                if false is False:
+                    raise e
+            else:
+                if false is True:
+                    assert False, f"ERROR: x ({x}) is the same as y ({y})!"
+
+
+def check_compute_single_action(
+    algorithm, include_state=False, include_prev_action_reward=False
+):
+    """Tests different combinations of args for algorithm.compute_single_action.
+
+    Args:
+        algorithm: The Algorithm object to test.
+        include_state: Whether to include the initial state of the Policy's
+            Model in the `compute_single_action` call.
+        include_prev_action_reward: Whether to include the prev-action and
+            -reward in the `compute_single_action` call.
+
+    Raises:
+        ValueError: If anything unexpected happens.
+    """
+    # Have to import this here to avoid circular dependency.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID, SampleBatch
+
+    # Some Algorithms may not abide to the standard API.
+    pid = DEFAULT_POLICY_ID
+    try:
+        # Multi-agent: Pick any learnable policy (or DEFAULT_POLICY if it's the only
+        # one).
+        pid = next(iter(algorithm.env_runner.get_policies_to_train()))
+        pol = algorithm.get_policy(pid)
+    except AttributeError:
+        pol = algorithm.policy
+    # Get the policy's model.
+    model = pol.model
+
+    action_space = pol.action_space
+
+    def _test(
+        what, method_to_test, obs_space, full_fetch, explore, timestep, unsquash, clip
+    ):
+        call_kwargs = {}
+        if what is algorithm:
+            call_kwargs["full_fetch"] = full_fetch
+            call_kwargs["policy_id"] = pid
+
+        obs = obs_space.sample()
+        if isinstance(obs_space, Box):
+            obs = np.clip(obs, -1.0, 1.0)
+        state_in = None
+        if include_state:
+            state_in = model.get_initial_state()
+            if not state_in:
+                state_in = []
+                i = 0
+                while f"state_in_{i}" in model.view_requirements:
+                    state_in.append(
+                        model.view_requirements[f"state_in_{i}"].space.sample()
+                    )
+                    i += 1
+        action_in = action_space.sample() if include_prev_action_reward else None
+        reward_in = 1.0 if include_prev_action_reward else None
+
+        if method_to_test == "input_dict":
+            assert what is pol
+
+            input_dict = {SampleBatch.OBS: obs}
+            if include_prev_action_reward:
+                input_dict[SampleBatch.PREV_ACTIONS] = action_in
+                input_dict[SampleBatch.PREV_REWARDS] = reward_in
+            if state_in:
+                if what.config.get("enable_rl_module_and_learner", False):
+                    input_dict["state_in"] = state_in
+                else:
+                    for i, s in enumerate(state_in):
+                        input_dict[f"state_in_{i}"] = s
+            input_dict_batched = SampleBatch(
+                tree.map_structure(lambda s: np.expand_dims(s, 0), input_dict)
+            )
+            action = pol.compute_actions_from_input_dict(
+                input_dict=input_dict_batched,
+                explore=explore,
+                timestep=timestep,
+                **call_kwargs,
+            )
+            # Unbatch everything to be able to compare against single
+            # action below.
+            # ARS and ES return action batches as lists.
+            if isinstance(action[0], list):
+                action = (np.array(action[0]), action[1], action[2])
+            action = tree.map_structure(lambda s: s[0], action)
+
+            try:
+                action2 = pol.compute_single_action(
+                    input_dict=input_dict,
+                    explore=explore,
+                    timestep=timestep,
+                    **call_kwargs,
+                )
+                # Make sure these are the same, unless we have exploration
+                # switched on (or noisy layers).
+                if not explore and not pol.config.get("noisy"):
+                    check(action, action2)
+            except TypeError:
+                pass
+        else:
+            action = what.compute_single_action(
+                obs,
+                state_in,
+                prev_action=action_in,
+                prev_reward=reward_in,
+                explore=explore,
+                timestep=timestep,
+                unsquash_action=unsquash,
+                clip_action=clip,
+                **call_kwargs,
+            )
+
+        state_out = None
+        if state_in or full_fetch or what is pol:
+            action, state_out, _ = action
+        if state_out:
+            for si, so in zip(tree.flatten(state_in), tree.flatten(state_out)):
+                if tf.is_tensor(si):
+                    # If si is a tensor of Dimensions, we need to convert it
+                    # We expect this to be the case for TF RLModules who's initial
+                    # states are Tf Tensors.
+                    si_shape = si.shape.as_list()
+                else:
+                    si_shape = list(si.shape)
+                check(si_shape, so.shape)
+
+        if unsquash is None:
+            unsquash = what.config["normalize_actions"]
+        if clip is None:
+            clip = what.config["clip_actions"]
+
+        # Test whether unsquash/clipping works on the Algorithm's
+        # compute_single_action method: Both flags should force the action
+        # to be within the space's bounds.
+        if method_to_test == "single" and what == algorithm:
+            if not action_space.contains(action) and (
+                clip or unsquash or not isinstance(action_space, Box)
+            ):
+                raise ValueError(
+                    f"Returned action ({action}) of algorithm/policy {what} "
+                    f"not in Env's action_space {action_space}"
+                )
+            # We are operating in normalized space: Expect only smaller action
+            # values.
+            if (
+                isinstance(action_space, Box)
+                and not unsquash
+                and what.config.get("normalize_actions")
+                and np.any(np.abs(action) > 15.0)
+            ):
+                raise ValueError(
+                    f"Returned action ({action}) of algorithm/policy {what} "
+                    "should be in normalized space, but seems too large/small "
+                    "for that!"
+                )
+
+    # Loop through: Policy vs Algorithm; Different API methods to calculate
+    # actions; unsquash option; clip option; full fetch or not.
+    for what in [pol, algorithm]:
+        if what is algorithm:
+            # Get the obs-space from Workers.env (not Policy) due to possible
+            # pre-processor up front.
+            worker_set = getattr(algorithm, "env_runner_group", None)
+            assert worker_set
+            if not worker_set.local_env_runner:
+                obs_space = algorithm.get_policy(pid).observation_space
+            else:
+                obs_space = worker_set.local_env_runner.for_policy(
+                    lambda p: p.observation_space, policy_id=pid
+                )
+            obs_space = getattr(obs_space, "original_space", obs_space)
+        else:
+            obs_space = pol.observation_space
+
+        for method_to_test in ["single"] + (["input_dict"] if what is pol else []):
+            for explore in [True, False]:
+                for full_fetch in [False, True] if what is algorithm else [False]:
+                    timestep = random.randint(0, 100000)
+                    for unsquash in [True, False, None]:
+                        for clip in [False] if unsquash else [True, False, None]:
+                            print("-" * 80)
+                            print(f"what={what}")
+                            print(f"method_to_test={method_to_test}")
+                            print(f"explore={explore}")
+                            print(f"full_fetch={full_fetch}")
+                            print(f"unsquash={unsquash}")
+                            print(f"clip={clip}")
+                            _test(
+                                what,
+                                method_to_test,
+                                obs_space,
+                                full_fetch,
+                                explore,
+                                timestep,
+                                unsquash,
+                                clip,
+                            )
+
+
+def check_inference_w_connectors(policy, env_name, max_steps: int = 100):
+    """Checks whether the given policy can infer actions from an env with connectors.
+
+    Args:
+        policy: The policy to check.
+        env_name: Name of the environment to check
+        max_steps: The maximum number of steps to run the environment for.
+
+    Raises:
+        ValueError: If the policy cannot infer actions from the environment.
+    """
+    # Avoids circular import
+    from ray.rllib.utils.policy import local_policy_inference
+
+    env = gym.make(env_name)
+
+    # Potentially wrap the env like we do in RolloutWorker
+    if is_atari(env):
+        env = wrap_deepmind(
+            env,
+            dim=policy.config["model"]["dim"],
+            framestack=policy.config["model"].get("framestack"),
+        )
+
+    obs, info = env.reset()
+    reward, terminated, truncated = 0.0, False, False
+    ts = 0
+    while not terminated and not truncated and ts < max_steps:
+        action_out = local_policy_inference(
+            policy,
+            env_id=0,
+            agent_id=0,
+            obs=obs,
+            reward=reward,
+            terminated=terminated,
+            truncated=truncated,
+            info=info,
+        )
+        obs, reward, terminated, truncated, info = env.step(action_out[0][0])
+
+        ts += 1
+
+
+def check_learning_achieved(
+    tune_results: "tune.ResultGrid",
+    min_value: float,
+    evaluation: Optional[bool] = None,
+    metric: str = f"{ENV_RUNNER_RESULTS}/episode_return_mean",
+):
+    """Throws an error if `min_reward` is not reached within tune_results.
+
+    Checks the last iteration found in tune_results for its
+    "episode_return_mean" value and compares it to `min_reward`.
+
+    Args:
+        tune_results: The tune.Tuner().fit() returned results object.
+        min_reward: The min reward that must be reached.
+        evaluation: If True, use `evaluation/env_runners/[metric]`, if False, use
+            `env_runners/[metric]`, if None, use evaluation sampler results if
+            available otherwise, use train sampler results.
+
+    Raises:
+        ValueError: If `min_reward` not reached.
+    """
+    # Get maximum value of `metrics` over all trials
+    # (check if at least one trial achieved some learning, not just the final one).
+    recorded_values = []
+    for _, row in tune_results.get_dataframe().iterrows():
+        if evaluation or (
+            evaluation is None and f"{EVALUATION_RESULTS}/{metric}" in row
+        ):
+            recorded_values.append(row[f"{EVALUATION_RESULTS}/{metric}"])
+        else:
+            recorded_values.append(row[metric])
+    best_value = max(recorded_values)
+    if best_value < min_value:
+        raise ValueError(f"`{metric}` of {min_value} not reached!")
+    print(f"`{metric}` of {min_value} reached! ok")
+
+
+def check_off_policyness(
+    results: ResultDict,
+    upper_limit: float,
+    lower_limit: float = 0.0,
+) -> Optional[float]:
+    """Verifies that the off-policy'ness of some update is within some range.
+
+    Off-policy'ness is defined as the average (across n workers) diff
+    between the number of gradient updates performed on the policy used
+    for sampling vs the number of gradient updates that have been performed
+    on the trained policy (usually the one on the local worker).
+
+    Uses the published DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY metric inside
+    a training results dict and compares to the given bounds.
+
+    Note: Only works with single-agent results thus far.
+
+    Args:
+        results: The training results dict.
+        upper_limit: The upper limit to for the off_policy_ness value.
+        lower_limit: The lower limit to for the off_policy_ness value.
+
+    Returns:
+        The off-policy'ness value (described above).
+
+    Raises:
+        AssertionError: If the value is out of bounds.
+    """
+
+    # Have to import this here to avoid circular dependency.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO
+
+    # Assert that the off-policy'ness is within the given bounds.
+    learner_info = results["info"][LEARNER_INFO]
+    if DEFAULT_POLICY_ID not in learner_info:
+        return None
+    off_policy_ness = learner_info[DEFAULT_POLICY_ID][
+        DIFF_NUM_GRAD_UPDATES_VS_SAMPLER_POLICY
+    ]
+    # Roughly: Reaches up to 0.4 for 2 rollout workers and up to 0.2 for
+    # 1 rollout worker.
+    if not (lower_limit <= off_policy_ness <= upper_limit):
+        raise AssertionError(
+            f"`off_policy_ness` ({off_policy_ness}) is outside the given bounds "
+            f"({lower_limit} - {upper_limit})!"
+        )
+
+    return off_policy_ness
+
+
+def check_train_results_new_api_stack(train_results: ResultDict) -> None:
+    """Checks proper structure of a Algorithm.train() returned dict.
+
+    Args:
+        train_results: The train results dict to check.
+
+    Raises:
+        AssertionError: If `train_results` doesn't have the proper structure or
+            data in it.
+    """
+    # Import these here to avoid circular dependencies.
+    from ray.rllib.utils.metrics import (
+        ENV_RUNNER_RESULTS,
+        FAULT_TOLERANCE_STATS,
+        LEARNER_RESULTS,
+        TIMERS,
+    )
+
+    # Assert that some keys are where we would expect them.
+    for key in [
+        ENV_RUNNER_RESULTS,
+        FAULT_TOLERANCE_STATS,
+        LEARNER_RESULTS,
+        TIMERS,
+        TRAINING_ITERATION,
+        "config",
+    ]:
+        assert (
+            key in train_results
+        ), f"'{key}' not found in `train_results` ({train_results})!"
+
+    # Make sure, `config` is an actual dict, not an AlgorithmConfig object.
+    assert isinstance(
+        train_results["config"], dict
+    ), "`config` in results not a python dict!"
+
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+
+    is_multi_agent = (
+        AlgorithmConfig()
+        .update_from_dict({"policies": train_results["config"]["policies"]})
+        .is_multi_agent()
+    )
+
+    # Check in particular the "info" dict.
+    learner_results = train_results[LEARNER_RESULTS]
+
+    # Make sure we have a `DEFAULT_MODULE_ID key if we are not in a
+    # multi-agent setup.
+    if not is_multi_agent:
+        assert len(learner_results) == 0 or DEFAULT_MODULE_ID in learner_results, (
+            f"'{DEFAULT_MODULE_ID}' not found in "
+            f"train_results['{LEARNER_RESULTS}']!"
+        )
+
+    for module_id, module_metrics in learner_results.items():
+        # The ModuleID can be __all_modules__ in multi-agent case when the new learner
+        # stack is enabled.
+        if module_id == "__all_modules__":
+            continue
+
+        # On the new API stack, policy has no LEARNER_STATS_KEY under it anymore.
+        for key, value in module_metrics.items():
+            # Min- and max-stats should be single values.
+            if key.endswith("_min") or key.endswith("_max"):
+                assert np.isscalar(value), f"'key' value not a scalar ({value})!"
+
+    return train_results
+
+
+@OldAPIStack
+def check_train_results(train_results: ResultDict):
+    """Checks proper structure of a Algorithm.train() returned dict.
+
+    Args:
+        train_results: The train results dict to check.
+
+    Raises:
+        AssertionError: If `train_results` doesn't have the proper structure or
+            data in it.
+    """
+    # Import these here to avoid circular dependencies.
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO, LEARNER_STATS_KEY
+
+    # Assert that some keys are where we would expect them.
+    for key in [
+        "config",
+        "custom_metrics",
+        ENV_RUNNER_RESULTS,
+        "info",
+        "iterations_since_restore",
+        "num_healthy_workers",
+        "perf",
+        "time_since_restore",
+        "time_this_iter_s",
+        "timers",
+        "time_total_s",
+        TRAINING_ITERATION,
+    ]:
+        assert (
+            key in train_results
+        ), f"'{key}' not found in `train_results` ({train_results})!"
+
+    for key in [
+        "episode_len_mean",
+        "episode_reward_max",
+        "episode_reward_mean",
+        "episode_reward_min",
+        "hist_stats",
+        "policy_reward_max",
+        "policy_reward_mean",
+        "policy_reward_min",
+        "sampler_perf",
+    ]:
+        assert key in train_results[ENV_RUNNER_RESULTS], (
+            f"'{key}' not found in `train_results[ENV_RUNNER_RESULTS]` "
+            f"({train_results[ENV_RUNNER_RESULTS]})!"
+        )
+
+    # Make sure, `config` is an actual dict, not an AlgorithmConfig object.
+    assert isinstance(
+        train_results["config"], dict
+    ), "`config` in results not a python dict!"
+
+    from ray.rllib.algorithms.algorithm_config import AlgorithmConfig
+
+    is_multi_agent = (
+        AlgorithmConfig()
+        .update_from_dict({"policies": train_results["config"]["policies"]})
+        .is_multi_agent()
+    )
+
+    # Check in particular the "info" dict.
+    info = train_results["info"]
+    assert LEARNER_INFO in info, f"'learner' not in train_results['infos'] ({info})!"
+    assert (
+        "num_steps_trained" in info or NUM_ENV_STEPS_TRAINED in info
+    ), f"'num_(env_)?steps_trained' not in train_results['infos'] ({info})!"
+
+    learner_info = info[LEARNER_INFO]
+
+    # Make sure we have a default_policy key if we are not in a
+    # multi-agent setup.
+    if not is_multi_agent:
+        # APEX algos sometimes have an empty learner info dict (no metrics
+        # collected yet).
+        assert len(learner_info) == 0 or DEFAULT_POLICY_ID in learner_info, (
+            f"'{DEFAULT_POLICY_ID}' not found in "
+            f"train_results['infos']['learner'] ({learner_info})!"
+        )
+
+    for pid, policy_stats in learner_info.items():
+        if pid == "batch_count":
+            continue
+
+        # the pid can be __all__ in multi-agent case when the new learner stack is
+        # enabled.
+        if pid == "__all__":
+            continue
+
+        # On the new API stack, policy has no LEARNER_STATS_KEY under it anymore.
+        if LEARNER_STATS_KEY in policy_stats:
+            learner_stats = policy_stats[LEARNER_STATS_KEY]
+        else:
+            learner_stats = policy_stats
+        for key, value in learner_stats.items():
+            # Min- and max-stats should be single values.
+            if key.startswith("min_") or key.startswith("max_"):
+                assert np.isscalar(value), f"'key' value not a scalar ({value})!"
+
+    return train_results
+
+
+# TODO (sven): Make this the de-facto, well documented, and unified utility for most of
+#  our tests:
+#  - CI (label: "learning_tests")
+#  - release tests (benchmarks)
+#  - example scripts
+def run_rllib_example_script_experiment(
+    base_config: "AlgorithmConfig",
+    args: Optional[argparse.Namespace] = None,
+    *,
+    stop: Optional[Dict] = None,
+    success_metric: Optional[Dict] = None,
+    trainable: Optional[Type] = None,
+    tune_callbacks: Optional[List] = None,
+    keep_config: bool = False,
+    scheduler=None,
+    progress_reporter=None,
+) -> Union[ResultDict, tune.result_grid.ResultGrid]:
+    """Given an algorithm config and some command line args, runs an experiment.
+
+    There are some constraints on what properties must be defined in `args`.
+    It should ideally be generated via calling
+    `args = add_rllib_example_script_args()`, which can be found in this very module
+    here.
+
+    The function sets up an Algorithm object from the given config (altered by the
+    contents of `args`), then runs the Algorithm via Tune (or manually, if
+    `args.no_tune` is set to True) using the stopping criteria in `stop`.
+
+    At the end of the experiment, if `args.as_test` is True, checks, whether the
+    Algorithm reached the `success_metric` (if None, use `env_runners/
+    episode_return_mean` with a minimum value of `args.stop_reward`).
+
+    See https://github.com/ray-project/ray/tree/master/rllib/examples for an overview
+    of all supported command line options.
+
+    Args:
+        base_config: The AlgorithmConfig object to use for this experiment. This base
+            config will be automatically "extended" based on some of the provided
+            `args`. For example, `args.num_env_runners` is used to set
+            `config.num_env_runners`, etc..
+        args: A argparse.Namespace object, ideally returned by calling
+            `args = add_rllib_example_script_args()`. It must have the following
+            properties defined: `stop_iters`, `stop_reward`, `stop_timesteps`,
+            `no_tune`, `verbose`, `checkpoint_freq`, `as_test`. Optionally, for WandB
+            logging: `wandb_key`, `wandb_project`, `wandb_run_name`.
+        stop: An optional dict mapping ResultDict key strings (using "/" in case of
+            nesting, e.g. "env_runners/episode_return_mean" for referring to
+            `result_dict['env_runners']['episode_return_mean']` to minimum
+            values, reaching of which will stop the experiment). Default is:
+            {
+            "env_runners/episode_return_mean": args.stop_reward,
+            "training_iteration": args.stop_iters,
+            "num_env_steps_sampled_lifetime": args.stop_timesteps,
+            }
+        success_metric: Only relevant if `args.as_test` is True.
+            A dict mapping a single(!) ResultDict key string (using "/" in
+            case of nesting, e.g. "env_runners/episode_return_mean" for referring
+            to `result_dict['env_runners']['episode_return_mean']` to a single(!)
+            minimum value to be reached in order for the experiment to count as
+            successful. If `args.as_test` is True AND this `success_metric` is not
+            reached with the bounds defined by `stop`, will raise an Exception.
+        trainable: The Trainable sub-class to run in the tune.Tuner. If None (default),
+            use the registered RLlib Algorithm class specified by args.algo.
+        tune_callbacks: A list of Tune callbacks to configure with the tune.Tuner.
+            In case `args.wandb_key` is provided, appends a WandB logger to this
+            list.
+        keep_config: Set this to True, if you don't want this utility to change the
+            given `base_config` in any way and leave it as-is. This is helpful
+            for those example scripts which demonstrate how to set config settings
+            that are taken care of automatically in this function otherwise (e.g.
+            `num_env_runners`).
+
+    Returns:
+        The last ResultDict from a --no-tune run OR the tune.Tuner.fit()
+        results.
+    """
+    if args is None:
+        parser = add_rllib_example_script_args()
+        args = parser.parse_args()
+
+    # If run --as-release-test, --as-test must also be set.
+    if args.as_release_test:
+        args.as_test = True
+
+    # Initialize Ray.
+    ray.init(
+        num_cpus=args.num_cpus or None,
+        local_mode=args.local_mode,
+        ignore_reinit_error=True,
+    )
+
+    # Define one or more stopping criteria.
+    if stop is None:
+        stop = {
+            f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": args.stop_reward,
+            f"{ENV_RUNNER_RESULTS}/{NUM_ENV_STEPS_SAMPLED_LIFETIME}": (
+                args.stop_timesteps
+            ),
+            TRAINING_ITERATION: args.stop_iters,
+        }
+
+    config = base_config
+
+    # Enhance the `base_config`, based on provided `args`.
+    if not keep_config:
+        # Set the framework.
+        config.framework(args.framework)
+
+        # Add an env specifier (only if not already set in config)?
+        if args.env is not None and config.env is None:
+            config.environment(args.env)
+
+        # Enable the new API stack?
+        if args.enable_new_api_stack:
+            config.api_stack(
+                enable_rl_module_and_learner=True,
+                enable_env_runner_and_connector_v2=True,
+            )
+
+        # Define EnvRunner/RolloutWorker scaling and behavior.
+        if args.num_env_runners is not None:
+            config.env_runners(num_env_runners=args.num_env_runners)
+
+        # Define compute resources used automatically (only using the --num-learners
+        # and --num-gpus-per-learner args).
+        # New stack.
+        if config.enable_rl_module_and_learner:
+            if args.num_gpus > 0:
+                raise ValueError(
+                    "--num-gpus is not supported on the new API stack! To train on "
+                    "GPUs, use the command line options `--num-gpus-per-learner=1` and "
+                    "`--num-learners=[your number of available GPUs]`, instead."
+                )
+
+            # Do we have GPUs available in the cluster?
+            num_gpus_available = ray.cluster_resources().get("GPU", 0)
+            # Number of actual Learner instances (including the local Learner if
+            # `num_learners=0`).
+            num_actual_learners = (
+                args.num_learners
+                if args.num_learners is not None
+                else config.num_learners
+            ) or 1  # 1: There is always a local Learner, if num_learners=0.
+            # How many were hard-requested by the user
+            # (through explicit `--num-gpus-per-learner >= 1`).
+            num_gpus_requested = (args.num_gpus_per_learner or 0) * num_actual_learners
+            # Number of GPUs needed, if `num_gpus_per_learner=None` (auto).
+            num_gpus_needed_if_available = (
+                args.num_gpus_per_learner
+                if args.num_gpus_per_learner is not None
+                else 1
+            ) * num_actual_learners
+            # Define compute resources used.
+            config.resources(num_gpus=0)  # old API stack setting
+            if args.num_learners is not None:
+                config.learners(num_learners=args.num_learners)
+
+            # User wants to use GPUs if available, but doesn't hard-require them.
+            if args.num_gpus_per_learner is None:
+                if num_gpus_available >= num_gpus_needed_if_available:
+                    config.learners(num_gpus_per_learner=1)
+                else:
+                    config.learners(num_gpus_per_learner=0, num_cpus_per_learner=1)
+
+            # User hard-requires n GPUs, but they are not available -> Error.
+            elif num_gpus_available < num_gpus_requested:
+                raise ValueError(
+                    "You are running your script with --num-learners="
+                    f"{args.num_learners} and --num-gpus-per-learner="
+                    f"{args.num_gpus_per_learner}, but your cluster only has "
+                    f"{num_gpus_available} GPUs! Will run "
+                    f"with {num_gpus_available} CPU Learners instead."
+                )
+
+            # All required GPUs are available -> Use them.
+            else:
+                config.learners(num_gpus_per_learner=args.num_gpus_per_learner)
+
+        # Old stack.
+        else:
+            config.resources(num_gpus=args.num_gpus)
+
+        # Evaluation setup.
+        if args.evaluation_interval > 0:
+            config.evaluation(
+                evaluation_num_env_runners=args.evaluation_num_env_runners,
+                evaluation_interval=args.evaluation_interval,
+                evaluation_duration=args.evaluation_duration,
+                evaluation_duration_unit=args.evaluation_duration_unit,
+                evaluation_parallel_to_training=args.evaluation_parallel_to_training,
+            )
+
+        # Set the log-level (if applicable).
+        if args.log_level is not None:
+            config.debugging(log_level=args.log_level)
+
+        # Set the output dir (if applicable).
+        if args.output is not None:
+            config.offline_data(output=args.output)
+
+    # Run the experiment w/o Tune (directly operate on the RLlib Algorithm object).
+    if args.no_tune:
+        assert not args.as_test and not args.as_release_test
+        algo = config.build()
+        for i in range(stop.get(TRAINING_ITERATION, args.stop_iters)):
+            results = algo.train()
+            if ENV_RUNNER_RESULTS in results:
+                mean_return = results[ENV_RUNNER_RESULTS].get(
+                    EPISODE_RETURN_MEAN, np.nan
+                )
+                print(f"iter={i} R={mean_return}", end="")
+            if EVALUATION_RESULTS in results:
+                Reval = results[EVALUATION_RESULTS][ENV_RUNNER_RESULTS][
+                    EPISODE_RETURN_MEAN
+                ]
+                print(f" R(eval)={Reval}", end="")
+            print()
+            for key, threshold in stop.items():
+                val = results
+                for k in key.split("/"):
+                    try:
+                        val = val[k]
+                    except KeyError:
+                        val = None
+                        break
+                if val is not None and not np.isnan(val) and val >= threshold:
+                    print(f"Stop criterium ({key}={threshold}) fulfilled!")
+                    ray.shutdown()
+                    return results
+
+        ray.shutdown()
+        return results
+
+    # Run the experiment using Ray Tune.
+
+    # Log results using WandB.
+    tune_callbacks = tune_callbacks or []
+    if hasattr(args, "wandb_key") and (
+        args.wandb_key is not None or WANDB_ENV_VAR in os.environ
+    ):
+        wandb_key = args.wandb_key or os.environ[WANDB_ENV_VAR]
+        project = args.wandb_project or (
+            args.algo.lower() + "-" + re.sub("\\W+", "-", str(config.env).lower())
+        )
+        tune_callbacks.append(
+            WandbLoggerCallback(
+                api_key=wandb_key,
+                project=project,
+                upload_checkpoints=True,
+                **({"name": args.wandb_run_name} if args.wandb_run_name else {}),
+            )
+        )
+
+    # Auto-configure a CLIReporter (to log the results to the console).
+    # Use better ProgressReporter for multi-agent cases: List individual policy rewards.
+    if progress_reporter is None and args.num_agents > 0:
+        progress_reporter = CLIReporter(
+            metric_columns={
+                **{
+                    TRAINING_ITERATION: "iter",
+                    "time_total_s": "total time (s)",
+                    NUM_ENV_STEPS_SAMPLED_LIFETIME: "ts",
+                    f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": "combined return",
+                },
+                **{
+                    (
+                        f"{ENV_RUNNER_RESULTS}/module_episode_returns_mean/" f"{pid}"
+                    ): f"return {pid}"
+                    for pid in config.policies
+                },
+            },
+        )
+
+    # Force Tuner to use old progress output as the new one silently ignores our custom
+    # `CLIReporter`.
+    os.environ["RAY_AIR_NEW_OUTPUT"] = "0"
+
+    # Run the actual experiment (using Tune).
+    start_time = time.time()
+    results = tune.Tuner(
+        trainable or config.algo_class,
+        param_space=config,
+        run_config=air.RunConfig(
+            stop=stop,
+            verbose=args.verbose,
+            callbacks=tune_callbacks,
+            checkpoint_config=air.CheckpointConfig(
+                checkpoint_frequency=args.checkpoint_freq,
+                checkpoint_at_end=args.checkpoint_at_end,
+            ),
+            progress_reporter=progress_reporter,
+        ),
+        tune_config=tune.TuneConfig(
+            num_samples=args.num_samples,
+            max_concurrent_trials=args.max_concurrent_trials,
+            scheduler=scheduler,
+        ),
+    ).fit()
+    time_taken = time.time() - start_time
+
+    ray.shutdown()
+
+    # If run as a test, check whether we reached the specified success criteria.
+    test_passed = False
+    if args.as_test:
+        # Success metric not provided, try extracting it from `stop`.
+        if success_metric is None:
+            for try_it in [
+                f"{EVALUATION_RESULTS}/{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}",
+                f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}",
+            ]:
+                if try_it in stop:
+                    success_metric = {try_it: stop[try_it]}
+                    break
+            if success_metric is None:
+                success_metric = {
+                    f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": args.stop_reward,
+                }
+        # TODO (sven): Make this work for more than one metric (AND-logic?).
+        # Get maximum value of `metric` over all trials
+        # (check if at least one trial achieved some learning, not just the final one).
+        success_metric_key, success_metric_value = next(iter(success_metric.items()))
+        best_value = max(
+            row[success_metric_key] for _, row in results.get_dataframe().iterrows()
+        )
+        if best_value >= success_metric_value:
+            test_passed = True
+            print(f"`{success_metric_key}` of {success_metric_value} reached! ok")
+
+        if args.as_release_test:
+            trial = results._experiment_analysis.trials[0]
+            stats = trial.last_result
+            stats.pop("config", None)
+            json_summary = {
+                "time_taken": float(time_taken),
+                "trial_states": [trial.status],
+                "last_update": float(time.time()),
+                "stats": stats,
+                "passed": [test_passed],
+                "not_passed": [not test_passed],
+                "failures": {str(trial): 1} if not test_passed else {},
+            }
+            with open(
+                os.environ.get("TEST_OUTPUT_JSON", "/tmp/learning_test.json"),
+                "wt",
+            ) as f:
+                try:
+                    json.dump(json_summary, f)
+                # Something went wrong writing json. Try again w/ simplified stats.
+                except Exception:
+                    from ray.rllib.algorithms.algorithm import Algorithm
+
+                    simplified_stats = {
+                        k: stats[k] for k in Algorithm._progress_metrics if k in stats
+                    }
+                    json_summary["stats"] = simplified_stats
+                    json.dump(json_summary, f)
+
+        if not test_passed:
+            raise ValueError(
+                f"`{success_metric_key}` of {success_metric_value} not reached!"
+            )
+
+    return results
+
+
+def check_same_batch(batch1, batch2) -> None:
+    """Check if both batches are (almost) identical.
+
+    For MultiAgentBatches, the step count and individual policy's
+    SampleBatches are checked for identity. For SampleBatches, identity is
+    checked as the almost numerical key-value-pair identity between batches
+    with ray.rllib.utils.test_utils.check(). unroll_id is compared only if
+    both batches have an unroll_id.
+
+    Args:
+        batch1: Batch to compare against batch2
+        batch2: Batch to compare against batch1
+    """
+    # Avoids circular import
+    from ray.rllib.policy.sample_batch import MultiAgentBatch, SampleBatch
+
+    assert type(batch1) is type(
+        batch2
+    ), "Input batches are of different types {} and {}".format(
+        str(type(batch1)), str(type(batch2))
+    )
+
+    def check_sample_batches(_batch1, _batch2, _policy_id=None):
+        unroll_id_1 = _batch1.get("unroll_id", None)
+        unroll_id_2 = _batch2.get("unroll_id", None)
+        # unroll IDs only have to fit if both batches have them
+        if unroll_id_1 is not None and unroll_id_2 is not None:
+            assert unroll_id_1 == unroll_id_2
+
+        batch1_keys = set()
+        for k, v in _batch1.items():
+            # unroll_id is compared above already
+            if k == "unroll_id":
+                continue
+            check(v, _batch2[k])
+            batch1_keys.add(k)
+
+        batch2_keys = set(_batch2.keys())
+        # unroll_id is compared above already
+        batch2_keys.discard("unroll_id")
+        _difference = batch1_keys.symmetric_difference(batch2_keys)
+
+        # Cases where one batch has info and the other has not
+        if _policy_id:
+            assert not _difference, (
+                "SampleBatches for policy with ID {} "
+                "don't share information on the "
+                "following information: \n{}"
+                "".format(_policy_id, _difference)
+            )
+        else:
+            assert not _difference, (
+                "SampleBatches don't share information "
+                "on the following information: \n{}"
+                "".format(_difference)
+            )
+
+    if type(batch1) is SampleBatch:
+        check_sample_batches(batch1, batch2)
+    elif type(batch1) is MultiAgentBatch:
+        assert batch1.count == batch2.count
+        batch1_ids = set()
+        for policy_id, policy_batch in batch1.policy_batches.items():
+            check_sample_batches(
+                policy_batch, batch2.policy_batches[policy_id], policy_id
+            )
+            batch1_ids.add(policy_id)
+
+        # Case where one ma batch has info on a policy the other has not
+        batch2_ids = set(batch2.policy_batches.keys())
+        difference = batch1_ids.symmetric_difference(batch2_ids)
+        assert (
+            not difference
+        ), f"MultiAgentBatches don't share the following information: \n{difference}."
+    else:
+        raise ValueError("Unsupported batch type " + str(type(batch1)))
+
+
+def check_reproducibilty(
+    algo_class: Type["Algorithm"],
+    algo_config: "AlgorithmConfig",
+    *,
+    fw_kwargs: Dict[str, Any],
+    training_iteration: int = 1,
+) -> None:
+    # TODO @kourosh: we can get rid of examples/deterministic_training.py once
+    # this is added to all algorithms
+    """Check if the algorithm is reproducible across different testing conditions:
+
+        frameworks: all input frameworks
+        num_gpus: int(os.environ.get("RLLIB_NUM_GPUS", "0"))
+        num_workers: 0 (only local workers) or
+                     4 ((1) local workers + (4) remote workers)
+        num_envs_per_env_runner: 2
+
+    Args:
+        algo_class: Algorithm class to test.
+        algo_config: Base config to use for the algorithm.
+        fw_kwargs: Framework iterator keyword arguments.
+        training_iteration: Number of training iterations to run.
+
+    Returns:
+        None
+
+    Raises:
+        It raises an AssertionError if the algorithm is not reproducible.
+    """
+    from ray.rllib.policy.sample_batch import DEFAULT_POLICY_ID
+    from ray.rllib.utils.metrics.learner_info import LEARNER_INFO
+
+    stop_dict = {TRAINING_ITERATION: training_iteration}
+    # use 0 and 2 workers (for more that 4 workers we have to make sure the instance
+    # type in ci build has enough resources)
+    for num_workers in [0, 2]:
+        algo_config = (
+            algo_config.debugging(seed=42).env_runners(
+                num_env_runners=num_workers, num_envs_per_env_runner=2
+            )
+            # new API
+            .learners(
+                num_gpus_per_learner=int(os.environ.get("RLLIB_NUM_GPUS", "0")),
+            )
+            # old API
+            .resources(
+                num_gpus=int(os.environ.get("RLLIB_NUM_GPUS", "0")),
+            )
+        )
+
+        print(
+            f"Testing reproducibility of {algo_class.__name__}"
+            f" with {num_workers} workers"
+        )
+        print("/// config")
+        pprint.pprint(algo_config.to_dict())
+        # test tune.Tuner().fit() reproducibility
+        results1 = tune.Tuner(
+            algo_class,
+            param_space=algo_config.to_dict(),
+            run_config=air.RunConfig(stop=stop_dict, verbose=1),
+        ).fit()
+        results1 = results1.get_best_result().metrics
+
+        results2 = tune.Tuner(
+            algo_class,
+            param_space=algo_config.to_dict(),
+            run_config=air.RunConfig(stop=stop_dict, verbose=1),
+        ).fit()
+        results2 = results2.get_best_result().metrics
+
+        # Test rollout behavior.
+        check(
+            results1[ENV_RUNNER_RESULTS]["hist_stats"],
+            results2[ENV_RUNNER_RESULTS]["hist_stats"],
+        )
+        # As well as training behavior (minibatch sequence during SGD
+        # iterations).
+        # As well as training behavior (minibatch sequence during SGD
+        # iterations).
+        if algo_config.enable_rl_module_and_learner:
+            check(
+                results1["info"][LEARNER_INFO][DEFAULT_POLICY_ID],
+                results2["info"][LEARNER_INFO][DEFAULT_POLICY_ID],
+            )
+        else:
+            check(
+                results1["info"][LEARNER_INFO][DEFAULT_POLICY_ID]["learner_stats"],
+                results2["info"][LEARNER_INFO][DEFAULT_POLICY_ID]["learner_stats"],
+            )
+
+
+def get_cartpole_dataset_reader(batch_size: int = 1) -> "DatasetReader":
+    """Returns a DatasetReader for the cartpole dataset.
+    Args:
+        batch_size: The batch size to use for the reader.
+    Returns:
+        A rllib DatasetReader for the cartpole dataset.
+    """
+    from ray.rllib.algorithms import AlgorithmConfig
+    from ray.rllib.offline import IOContext
+    from ray.rllib.offline.dataset_reader import (
+        DatasetReader,
+        get_dataset_and_shards,
+    )
+
+    path = "tests/data/cartpole/large.json"
+    input_config = {"format": "json", "paths": path}
+    dataset, _ = get_dataset_and_shards(
+        AlgorithmConfig().offline_data(input_="dataset", input_config=input_config)
+    )
+    ioctx = IOContext(
+        config=(
+            AlgorithmConfig()
+            .training(train_batch_size=batch_size)
+            .offline_data(actions_in_input_normalized=True)
+        ),
+        worker_index=0,
+    )
+    reader = DatasetReader(dataset, ioctx)
+    return reader
+
+
+class ModelChecker:
+    """Helper class to compare architecturally identical Models across frameworks.
+
+    Holds a ModelConfig, such that individual models can be added simply via their
+    framework string (by building them with config.build(framework=...).
+    A call to `check()` forces all added models to be compared in terms of their
+    number of trainable and non-trainable parameters, as well as, their
+    computation results given a common weights structure and values and identical
+    inputs to the models.
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+        # To compare number of params between frameworks.
+        self.param_counts = {}
+        # To compare computed outputs from fixed-weights-nets between frameworks.
+        self.output_values = {}
+
+        # We will pass an observation filled with this one random value through
+        # all DL networks (after they have been set to fixed-weights) to compare
+        # the computed outputs.
+        self.random_fill_input_value = np.random.uniform(-0.01, 0.01)
+
+        # Dict of models to check against each other.
+        self.models = {}
+
+    def add(self, framework: str = "torch", obs=True, state=False) -> Any:
+        """Builds a new Model for the given framework."""
+        model = self.models[framework] = self.config.build(framework=framework)
+
+        # Pass a B=1 observation through the model.
+        inputs = np.full(
+            [1] + ([1] if state else []) + list(self.config.input_dims),
+            self.random_fill_input_value,
+        )
+        if obs:
+            inputs = {Columns.OBS: inputs}
+        if state:
+            inputs[Columns.STATE_IN] = tree.map_structure(
+                lambda s: np.zeros(shape=[1] + list(s)), state
+            )
+        if framework == "torch":
+            from ray.rllib.utils.torch_utils import convert_to_torch_tensor
+
+            inputs = convert_to_torch_tensor(inputs)
+        # w/ old specs: inputs = model.input_specs.fill(self.random_fill_input_value)
+
+        outputs = model(inputs)
+
+        # Bring model into a reproducible, comparable state (so we can compare
+        # computations across frameworks). Use only a value-sequence of len=1 here
+        # as it could possibly be that the layers are stored in different order
+        # across the different frameworks.
+        model._set_to_dummy_weights(value_sequence=(self.random_fill_input_value,))
+
+        # Perform another forward pass.
+        comparable_outputs = model(inputs)
+
+        # Store the number of parameters for this framework's net.
+        self.param_counts[framework] = model.get_num_parameters()
+        # Store the fixed-weights-net outputs for this framework's net.
+        if framework == "torch":
+            self.output_values[framework] = tree.map_structure(
+                lambda s: s.detach().numpy() if s is not None else None,
+                comparable_outputs,
+            )
+        else:
+            self.output_values[framework] = tree.map_structure(
+                lambda s: s.numpy() if s is not None else None, comparable_outputs
+            )
+        return outputs
+
+    def check(self):
+        """Compares all added Models with each other and possibly raises errors."""
+
+        main_key = next(iter(self.models.keys()))
+        # Compare number of trainable and non-trainable params between all
+        # frameworks.
+        for c in self.param_counts.values():
+            check(c, self.param_counts[main_key])
+
+        # Compare dummy outputs by exact values given that all nets received the
+        # same input and all nets have the same (dummy) weight values.
+        for v in self.output_values.values():
+            check(v, self.output_values[main_key], atol=0.0005)
+
+
+def _get_mean_action_from_algorithm(alg: "Algorithm", obs: np.ndarray) -> np.ndarray:
+    """Returns the mean action computed by the given algorithm.
+
+    Note: This makes calls to `Algorithm.compute_single_action`
+
+    Args:
+        alg: The constructed algorithm to run inference on.
+        obs: The observation to compute the action for.
+
+    Returns:
+        The mean action computed by the algorithm over 5000 samples.
+
+    """
+    out = []
+    for _ in range(5000):
+        out.append(float(alg.compute_single_action(obs)))
+    return np.mean(out)
+
+
+def check_supported_spaces(
+    alg: str,
+    config: "AlgorithmConfig",
+    train: bool = True,
+    check_bounds: bool = False,
+    frameworks: Optional[Tuple[str]] = None,
+    use_gpu: bool = False,
+):
+    """Checks whether the given algorithm supports different action and obs spaces.
+
+        Performs the checks by constructing an rllib algorithm from the config and
+        checking to see that the model inside the policy is the correct one given
+        the action and obs spaces. For example if the action space is discrete and
+        the obs space is an image, then the model should be a vision network with
+        a categorical action distribution.
+
+    Args:
+        alg: The name of the algorithm to test.
+        config: The config to use for the algorithm.
+        train: Whether to train the algorithm for a few iterations.
+        check_bounds: Whether to check the bounds of the action space.
+        frameworks: The frameworks to test the algorithm with.
+        use_gpu: Whether to check support for training on a gpu.
+
+
+    """
+    # Do these imports here because otherwise we have circular imports.
+    from ray.rllib.examples.envs.classes.random_env import RandomEnv
+    from ray.rllib.models.torch.complex_input_net import (
+        ComplexInputNetwork as TorchComplexNet,
+    )
+    from ray.rllib.models.torch.fcnet import FullyConnectedNetwork as TorchFCNet
+    from ray.rllib.models.torch.visionnet import VisionNetwork as TorchVisionNet
+
+    action_spaces_to_test = {
+        # Test discrete twice here until we support multi_binary action spaces
+        "discrete": Discrete(5),
+        "continuous": Box(-1.0, 1.0, (5,), dtype=np.float32),
+        "int_actions": Box(0, 3, (2, 3), dtype=np.int32),
+        "multidiscrete": MultiDiscrete([1, 2, 3, 4]),
+        "tuple": GymTuple(
+            [Discrete(2), Discrete(3), Box(-1.0, 1.0, (5,), dtype=np.float32)]
+        ),
+        "dict": GymDict(
+            {
+                "action_choice": Discrete(3),
+                "parameters": Box(-1.0, 1.0, (1,), dtype=np.float32),
+                "yet_another_nested_dict": GymDict(
+                    {"a": GymTuple([Discrete(2), Discrete(3)])}
+                ),
+            }
+        ),
+    }
+
+    observation_spaces_to_test = {
+        "multi_binary": MultiBinary([3, 10, 10]),
+        "discrete": Discrete(5),
+        "continuous": Box(-1.0, 1.0, (5,), dtype=np.float32),
+        "vector2d": Box(-1.0, 1.0, (5, 5), dtype=np.float32),
+        "image": Box(-1.0, 1.0, (84, 84, 1), dtype=np.float32),
+        "tuple": GymTuple([Discrete(10), Box(-1.0, 1.0, (5,), dtype=np.float32)]),
+        "dict": GymDict(
+            {
+                "task": Discrete(10),
+                "position": Box(-1.0, 1.0, (5,), dtype=np.float32),
+            }
+        ),
+    }
+
+    # The observation spaces that we test RLModules with
+    rlmodule_supported_observation_spaces = [
+        "multi_binary",
+        "discrete",
+        "continuous",
+        "image",
+        "tuple",
+        "dict",
+    ]
+
+    # The action spaces that we test RLModules with
+    rlmodule_supported_action_spaces = ["discrete", "continuous"]
+
+    default_observation_space = default_action_space = "discrete"
+
+    config["log_level"] = "ERROR"
+    config["env"] = RandomEnv
+
+    def _do_check(alg, config, a_name, o_name):
+        # We need to copy here so that this validation does not affect the actual
+        # validation method call further down the line.
+        config_copy = config.copy()
+        config_copy.validate()
+        # If RLModules are enabled, we need to skip a few tests for now:
+        if config_copy.enable_rl_module_and_learner:
+            # Skip PPO cases in which RLModules don't support the given spaces yet.
+            if o_name not in rlmodule_supported_observation_spaces:
+                logger.warning(
+                    "Skipping PPO test with RLModules for obs space {}".format(o_name)
+                )
+                return
+            if a_name not in rlmodule_supported_action_spaces:
+                logger.warning(
+                    "Skipping PPO test with RLModules for action space {}".format(
+                        a_name
+                    )
+                )
+                return
+
+        fw = config["framework"]
+        action_space = action_spaces_to_test[a_name]
+        obs_space = observation_spaces_to_test[o_name]
+        print(
+            "=== Testing {} (fw={}) action_space={} obs_space={} ===".format(
+                alg, fw, action_space, obs_space
+            )
+        )
+        t0 = time.time()
+        config.update_from_dict(
+            dict(
+                env_config=dict(
+                    action_space=action_space,
+                    observation_space=obs_space,
+                    reward_space=Box(1.0, 1.0, shape=(), dtype=np.float32),
+                    p_terminated=1.0,
+                    check_action_bounds=check_bounds,
+                )
+            )
+        )
+        stat = "ok"
+
+        try:
+            algo = config.build()
+        except ray.exceptions.RayActorError as e:
+            if len(e.args) >= 2 and isinstance(e.args[2], UnsupportedSpaceException):
+                stat = "unsupported"
+            elif isinstance(e.args[0].args[2], UnsupportedSpaceException):
+                stat = "unsupported"
+            else:
+                raise
+        except UnsupportedSpaceException:
+            stat = "unsupported"
+        else:
+            if alg not in ["SAC", "PPO"]:
+                # 2D (image) input: Expect VisionNet.
+                if o_name in ["atari", "image"]:
+                    assert isinstance(algo.get_policy().model, TorchVisionNet)
+                # 1D input: Expect FCNet.
+                elif o_name == "continuous":
+                    assert isinstance(algo.get_policy().model, TorchFCNet)
+                # Could be either one: ComplexNet (if disabled Preprocessor)
+                # or FCNet (w/ Preprocessor).
+                elif o_name == "vector2d":
+                    assert isinstance(
+                        algo.get_policy().model, (TorchComplexNet, TorchFCNet)
+                    )
+            if train:
+                algo.train()
+            algo.stop()
+        print("Test: {}, ran in {}s".format(stat, time.time() - t0))
+
+    if not frameworks:
+        frameworks = ("tf2", "tf", "torch")
+
+    _do_check_remote = ray.remote(_do_check)
+    _do_check_remote = _do_check_remote.options(num_gpus=1 if use_gpu else 0)
+    # Test all action spaces first.
+    for a_name in action_spaces_to_test.keys():
+        o_name = default_observation_space
+        ray.get(_do_check_remote.remote(alg, config, a_name, o_name))
+
+    # Now test all observation spaces.
+    for o_name in observation_spaces_to_test.keys():
+        a_name = default_action_space
+        ray.get(_do_check_remote.remote(alg, config, a_name, o_name))

deepseek/lib/python3.10/site-packages/ray/rllib/utils/torch_utils.py

@@ -0,0 +1,745 @@
+import logging
+import os
+import warnings
+from typing import Dict, List, Optional, TYPE_CHECKING, Union
+
+import gymnasium as gym
+from gymnasium.spaces import Discrete, MultiDiscrete
+import numpy as np
+from packaging import version
+import tree  # pip install dm_tree
+
+from ray.rllib.models.repeated_values import RepeatedValues
+from ray.rllib.utils.annotations import PublicAPI, DeveloperAPI
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.numpy import SMALL_NUMBER
+from ray.rllib.utils.typing import (
+    LocalOptimizer,
+    NetworkType,
+    SpaceStruct,
+    TensorStructType,
+    TensorType,
+)
+
+if TYPE_CHECKING:
+    from ray.rllib.core.learner.learner import ParamDict, ParamList
+    from ray.rllib.policy.torch_policy import TorchPolicy
+    from ray.rllib.policy.torch_policy_v2 import TorchPolicyV2
+
+logger = logging.getLogger(__name__)
+torch, nn = try_import_torch()
+
+# Limit values suitable for use as close to a -inf logit. These are useful
+# since -inf / inf cause NaNs during backprop.
+FLOAT_MIN = -3.4e38
+FLOAT_MAX = 3.4e38
+
+if torch:
+    TORCH_COMPILE_REQUIRED_VERSION = version.parse("2.0.0")
+else:
+    TORCH_COMPILE_REQUIRED_VERSION = ValueError(
+        "torch is not installed. " "TORCH_COMPILE_REQUIRED_VERSION is " "not defined."
+    )
+
+
+# TODO (sven): Deprecate this function once we have moved completely to the Learner API.
+#  Replaced with `clip_gradients()`.
+@PublicAPI
+def apply_grad_clipping(
+    policy: "TorchPolicy", optimizer: LocalOptimizer, loss: TensorType
+) -> Dict[str, TensorType]:
+    """Applies gradient clipping to already computed grads inside `optimizer`.
+
+    Note: This function does NOT perform an analogous operation as
+    tf.clip_by_global_norm. It merely clips by norm (per gradient tensor) and
+    then computes the global norm across all given tensors (but without clipping
+    by that global norm).
+
+    Args:
+        policy: The TorchPolicy, which calculated `loss`.
+        optimizer: A local torch optimizer object.
+        loss: The torch loss tensor.
+
+    Returns:
+        An info dict containing the "grad_norm" key and the resulting clipped
+        gradients.
+    """
+    grad_gnorm = 0
+    if policy.config["grad_clip"] is not None:
+        clip_value = policy.config["grad_clip"]
+    else:
+        clip_value = np.inf
+
+    num_none_grads = 0
+    for param_group in optimizer.param_groups:
+        # Make sure we only pass params with grad != None into torch
+        # clip_grad_norm_. Would fail otherwise.
+        params = list(filter(lambda p: p.grad is not None, param_group["params"]))
+        if params:
+            # PyTorch clips gradients inplace and returns the norm before clipping
+            # We therefore need to compute grad_gnorm further down (fixes #4965)
+            global_norm = nn.utils.clip_grad_norm_(params, clip_value)
+
+            if isinstance(global_norm, torch.Tensor):
+                global_norm = global_norm.cpu().numpy()
+
+            grad_gnorm += min(global_norm, clip_value)
+        else:
+            num_none_grads += 1
+
+    # Note (Kourosh): grads could indeed be zero. This method should still return
+    # grad_gnorm in that case.
+    if num_none_grads == len(optimizer.param_groups):
+        # No grads available
+        return {}
+    return {"grad_gnorm": grad_gnorm}
+
+
+@PublicAPI
+def clip_gradients(
+    gradients_dict: "ParamDict",
+    *,
+    grad_clip: Optional[float] = None,
+    grad_clip_by: str = "value",
+) -> TensorType:
+    """Performs gradient clipping on a grad-dict based on a clip value and clip mode.
+
+    Changes the provided gradient dict in place.
+
+    Args:
+        gradients_dict: The gradients dict, mapping str to gradient tensors.
+        grad_clip: The value to clip with. The way gradients are clipped is defined
+            by the `grad_clip_by` arg (see below).
+        grad_clip_by: One of 'value', 'norm', or 'global_norm'.
+
+    Returns:
+        If `grad_clip_by`="global_norm" and `grad_clip` is not None, returns the global
+        norm of all tensors, otherwise returns None.
+    """
+    # No clipping, return.
+    if grad_clip is None:
+        return
+
+    # Clip by value (each gradient individually).
+    if grad_clip_by == "value":
+        for k, v in gradients_dict.copy().items():
+            gradients_dict[k] = (
+                None if v is None else torch.clip(v, -grad_clip, grad_clip)
+            )
+
+    # Clip by L2-norm (per gradient tensor).
+    elif grad_clip_by == "norm":
+        for k, v in gradients_dict.copy().items():
+            if v is not None:
+                # Compute the L2-norm of the gradient tensor.
+                norm = v.norm(2).nan_to_num(neginf=-10e8, posinf=10e8)
+                # Clip all the gradients.
+                if norm > grad_clip:
+                    v.mul_(grad_clip / norm)
+
+    # Clip by global L2-norm (across all gradient tensors).
+    else:
+        assert (
+            grad_clip_by == "global_norm"
+        ), f"`grad_clip_by` ({grad_clip_by}) must be one of [value|norm|global_norm]!"
+        gradients_list = list(gradients_dict.values())
+        total_norm = compute_global_norm(gradients_list)
+        # We do want the coefficient to be in between 0.0 and 1.0, therefore
+        # if the global_norm is smaller than the clip value, we use the clip value
+        # as normalization constant.
+        device = gradients_list[0].device
+        clip_coef = grad_clip / torch.maximum(
+            torch.tensor(grad_clip).to(device), total_norm + 1e-6
+        )
+        # Note: multiplying by the clamped coef is redundant when the coef is clamped to
+        # 1, but doing so avoids a `if clip_coef < 1:` conditional which can require a
+        # CPU <=> device synchronization when the gradients do not reside in CPU memory.
+        clip_coef_clamped = torch.clamp(clip_coef, max=1.0)
+        for g in gradients_list:
+            if g is not None:
+                g.detach().mul_(clip_coef_clamped.to(g.device))
+        return total_norm
+
+
+@PublicAPI
+def compute_global_norm(gradients_list: "ParamList") -> TensorType:
+    """Computes the global norm for a gradients dict.
+
+    Args:
+        gradients_list: The gradients list containing parameters.
+
+    Returns:
+        Returns the global norm of all tensors in `gradients_list`.
+    """
+    # Define the norm type to be L2.
+    norm_type = 2.0
+    # If we have no grads, return zero.
+    if len(gradients_list) == 0:
+        return torch.tensor(0.0)
+    device = gradients_list[0].device
+
+    # Compute the global norm.
+    total_norm = torch.norm(
+        torch.stack(
+            [
+                torch.norm(g.detach(), norm_type)
+                # Note, we want to avoid overflow in the norm computation, this does
+                # not affect the gradients themselves as we clamp by multiplying and
+                # not by overriding tensor values.
+                .nan_to_num(neginf=-10e8, posinf=10e8).to(device)
+                for g in gradients_list
+                if g is not None
+            ]
+        ),
+        norm_type,
+    ).nan_to_num(neginf=-10e8, posinf=10e8)
+    if torch.logical_or(total_norm.isnan(), total_norm.isinf()):
+        raise RuntimeError(
+            f"The total norm of order {norm_type} for gradients from "
+            "`parameters` is non-finite, so it cannot be clipped. "
+        )
+    # Return the global norm.
+    return total_norm
+
+
+@PublicAPI
+def concat_multi_gpu_td_errors(
+    policy: Union["TorchPolicy", "TorchPolicyV2"]
+) -> Dict[str, TensorType]:
+    """Concatenates multi-GPU (per-tower) TD error tensors given TorchPolicy.
+
+    TD-errors are extracted from the TorchPolicy via its tower_stats property.
+
+    Args:
+        policy: The TorchPolicy to extract the TD-error values from.
+
+    Returns:
+        A dict mapping strings "td_error" and "mean_td_error" to the
+        corresponding concatenated and mean-reduced values.
+    """
+    td_error = torch.cat(
+        [
+            t.tower_stats.get("td_error", torch.tensor([0.0])).to(policy.device)
+            for t in policy.model_gpu_towers
+        ],
+        dim=0,
+    )
+    policy.td_error = td_error
+    return {
+        "td_error": td_error,
+        "mean_td_error": torch.mean(td_error),
+    }
+
+
+@PublicAPI
+def convert_to_torch_tensor(
+    x: TensorStructType,
+    device: Optional[str] = None,
+    pin_memory: bool = False,
+):
+    """Converts any struct to torch.Tensors.
+
+    Args:
+        x: Any (possibly nested) struct, the values in which will be
+            converted and returned as a new struct with all leaves converted
+            to torch tensors.
+        device: The device to create the tensor on.
+        pin_memory: If True, will call the `pin_memory()` method on the created tensors.
+
+    Returns:
+        Any: A new struct with the same structure as `x`, but with all
+        values converted to torch Tensor types. This does not convert possibly
+        nested elements that are None because torch has no representation for that.
+    """
+
+    def mapping(item):
+        if item is None:
+            # Torch has no representation for `None`, so we return None
+            return item
+
+        # Special handling of "Repeated" values.
+        if isinstance(item, RepeatedValues):
+            return RepeatedValues(
+                tree.map_structure(mapping, item.values), item.lengths, item.max_len
+            )
+
+        # Already torch tensor -> make sure it's on right device.
+        if torch.is_tensor(item):
+            tensor = item
+        # Numpy arrays.
+        elif isinstance(item, np.ndarray):
+            # Object type (e.g. info dicts in train batch): leave as-is.
+            # str type (e.g. agent_id in train batch): leave as-is.
+            if item.dtype == object or item.dtype.type is np.str_:
+                return item
+            # Non-writable numpy-arrays will cause PyTorch warning.
+            elif item.flags.writeable is False:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    tensor = torch.from_numpy(item)
+            # Already numpy: Wrap as torch tensor.
+            else:
+                tensor = torch.from_numpy(item)
+        # Everything else: Convert to numpy, then wrap as torch tensor.
+        else:
+            tensor = torch.from_numpy(np.asarray(item))
+
+        # Floatify all float64 tensors (but leave float16 as-is).
+        if tensor.is_floating_point() and str(tensor.dtype) != "torch.float16":
+            tensor = tensor.float()
+
+        # Pin the tensor's memory (for faster transfer to GPU later).
+        if pin_memory and torch.cuda.is_available():
+            tensor.pin_memory()
+
+        return tensor if device is None else tensor.to(device)
+
+    return tree.map_structure(mapping, x)
+
+
+@PublicAPI
+def copy_torch_tensors(x: TensorStructType, device: Optional[str] = None):
+    """Creates a copy of `x` and makes deep copies torch.Tensors in x.
+
+    Also moves the copied tensors to the specified device (if not None).
+
+    Note if an object in x is not a torch.Tensor, it will be shallow-copied.
+
+    Args:
+        x : Any (possibly nested) struct possibly containing torch.Tensors.
+        device : The device to move the tensors to.
+
+    Returns:
+        Any: A new struct with the same structure as `x`, but with all
+            torch.Tensors deep-copied and moved to the specified device.
+
+    """
+
+    def mapping(item):
+        if isinstance(item, torch.Tensor):
+            return (
+                torch.clone(item.detach())
+                if device is None
+                else item.detach().to(device)
+            )
+        else:
+            return item
+
+    return tree.map_structure(mapping, x)
+
+
+@PublicAPI
+def explained_variance(y: TensorType, pred: TensorType) -> TensorType:
+    """Computes the explained variance for a pair of labels and predictions.
+
+    The formula used is:
+    max(-1.0, 1.0 - (std(y - pred)^2 / std(y)^2))
+
+    Args:
+        y: The labels.
+        pred: The predictions.
+
+    Returns:
+        The explained variance given a pair of labels and predictions.
+    """
+    y_var = torch.var(y, dim=[0])
+    diff_var = torch.var(y - pred, dim=[0])
+    min_ = torch.tensor([-1.0]).to(pred.device)
+    return torch.max(min_, 1 - (diff_var / (y_var + SMALL_NUMBER)))[0]
+
+
+@PublicAPI
+def flatten_inputs_to_1d_tensor(
+    inputs: TensorStructType,
+    spaces_struct: Optional[SpaceStruct] = None,
+    time_axis: bool = False,
+) -> TensorType:
+    """Flattens arbitrary input structs according to the given spaces struct.
+
+    Returns a single 1D tensor resulting from the different input
+    components' values.
+
+    Thereby:
+    - Boxes (any shape) get flattened to (B, [T]?, -1). Note that image boxes
+    are not treated differently from other types of Boxes and get
+    flattened as well.
+    - Discrete (int) values are one-hot'd, e.g. a batch of [1, 0, 3] (B=3 with
+    Discrete(4) space) results in [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]].
+    - MultiDiscrete values are multi-one-hot'd, e.g. a batch of
+    [[0, 2], [1, 4]] (B=2 with MultiDiscrete([2, 5]) space) results in
+    [[1, 0,  0, 0, 1, 0, 0], [0, 1,  0, 0, 0, 0, 1]].
+
+    Args:
+        inputs: The inputs to be flattened.
+        spaces_struct: The structure of the spaces that behind the input
+        time_axis: Whether all inputs have a time-axis (after the batch axis).
+            If True, will keep not only the batch axis (0th), but the time axis
+            (1st) as-is and flatten everything from the 2nd axis up.
+
+    Returns:
+        A single 1D tensor resulting from concatenating all
+        flattened/one-hot'd input components. Depending on the time_axis flag,
+        the shape is (B, n) or (B, T, n).
+
+    .. testcode::
+
+        from gymnasium.spaces import Discrete, Box
+        from ray.rllib.utils.torch_utils import flatten_inputs_to_1d_tensor
+        import torch
+        struct = {
+            "a": np.array([1, 3]),
+            "b": (
+                np.array([[1.0, 2.0], [4.0, 5.0]]),
+                np.array(
+                    [[[8.0], [7.0]], [[5.0], [4.0]]]
+                ),
+            ),
+                "c": {
+                    "cb": np.array([1.0, 2.0]),
+                },
+        }
+        struct_torch = tree.map_structure(lambda s: torch.from_numpy(s), struct)
+        spaces = dict(
+            {
+                "a": gym.spaces.Discrete(4),
+                "b": (gym.spaces.Box(-1.0, 10.0, (2,)), gym.spaces.Box(-1.0, 1.0, (2,
+                        1))),
+                "c": dict(
+                    {
+                        "cb": gym.spaces.Box(-1.0, 1.0, ()),
+                    }
+                ),
+            }
+        )
+        print(flatten_inputs_to_1d_tensor(struct_torch, spaces_struct=spaces))
+
+    .. testoutput::
+
+        tensor([[0., 1., 0., 0., 1., 2., 8., 7., 1.],
+                [0., 0., 0., 1., 4., 5., 5., 4., 2.]])
+
+    """
+
+    flat_inputs = tree.flatten(inputs)
+    flat_spaces = (
+        tree.flatten(spaces_struct)
+        if spaces_struct is not None
+        else [None] * len(flat_inputs)
+    )
+
+    B = None
+    T = None
+    out = []
+    for input_, space in zip(flat_inputs, flat_spaces):
+        # Store batch and (if applicable) time dimension.
+        if B is None:
+            B = input_.shape[0]
+            if time_axis:
+                T = input_.shape[1]
+
+        # One-hot encoding.
+        if isinstance(space, Discrete):
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T])
+            out.append(one_hot(input_, space).float())
+        # Multi one-hot encoding.
+        elif isinstance(space, MultiDiscrete):
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T, -1])
+            out.append(one_hot(input_, space).float())
+        # Box: Flatten.
+        else:
+            if time_axis:
+                input_ = torch.reshape(input_, [B * T, -1])
+            else:
+                input_ = torch.reshape(input_, [B, -1])
+            out.append(input_.float())
+
+    merged = torch.cat(out, dim=-1)
+    # Restore the time-dimension, if applicable.
+    if time_axis:
+        merged = torch.reshape(merged, [B, T, -1])
+
+    return merged
+
+
+@PublicAPI
+def global_norm(tensors: List[TensorType]) -> TensorType:
+    """Returns the global L2 norm over a list of tensors.
+
+    output = sqrt(SUM(t ** 2 for t in tensors)),
+        where SUM reduces over all tensors and over all elements in tensors.
+
+    Args:
+        tensors: The list of tensors to calculate the global norm over.
+
+    Returns:
+        The global L2 norm over the given tensor list.
+    """
+    # List of single tensors' L2 norms: SQRT(SUM(xi^2)) over all xi in tensor.
+    single_l2s = [torch.pow(torch.sum(torch.pow(t, 2.0)), 0.5) for t in tensors]
+    # Compute global norm from all single tensors' L2 norms.
+    return torch.pow(sum(torch.pow(l2, 2.0) for l2 in single_l2s), 0.5)
+
+
+@PublicAPI
+def huber_loss(x: TensorType, delta: float = 1.0) -> TensorType:
+    """Computes the huber loss for a given term and delta parameter.
+
+    Reference: https://en.wikipedia.org/wiki/Huber_loss
+    Note that the factor of 0.5 is implicitly included in the calculation.
+
+    Formula:
+        L = 0.5 * x^2  for small abs x (delta threshold)
+        L = delta * (abs(x) - 0.5*delta)  for larger abs x (delta threshold)
+
+    Args:
+        x: The input term, e.g. a TD error.
+        delta: The delta parmameter in the above formula.
+
+    Returns:
+        The Huber loss resulting from `x` and `delta`.
+    """
+    return torch.where(
+        torch.abs(x) < delta,
+        torch.pow(x, 2.0) * 0.5,
+        delta * (torch.abs(x) - 0.5 * delta),
+    )
+
+
+@PublicAPI
+def l2_loss(x: TensorType) -> TensorType:
+    """Computes half the L2 norm over a tensor's values without the sqrt.
+
+    output = 0.5 * sum(x ** 2)
+
+    Args:
+        x: The input tensor.
+
+    Returns:
+        0.5 times the L2 norm over the given tensor's values (w/o sqrt).
+    """
+    return 0.5 * torch.sum(torch.pow(x, 2.0))
+
+
+@PublicAPI
+def minimize_and_clip(
+    optimizer: "torch.optim.Optimizer", clip_val: float = 10.0
+) -> None:
+    """Clips grads found in `optimizer.param_groups` to given value in place.
+
+    Ensures the norm of the gradients for each variable is clipped to
+    `clip_val`.
+
+    Args:
+        optimizer: The torch.optim.Optimizer to get the variables from.
+        clip_val: The global norm clip value. Will clip around -clip_val and
+            +clip_val.
+    """
+    # Loop through optimizer's variables and norm per variable.
+    for param_group in optimizer.param_groups:
+        for p in param_group["params"]:
+            if p.grad is not None:
+                torch.nn.utils.clip_grad_norm_(p.grad, clip_val)
+
+
+@PublicAPI
+def one_hot(x: TensorType, space: gym.Space) -> TensorType:
+    """Returns a one-hot tensor, given and int tensor and a space.
+
+    Handles the MultiDiscrete case as well.
+
+    Args:
+        x: The input tensor.
+        space: The space to use for generating the one-hot tensor.
+
+    Returns:
+        The resulting one-hot tensor.
+
+    Raises:
+        ValueError: If the given space is not a discrete one.
+
+    .. testcode::
+
+        import torch
+        import gymnasium as gym
+        from ray.rllib.utils.torch_utils import one_hot
+        x = torch.IntTensor([0, 3])  # batch-dim=2
+        # Discrete space with 4 (one-hot) slots per batch item.
+        s = gym.spaces.Discrete(4)
+        print(one_hot(x, s))
+        x = torch.IntTensor([[0, 1, 2, 3]])  # batch-dim=1
+        # MultiDiscrete space with 5 + 4 + 4 + 7 = 20 (one-hot) slots
+        # per batch item.
+        s = gym.spaces.MultiDiscrete([5, 4, 4, 7])
+        print(one_hot(x, s))
+
+    .. testoutput::
+
+        tensor([[1, 0, 0, 0],
+                [0, 0, 0, 1]])
+        tensor([[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0]])
+    """
+    if isinstance(space, Discrete):
+        return nn.functional.one_hot(x.long(), space.n)
+    elif isinstance(space, MultiDiscrete):
+        if isinstance(space.nvec[0], np.ndarray):
+            nvec = np.ravel(space.nvec)
+            x = x.reshape(x.shape[0], -1)
+        else:
+            nvec = space.nvec
+        return torch.cat(
+            [nn.functional.one_hot(x[:, i].long(), n) for i, n in enumerate(nvec)],
+            dim=-1,
+        )
+    else:
+        raise ValueError("Unsupported space for `one_hot`: {}".format(space))
+
+
+@PublicAPI
+def reduce_mean_ignore_inf(x: TensorType, axis: Optional[int] = None) -> TensorType:
+    """Same as torch.mean() but ignores -inf values.
+
+    Args:
+        x: The input tensor to reduce mean over.
+        axis: The axis over which to reduce. None for all axes.
+
+    Returns:
+        The mean reduced inputs, ignoring inf values.
+    """
+    mask = torch.ne(x, float("-inf"))
+    x_zeroed = torch.where(mask, x, torch.zeros_like(x))
+    return torch.sum(x_zeroed, axis) / torch.sum(mask.float(), axis)
+
+
+@PublicAPI
+def sequence_mask(
+    lengths: TensorType,
+    maxlen: Optional[int] = None,
+    dtype=None,
+    time_major: bool = False,
+) -> TensorType:
+    """Offers same behavior as tf.sequence_mask for torch.
+
+    Thanks to Dimitris Papatheodorou
+    (https://discuss.pytorch.org/t/pytorch-equivalent-for-tf-sequence-mask/
+    39036).
+
+    Args:
+        lengths: The tensor of individual lengths to mask by.
+        maxlen: The maximum length to use for the time axis. If None, use
+            the max of `lengths`.
+        dtype: The torch dtype to use for the resulting mask.
+        time_major: Whether to return the mask as [B, T] (False; default) or
+            as [T, B] (True).
+
+    Returns:
+         The sequence mask resulting from the given input and parameters.
+    """
+    # If maxlen not given, use the longest lengths in the `lengths` tensor.
+    if maxlen is None:
+        maxlen = lengths.max()
+
+    mask = torch.ones(tuple(lengths.shape) + (int(maxlen),))
+
+    mask = ~(mask.to(lengths.device).cumsum(dim=1).t() > lengths)
+    # Time major transformation.
+    if not time_major:
+        mask = mask.t()
+
+    # By default, set the mask to be boolean.
+    mask.type(dtype or torch.bool)
+
+    return mask
+
+
+@PublicAPI
+def update_target_network(
+    main_net: NetworkType,
+    target_net: NetworkType,
+    tau: float,
+) -> None:
+    """Updates a torch.nn.Module target network using Polyak averaging.
+
+    new_target_net_weight = (
+        tau * main_net_weight + (1.0 - tau) * current_target_net_weight
+    )
+
+    Args:
+        main_net: The nn.Module to update from.
+        target_net: The target network to update.
+        tau: The tau value to use in the Polyak averaging formula.
+    """
+    # Get the current parameters from the Q network.
+    state_dict = main_net.state_dict()
+    # Use here Polyak averaging.
+    new_state_dict = {
+        k: tau * state_dict[k] + (1 - tau) * v
+        for k, v in target_net.state_dict().items()
+    }
+    # Apply the new parameters to the target Q network.
+    target_net.load_state_dict(new_state_dict)
+
+
+@DeveloperAPI
+def warn_if_infinite_kl_divergence(
+    policy: "TorchPolicy",
+    kl_divergence: TensorType,
+) -> None:
+    if policy.loss_initialized() and kl_divergence.isinf():
+        logger.warning(
+            "KL divergence is non-finite, this will likely destabilize your model and"
+            " the training process. Action(s) in a specific state have near-zero"
+            " probability. This can happen naturally in deterministic environments"
+            " where the optimal policy has zero mass for a specific action. To fix this"
+            " issue, consider setting the coefficient for the KL loss term to zero or"
+            " increasing policy entropy."
+        )
+
+
+@PublicAPI
+def set_torch_seed(seed: Optional[int] = None) -> None:
+    """Sets the torch random seed to the given value.
+
+    Args:
+        seed: The seed to use or None for no seeding.
+    """
+    if seed is not None and torch:
+        torch.manual_seed(seed)
+        # See https://github.com/pytorch/pytorch/issues/47672.
+        cuda_version = torch.version.cuda
+        if cuda_version is not None and float(torch.version.cuda) >= 10.2:
+            os.environ["CUBLAS_WORKSPACE_CONFIG"] = "4096:8"
+        else:
+            # Not all Operations support this.
+            torch.use_deterministic_algorithms(True)
+        # This is only for Convolution no problem.
+        torch.backends.cudnn.deterministic = True
+
+
+@PublicAPI
+def softmax_cross_entropy_with_logits(
+    logits: TensorType,
+    labels: TensorType,
+) -> TensorType:
+    """Same behavior as tf.nn.softmax_cross_entropy_with_logits.
+
+    Args:
+        x: The input predictions.
+        labels: The labels corresponding to `x`.
+
+    Returns:
+        The resulting softmax cross-entropy given predictions and labels.
+    """
+    return torch.sum(-labels * nn.functional.log_softmax(logits, -1), -1)
+
+
+def _dynamo_is_available():
+    # This only works if torch._dynamo is available
+    try:
+        # TODO(Artur): Remove this once torch._dynamo is available on CI
+        import torch._dynamo as dynamo  # noqa: F401
+
+        return True
+    except ImportError:
+        return False