Add files using upload-large-folder tool

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/coin_game_non_vectorized_env.py

@@ -0,0 +1,344 @@
+##########
+# Contribution by the Center on Long-Term Risk:
+# https://github.com/longtermrisk/marltoolbox
+##########
+
+import copy
+
+try:
+    # This works in Python<3.9
+    from collections import Iterable
+except ImportError:
+    # This works in Python>=3.9
+    from collections.abc import Iterable
+
+import gymnasium as gym
+import logging
+import numpy as np
+from gymnasium.spaces import Discrete
+from gymnasium.utils import seeding
+from ray.rllib.env.multi_agent_env import MultiAgentEnv
+from ray.rllib.utils import override
+from typing import Dict, Optional
+
+from ray.rllib.examples.envs.classes.utils.interfaces import InfoAccumulationInterface
+
+logger = logging.getLogger(__name__)
+
+
+class CoinGame(InfoAccumulationInterface, MultiAgentEnv, gym.Env):
+    """
+    Coin Game environment.
+    """
+
+    NAME = "CoinGame"
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 4
+    action_space = Discrete(NUM_ACTIONS)
+    observation_space = None
+    MOVES = [
+        np.array([0, 1]),
+        np.array([0, -1]),
+        np.array([1, 0]),
+        np.array([-1, 0]),
+    ]
+
+    def __init__(self, config: Optional[Dict] = None):
+        if config is None:
+            config = {}
+
+        self._validate_config(config)
+
+        self._load_config(config)
+        self.player_red_id, self.player_blue_id = self.players_ids
+        self.n_features = self.grid_size**2 * (2 * self.NUM_AGENTS)
+        self.observation_space = gym.spaces.Box(
+            low=0, high=1, shape=(self.grid_size, self.grid_size, 4), dtype="uint8"
+        )
+
+        self.step_count_in_current_episode = None
+        if self.output_additional_info:
+            self._init_info()
+
+    def _validate_config(self, config):
+        if "players_ids" in config:
+            assert isinstance(config["players_ids"], Iterable)
+            assert len(config["players_ids"]) == self.NUM_AGENTS
+
+    def _load_config(self, config):
+        self.players_ids = config.get("players_ids", ["player_red", "player_blue"])
+        self.max_steps = config.get("max_steps", 20)
+        self.grid_size = config.get("grid_size", 3)
+        self.output_additional_info = config.get("output_additional_info", True)
+        self.asymmetric = config.get("asymmetric", False)
+        self.both_players_can_pick_the_same_coin = config.get(
+            "both_players_can_pick_the_same_coin", True
+        )
+
+    @override(gym.Env)
+    def reset(self, *, seed=None, options=None):
+        self.np_random, seed = seeding.np_random(seed)
+
+        self.step_count_in_current_episode = 0
+
+        if self.output_additional_info:
+            self._reset_info()
+
+        self._randomize_color_and_player_positions()
+        self._generate_coin()
+        obs = self._generate_observation()
+
+        return {self.player_red_id: obs[0], self.player_blue_id: obs[1]}, {}
+
+    def _randomize_color_and_player_positions(self):
+        # Reset coin color and the players and coin positions
+        self.red_coin = self.np_random.integers(low=0, high=2)
+        self.red_pos = self.np_random.integers(low=0, high=self.grid_size, size=(2,))
+        self.blue_pos = self.np_random.integers(low=0, high=self.grid_size, size=(2,))
+        self.coin_pos = np.zeros(shape=(2,), dtype=np.int8)
+
+        self._players_do_not_overlap_at_start()
+
+    def _players_do_not_overlap_at_start(self):
+        while self._same_pos(self.red_pos, self.blue_pos):
+            self.blue_pos = self.np_random.integers(self.grid_size, size=2)
+
+    def _generate_coin(self):
+        self._switch_between_coin_color_at_each_generation()
+        self._coin_position_different_from_players_positions()
+
+    def _switch_between_coin_color_at_each_generation(self):
+        self.red_coin = 1 - self.red_coin
+
+    def _coin_position_different_from_players_positions(self):
+        success = 0
+        while success < self.NUM_AGENTS:
+            self.coin_pos = self.np_random.integers(self.grid_size, size=2)
+            success = 1 - self._same_pos(self.red_pos, self.coin_pos)
+            success += 1 - self._same_pos(self.blue_pos, self.coin_pos)
+
+    def _generate_observation(self):
+        obs = np.zeros((self.grid_size, self.grid_size, 4))
+        obs[self.red_pos[0], self.red_pos[1], 0] = 1
+        obs[self.blue_pos[0], self.blue_pos[1], 1] = 1
+        if self.red_coin:
+            obs[self.coin_pos[0], self.coin_pos[1], 2] = 1
+        else:
+            obs[self.coin_pos[0], self.coin_pos[1], 3] = 1
+
+        obs = self._get_obs_invariant_to_the_player_trained(obs)
+
+        return obs
+
+    @override(gym.Env)
+    def step(self, actions: Dict):
+        """
+        :param actions: Dict containing both actions for player_1 and player_2
+        :return: observations, rewards, done, info
+        """
+        actions = self._from_RLlib_API_to_list(actions)
+
+        self.step_count_in_current_episode += 1
+        self._move_players(actions)
+        reward_list, generate_new_coin = self._compute_reward()
+        if generate_new_coin:
+            self._generate_coin()
+        observations = self._generate_observation()
+
+        return self._to_RLlib_API(observations, reward_list)
+
+    def _same_pos(self, x, y):
+        return (x == y).all()
+
+    def _move_players(self, actions):
+        self.red_pos = (self.red_pos + self.MOVES[actions[0]]) % self.grid_size
+        self.blue_pos = (self.blue_pos + self.MOVES[actions[1]]) % self.grid_size
+
+    def _compute_reward(self):
+
+        reward_red = 0.0
+        reward_blue = 0.0
+        generate_new_coin = False
+        red_pick_any, red_pick_red, blue_pick_any, blue_pick_blue = (
+            False,
+            False,
+            False,
+            False,
+        )
+
+        red_first_if_both = None
+        if not self.both_players_can_pick_the_same_coin:
+            if self._same_pos(self.red_pos, self.coin_pos) and self._same_pos(
+                self.blue_pos, self.coin_pos
+            ):
+                red_first_if_both = bool(self.np_random.integers(low=0, high=2))
+
+        if self.red_coin:
+            if self._same_pos(self.red_pos, self.coin_pos) and (
+                red_first_if_both is None or red_first_if_both
+            ):
+                generate_new_coin = True
+                reward_red += 1
+                if self.asymmetric:
+                    reward_red += 3
+                red_pick_any = True
+                red_pick_red = True
+            if self._same_pos(self.blue_pos, self.coin_pos) and (
+                red_first_if_both is None or not red_first_if_both
+            ):
+                generate_new_coin = True
+                reward_red += -2
+                reward_blue += 1
+                blue_pick_any = True
+        else:
+            if self._same_pos(self.red_pos, self.coin_pos) and (
+                red_first_if_both is None or red_first_if_both
+            ):
+                generate_new_coin = True
+                reward_red += 1
+                reward_blue += -2
+                if self.asymmetric:
+                    reward_red += 3
+                red_pick_any = True
+            if self._same_pos(self.blue_pos, self.coin_pos) and (
+                red_first_if_both is None or not red_first_if_both
+            ):
+                generate_new_coin = True
+                reward_blue += 1
+                blue_pick_blue = True
+                blue_pick_any = True
+
+        reward_list = [reward_red, reward_blue]
+
+        if self.output_additional_info:
+            self._accumulate_info(
+                red_pick_any=red_pick_any,
+                red_pick_red=red_pick_red,
+                blue_pick_any=blue_pick_any,
+                blue_pick_blue=blue_pick_blue,
+            )
+
+        return reward_list, generate_new_coin
+
+    def _from_RLlib_API_to_list(self, actions):
+        """
+        Format actions from dict of players to list of lists
+        """
+        actions = [actions[player_id] for player_id in self.players_ids]
+        return actions
+
+    def _get_obs_invariant_to_the_player_trained(self, observation):
+        """
+        We want to be able to use a policy trained as player 1,
+        for evaluation as player 2 and vice versa.
+        """
+
+        # player_red_observation contains
+        # [Red pos, Blue pos, Red coin pos, Blue coin pos]
+        player_red_observation = observation
+        # After modification, player_blue_observation will contain
+        # [Blue pos, Red pos, Blue coin pos, Red coin pos]
+        player_blue_observation = copy.deepcopy(observation)
+        player_blue_observation[..., 0] = observation[..., 1]
+        player_blue_observation[..., 1] = observation[..., 0]
+        player_blue_observation[..., 2] = observation[..., 3]
+        player_blue_observation[..., 3] = observation[..., 2]
+
+        return [player_red_observation, player_blue_observation]
+
+    def _to_RLlib_API(self, observations, rewards):
+        state = {
+            self.player_red_id: observations[0],
+            self.player_blue_id: observations[1],
+        }
+        rewards = {
+            self.player_red_id: rewards[0],
+            self.player_blue_id: rewards[1],
+        }
+
+        epi_is_done = self.step_count_in_current_episode >= self.max_steps
+        if self.step_count_in_current_episode > self.max_steps:
+            logger.warning(
+                "step_count_in_current_episode > self.max_steps: "
+                f"{self.step_count_in_current_episode} > {self.max_steps}"
+            )
+
+        done = {
+            self.player_red_id: epi_is_done,
+            self.player_blue_id: epi_is_done,
+            "__all__": epi_is_done,
+        }
+
+        if epi_is_done and self.output_additional_info:
+            player_red_info, player_blue_info = self._get_episode_info()
+            info = {
+                self.player_red_id: player_red_info,
+                self.player_blue_id: player_blue_info,
+            }
+        else:
+            info = {}
+
+        return state, rewards, done, done, info
+
+    @override(InfoAccumulationInterface)
+    def _get_episode_info(self):
+        """
+        Output the following information:
+        pick_speed is the fraction of steps during which the player picked a
+        coin.
+        pick_own_color is the fraction of coins picked by the player which have
+        the same color as the player.
+        """
+        player_red_info, player_blue_info = {}, {}
+
+        if len(self.red_pick) > 0:
+            red_pick = sum(self.red_pick)
+            player_red_info["pick_speed"] = red_pick / len(self.red_pick)
+            if red_pick > 0:
+                player_red_info["pick_own_color"] = sum(self.red_pick_own) / red_pick
+
+        if len(self.blue_pick) > 0:
+            blue_pick = sum(self.blue_pick)
+            player_blue_info["pick_speed"] = blue_pick / len(self.blue_pick)
+            if blue_pick > 0:
+                player_blue_info["pick_own_color"] = sum(self.blue_pick_own) / blue_pick
+
+        return player_red_info, player_blue_info
+
+    @override(InfoAccumulationInterface)
+    def _reset_info(self):
+        self.red_pick.clear()
+        self.red_pick_own.clear()
+        self.blue_pick.clear()
+        self.blue_pick_own.clear()
+
+    @override(InfoAccumulationInterface)
+    def _accumulate_info(
+        self, red_pick_any, red_pick_red, blue_pick_any, blue_pick_blue
+    ):
+
+        self.red_pick.append(red_pick_any)
+        self.red_pick_own.append(red_pick_red)
+        self.blue_pick.append(blue_pick_any)
+        self.blue_pick_own.append(blue_pick_blue)
+
+    @override(InfoAccumulationInterface)
+    def _init_info(self):
+        self.red_pick = []
+        self.red_pick_own = []
+        self.blue_pick = []
+        self.blue_pick_own = []
+
+
+class AsymCoinGame(CoinGame):
+    NAME = "AsymCoinGame"
+
+    def __init__(self, config: Optional[dict] = None):
+        if config is None:
+            config = {}
+
+        if "asymmetric" in config:
+            assert config["asymmetric"]
+        else:
+            config["asymmetric"] = True
+        super().__init__(config)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/correlated_actions_env.py

