Add files using upload-large-folder tool

minigpt2/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",
+]

minigpt2/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)
+        ]

minigpt2/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__

minigpt2/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])

minigpt2/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",
+]

minigpt2/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

minigpt2/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)

minigpt2/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))

minigpt2/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)

minigpt2/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

minigpt2/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:])])

minigpt2/lib/python3.10/site-packages/ray/rllib/models/tf/noop.py

@@ -0,0 +1,17 @@
+from ray.rllib.models.modelv2 import ModelV2
+from ray.rllib.models.tf.tf_modelv2 import TFModelV2
+from ray.rllib.utils.annotations import OldAPIStack, override
+from ray.rllib.utils.framework import try_import_tf
+
+_, tf, _ = try_import_tf()
+
+
+@OldAPIStack
+class NoopModel(TFModelV2):
+    """Trivial model that just returns the obs flattened.
+
+    This is the model used if use_state_preprocessor=False."""
+
+    @override(ModelV2)
+    def forward(self, input_dict, state, seq_lens):
+        return tf.cast(input_dict["obs_flat"], tf.float32), state

minigpt2/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])

minigpt2/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)

minigpt2/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)

minigpt2/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 {}

minigpt2/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])