@@ -0,0 +1,74 @@
+import gymnasium as gym
+from gymnasium.spaces import Box, Discrete, Tuple
+import numpy as np
+from typing import Any, Dict, Optional
+
+
+class AutoRegressiveActionEnv(gym.Env):
+    """Custom Environment with autoregressive continuous actions.
+
+    Simple env in which the policy has to emit a tuple of correlated actions.
+
+    In each step, the agent observes a random number (between -1 and 1) and has
+    to choose two actions a1 and a2.
+
+    It gets 0 reward for matching a2 to the random obs times action a1. In all
+    other cases the negative deviance between the desired action a2 and its
+    actual counterpart serves as reward. The reward is constructed in such a
+    way that actions need to be correlated to succeed. It is not possible
+    for the network to learn each action head separately.
+
+    One way to effectively learn this is through correlated action
+    distributions, e.g., in examples/rl_modules/autoregressive_action_rlm.py
+
+    The game ends after the first step.
+    """
+
+    def __init__(self, _=None):
+
+        # Define the action space (two continuous actions a1, a2)
+        self.action_space = Tuple([Discrete(2), Discrete(2)])
+
+        # Define the observation space (state is a single continuous value)
+        self.observation_space = Box(low=-1, high=1, shape=(1,), dtype=np.float32)
+
+        # Internal state for the environment (e.g., could represent a factor
+        # influencing the relationship)
+        self.state = None
+
+    def reset(
+        self, seed: Optional[int] = None, options: Optional[Dict[str, Any]] = None
+    ):
+        """Reset the environment to an initial state."""
+        super().reset(seed=seed, options=options)
+
+        # Randomly initialize the state between -1 and 1
+        self.state = np.random.uniform(-1, 1, size=(1,))
+
+        return self.state, {}
+
+    def step(self, action):
+        """Apply the autoregressive action and return step information."""
+
+        # Extract actions
+        a1, a2 = action
+
+        # The state determines the desired relationship between a1 and a2
+        desired_a2 = (
+            self.state[0] * a1
+        )  # Autoregressive relationship dependent on state
+
+        # Reward is based on how close a2 is to the state-dependent autoregressive
+        # relationship
+        reward = -np.abs(a2 - desired_a2)  # Negative absolute error as the reward
+
+        # Optionally: add some noise or complexity to the reward function
+        # reward += np.random.normal(0, 0.01)  # Small noise can be added
+
+        # Terminate after each step (no episode length in this simple example)
+        done = True
+
+        # Empty info dictionary
+        info = {}
+
+        return self.state, reward, done, False, info

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/deterministic_envs.py

@@ -0,0 +1,13 @@
+import gymnasium as gym
+
+
+def create_cartpole_deterministic(config):
+    env = gym.make("CartPole-v1")
+    env.reset(seed=config.get("seed", 0))
+    return env
+
+
+def create_pendulum_deterministic(config):
+    env = gym.make("Pendulum-v1")
+    env.reset(seed=config.get("seed", 0))
+    return env

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/matrix_sequential_social_dilemma.py

@@ -0,0 +1,314 @@
+##########
+# Contribution by the Center on Long-Term Risk:
+# https://github.com/longtermrisk/marltoolbox
+# Some parts are originally from:
+# https://github.com/alshedivat/lola/tree/master/lola
+##########
+
+import logging
+from abc import ABC
+from collections import Iterable
+from typing import Dict, Optional
+
+import numpy as np
+from gymnasium.spaces import Discrete
+from gymnasium.utils import seeding
+from ray.rllib.env.multi_agent_env import MultiAgentEnv
+from ray.rllib.examples.envs.classes.utils.interfaces import InfoAccumulationInterface
+from ray.rllib.examples.envs.classes.utils.mixins import (
+    TwoPlayersTwoActionsInfoMixin,
+    NPlayersNDiscreteActionsInfoMixin,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MatrixSequentialSocialDilemma(InfoAccumulationInterface, MultiAgentEnv, ABC):
+    """
+    A multi-agent abstract class for two player matrix games.
+
+    PAYOUT_MATRIX: Numpy array. Along the dimension N, the action of the
+    Nth player change. The last dimension is used to select the player
+    whose reward you want to know.
+
+    max_steps: number of step in one episode
+
+    players_ids: list of the RLlib agent id of each player
+
+    output_additional_info: ask the environment to aggregate information
+    about the last episode and output them as info at the end of the
+    episode.
+    """
+
+    def __init__(self, config: Optional[Dict] = None):
+        if config is None:
+            config = {}
+
+        assert "reward_randomness" not in config.keys()
+        assert self.PAYOUT_MATRIX is not None
+        if "players_ids" in config:
+            assert (
+                isinstance(config["players_ids"], Iterable)
+                and len(config["players_ids"]) == self.NUM_AGENTS
+            )
+
+        self.players_ids = config.get("players_ids", ["player_row", "player_col"])
+        self.player_row_id, self.player_col_id = self.players_ids
+        self.max_steps = config.get("max_steps", 20)
+        self.output_additional_info = config.get("output_additional_info", True)
+
+        self.step_count_in_current_episode = None
+
+        # To store info about the fraction of each states
+        if self.output_additional_info:
+            self._init_info()
+
+    def reset(self, *, seed=None, options=None):
+        self.np_random, seed = seeding.np_random(seed)
+
+        self.step_count_in_current_episode = 0
+        if self.output_additional_info:
+            self._reset_info()
+        return {
+            self.player_row_id: self.NUM_STATES - 1,
+            self.player_col_id: self.NUM_STATES - 1,
+        }, {}
+
+    def step(self, actions: dict):
+        """
+        :param actions: Dict containing both actions for player_1 and player_2
+        :return: observations, rewards, done, info
+        """
+        self.step_count_in_current_episode += 1
+        action_player_row = actions[self.player_row_id]
+        action_player_col = actions[self.player_col_id]
+
+        if self.output_additional_info:
+            self._accumulate_info(action_player_row, action_player_col)
+
+        observations = self._produce_observations_invariant_to_the_player_trained(
+            action_player_row, action_player_col
+        )
+        rewards = self._get_players_rewards(action_player_row, action_player_col)
+        epi_is_done = self.step_count_in_current_episode >= self.max_steps
+        if self.step_count_in_current_episode > self.max_steps:
+            logger.warning("self.step_count_in_current_episode >= self.max_steps")
+        info = self._get_info_for_current_epi(epi_is_done)
+
+        return self._to_RLlib_API(observations, rewards, epi_is_done, info)
+
+    def _produce_observations_invariant_to_the_player_trained(
+        self, action_player_0: int, action_player_1: int
+    ):
+        """
+        We want to be able to use a policy trained as player 1
+        for evaluation as player 2 and vice versa.
+        """
+        return [
+            action_player_0 * self.NUM_ACTIONS + action_player_1,
+            action_player_1 * self.NUM_ACTIONS + action_player_0,
+        ]
+
+    def _get_players_rewards(self, action_player_0: int, action_player_1: int):
+        return [
+            self.PAYOUT_MATRIX[action_player_0][action_player_1][0],
+            self.PAYOUT_MATRIX[action_player_0][action_player_1][1],
+        ]
+
+    def _to_RLlib_API(
+        self, observations: list, rewards: list, epi_is_done: bool, info: dict
+    ):
+
+        observations = {
+            self.player_row_id: observations[0],
+            self.player_col_id: observations[1],
+        }
+
+        rewards = {self.player_row_id: rewards[0], self.player_col_id: rewards[1]}
+
+        if info is None:
+            info = {}
+        else:
+            info = {self.player_row_id: info, self.player_col_id: info}
+
+        done = {
+            self.player_row_id: epi_is_done,
+            self.player_col_id: epi_is_done,
+            "__all__": epi_is_done,
+        }
+
+        return observations, rewards, done, done, info
+
+    def _get_info_for_current_epi(self, epi_is_done):
+        if epi_is_done and self.output_additional_info:
+            info_for_current_epi = self._get_episode_info()
+        else:
+            info_for_current_epi = None
+        return info_for_current_epi
+
+    def __str__(self):
+        return self.NAME
+
+
+class IteratedMatchingPennies(
+    TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma
+):
+    """
+    A two-agent environment for the Matching Pennies game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[+1, -1], [-1, +1]], [[-1, +1], [+1, -1]]])
+    NAME = "IMP"
+
+
+class IteratedPrisonersDilemma(
+    TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma
+):
+    """
+    A two-agent environment for the Prisoner's Dilemma game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[-1, -1], [-3, +0]], [[+0, -3], [-2, -2]]])
+    NAME = "IPD"
+
+
+class IteratedAsymPrisonersDilemma(
+    TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma
+):
+    """
+    A two-agent environment for the Asymmetric Prisoner's Dilemma game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[+0, -1], [-3, +0]], [[+0, -3], [-2, -2]]])
+    NAME = "IPD"
+
+
+class IteratedStagHunt(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+    """
+    A two-agent environment for the Stag Hunt game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[3, 3], [0, 2]], [[2, 0], [1, 1]]])
+    NAME = "IteratedStagHunt"
+
+
+class IteratedChicken(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+    """
+    A two-agent environment for the Chicken game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[+0, +0], [-1.0, +1.0]], [[+1, -1], [-10, -10]]])
+    NAME = "IteratedChicken"
+
+
+class IteratedAsymChicken(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+    """
+    A two-agent environment for the Asymmetric Chicken game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array([[[+2.0, +0], [-1.0, +1.0]], [[+2.5, -1], [-10, -10]]])
+    NAME = "AsymmetricIteratedChicken"
+
+
+class IteratedBoS(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+    """
+    A two-agent environment for the BoS game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array(
+        [[[+3.0, +2.0], [+0.0, +0.0]], [[+0.0, +0.0], [+2.0, +3.0]]]
+    )
+    NAME = "IteratedBoS"
+
+
+class IteratedAsymBoS(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+    """
+    A two-agent environment for the BoS game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 2
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array(
+        [[[+4.0, +1.0], [+0.0, +0.0]], [[+0.0, +0.0], [+2.0, +2.0]]]
+    )
+    NAME = "AsymmetricIteratedBoS"
+
+
+def define_greed_fear_matrix_game(greed, fear):
+    class GreedFearGame(TwoPlayersTwoActionsInfoMixin, MatrixSequentialSocialDilemma):
+        NUM_AGENTS = 2
+        NUM_ACTIONS = 2
+        NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+        ACTION_SPACE = Discrete(NUM_ACTIONS)
+        OBSERVATION_SPACE = Discrete(NUM_STATES)
+        R = 3
+        P = 1
+        T = R + greed
+        S = P - fear
+        PAYOUT_MATRIX = np.array([[[R, R], [S, T]], [[T, S], [P, P]]])
+        NAME = "IteratedGreedFear"
+
+        def __str__(self):
+            return f"{self.NAME} with greed={greed} and fear={fear}"
+
+    return GreedFearGame
+
+
+class IteratedBoSAndPD(
+    NPlayersNDiscreteActionsInfoMixin, MatrixSequentialSocialDilemma
+):
+    """
+    A two-agent environment for the BOTS + PD game.
+    """
+
+    NUM_AGENTS = 2
+    NUM_ACTIONS = 3
+    NUM_STATES = NUM_ACTIONS**NUM_AGENTS + 1
+    ACTION_SPACE = Discrete(NUM_ACTIONS)
+    OBSERVATION_SPACE = Discrete(NUM_STATES)
+    PAYOUT_MATRIX = np.array(
+        [
+            [[3.5, +1], [+0, +0], [-3, +2]],
+            [[+0.0, +0], [+1, +3], [-3, +2]],
+            [[+2.0, -3], [+2, -3], [-1, -1]],
+        ]
+    )
+    NAME = "IteratedBoSAndPD"

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/memory_leaking_env.py

@@ -0,0 +1,35 @@
+import logging
+import uuid
+
+from ray.rllib.examples.envs.classes.random_env import RandomEnv
+from ray.rllib.utils.annotations import override
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryLeakingEnv(RandomEnv):
+    """An env that leaks very little memory.
+
+    Useful for proving that our memory-leak tests can catch the
+    slightest leaks.
+    """
+
+    def __init__(self, config=None):
+        super().__init__(config)
+        self._leak = {}
+        self._steps_after_reset = 0
+
+    @override(RandomEnv)
+    def reset(self, *, seed=None, options=None):
+        self._steps_after_reset = 0
+        return super().reset(seed=seed, options=options)
+
+    @override(RandomEnv)
+    def step(self, action):
+        self._steps_after_reset += 1
+
+        # Only leak once an episode.
+        if self._steps_after_reset == 2:
+            self._leak[uuid.uuid4().hex.upper()] = 1
+
+        return super().step(action)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/mock_env.py

@@ -0,0 +1,220 @@
+import gymnasium as gym
+import numpy as np
+from typing import Optional
+
+from ray.rllib.env.vector_env import VectorEnv
+from ray.rllib.utils.annotations import override
+
+
+class MockEnv(gym.Env):
+    """Mock environment for testing purposes.
+
+    Observation=0, reward=1.0, episode-len is configurable.
+    Actions are ignored.
+    """
+
+    def __init__(self, episode_length, config=None):
+        self.episode_length = episode_length
+        self.config = config
+        self.i = 0
+        self.observation_space = gym.spaces.Discrete(1)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def reset(self, *, seed=None, options=None):
+        self.i = 0
+        return 0, {}
+
+    def step(self, action):
+        self.i += 1
+        terminated = truncated = self.i >= self.episode_length
+        return 0, 1.0, terminated, truncated, {}
+
+
+class MockEnv2(gym.Env):
+    """Mock environment for testing purposes.
+
+    Observation=ts (discrete space!), reward=100.0, episode-len is
+    configurable. Actions are ignored.
+    """
+
+    metadata = {
+        "render.modes": ["rgb_array"],
+    }
+    render_mode: Optional[str] = "rgb_array"
+
+    def __init__(self, episode_length):
+        self.episode_length = episode_length
+        self.i = 0
+        self.observation_space = gym.spaces.Discrete(self.episode_length + 1)
+        self.action_space = gym.spaces.Discrete(2)
+        self.rng_seed = None
+
+    def reset(self, *, seed=None, options=None):
+        self.i = 0
+        if seed is not None:
+            self.rng_seed = seed
+        return self.i, {}
+
+    def step(self, action):
+        self.i += 1
+        terminated = truncated = self.i >= self.episode_length
+        return self.i, 100.0, terminated, truncated, {}
+
+    def render(self):
+        # Just generate a random image here for demonstration purposes.
+        # Also see `gym/envs/classic_control/cartpole.py` for
+        # an example on how to use a Viewer object.
+        return np.random.randint(0, 256, size=(300, 400, 3), dtype=np.uint8)
+
+
+class MockEnv3(gym.Env):
+    """Mock environment for testing purposes.
+
+    Observation=ts (discrete space!), reward=100.0, episode-len is
+    configurable. Actions are ignored.
+    """
+
+    def __init__(self, episode_length):
+        self.episode_length = episode_length
+        self.i = 0
+        self.observation_space = gym.spaces.Discrete(100)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def reset(self, *, seed=None, options=None):
+        self.i = 0
+        return self.i, {"timestep": 0}
+
+    def step(self, action):
+        self.i += 1
+        terminated = truncated = self.i >= self.episode_length
+        return self.i, self.i, terminated, truncated, {"timestep": self.i}
+
+
+class VectorizedMockEnv(VectorEnv):
+    """Vectorized version of the MockEnv.
+
+    Contains `num_envs` MockEnv instances, each one having its own
+    `episode_length` horizon.
+    """
+
+    def __init__(self, episode_length, num_envs):
+        super().__init__(
+            observation_space=gym.spaces.Discrete(1),
+            action_space=gym.spaces.Discrete(2),
+            num_envs=num_envs,
+        )
+        self.envs = [MockEnv(episode_length) for _ in range(num_envs)]
+
+    @override(VectorEnv)
+    def vector_reset(self, *, seeds=None, options=None):
+        seeds = seeds or [None] * self.num_envs
+        options = options or [None] * self.num_envs
+        obs_and_infos = [
+            e.reset(seed=seeds[i], options=options[i]) for i, e in enumerate(self.envs)
+        ]
+        return [oi[0] for oi in obs_and_infos], [oi[1] for oi in obs_and_infos]
+
+    @override(VectorEnv)
+    def reset_at(self, index, *, seed=None, options=None):
+        return self.envs[index].reset(seed=seed, options=options)
+
+    @override(VectorEnv)
+    def vector_step(self, actions):
+        obs_batch, rew_batch, terminated_batch, truncated_batch, info_batch = (
+            [],
+            [],
+            [],
+            [],
+            [],
+        )
+        for i in range(len(self.envs)):
+            obs, rew, terminated, truncated, info = self.envs[i].step(actions[i])
+            obs_batch.append(obs)
+            rew_batch.append(rew)
+            terminated_batch.append(terminated)
+            truncated_batch.append(truncated)
+            info_batch.append(info)
+        return obs_batch, rew_batch, terminated_batch, truncated_batch, info_batch
+
+    @override(VectorEnv)
+    def get_sub_environments(self):
+        return self.envs
+
+
+class MockVectorEnv(VectorEnv):
+    """A custom vector env that uses a single(!) CartPole sub-env.
+
+    However, this env pretends to be a vectorized one to illustrate how one
+    could create custom VectorEnvs w/o the need for actual vectorizations of
+    sub-envs under the hood.
+    """
+
+    def __init__(self, episode_length, mocked_num_envs):
+        self.env = gym.make("CartPole-v1")
+        super().__init__(
+            observation_space=self.env.observation_space,
+            action_space=self.env.action_space,
+            num_envs=mocked_num_envs,
+        )
+        self.episode_len = episode_length
+        self.ts = 0
+
+    @override(VectorEnv)
+    def vector_reset(self, *, seeds=None, options=None):
+        # Since we only have one underlying sub-environment, just use the first seed
+        # and the first options dict (the user of this env thinks, there are
+        # `self.num_envs` sub-environments and sends that many seeds/options).
+        seeds = seeds or [None]
+        options = options or [None]
+        obs, infos = self.env.reset(seed=seeds[0], options=options[0])
+        # Simply repeat the single obs/infos to pretend we really have
+        # `self.num_envs` sub-environments.
+        return (
+            [obs for _ in range(self.num_envs)],
+            [infos for _ in range(self.num_envs)],
+        )
+
+    @override(VectorEnv)
+    def reset_at(self, index, *, seed=None, options=None):
+        self.ts = 0
+        return self.env.reset(seed=seed, options=options)
+
+    @override(VectorEnv)
+    def vector_step(self, actions):
+        self.ts += 1
+        # Apply all actions sequentially to the same env.
+        # Whether this would make a lot of sense is debatable.
+        obs_batch, rew_batch, terminated_batch, truncated_batch, info_batch = (
+            [],
+            [],
+            [],
+            [],
+            [],
+        )
+        for i in range(self.num_envs):
+            obs, rew, terminated, truncated, info = self.env.step(actions[i])
+            # Artificially truncate once time step limit has been reached.
+            # Note: Also terminate/truncate, when underlying CartPole is
+            # terminated/truncated.
+            if self.ts >= self.episode_len:
+                truncated = True
+            obs_batch.append(obs)
+            rew_batch.append(rew)
+            terminated_batch.append(terminated)
+            truncated_batch.append(truncated)
+            info_batch.append(info)
+            if terminated or truncated:
+                remaining = self.num_envs - (i + 1)
+                obs_batch.extend([obs for _ in range(remaining)])
+                rew_batch.extend([rew for _ in range(remaining)])
+                terminated_batch.extend([terminated for _ in range(remaining)])
+                truncated_batch.extend([truncated for _ in range(remaining)])
+                info_batch.extend([info for _ in range(remaining)])
+                break
+        return obs_batch, rew_batch, terminated_batch, truncated_batch, info_batch
+
+    @override(VectorEnv)
+    def get_sub_environments(self):
+        # You may also leave this method as-is, in which case, it would
+        # return an empty list.
+        return [self.env for _ in range(self.num_envs)]

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/pendulum_mass.py

@@ -0,0 +1,33 @@
+from gymnasium.envs.classic_control.pendulum import PendulumEnv
+from gymnasium.utils import EzPickle
+import numpy as np
+
+from ray.rllib.env.apis.task_settable_env import TaskSettableEnv
+
+
+class PendulumMassEnv(PendulumEnv, EzPickle, TaskSettableEnv):
+    """PendulumMassEnv varies the weight of the pendulum
+
+    Tasks are defined to be weight uniformly sampled between [0.5,2]
+    """
+
+    def sample_tasks(self, n_tasks):
+        # Sample new pendulum masses (random floats between 0.5 and 2).
+        return np.random.uniform(low=0.5, high=2.0, size=(n_tasks,))
+
+    def set_task(self, task):
+        """
+        Args:
+            task: Task of the meta-learning environment (here: mass of
+                the pendulum).
+        """
+        # self.m is the mass property of the pendulum.
+        self.m = task
+
+    def get_task(self):
+        """
+        Returns:
+            float: The current mass of the pendulum (self.m in the PendulumEnv
+                object).
+        """
+        return self.m

deepseek/lib/python3.10/site-packages/ray/rllib/examples/envs/classes/stateless_cartpole.py

@@ -0,0 +1,39 @@
+from gymnasium.spaces import Box
+import numpy as np
+
+from gymnasium.envs.classic_control import CartPoleEnv
+
+
+class StatelessCartPole(CartPoleEnv):
+    """Partially observable variant of the CartPole gym environment.
+
+    https://github.com/openai/gym/blob/master/gym/envs/classic_control/
+    cartpole.py
+
+    We delete the x- and angular velocity components of the state, so that it
+    can only be solved by a memory enhanced model (policy).
+    """
+
+    def __init__(self, config=None):
+        super().__init__()
+
+        # Fix our observation-space (remove 2 velocity components).
+        high = np.array(
+            [
+                self.x_threshold * 2,
+                self.theta_threshold_radians * 2,
+            ],
+            dtype=np.float32,
+        )
+
+        self.observation_space = Box(low=-high, high=high, dtype=np.float32)
+
+    def step(self, action):
+        next_obs, reward, done, truncated, info = super().step(action)
+        # next_obs is [x-pos, x-veloc, angle, angle-veloc]
+        return np.array([next_obs[0], next_obs[2]]), reward, done, truncated, info
+
+    def reset(self, *, seed=None, options=None):
+        init_obs, init_info = super().reset(seed=seed, options=options)
+        # init_obs is [x-pos, x-veloc, angle, angle-veloc]
+        return np.array([init_obs[0], init_obs[2]]), init_info

deepseek/lib/python3.10/site-packages/ray/rllib/examples/fault_tolerance/crashing_and_stalling_env.py

@@ -0,0 +1,177 @@
+"""Example demonstrating that RLlib can learn (at scale) in unstable environments.
+
+This script uses the `CartPoleCrashing` environment, an adapted cartpole env whose
+instability is configurable through setting the probability of a crash and/or stall
+(sleep for a configurable amount of time) during `reset()` and/or `step()`.
+
+RLlib has two major flags for EnvRunner fault tolerance, which can be independently
+set to True:
+1) `config.fault_tolerance(restart_failed_sub_environments=True)` causes only the
+(gymnasium) environment object on an EnvRunner to be closed (try calling `close()` on
+the faulty object), garbage collected, and finally recreated from scratch. Note that
+during this process, the containing EnvRunner remaing up and running and sampling
+simply continues after the env recycling. This is the lightest and fastest form of
+fault tolerance and should be attempted first.
+2) `config.fault_tolerance(restart_failed_env_runners=True)` causes the entire
+EnvRunner (a Ray remote actor) to be restarted. This restart logically includes the
+gymnasium environment, the RLModule, and all connector pipelines on the EnvRunner.
+Use this option only if you face problems with the first option
+(restart_failed_sub_environments=True), such as incomplete cleanups and memory leaks.
+
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack
+
+You can switch on the fault tolerant behavior (1) (restart_failed_sub_environments)
+through the `--restart-failed-envs` flag. If this flag is not set, the script will
+recreate the entire (faulty) EnvRunner.
+
+You can switch on stalling (besides crashing) through the `--stall` command line flag.
+If set, besides crashing on `reset()` and/or `step()`, there is also a chance of
+stalling for a few seconds on each of these events.
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+
+
+Results to expect
+-----------------
+You should see the following (or very similar) console output when running this script
+with:
+`--algo=PPO --stall --restart-failed-envs --stop-reward=450.0`
++---------------------+------------+----------------+--------+------------------+
+| Trial name          | status     | loc            |   iter |   total time (s) |
+|                     |            |                |        |                  |
+|---------------------+------------+----------------+--------+------------------+
+| PPO_env_ba39b_00000 | TERMINATED | 127.0.0.1:1401 |     22 |          133.497 |
++---------------------+------------+----------------+--------+------------------+
++------------------------+------------------------+------------------------+
+|    episode_return_mean |   num_episodes_lifetim |   num_env_steps_traine |
+|                        |                      e |             d_lifetime |
+|------------------------+------------------------+------------------------|
+|                 450.24 |                    542 |                  88628 |
++------------------------+------------------------+------------------------+
+
+For APPO and testing restarting the entire EnvRunners, you could run the script with:
+`--algo=APPO --stall --stop-reward=450.0`
++----------------------+------------+----------------+--------+------------------+
+| Trial name           | status     | loc            |   iter |   total time (s) |
+|                      |            |                |        |                  |
+|----------------------+------------+----------------+--------+------------------+
+| APPO_env_ba39b_00000 | TERMINATED | 127.0.0.1:4653 |     10 |          101.531 |
++----------------------+------------+----------------+--------+------------------+
++------------------------+------------------------+------------------------+
+|    episode_return_mean |   num_episodes_lifetim |   num_env_steps_traine |
+|                        |                      e |             d_lifetime |
+|------------------------+------------------------+------------------------|
+|                 478.85 |                   2546 |                 321500 |
++------------------------+------------------------+------------------------+
+"""
+from gymnasium.wrappers import TimeLimit
+
+from ray import tune
+from ray.rllib.core.rl_module.default_model_config import DefaultModelConfig
+from ray.rllib.examples.envs.classes.cartpole_crashing import (
+    CartPoleCrashing,
+    MultiAgentCartPoleCrashing,
+)
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+
+parser = add_rllib_example_script_args(
+    default_reward=450.0,
+    default_timesteps=2000000,
+)
+parser.set_defaults(
+    enable_new_api_stack=True,
+    num_env_runners=4,
+    num_envs_per_env_runner=2,
+)
+# Use `parser` to add your own custom command line options to this script
+# and (if needed) use their values to set up `config` below.
+parser.add_argument(
+    "--stall",
+    action="store_true",
+    help="Whether to also stall the env from time to time",
+)
+parser.add_argument(
+    "--restart-failed-envs",
+    action="store_true",
+    help="Whether to restart a failed environment (vs restarting the entire "
+    "EnvRunner).",
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    # Register our environment with tune.
+    if args.num_agents > 0:
+        tune.register_env("env", lambda cfg: MultiAgentCartPoleCrashing(cfg))
+    else:
+        tune.register_env(
+            "env",
+            lambda cfg: TimeLimit(CartPoleCrashing(cfg), max_episode_steps=500),
+        )
+
+    base_config = (
+        tune.registry.get_trainable_cls(args.algo)
+        .get_default_config()
+        .environment(
+            "env",
+            env_config={
+                "num_agents": args.num_agents,
+                # Probability to crash during step().
+                "p_crash": 0.0001,
+                # Probability to crash during reset().
+                "p_crash_reset": 0.001,
+                "crash_on_worker_indices": [1, 2],
+                "init_time_s": 2.0,
+                # Probability to stall during step().
+                "p_stall": 0.0005,
+                # Probability to stall during reset().
+                "p_stall_reset": 0.001,
+                # Stall from 2 to 5sec (or 0.0 if --stall not set).
+                "stall_time_sec": (2, 5) if args.stall else 0.0,
+                # EnvRunner indices to stall on.
+                "stall_on_worker_indices": [2, 3],
+            },
+        )
+        # Switch on resiliency.
+        .fault_tolerance(
+            # Recreate any failed EnvRunners.
+            restart_failed_env_runners=True,
+            # Restart any failed environment (w/o recreating the EnvRunner). Note that
+            # this is the much faster option.
+            restart_failed_sub_environments=args.restart_failed_envs,
+        )
+    )
+
+    # Use more stabilizing hyperparams for APPO.
+    if args.algo == "APPO":
+        base_config.training(
+            grad_clip=40.0,
+            entropy_coeff=0.0,
+            vf_loss_coeff=0.05,
+        )
+        base_config.rl_module(
+            model_config=DefaultModelConfig(vf_share_layers=True),
+        )
+
+    # Add a simple multi-agent setup.
+    if args.num_agents > 0:
+        base_config.multi_agent(
+            policies={f"p{i}" for i in range(args.num_agents)},
+            policy_mapping_fn=lambda aid, *a, **kw: f"p{aid}",
+        )
+
+    run_rllib_example_script_experiment(base_config, args=args)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/inference/policy_inference_after_training.py

@@ -0,0 +1,188 @@
+"""Example on how to compute actions in production on an already trained policy.
+
+This example uses the simplest setup possible: An RLModule (policy net) recovered
+from a checkpoint and a manual env-loop (CartPole-v1). No ConnectorV2s or EnvRunners are
+used in this example.
+
+This example:
+    - shows how to use an already existing checkpoint to extract a single-agent RLModule
+    from (our policy network).
+    - shows how to setup this recovered policy net for action computations (with or
+    without using exploration).
+    - shows have the policy run through a very simple gymnasium based env-loop, w/o
+    using RLlib's ConnectorV2s or EnvRunners.
+
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack --stop-reward=200.0`
+
+Use the `--explore-during-inference` option to switch on exploratory behavior
+during inference. Normally, you should not explore during inference, though,
+unless your environment has a stochastic optimal solution.
+Use the `--num-episodes-during-inference=[int]` option to set the number of
+episodes to run through during the inference phase using the restored RLModule.
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+Note that the shown GPU settings in this script also work in case you are not
+running via tune, but instead are using the `--no-tune` command line option.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+
+You can visualize experiment results in ~/ray_results using TensorBoard.
+
+
+Results to expect
+-----------------
+
+For the training step - depending on your `--stop-reward` setting, you should see
+something similar to this:
+
+Number of trials: 1/1 (1 TERMINATED)
++-----------------------------+------------+-----------------+--------+
+| Trial name                  | status     | loc             |   iter |
+|                             |            |                 |        |
+|-----------------------------+------------+-----------------+--------+
+| PPO_CartPole-v1_6660c_00000 | TERMINATED | 127.0.0.1:43566 |      8 |
++-----------------------------+------------+-----------------+--------+
++------------------+------------------------+------------------------+
+|   total time (s) |   num_env_steps_sample |   num_env_steps_traine |
+|                  |             d_lifetime |             d_lifetime |
++------------------+------------------------+------------------------+
+|          21.0283 |                  32000 |                  32000 |
++------------------+------------------------+------------------------+
+
+Then, after restoring the RLModule for the inference phase, your output should
+look similar to:
+
+Training completed. Restoring new RLModule for action inference.
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Episode done: Total reward = 500.0
+Done performing action inference through 10 Episodes
+"""
+import gymnasium as gym
+import numpy as np
+import os
+
+from ray.rllib.core import DEFAULT_MODULE_ID
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.numpy import convert_to_numpy, softmax
+from ray.rllib.utils.metrics import (
+    ENV_RUNNER_RESULTS,
+    EPISODE_RETURN_MEAN,
+)
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls
+
+torch, _ = try_import_torch()
+
+parser = add_rllib_example_script_args(default_reward=200.0)
+parser.set_defaults(
+    # Make sure that - by default - we produce checkpoints during training.
+    checkpoint_freq=1,
+    checkpoint_at_end=True,
+    # Use CartPole-v1 by default.
+    env="CartPole-v1",
+    # Script only runs on new API stack.
+    enable_new_api_stack=True,
+)
+parser.add_argument(
+    "--explore-during-inference",
+    action="store_true",
+    help="Whether the trained policy should use exploration during action "
+    "inference.",
+)
+parser.add_argument(
+    "--num-episodes-during-inference",
+    type=int,
+    default=10,
+    help="Number of episodes to do inference over (after restoring from a checkpoint).",
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    assert (
+        args.enable_new_api_stack
+    ), "Must set --enable-new-api-stack when running this script!"
+
+    base_config = get_trainable_cls(args.algo).get_default_config()
+
+    print("Training policy until desired reward/timesteps/iterations. ...")
+    results = run_rllib_example_script_experiment(base_config, args)
+
+    print("Training completed. Restoring new RLModule for action inference.")
+    # Get the last checkpoint from the above training run.
+    best_result = results.get_best_result(
+        metric=f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}", mode="max"
+    )
+    # Create new RLModule and restore its state from the last algo checkpoint.
+    # Note that the checkpoint for the RLModule can be found deeper inside the algo
+    # checkpoint's subdirectories ([algo dir] -> "learner/" -> "module_state/" ->
+    # "[module ID]):
+    rl_module = RLModule.from_checkpoint(
+        os.path.join(
+            best_result.checkpoint.path,
+            "learner_group",
+            "learner",
+            "rl_module",
+            DEFAULT_MODULE_ID,
+        )
+    )
+
+    # Create an env to do inference in.
+    env = gym.make(args.env)
+    obs, info = env.reset()
+
+    num_episodes = 0
+    episode_return = 0.0
+
+    while num_episodes < args.num_episodes_during_inference:
+        # Compute an action using a B=1 observation "batch".
+        input_dict = {Columns.OBS: torch.from_numpy(obs).unsqueeze(0)}
+        # No exploration.
+        if not args.explore_during_inference:
+            rl_module_out = rl_module.forward_inference(input_dict)
+        # Using exploration.
+        else:
+            rl_module_out = rl_module.forward_exploration(input_dict)
+
+        # For discrete action spaces used here, normally, an RLModule "only"
+        # produces action logits, from which we then have to sample.
+        # However, you can also write custom RLModules that output actions
+        # directly, performing the sampling step already inside their
+        # `forward_...()` methods.
+        logits = convert_to_numpy(rl_module_out[Columns.ACTION_DIST_INPUTS])
+        # Perform the sampling step in numpy for simplicity.
+        action = np.random.choice(env.action_space.n, p=softmax(logits[0]))
+        # Send the computed action `a` to the env.
+        obs, reward, terminated, truncated, _ = env.step(action)
+        episode_return += reward
+        # Is the episode `done`? -> Reset.
+        if terminated or truncated:
+            print(f"Episode done: Total reward = {episode_return}")
+            obs, info = env.reset()
+            num_episodes += 1
+            episode_return = 0.0
+
+    print(f"Done performing action inference through {num_episodes} Episodes")

deepseek/lib/python3.10/site-packages/ray/rllib/examples/inference/policy_inference_after_training_w_connector.py

@@ -0,0 +1,274 @@
+"""Example on how to compute actions in production on an already trained policy.
+
+This example uses a more complex setup including a gymnasium environment, an
+RLModule (one or more neural networks/policies), an env-to-module/module-to-env
+ConnectorV2 pair, and an Episode object to store the ongoing episode in.
+The RLModule contains an LSTM that requires its own previous STATE_OUT as new input
+at every episode step to compute a new action.
+
+This example:
+    - shows how to use an already existing checkpoint to extract a single-agent RLModule
+    from (our policy network).
+    - shows how to setup this recovered policy net for action computations (with or
+    without using exploration).
+    - shows how to create a more complex env-loop in which the action-computing RLModule
+    requires its own previous state outputs as new input and how to use RLlib's Episode
+    APIs to achieve this.
+
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack --stop-reward=200.0`
+
+Use the `--explore-during-inference` option to switch on exploratory behavior
+during inference. Normally, you should not explore during inference, though,
+unless your environment has a stochastic optimal solution.
+Use the `--num-episodes-during-inference=[int]` option to set the number of
+episodes to run through during the inference phase using the restored RLModule.
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+Note that the shown GPU settings in this script also work in case you are not
+running via tune, but instead are using the `--no-tune` command line option.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+
+You can visualize experiment results in ~/ray_results using TensorBoard.
+
+
+Results to expect
+-----------------
+
+For the training step - depending on your `--stop-reward` setting, you should see
+something similar to this:
+
+Number of trials: 1/1 (1 TERMINATED)
++--------------------------------+------------+-----------------+--------+
+| Trial name                     | status     | loc             |   iter |
+|                                |            |                 |        |
+|--------------------------------+------------+-----------------+--------+
+| PPO_stateless-cart_cc890_00000 | TERMINATED | 127.0.0.1:72238 |      7 |
++--------------------------------+------------+-----------------+--------+
++------------------+------------------------+------------------------+
+|   total time (s) |   num_env_steps_sample |   num_env_steps_traine |
+|                  |             d_lifetime |             d_lifetime |
++------------------+------------------------+------------------------+
+|          31.9655 |                  28000 |                  28000 |
++------------------+------------------------+------------------------+
+
+Then, after restoring the RLModule for the inference phase, your output should
+look similar to:
+
+Training completed. Creating an env-loop for inference ...
+Env ...
+Env-to-module ConnectorV2 ...
+RLModule restored ...
+Module-to-env ConnectorV2 ...
+Episode done: Total reward = 103.0
+Episode done: Total reward = 90.0
+Episode done: Total reward = 100.0
+Episode done: Total reward = 111.0
+Episode done: Total reward = 85.0
+Episode done: Total reward = 90.0
+Episode done: Total reward = 100.0
+Episode done: Total reward = 102.0
+Episode done: Total reward = 97.0
+Episode done: Total reward = 81.0
+Done performing action inference through 10 Episodes
+"""
+import os
+
+from ray.rllib.connectors.env_to_module import EnvToModulePipeline
+from ray.rllib.connectors.module_to_env import ModuleToEnvPipeline
+from ray.rllib.core import (
+    COMPONENT_ENV_RUNNER,
+    COMPONENT_ENV_TO_MODULE_CONNECTOR,
+    COMPONENT_MODULE_TO_ENV_CONNECTOR,
+    COMPONENT_LEARNER_GROUP,
+    COMPONENT_LEARNER,
+    COMPONENT_RL_MODULE,
+    DEFAULT_MODULE_ID,
+)
+from ray.rllib.core.columns import Columns
+from ray.rllib.core.rl_module.default_model_config import DefaultModelConfig
+from ray.rllib.core.rl_module.rl_module import RLModule
+from ray.rllib.env.single_agent_episode import SingleAgentEpisode
+from ray.rllib.examples.envs.classes.stateless_cartpole import StatelessCartPole
+from ray.rllib.utils.framework import try_import_torch
+from ray.rllib.utils.metrics import (
+    ENV_RUNNER_RESULTS,
+    EPISODE_RETURN_MEAN,
+)
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls, register_env
+
+torch, _ = try_import_torch()
+
+
+def _env_creator(cfg):
+    return StatelessCartPole(cfg)
+
+
+register_env("stateless-cart", _env_creator)
+
+
+parser = add_rllib_example_script_args(default_reward=200.0)
+parser.set_defaults(
+    # Script only runs on new API stack.
+    enable_new_api_stack=True,
+    # Make sure that - by default - we produce checkpoints during training.
+    checkpoint_freq=1,
+    checkpoint_at_end=True,
+    # Use StatelessCartPole by default.
+    env="stateless-cart",
+)
+parser.add_argument(
+    "--explore-during-inference",
+    action="store_true",
+    help="Whether the trained policy should use exploration during action "
+    "inference.",
+)
+parser.add_argument(
+    "--num-episodes-during-inference",
+    type=int,
+    default=10,
+    help="Number of episodes to do inference over (after restoring from a checkpoint).",
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    base_config = (
+        get_trainable_cls(args.algo)
+        .get_default_config()
+        .training(
+            num_epochs=6,
+            lr=0.0003,
+            vf_loss_coeff=0.01,
+        )
+        # Add an LSTM setup to the default RLModule used.
+        .rl_module(model_config=DefaultModelConfig(use_lstm=True))
+    )
+
+    print("Training LSTM-policy until desired reward/timesteps/iterations. ...")
+    results = run_rllib_example_script_experiment(base_config, args)
+
+    # Get the last checkpoint from the above training run.
+    metric_key = metric = f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}"
+    best_result = results.get_best_result(metric=metric_key, mode="max")
+
+    print(
+        "Training completed (R="
+        f"{best_result.metrics[ENV_RUNNER_RESULTS][EPISODE_RETURN_MEAN]}). "
+        "Creating an env-loop for inference ..."
+    )
+
+    print("Env ...", end="")
+    env = _env_creator(base_config.env_config)
+    print(" ok")
+
+    # Create the env-to-module pipeline from the checkpoint.
+    print("Restore env-to-module connector from checkpoint ...", end="")
+    env_to_module = EnvToModulePipeline.from_checkpoint(
+        os.path.join(
+            best_result.checkpoint.path,
+            COMPONENT_ENV_RUNNER,
+            COMPONENT_ENV_TO_MODULE_CONNECTOR,
+        )
+    )
+    print(" ok")
+
+    print("Restore RLModule from checkpoint ...", end="")
+    # Create RLModule from a checkpoint.
+    rl_module = RLModule.from_checkpoint(
+        os.path.join(
+            best_result.checkpoint.path,
+            COMPONENT_LEARNER_GROUP,
+            COMPONENT_LEARNER,
+            COMPONENT_RL_MODULE,
+            DEFAULT_MODULE_ID,
+        )
+    )
+    print(" ok")
+
+    # For the module-to-env pipeline, we will use the convenient config utility.
+    print("Restore module-to-env connector from checkpoint ...", end="")
+    module_to_env = ModuleToEnvPipeline.from_checkpoint(
+        os.path.join(
+            best_result.checkpoint.path,
+            COMPONENT_ENV_RUNNER,
+            COMPONENT_MODULE_TO_ENV_CONNECTOR,
+        )
+    )
+    print(" ok")
+
+    # Now our setup is complete:
+    # [gym.Env] -> env-to-module -> [RLModule] -> module-to-env -> [gym.Env] ... repeat
+    num_episodes = 0
+
+    obs, _ = env.reset()
+    episode = SingleAgentEpisode(
+        observations=[obs],
+        observation_space=env.observation_space,
+        action_space=env.action_space,
+    )
+
+    while num_episodes < args.num_episodes_during_inference:
+        shared_data = {}
+        input_dict = env_to_module(
+            episodes=[episode],  # ConnectorV2 pipelines operate on lists of episodes.
+            rl_module=rl_module,
+            explore=args.explore_during_inference,
+            shared_data=shared_data,
+        )
+        # No exploration.
+        if not args.explore_during_inference:
+            rl_module_out = rl_module.forward_inference(input_dict)
+        # Using exploration.
+        else:
+            rl_module_out = rl_module.forward_exploration(input_dict)
+
+        to_env = module_to_env(
+            batch=rl_module_out,
+            episodes=[episode],  # ConnectorV2 pipelines operate on lists of episodes.
+            rl_module=rl_module,
+            explore=args.explore_during_inference,
+            shared_data=shared_data,
+        )
+        # Send the computed action to the env. Note that the RLModule and the
+        # connector pipelines work on batched data (B=1 in this case), whereas the Env
+        # is not vectorized here, so we need to use `action[0]`.
+        action = to_env.pop(Columns.ACTIONS)[0]
+        obs, reward, terminated, truncated, _ = env.step(action)
+        # Keep our `SingleAgentEpisode` instance updated at all times.
+        episode.add_env_step(
+            obs,
+            action,
+            reward,
+            terminated=terminated,
+            truncated=truncated,
+            # Same here: [0] b/c RLModule output is batched (w/ B=1).
+            extra_model_outputs={k: v[0] for k, v in to_env.items()},
+        )
+
+        # Is the episode `done`? -> Reset.
+        if episode.is_done:
+            print(f"Episode done: Total reward = {episode.get_return()}")
+            obs, info = env.reset()
+            episode = SingleAgentEpisode(
+                observations=[obs],
+                observation_space=env.observation_space,
+                action_space=env.action_space,
+            )
+            num_episodes += 1
+
+    print(f"Done performing action inference through {num_episodes} Episodes")

deepseek/lib/python3.10/site-packages/ray/rllib/examples/inference/policy_inference_after_training_with_lstm.py

@@ -0,0 +1,185 @@
+# @OldAPIStack
+"""
+Example showing how you can use your trained policy for inference
+(computing actions) in an environment.
+
+Includes options for LSTM-based models (--use-lstm), attention-net models
+(--use-attention), and plain (non-recurrent) models.
+"""
+import argparse
+import gymnasium as gym
+import numpy as np
+import os
+
+import ray
+from ray import air, tune
+from ray.air.constants import TRAINING_ITERATION
+from ray.rllib.algorithms.algorithm import Algorithm
+from ray.rllib.utils.metrics import (
+    ENV_RUNNER_RESULTS,
+    EPISODE_RETURN_MEAN,
+    NUM_ENV_STEPS_SAMPLED_LIFETIME,
+)
+from ray.tune.registry import get_trainable_cls
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--run", type=str, default="PPO", help="The RLlib-registered algorithm to use."
+)
+parser.add_argument("--num-cpus", type=int, default=0)
+parser.add_argument(
+    "--framework",
+    choices=["tf", "tf2", "torch"],
+    default="torch",
+    help="The DL framework specifier.",
+)
+parser.add_argument(
+    "--prev-action",
+    action="store_true",
+    help="Feed most recent action to the LSTM as part of its input.",
+)
+parser.add_argument(
+    "--prev-reward",
+    action="store_true",
+    help="Feed most recent reward to the LSTM as part of its input.",
+)
+parser.add_argument(
+    "--stop-iters",
+    type=int,
+    default=2,
+    help="Number of iterations to train before we do inference.",
+)
+parser.add_argument(
+    "--stop-timesteps",
+    type=int,
+    default=100000,
+    help="Number of timesteps to train before we do inference.",
+)
+parser.add_argument(
+    "--stop-reward",
+    type=float,
+    default=0.8,
+    help="Reward at which we stop training before we do inference.",
+)
+parser.add_argument(
+    "--explore-during-inference",
+    action="store_true",
+    help="Whether the trained policy should use exploration during action "
+    "inference.",
+)
+parser.add_argument(
+    "--num-episodes-during-inference",
+    type=int,
+    default=10,
+    help="Number of episodes to do inference over after training.",
+)
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    ray.init(num_cpus=args.num_cpus or None)
+
+    config = (
+        get_trainable_cls(args.run)
+        .get_default_config()
+        .api_stack(
+            enable_env_runner_and_connector_v2=False,
+            enable_rl_module_and_learner=False,
+        )
+        .environment("FrozenLake-v1")
+        # Run with tracing enabled for tf2?
+        .framework(args.framework)
+        .training(
+            model={
+                "use_lstm": True,
+                "lstm_cell_size": 256,
+                "lstm_use_prev_action": args.prev_action,
+                "lstm_use_prev_reward": args.prev_reward,
+            },
+        )
+        # Use GPUs iff `RLLIB_NUM_GPUS` env var set to > 0.
+        .resources(num_gpus=int(os.environ.get("RLLIB_NUM_GPUS", "0")))
+    )
+
+    stop = {
+        TRAINING_ITERATION: args.stop_iters,
+        NUM_ENV_STEPS_SAMPLED_LIFETIME: args.stop_timesteps,
+        f"{ENV_RUNNER_RESULTS}/{EPISODE_RETURN_MEAN}": args.stop_reward,
+    }
+
+    print("Training policy until desired reward/timesteps/iterations. ...")
+    tuner = tune.Tuner(
+        args.run,
+        param_space=config,
+        run_config=air.RunConfig(
+            stop=stop,
+            verbose=2,
+            checkpoint_config=air.CheckpointConfig(
+                checkpoint_frequency=1,
+                checkpoint_at_end=True,
+            ),
+        ),
+    )
+    results = tuner.fit()
+
+    print("Training completed. Restoring new Algorithm for action inference.")
+    # Get the last checkpoint from the above training run.
+    checkpoint = results.get_best_result().checkpoint
+    # Create new Algorithm from the last checkpoint.
+    algo = Algorithm.from_checkpoint(checkpoint)
+
+    # Create the env to do inference in.
+    env = gym.make("FrozenLake-v1")
+    obs, info = env.reset()
+
+    # In case the model needs previous-reward/action inputs, keep track of
+    # these via these variables here (we'll have to pass them into the
+    # compute_actions methods below).
+    init_prev_a = prev_a = None
+    init_prev_r = prev_r = None
+
+    # Set LSTM's initial internal state.
+    lstm_cell_size = config["model"]["lstm_cell_size"]
+    # range(2) b/c h- and c-states of the LSTM.
+    if algo.config.enable_rl_module_and_learner:
+        init_state = state = algo.get_policy().model.get_initial_state()
+    else:
+        init_state = state = [np.zeros([lstm_cell_size], np.float32) for _ in range(2)]
+    # Do we need prev-action/reward as part of the input?
+    if args.prev_action:
+        init_prev_a = prev_a = 0
+    if args.prev_reward:
+        init_prev_r = prev_r = 0.0
+
+    num_episodes = 0
+
+    while num_episodes < args.num_episodes_during_inference:
+        # Compute an action (`a`).
+        a, state_out, _ = algo.compute_single_action(
+            observation=obs,
+            state=state,
+            prev_action=prev_a,
+            prev_reward=prev_r,
+            explore=args.explore_during_inference,
+            policy_id="default_policy",  # <- default value
+        )
+        # Send the computed action `a` to the env.
+        obs, reward, done, truncated, info = env.step(a)
+        # Is the episode `done`? -> Reset.
+        if done:
+            obs, info = env.reset()
+            num_episodes += 1
+            state = init_state
+            prev_a = init_prev_a
+            prev_r = init_prev_r
+        # Episode is still ongoing -> Continue.
+        else:
+            state = state_out
+            if init_prev_a is not None:
+                prev_a = a
+            if init_prev_r is not None:
+                prev_r = reward
+
+    algo.stop()
+
+    ray.shutdown()

deepseek/lib/python3.10/site-packages/ray/rllib/examples/multi_agent/custom_heuristic_policy.py

@@ -0,0 +1,101 @@
+"""Example of running a custom heuristic (hand-coded) policy alongside trainable ones.
+
+This example has two RLModules (as action computing policies):
+    (1) one trained by a PPOLearner
+    (2) one hand-coded policy that acts at random in the env (doesn't learn).
+
+The environment is MultiAgentCartPole, in which there are n agents both policies
+
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack --num-agents=2`
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+
+
+Results to expect
+-----------------
+In the console output, you can see the PPO policy ("learnable_policy") does much
+better than "random":
+
++-------------------+------------+----------+------+----------------+
+| Trial name        | status     | loc      | iter | total time (s) |
+|                   |            |          |      |                |
+|-------------------+------------+----------+------+----------------+
+| PPO_multi_agen... | TERMINATED | 127. ... |   20 |         58.646 |
++-------------------+------------+----------+------+----------------+
+
++--------+-------------------+-----------------+--------------------+
+|     ts |   combined reward |   reward random |             reward |
+|        |                   |                 |   learnable_policy |
++--------+-------------------+-----------------+--------------------|
+|  80000 |            481.26 |           78.41 |             464.41 |
++--------+-------------------+-----------------+--------------------+
+"""
+
+from ray.rllib.algorithms.ppo import PPOConfig
+from ray.rllib.core.rl_module.rl_module import RLModuleSpec
+from ray.rllib.core.rl_module.multi_rl_module import MultiRLModuleSpec
+from ray.rllib.examples.envs.classes.multi_agent import MultiAgentCartPole
+from ray.rllib.examples.rl_modules.classes.random_rlm import RandomRLModule
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import register_env
+
+
+parser = add_rllib_example_script_args(
+    default_iters=40, default_reward=500.0, default_timesteps=200000
+)
+parser.set_defaults(
+    enable_new_api_stack=True,
+    num_agents=2,
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    assert args.num_agents == 2, "Must set --num-agents=2 when running this script!"
+
+    # Simple environment with n independent cartpole entities.
+    register_env(
+        "multi_agent_cartpole",
+        lambda _: MultiAgentCartPole({"num_agents": args.num_agents}),
+    )
+
+    base_config = (
+        PPOConfig()
+        .environment("multi_agent_cartpole")
+        .multi_agent(
+            policies={"learnable_policy", "random"},
+            # Map to either random behavior or PPO learning behavior based on
+            # the agent's ID.
+            policy_mapping_fn=lambda agent_id, *args, **kwargs: [
+                "learnable_policy",
+                "random",
+            ][agent_id % 2],
+            # We need to specify this here, b/c the `forward_train` method of
+            # `RandomRLModule` (ModuleID="random") throws a not-implemented error.
+            policies_to_train=["learnable_policy"],
+        )
+        .rl_module(
+            rl_module_spec=MultiRLModuleSpec(
+                rl_module_specs={
+                    "learnable_policy": RLModuleSpec(),
+                    "random": RLModuleSpec(module_class=RandomRLModule),
+                }
+            ),
+        )
+    )
+
+    run_rllib_example_script_experiment(base_config, args)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/multi_agent/different_spaces_for_agents.py

@@ -0,0 +1,112 @@
+"""
+Example showing how to create a multi-agent env, in which the different agents
+have different observation and action spaces.
+
+These spaces do NOT necessarily have to be specified manually by the user. Instead,
+RLlib tries to automatically infer them from the env provided spaces dicts
+(agentID -> obs/act space) and the policy mapping fn (mapping agent IDs to policy IDs).
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack --num-agents=2`
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+"""
+
+import gymnasium as gym
+
+from ray.rllib.env.multi_agent_env import MultiAgentEnv
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls
+
+
+class BasicMultiAgentMultiSpaces(MultiAgentEnv):
+    """A simple multi-agent example environment where agents have different spaces.
+
+    agent0: obs=Box(10,), act=Discrete(2)
+    agent1: obs=Box(20,), act=Discrete(3)
+
+    The logic of the env doesn't really matter for this example. The point of this env
+    is to show how to use multi-agent envs, in which the different agents utilize
+    different obs- and action spaces.
+    """
+
+    def __init__(self, config=None):
+        self.agents = ["agent0", "agent1"]
+
+        self.terminateds = set()
+        self.truncateds = set()
+
+        # Provide full (preferred format) observation- and action-spaces as Dicts
+        # mapping agent IDs to the individual agents' spaces.
+        self.observation_spaces = {
+            "agent0": gym.spaces.Box(low=-1.0, high=1.0, shape=(10,)),
+            "agent1": gym.spaces.Box(low=-1.0, high=1.0, shape=(20,)),
+        }
+        self.action_spaces = {
+            "agent0": gym.spaces.Discrete(2),
+            "agent1": gym.spaces.Discrete(3),
+        }
+
+        super().__init__()
+
+    def reset(self, *, seed=None, options=None):
+        self.terminateds = set()
+        self.truncateds = set()
+        return {i: self.get_observation_space(i).sample() for i in self.agents}, {}
+
+    def step(self, action_dict):
+        obs, rew, terminated, truncated, info = {}, {}, {}, {}, {}
+        for i, action in action_dict.items():
+            obs[i] = self.get_observation_space(i).sample()
+            rew[i] = 0.0
+            terminated[i] = False
+            truncated[i] = False
+            info[i] = {}
+        terminated["__all__"] = len(self.terminateds) == len(self.agents)
+        truncated["__all__"] = len(self.truncateds) == len(self.agents)
+        return obs, rew, terminated, truncated, info
+
+
+parser = add_rllib_example_script_args(
+    default_iters=10, default_reward=80.0, default_timesteps=10000
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    assert (
+        args.enable_new_api_stack
+    ), "Must set --enable-new-api-stack when running this script!"
+
+    base_config = (
+        get_trainable_cls(args.algo)
+        .get_default_config()
+        .environment(env=BasicMultiAgentMultiSpaces)
+        .training(train_batch_size=1024)
+        .multi_agent(
+            # Use a simple set of policy IDs. Spaces for the individual policies
+            # are inferred automatically using reverse lookup via the
+            # `policy_mapping_fn` and the env provided spaces for the different
+            # agents. Alternatively, you could use:
+            # policies: {main0: PolicySpec(...), main1: PolicySpec}
+            policies={"main0", "main1"},
+            # Simple mapping fn, mapping agent0 to main0 and agent1 to main1.
+            policy_mapping_fn=(lambda aid, episode, **kw: f"main{aid[-1]}"),
+            # Only train main0.
+            policies_to_train=["main0"],
+        )
+    )
+
+    run_rllib_example_script_experiment(base_config, args)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/multi_agent/pettingzoo_parameter_sharing.py

@@ -0,0 +1,105 @@
+"""Runs the PettingZoo Waterworld multi-agent env in RLlib using single policy learning.
+
+Other than the `pettingzoo_independent_learning.py` example (in this same folder),
+this example simply trains a single policy (shared by all agents).
+
+See: https://pettingzoo.farama.org/environments/sisl/waterworld/
+for more details on the environment.
+
+
+How to run this script
+----------------------
+`python [script file name].py --enable-new-api-stack --num-agents=2`
+
+Control the number of agents and policies (RLModules) via --num-agents and
+--num-policies.
+
+This works with hundreds of agents and policies, but note that initializing
+many policies might take some time.
+
+For debugging, use the following additional command line options
+`--no-tune --num-env-runners=0`
+which should allow you to set breakpoints anywhere in the RLlib code and
+have the execution stop there for inspection and debugging.
+
+For logging to your WandB account, use:
+`--wandb-key=[your WandB API key] --wandb-project=[some project name]
+--wandb-run-name=[optional: WandB run name (within the defined project)]`
+
+
+Results to expect
+-----------------
+The above options can reach a combined reward of roughly ~0.0 after about 500k-1M env
+timesteps. Keep in mind, though, that in this setup, the agents do not have the
+opportunity to benefit from or even out other agents' mistakes (and behavior in general)
+as everyone is using the same policy. Hence, this example learns a more generic policy,
+which might be less specialized to certain "niche exploitation opportunities" inside
+the env:
+
++---------------------+----------+-----------------+--------+-----------------+
+| Trial name          | status   | loc             |   iter |  total time (s) |
+|---------------------+----------+-----------------+--------+-----------------+
+| PPO_env_91f49_00000 | RUNNING  | 127.0.0.1:63676 |    200 |         605.176 |
++---------------------+----------+-----------------+--------+-----------------+
+
++--------+-------------------+-------------+
+|     ts |   combined reward |   reward p0 |
++--------+-------------------+-------------|
+| 800000 |          0.323752 |    0.161876 |
++--------+-------------------+-------------+
+"""
+from pettingzoo.sisl import waterworld_v4
+
+from ray.rllib.core.rl_module.multi_rl_module import MultiRLModuleSpec
+from ray.rllib.core.rl_module.rl_module import RLModuleSpec
+from ray.rllib.env.wrappers.pettingzoo_env import PettingZooEnv
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls, register_env
+
+
+parser = add_rllib_example_script_args(
+    default_iters=200,
+    default_timesteps=1000000,
+    default_reward=0.0,
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    assert args.num_agents > 0, "Must set --num-agents > 0 when running this script!"
+    assert (
+        args.enable_new_api_stack
+    ), "Must set --enable-new-api-stack when running this script!"
+
+    # Here, we use the "Agent Environment Cycle" (AEC) PettingZoo environment type.
+    # For a "Parallel" environment example, see the rock paper scissors examples
+    # in this same repository folder.
+    register_env("env", lambda _: PettingZooEnv(waterworld_v4.env()))
+
+    base_config = (
+        get_trainable_cls(args.algo)
+        .get_default_config()
+        .environment("env")
+        .multi_agent(
+            policies={"p0"},
+            # All agents map to the exact same policy.
+            policy_mapping_fn=(lambda aid, *args, **kwargs: "p0"),
+        )
+        .training(
+            model={
+                "vf_share_layers": True,
+            },
+            vf_loss_coeff=0.005,
+        )
+        .rl_module(
+            rl_module_spec=MultiRLModuleSpec(
+                rl_module_specs={"p0": RLModuleSpec()},
+            ),
+        )
+    )
+
+    run_rllib_example_script_experiment(base_config, args)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/multi_agent/rock_paper_scissors_learned_vs_learned.py

@@ -0,0 +1,91 @@
+"""A simple multi-agent env with two agents play rock paper scissors.
+
+This demonstrates running two learning policies in competition, both using the same
+RLlib algorithm (PPO by default).
+
+The combined reward as well as individual rewards should roughly remain at 0.0 as no
+policy should - in the long run - be able to learn a better strategy than chosing
+actions at random. However, it could be possible that - for some time - one or the other
+policy can exploit a "stochastic weakness" of the opponent policy. For example a policy
+`A` learns that its opponent `B` has learnt to choose "paper" more often, which in
+return makes `A` choose "scissors" more often as a countermeasure.
+"""
+
+import re
+
+from pettingzoo.classic import rps_v2
+
+from ray.rllib.connectors.env_to_module import FlattenObservations
+from ray.rllib.core.rl_module.default_model_config import DefaultModelConfig
+from ray.rllib.core.rl_module.multi_rl_module import MultiRLModuleSpec
+from ray.rllib.core.rl_module.rl_module import RLModuleSpec
+from ray.rllib.env.wrappers.pettingzoo_env import ParallelPettingZooEnv
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls, register_env
+
+
+parser = add_rllib_example_script_args(
+    default_iters=50,
+    default_timesteps=200000,
+    default_reward=6.0,
+)
+parser.set_defaults(
+    enable_new_api_stack=True,
+    num_agents=2,
+)
+parser.add_argument(
+    "--use-lstm",
+    action="store_true",
+    help="Whether to use an LSTM wrapped module instead of a simple MLP one. With LSTM "
+    "the reward diff can reach 7.0, without only 5.0.",
+)
+
+
+register_env(
+    "RockPaperScissors",
+    lambda _: ParallelPettingZooEnv(rps_v2.parallel_env()),
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    assert args.num_agents == 2, "Must set --num-agents=2 when running this script!"
+
+    base_config = (
+        get_trainable_cls(args.algo)
+        .get_default_config()
+        .environment("RockPaperScissors")
+        .env_runners(
+            env_to_module_connector=lambda env: FlattenObservations(multi_agent=True),
+        )
+        .multi_agent(
+            policies={"p0", "p1"},
+            # `player_0` uses `p0`, `player_1` uses `p1`.
+            policy_mapping_fn=lambda aid, episode: re.sub("^player_", "p", aid),
+        )
+        .training(
+            vf_loss_coeff=0.005,
+        )
+        .rl_module(
+            model_config=DefaultModelConfig(
+                use_lstm=args.use_lstm,
+                # Use a simpler FCNet when we also have an LSTM.
+                fcnet_hiddens=[32] if args.use_lstm else [256, 256],
+                lstm_cell_size=256,
+                max_seq_len=15,
+                vf_share_layers=True,
+            ),
+            rl_module_spec=MultiRLModuleSpec(
+                rl_module_specs={
+                    "p0": RLModuleSpec(),
+                    "p1": RLModuleSpec(),
+                }
+            ),
+        )
+    )
+
+    run_rllib_example_script_experiment(base_config, args)

deepseek/lib/python3.10/site-packages/ray/rllib/examples/multi_agent/self_play_with_open_spiel.py

@@ -0,0 +1,236 @@
+"""Example showing how one can implement a simple self-play training workflow.
+
+Uses the open spiel adapter of RLlib with the "connect_four" game and
+a multi-agent setup with a "main" policy and n "main_v[x]" policies
+(x=version number), which are all at-some-point-frozen copies of
+"main". At the very beginning, "main" plays against RandomPolicy.
+
+Checks for the training progress after each training update via a custom
+callback. We simply measure the win rate of "main" vs the opponent
+("main_v[x]" or RandomPolicy at the beginning) by looking through the
+achieved rewards in the episodes in the train batch. If this win rate
+reaches some configurable threshold, we add a new policy to
+the policy map (a frozen copy of the current "main" one) and change the
+policy_mapping_fn to make new matches of "main" vs any of the previous
+versions of "main" (including the just added one).
+
+After training for n iterations, a configurable number of episodes can
+be played by the user against the "main" agent on the command line.
+"""
+
+import functools
+
+import numpy as np
+
+from ray.air.constants import TRAINING_ITERATION
+from ray.rllib.core.rl_module.default_model_config import DefaultModelConfig
+from ray.rllib.core.rl_module.multi_rl_module import MultiRLModuleSpec
+from ray.rllib.core.rl_module.rl_module import RLModuleSpec
+from ray.rllib.env.utils import try_import_pyspiel, try_import_open_spiel
+from ray.rllib.env.wrappers.open_spiel import OpenSpielEnv
+from ray.rllib.examples.rl_modules.classes.random_rlm import RandomRLModule
+from ray.rllib.examples.multi_agent.utils import (
+    ask_user_for_action,
+    SelfPlayCallback,
+    SelfPlayCallbackOldAPIStack,
+)
+from ray.rllib.examples._old_api_stack.policy.random_policy import RandomPolicy
+from ray.rllib.policy.policy import PolicySpec
+from ray.rllib.utils.metrics import NUM_ENV_STEPS_SAMPLED_LIFETIME
+from ray.rllib.utils.test_utils import (
+    add_rllib_example_script_args,
+    run_rllib_example_script_experiment,
+)
+from ray.tune.registry import get_trainable_cls, register_env
+
+open_spiel = try_import_open_spiel(error=True)
+pyspiel = try_import_pyspiel(error=True)
+
+# Import after try_import_open_spiel, so we can error out with hints.
+from open_spiel.python.rl_environment import Environment  # noqa: E402
+
+
+parser = add_rllib_example_script_args(default_timesteps=2000000)
+parser.set_defaults(env="connect_four")
+parser.add_argument(
+    "--win-rate-threshold",
+    type=float,
+    default=0.95,
+    help="Win-rate at which we setup another opponent by freezing the "
+    "current main policy and playing against a uniform distribution "
+    "of previously frozen 'main's from here on.",
+)
+parser.add_argument(
+    "--min-league-size",
+    type=float,
+    default=3,
+    help="Minimum number of policies/RLModules to consider the test passed. "
+    "The initial league size is 2: `main` and `random`. "
+    "`--min-league-size=3` thus means that one new policy/RLModule has been "
+    "added so far (b/c the `main` one has reached the `--win-rate-threshold "
+    "against the `random` Policy/RLModule).",
+)
+parser.add_argument(
+    "--num-episodes-human-play",
+    type=int,
+    default=10,
+    help="How many episodes to play against the user on the command "
+    "line after training has finished.",
+)
+parser.add_argument(
+    "--from-checkpoint",
+    type=str,
+    default=None,
+    help="Full path to a checkpoint file for restoring a previously saved "
+    "Algorithm state.",
+)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    register_env("open_spiel_env", lambda _: OpenSpielEnv(pyspiel.load_game(args.env)))
+
+    def agent_to_module_mapping_fn(agent_id, episode, **kwargs):
+        # agent_id = [0|1] -> module depends on episode ID
+        # This way, we make sure that both modules sometimes play agent0
+        # (start player) and sometimes agent1 (player to move 2nd).
+        return "main" if hash(episode.id_) % 2 == agent_id else "random"
+
+    def policy_mapping_fn(agent_id, episode, worker, **kwargs):
+        return "main" if episode.episode_id % 2 == agent_id else "random"
+
+    config = (
+        get_trainable_cls(args.algo)
+        .get_default_config()
+        .api_stack(
+            enable_rl_module_and_learner=args.enable_new_api_stack,
+            enable_env_runner_and_connector_v2=args.enable_new_api_stack,
+        )
+        .environment("open_spiel_env")
+        .framework(args.framework)
+        # Set up the main piece in this experiment: The league-bases self-play
+        # callback, which controls adding new policies/Modules to the league and
+        # properly matching the different policies in the league with each other.
+        .callbacks(
+            functools.partial(
+                (
+                    SelfPlayCallback
+                    if args.enable_new_api_stack
+                    else SelfPlayCallbackOldAPIStack
+                ),
+                win_rate_threshold=args.win_rate_threshold,
+            )
+        )
+        .env_runners(
+            num_env_runners=(args.num_env_runners or 2),
+            num_envs_per_env_runner=1 if args.enable_new_api_stack else 5,
+        )
+        .resources(
+            num_cpus_for_main_process=1,
+        )
+        .multi_agent(
+            # Initial policy map: Random and default algo one. This will be expanded
+            # to more policy snapshots taken from "main" against which "main"
+            # will then play (instead of "random"). This is done in the
+            # custom callback defined above (`SelfPlayCallback`).
+            policies=(
+                {
+                    # Our main policy, we'd like to optimize.
+                    "main": PolicySpec(),
+                    # An initial random opponent to play against.
+                    "random": PolicySpec(policy_class=RandomPolicy),
+                }
+                if not args.enable_new_api_stack
+                else {"main", "random"}
+            ),
+            # Assign agent 0 and 1 randomly to the "main" policy or
+            # to the opponent ("random" at first). Make sure (via episode_id)
+            # that "main" always plays against "random" (and not against
+            # another "main").
+            policy_mapping_fn=(
+                agent_to_module_mapping_fn
+                if args.enable_new_api_stack
+                else policy_mapping_fn
+            ),
+            # Always just train the "main" policy.
+            policies_to_train=["main"],
+        )
+        .rl_module(
+            model_config=DefaultModelConfig(fcnet_hiddens=[512, 512]),
+            rl_module_spec=MultiRLModuleSpec(
+                rl_module_specs={
+                    "main": RLModuleSpec(),
+                    "random": RLModuleSpec(module_class=RandomRLModule),
+                }
+            ),
+        )
+    )
+
+    # Only for PPO, change the `num_epochs` setting.
+    if args.algo == "PPO":
+        config.training(num_epochs=20)
+
+    stop = {
+        NUM_ENV_STEPS_SAMPLED_LIFETIME: args.stop_timesteps,
+        TRAINING_ITERATION: args.stop_iters,
+        "league_size": args.min_league_size,
+    }
+
+    # Train the "main" policy to play really well using self-play.
+    results = None
+    if not args.from_checkpoint:
+        results = run_rllib_example_script_experiment(config, args, stop=stop)
+
+    # Restore trained Algorithm (set to non-explore behavior) and play against
+    # human on command line.
+    if args.num_episodes_human_play > 0:
+        num_episodes = 0
+        config.explore = False
+        algo = config.build()
+        if args.from_checkpoint:
+            algo.restore(args.from_checkpoint)
+        else:
+            checkpoint = results.get_best_result().checkpoint
+            if not checkpoint:
+                raise ValueError("No last checkpoint found in results!")
+            algo.restore(checkpoint)
+
+        # Play from the command line against the trained agent
+        # in an actual (non-RLlib-wrapped) open-spiel env.
+        human_player = 1
+        env = Environment(args.env)
+
+        while num_episodes < args.num_episodes_human_play:
+            print("You play as {}".format("o" if human_player else "x"))
+            time_step = env.reset()
+            while not time_step.last():
+                player_id = time_step.observations["current_player"]
+                if player_id == human_player:
+                    action = ask_user_for_action(time_step)
+                else:
+                    obs = np.array(time_step.observations["info_state"][player_id])
+                    action = algo.compute_single_action(obs, policy_id="main")
+                    # In case computer chooses an invalid action, pick a
+                    # random one.
+                    legal = time_step.observations["legal_actions"][player_id]
+                    if action not in legal:
+                        action = np.random.choice(legal)
+                time_step = env.step([action])
+                print(f"\n{env.get_state}")
+
+            print(f"\n{env.get_state}")
+
+            print("End of game!")
+            if time_step.rewards[human_player] > 0:
+                print("You win")
+            elif time_step.rewards[human_player] < 0:
+                print("You lose")
+            else:
+                print("Draw")
+            # Switch order of players.
+            human_player = 1 - human_player
+
+            num_episodes += 1
+
+        algo.stop()

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

@@ -0,0 +1,43 @@
+import sys
+
+from ray.rllib.examples.multi_agent.utils.self_play_callback import SelfPlayCallback
+from ray.rllib.examples.multi_agent.utils.self_play_league_based_callback import (
+    SelfPlayLeagueBasedCallback,
+)
+from ray.rllib.examples.multi_agent.utils.self_play_callback_old_api_stack import (
+    SelfPlayCallbackOldAPIStack,
+)
+from ray.rllib.examples.multi_agent.utils.self_play_league_based_callback_old_api_stack import (  # noqa
+    SelfPlayLeagueBasedCallbackOldAPIStack,
+)
+
+
+def ask_user_for_action(time_step):
+    """Asks the user for a valid action on the command line and returns it.
+
+    Re-queries the user until she picks a valid one.
+
+    Args:
+        time_step: The open spiel Environment time-step object.
+    """
+    pid = time_step.observations["current_player"]
+    legal_moves = time_step.observations["legal_actions"][pid]
+    choice = -1
+    while choice not in legal_moves:
+        print("Choose an action from {}:".format(legal_moves))
+        sys.stdout.flush()
+        choice_str = input()
+        try:
+            choice = int(choice_str)
+        except ValueError:
+            continue
+    return choice
+
+
+__all__ = [
+    "ask_user_for_action",
+    "SelfPlayCallback",
+    "SelfPlayLeagueBasedCallback",
+    "SelfPlayCallbackOldAPIStack",
+    "SelfPlayLeagueBasedCallbackOldAPIStack",
+]