Add files using upload-large-folder tool

cleanrl/docs/benchmark/ppo_atari_multigpu_runtimes.md

@@ -0,0 +1,5 @@
+|                         |   openrlbenchmark/cleanrl/ppo_atari_multigpu ({'tag': ['pr-424']}) |
+|:------------------------|-------------------------------------------------------------------:|
+| PongNoFrameskip-v4      |                                                            276.599 |
+| BeamRiderNoFrameskip-v4 |                                                            280.902 |
+| BreakoutNoFrameskip-v4  |                                                            270.532 |

cleanrl/docs/benchmark/ppo_continuous_action.md

@@ -0,0 +1,11 @@
+|                                      | openrlbenchmark/cleanrl/ppo_continuous_action ({'tag': ['pr-424']})   |
+|:-------------------------------------|:----------------------------------------------------------------------|
+| HalfCheetah-v4                       | 1442.64 ± 46.03                                                       |
+| Walker2d-v4                          | 2287.95 ± 571.78                                                      |
+| Hopper-v4                            | 2382.86 ± 271.74                                                      |
+| InvertedPendulum-v4                  | 963.09 ± 22.20                                                        |
+| Humanoid-v4                          | 716.11 ± 49.08                                                        |
+| Pusher-v4                            | -40.38 ± 7.15                                                         |
+| dm_control/acrobot-swingup-v0        | 25.60 ± 6.30                                                          |
+| dm_control/acrobot-swingup_sparse-v0 | 1.35 ± 0.27                                                           |
+| dm_control/ball_in_cup-catch-v0      | 619.26 ± 278.67                                                       |

cleanrl/docs/benchmark/ppo_envpool.md

@@ -0,0 +1,5 @@
+|              | openrlbenchmark/cleanrl/ppo_atari_envpool_xla_jax ({'tag': ['pr-424']})   | openrlbenchmark/cleanrl/ppo_atari_envpool_xla_jax_scan ({'tag': ['pr-424']})   | openrlbenchmark/cleanrl/ppo_atari_envpool ({'tag': ['pr-424']})   |
+|:-------------|:--------------------------------------------------------------------------|:-------------------------------------------------------------------------------|:------------------------------------------------------------------|
+| Pong-v5      | 20.82 ± 0.21                                                              | 20.52 ± 0.32                                                                   | 20.45 ± 0.09                                                      |
+| BeamRider-v5 | 2678.73 ± 426.42                                                          | 2860.61 ± 801.30                                                               | 2501.85 ± 210.52                                                  |
+| Breakout-v5  | 420.92 ± 16.75                                                            | 423.90 ± 5.49                                                                  | 211.24 ± 151.84                                                   |

cleanrl/docs/benchmark/ppo_envpool_runtimes.md

@@ -0,0 +1,5 @@
+|              |   openrlbenchmark/cleanrl/ppo_atari_envpool_xla_jax ({'tag': ['pr-424']}) |   openrlbenchmark/cleanrl/ppo_atari_envpool_xla_jax_scan ({'tag': ['pr-424']}) |   openrlbenchmark/cleanrl/ppo_atari_envpool ({'tag': ['pr-424']}) |
+|:-------------|--------------------------------------------------------------------------:|-------------------------------------------------------------------------------:|------------------------------------------------------------------:|
+| Pong-v5      |                                                                   34.3237 |                                                                        34.701  |                                                           178.375 |
+| BeamRider-v5 |                                                                   37.1076 |                                                                        37.2449 |                                                           182.944 |
+| Breakout-v5  |                                                                   39.576  |                                                                        39.775  |                                                           151.384 |

cleanrl/docs/benchmark/ppo_procgen.md

@@ -0,0 +1,5 @@
+|           | openrlbenchmark/cleanrl/ppo_procgen ({'tag': ['pr-424']})   |
+|:----------|:------------------------------------------------------------|
+| starpilot | 30.99 ± 1.96                                                |
+| bossfight | 8.85 ± 0.33                                                 |
+| bigfish   | 16.46 ± 2.71                                                |

cleanrl/docs/benchmark/sac.md

@@ -0,0 +1,8 @@
+|                     | openrlbenchmark/cleanrl/sac_continuous_action ({'tag': ['pr-424']})   |
+|:--------------------|:----------------------------------------------------------------------|
+| HalfCheetah-v4      | 9634.89 ± 1423.73                                                     |
+| Walker2d-v4         | 3591.45 ± 911.33                                                      |
+| Hopper-v4           | 2310.46 ± 342.82                                                      |
+| InvertedPendulum-v4 | 909.37 ± 55.66                                                        |
+| Humanoid-v4         | 4996.29 ± 686.40                                                      |
+| Pusher-v4           | -22.45 ± 0.51                                                         |

cleanrl/docs/benchmark/td3.md

@@ -0,0 +1,8 @@
+|                     | openrlbenchmark/cleanrl/td3_continuous_action ({'tag': ['pr-424']})   | openrlbenchmark/cleanrl/td3_continuous_action_jax ({'tag': ['pr-424']})   |
+|:--------------------|:----------------------------------------------------------------------|:--------------------------------------------------------------------------|
+| HalfCheetah-v4      | 9583.22 ± 126.09                                                      | 9345.93 ± 770.54                                                          |
+| Walker2d-v4         | 4057.59 ± 658.78                                                      | 3686.19 ± 141.23                                                          |
+| Hopper-v4           | 3134.61 ± 360.18                                                      | 2940.10 ± 655.63                                                          |
+| InvertedPendulum-v4 | 968.99 ± 25.80                                                        | 988.94 ± 8.86                                                             |
+| Humanoid-v4         | 5035.36 ± 21.67                                                       | 5033.22 ± 122.14                                                          |
+| Pusher-v4           | -30.92 ± 1.05                                                         | -29.18 ± 1.02                                                             |

cleanrl/docs/rl-algorithms/c51.md

@@ -0,0 +1,354 @@
+# Categorical DQN (C51)
+
+## Overview
+
+C51 introduces a distributional perspective for DQN: instead of learning a single value for an action, C51 learns to predict a distribution of values for the action. Empirically, C51 demonstrates impressive performance in ALE.
+
+
+Original papers: 
+
+* [A Distributional Perspective on Reinforcement Learning](https://arxiv.org/abs/1707.06887)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`c51_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari.py), :material-file-document: [docs](/rl-algorithms/c51/#c51_ataripy) |  For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques. |
+| :material-github: [`c51.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51.py), :material-file-document: [docs](/rl-algorithms/c51/#c51py) | For classic control tasks like `CartPole-v1`. |
+| :material-github: [`c51_atari_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari_jax.py), :material-file-document: [docs](/rl-algorithms/c51/#c51_atari_jaxpy) |  For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques. |
+| :material-github: [`c51_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_jax.py), :material-file-document: [docs](/rl-algorithms/c51/#c51_jaxpy) | For classic control tasks like `CartPole-v1`. |
+
+Below are our single-file implementations of C51:
+
+
+## `c51_atari.py`
+
+The [c51_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari.py) has the following features:
+
+* For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques.
+* Works with the Atari's pixel `Box` observation space of shape `(210, 160, 3)`
+* Works with the `Discrete` action space
+
+### Usage
+
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[atari]"
+    uv run python cleanrl/c51_atari.py --env-id BreakoutNoFrameskip-v4
+    uv run python cleanrl/c51_atari.py --env-id PongNoFrameskip-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-atari.txt
+    python cleanrl/c51_atari.py --env-id BreakoutNoFrameskip-v4
+    python cleanrl/c51_atari.py --env-id PongNoFrameskip-v4
+    ```
+
+
+### Explanation of the logged metrics
+
+Running `python cleanrl/c51_atari.py` will automatically record various metrics such as actor or value losses in Tensorboard. Below is the documentation for these metrics:
+
+* `charts/episodic_return`: episodic return of the game
+* `charts/SPS`: number of steps per second
+* `losses/loss`: the cross entropy loss between the $t$ step state value distribution and the projected $t+1$ step state value distribution
+* `losses/q_values`: implemented as `(old_pmfs * q_network.atoms).sum(1)`, which is the sum of the probability of getting returns $x$ (`old_pmfs`) multiplied by $x$ (`q_network.atoms`), averaged over the sample obtained from the replay buffer; useful when gauging if under or over estimation happens
+
+
+### Implementation details
+
+[c51_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari.py) is based on (Bellemare et al., 2017)[^1] but presents a few implementation differences:
+
+1. (Bellemare et al., 2017)[^1] injects stochaticity by doing "on each frame the environment rejects the agent’s selected action with probability $p = 0.25$", but `c51_atari.py` does not do this
+1. `c51_atari.py` use a self-contained evaluation scheme: `c51_atari.py` reports the episodic returns obtained throughout training, whereas (Bellemare et al., 2017)[^1] is trained with `--end-e=0.01` but reported episodic returns using a separate evaluation process with `--end-e=0.001` (See "5.2. State-of-the-Art Results" on page 7).
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/c51.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/c51.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fc51.sh%23L8-L13&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for `c51_atari.py`. 
+
+
+| Environment      | `c51_atari.py` 10M steps | (Bellemare et al., 2017, Figure 14)[^1] 50M steps | (Hessel et al., 2017, Figure 5)[^3] 
+| ----------- | ----------- | ----------- | ---- |
+| BreakoutNoFrameskip-v4      | 461.86 ± 69.65      | 748  | ~500 at 10M steps, ~600 at 50M steps
+| PongNoFrameskip-v4  | 19.46 ± 0.70    |  20.9 |  ~20 10M steps, ~20 at 50M steps 
+| BeamRiderNoFrameskip-v4   | 9592.90 ± 2270.15        | 14,074 | ~12000 10M steps, ~14000 at 50M steps 
+
+
+Note that we save computational time by reducing timesteps from 50M to 10M, but our `c51_atari.py` scores the same or higher than (Mnih et al., 2015)[^1] in 10M steps.
+
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../c51/BeamRiderNoFrameskip-v4.png">
+
+<img src="../c51/BreakoutNoFrameskip-v4.png">
+
+<img src="../c51/PongNoFrameskip-v4.png">
+</div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Atari-CleanRL-s-C51--VmlldzoxNzI0NzQ0" style="width:100%; height:500px" title="CleanRL C51 Tracked Experiments"></iframe>
+
+
+
+## `c51.py`
+
+The [c51.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51.py) has the following features:
+
+* Works with the `Box` observation space of low-level features
+* Works with the `Discrete` action space
+* Works with envs like `CartPole-v1`
+
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv run python cleanrl/c51.py --env-id CartPole-v1
+    ```
+
+=== "pip"
+
+    ```bash
+    python cleanrl/c51.py --env-id CartPole-v1
+    ```
+
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/c51/#explanation-of-the-logged-metrics) for `c51_atari.py`.
+
+### Implementation details
+
+The [c51.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51.py) shares the same implementation details as [`c51_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari.py) except the `c51.py` runs with different hyperparameters and neural network architecture. Specifically,
+
+1. `c51.py` uses a simpler neural network as follows:
+        ```python
+        self.network = nn.Sequential(
+            nn.Linear(np.array(env.single_observation_space.shape).prod(), 120),
+            nn.ReLU(),
+            nn.Linear(120, 84),
+            nn.ReLU(),
+            nn.Linear(84, env.single_action_space.n),
+        )
+        ```
+2. `c51.py` runs with different hyperparameters:
+
+    ```bash
+    python c51.py --total-timesteps 500000 \
+        --learning-rate 2.5e-4 \
+        --buffer-size 10000 \
+        --gamma 0.99 \
+        --target-network-frequency 500 \
+        --max-grad-norm 0.5 \
+        --batch-size 128 \
+        --start-e 1 \
+        --end-e 0.05 \
+        --exploration-fraction 0.5 \
+        --learning-starts 10000 \
+        --train-frequency 10
+    ```
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/c51.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/c51.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fc51.sh%23L2-L6&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+
+Below are the average episodic returns for `c51.py`. 
+
+
+| Environment      | `c51.py`  | 
+| ----------- | ----------- | 
+| CartPole-v1      | 481.20 ± 20.53      |
+| Acrobot-v1  | -87.70 ± 5.52     | 
+| MountainCar-v0   | -166.38 ± 27.94        | 
+
+
+Note that the C51 has no official benchmark on classic control environments, so we did not include a comparison. That said, our `c51.py` was able to achieve near perfect scores in `CartPole-v1` and `Acrobot-v1`; further, it can obtain successful runs in the sparse environment `MountainCar-v0`.
+
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../c51/CartPole-v1.png">
+
+<img src="../c51/Acrobot-v1.png">
+
+<img src="../c51/MountainCar-v0.png">
+</div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Classic-Control-CleanRL-s-C51--VmlldzoxODIwMTE4" style="width:100%; height:500px" title="CleanRL C51 Tracked Experiments"></iframe>
+
+
+## `c51_atari_jax.py`
+
+The [c51_atari_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari_jax.py) has the following features:
+
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [c51_atari_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari_jax.py) is roughly 25% faster than  [c51_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_atari.py)
+* For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques.
+* Works with the Atari's pixel `Box` observation space of shape `(210, 160, 3)`
+* Works with the `Discrete` action space
+
+### Usage
+
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[atari, jax]"
+    uv pip install --upgrade "jax[cuda11_cudnn82]==0.4.8" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    uv run python cleanrl/c51_atari_jax.py --env-id BreakoutNoFrameskip-v4
+    uv run python cleanrl/c51_atari_jax.py --env-id PongNoFrameskip-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-atari.txt
+    pip install -r requirements/requirements-jax.txt
+    pip install --upgrade "jax[cuda]==0.3.17" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    python cleanrl/c51_atari_jax.py --env-id BreakoutNoFrameskip-v4
+    python cleanrl/c51_atari_jax.py --env-id PongNoFrameskip-v4
+    ```
+
+
+### Explanation of the logged metrics
+See [related docs](/rl-algorithms/c51/#explanation-of-the-logged-metrics) for `c51_atari.py`.
+
+
+### Implementation details
+See [related docs](/rl-algorithms/c51/#implementation-details) for `c51_atari.py`.
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/c51.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/c51.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fc51.sh%23L23-L29&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for `c51_atari_jax.py`. 
+
+
+| Environment             | `c51_atari_jax.py` 10M steps | `c51_atari.py` 10M steps | (Bellemare et al., 2017, Figure 14)[^1] 50M steps | (Hessel et al., 2017, Figure 5)[^3]   |
+| ----------------------- | ---------------------------- | ------------------------ | ------------------------------------------------- | ------------------------------------- |
+| BreakoutNoFrameskip-v4  | 448.56 ± 17.02               | 461.86 ± 69.65           | 748                                               | ~500 at 10M steps, ~600 at 50M steps  |
+| PongNoFrameskip-v4      | 19.88 ± 0.31                 | 19.46 ± 0.70             | 20.9                                              | ~20 10M steps, ~20 at 50M steps       |
+| BeamRiderNoFrameskip-v4 | 9504.91 ± 709.69             | 9592.90 ± 2270.15        | 14,074                                            | ~12000 10M steps, ~14000 at 50M steps |
+
+
+
+Learning curves:
+<div class="grid-container">
+<img src="../c51/jax/BeamRiderNoFrameskip-v4.png">
+<img src="../c51/jax/BeamRiderNoFrameskip-v4-time.png">
+
+<img src="../c51/jax/BreakoutNoFrameskip-v4.png">
+<img src="../c51/jax/BreakoutNoFrameskip-v4-time.png">
+
+<img src="../c51/jax/PongNoFrameskip-v4.png">
+<img src="../c51/jax/PongNoFrameskip-v4-time.png">
+</div>
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Atari-CleanRL-s-C51-JAX--VmlldzozMjM4MTIy" style="width:100%; height:500px" title="CleanRL C51 Tracked Experiments"></iframe>
+
+
+## `c51_jax.py`
+
+The [c51_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_jax.py) has the following features:
+
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [c51_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51_jax.py) is roughly 55% faster than  [c51.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/c51.py)
+* Works with the `Box` observation space of low-level features
+* Works with the `Discrete` action space
+* Works with envs like `CartPole-v1`
+
+
+### Usage
+
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[jax]"
+    uv pip install --upgrade "jax[cuda11_cudnn82]==0.4.8" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    uv run python cleanrl/c51_jax.py --env-id CartPole-v1
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-jax.txt
+    pip install --upgrade "jax[cuda]==0.3.17" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    python cleanrl/c51_jax.py --env-id CartPole-v1
+    ```
+
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/c51/#explanation-of-the-logged-metrics) for `c51_atari.py`.
+
+### Implementation details
+
+See [related docs](/rl-algorithms/c51/#implementation-details_1) for `c51.py`.
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/c51.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/c51.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fc51.sh%23L15-L21&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+
+Below are the average episodic returns for `c51_jax.py`. 
+
+
+| Environment    | `c51_jax.py`    | `c51.py`        |
+| -------------- | --------------- | --------------- |
+| CartPole-v1    | 491.07 ± 9.70   | 481.20 ± 20.53  |
+| Acrobot-v1     | -86.74 ± 2.19   | -87.70 ± 5.52   |
+| MountainCar-v0 | -174.30 ± 36.35 | -166.38 ± 27.94 |
+
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../c51/jax/CartPole-v1.png">
+<img src="../c51/jax/CartPole-v1-time.png">
+
+<img src="../c51/jax/Acrobot-v1.png">
+<img src="../c51/jax/Acrobot-v1-time.png">
+
+<img src="../c51/jax/MountainCar-v0.png">
+<img src="../c51/jax/MountainCar-v0-time.png">
+</div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Classic-Control-CleanRL-s-C51-JAX--VmlldzozMjM4MTM4" style="width:100%; height:500px" title="CleanRL C51 Tracked Experiments"></iframe>
+
+
+[^1]:Bellemare, M.G., Dabney, W., & Munos, R. (2017). A Distributional Perspective on Reinforcement Learning. ICML.
+[^2]:\[Proposal\] Formal API handling of truncation vs termination. https://github.com/openai/gym/issues/2510
+[^3]: Hessel, M., Modayil, J., Hasselt, H.V., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M.G., & Silver, D. (2018). Rainbow: Combining Improvements in Deep Reinforcement Learning. AAAI.

cleanrl/docs/rl-algorithms/ddpg.md

@@ -0,0 +1,375 @@
+# Deep Deterministic Policy Gradient (DDPG)
+
+
+## Overview
+
+DDPG is a popular DRL algorithm for continuous control. It extends DQN to work with the continuous action space by introducing a deterministic actor that directly outputs continuous actions. DDPG also combines techniques from DQN, such as the replay buffer and target network.
+
+
+Original paper: 
+
+* [Continuous control with deep reinforcement learning](https://arxiv.org/abs/1509.02971)
+
+Reference resources:
+
+* :material-github: [sfujim/TD3](https://github.com/sfujim/TD3)
+* [Deep Deterministic Policy Gradient | Spinning Up in Deep RL](https://spinningup.openai.com/en/latest/algorithms/ddpg.html)
+* :material-github: [ikostrikov/jaxrl](https://github.com/ikostrikov/jaxrl) (helpful reference when implemented [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py))
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py), :material-file-document: [docs](/rl-algorithms/ddpg/#ddpg_continuous_actionpy) | For continuous action space |
+| :material-github: [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py), :material-file-document: [docs](/rl-algorithms/ddpg/#ddpg_continuous_action_jaxpy) | For continuous action space |
+
+Below is our single-file implementation of DDPG:
+
+## `ddpg_continuous_action.py`
+
+The [ddpg_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) has the following features:
+
+* For continuous action space
+* Works with the `Box` observation space of low-level features
+* Works with the `Box` (continuous) action space
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv pip install .
+    uv run python cleanrl/ddpg_continuous_action.py --help
+    uv pip install ".[mujoco]"
+    uv run python cleanrl/ddpg_continuous_action.py --env-id Hopper-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    python cleanrl/ddpg_continuous_action.py --help
+    pip install -r requirements/requirements-mujoco.txt
+    python cleanrl/ddpg_continuous_actions.py --env-id Hopper-v4
+    ```
+
+### Explanation of the logged metrics
+
+Running `python cleanrl/ddpg_continuous_action.py` will automatically record various metrics such as actor or value losses in Tensorboard. Below is the documentation for these metrics:
+
+* `charts/episodic_return`: episodic return of the game
+* `charts/SPS`: number of steps per second
+* `losses/qf1_loss`: the mean squared error (MSE) between the Q values at timestep $t$ and the Bellman update target estimated using the reward $r_t$ and the Q values at timestep $t+1$, thus minimizing the *one-step* temporal difference. Formally, it can be expressed by the equation below.
+$$
+    J(\theta^{Q}) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{D}} \big[ (Q(s, a) - y)^2 \big],
+$$
+with the Bellman update target $y = r + \gamma \, Q^{'}(s', a')$, where $a' \sim \mu^{'}(s')$, and the replay buffer $\mathcal{D}$.
+
+* `losses/actor_loss`: implemented as `-qf1(data.observations, actor(data.observations)).mean()`; it is the *negative* average Q values calculated based on the 1) observations and the 2) actions computed by the actor based on these observations. By minimizing `actor_loss`, the optimizer updates the actors parameter using the following gradient (Lillicrap et al., 2016, Algorithm 1)[^1]:
+
+$$ \nabla_{\theta^{\mu}} J \approx  \frac{1}{N}\sum_i\left.\left.\nabla_{a} Q\left(s, a \mid \theta^{Q}\right)\right|_{s=s_{i}, a=\mu\left(s_{i}\right)} \nabla_{\theta^{\mu}} \mu\left(s \mid \theta^{\mu}\right)\right|_{s_{i}} $$
+
+* `losses/qf1_values`: implemented as `qf1(data.observations, data.actions).view(-1)`, it is the average Q values of the sampled data in the replay buffer; useful when gauging if under or over estimation happens.
+
+
+### Implementation details
+
+Our [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) is based on the [`OurDDPG.py`](https://github.com/sfujim/TD3/blob/master/OurDDPG.py) from :material-github: [sfujim/TD3](https://github.com/sfujim/TD3), which presents the the following implementation difference from (Lillicrap et al., 2016)[^1]:
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) uses a gaussian exploration noise $\mathcal{N}(0, 0.1)$, while (Lillicrap et al., 2016)[^1] uses Ornstein-Uhlenbeck process with $\theta=0.15$ and $\sigma=0.2$.
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) runs the experiments using the `openai/gym` MuJoCo environments, while (Lillicrap et al., 2016)[^1] uses their proprietary MuJoCo environments.
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) uses the following architecture:
+    ```python
+    class QNetwork(nn.Module):
+        def __init__(self, env):
+            super().__init__()
+            self.fc1 = nn.Linear(np.array(env.single_observation_space.shape).prod() + np.prod(env.single_action_space.shape), 256)
+            self.fc2 = nn.Linear(256, 256)
+            self.fc3 = nn.Linear(256, 1)
+
+        def forward(self, x, a):
+            x = torch.cat([x, a], 1)
+            x = F.relu(self.fc1(x))
+            x = F.relu(self.fc2(x))
+            x = self.fc3(x)
+            return x
+
+
+    class Actor(nn.Module):
+        def __init__(self, env):
+            super().__init__()
+            self.fc1 = nn.Linear(np.array(env.single_observation_space.shape).prod(), 256)
+            self.fc2 = nn.Linear(256, 256)
+            self.fc_mu = nn.Linear(256, np.prod(env.single_action_space.shape))
+            # action rescaling
+            self.register_buffer(
+                "action_scale", torch.tensor((env.action_space.high - env.action_space.low) / 2.0, dtype=torch.float32)
+            )
+            self.register_buffer(
+                "action_bias", torch.tensor((env.action_space.high + env.action_space.low) / 2.0, dtype=torch.float32)
+            )
+
+        def forward(self, x):
+            x = F.relu(self.fc1(x))
+            x = F.relu(self.fc2(x))
+            x = torch.tanh(self.fc_mu(x))
+            return x * self.action_scale + self.action_bias
+    ```
+    while (Lillicrap et al., 2016, see Appendix 7 EXPERIMENT DETAILS)[^1] uses the following architecture (difference highlighted):
+
+    ```python hl_lines="4-6 9-11 19-21"
+    class QNetwork(nn.Module):
+        def __init__(self, env):
+            super(QNetwork, self).__init__()
+            self.fc1 = nn.Linear(p.array(env.single_observation_space.shape).prod() + np.prod(env.single_action_space.shape), 400)
+            self.fc2 = nn.Linear(400 + np.prod(env.single_action_space.shape), 300)
+            self.fc3 = nn.Linear(300, 1)
+
+        def forward(self, x, a):
+            x = F.relu(self.fc1(x))
+            x = torch.cat([x, a], 1)
+            x = F.relu(self.fc2(x))
+            x = self.fc3(x)
+            return x
+
+
+    class Actor(nn.Module):
+        def __init__(self, env):
+            super(Actor, self).__init__()
+            self.fc1 = nn.Linear(np.array(env.single_observation_space.shape).prod(), 400)
+            self.fc2 = nn.Linear(400, 300)
+            self.fc_mu = nn.Linear(300, np.prod(env.single_action_space.shape))
+            # action rescaling
+            self.register_buffer(
+                "action_scale", torch.tensor((env.action_space.high - env.action_space.low) / 2.0, dtype=torch.float32)
+            )
+            self.register_buffer(
+                "action_bias", torch.tensor((env.action_space.high + env.action_space.low) / 2.0, dtype=torch.float32)
+            )
+
+        def forward(self, x):
+            x = F.relu(self.fc1(x))
+            x = F.relu(self.fc2(x))
+            x = torch.tanh(self.fc_mu(x))
+            return x * self.action_scale + self.action_bias
+    ```
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) uses the following learning rates:
+
+    ```python
+    q_optimizer = optim.Adam(list(qf1.parameters()), lr=3e-4)
+    actor_optimizer = optim.Adam(list(actor.parameters()), lr=3e-4)
+    ```
+    while (Lillicrap et al., 2016, see Appendix 7 EXPERIMENT DETAILS)[^1] uses the following learning rates:
+
+    ```python
+    q_optimizer = optim.Adam(list(qf1.parameters()), lr=1e-4)
+    actor_optimizer = optim.Adam(list(actor.parameters()), lr=1e-3)
+    ```
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) uses `--batch-size=256 --tau=0.005`, while (Lillicrap et al., 2016, see Appendix 7 EXPERIMENT DETAILS)[^1] uses `--batch-size=64 --tau=0.001`
+
+1. [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py)  also adds support for handling continuous environments where the lower and higher bounds of the action space are not $[-1,1]$, or are asymmetric.
+The case where the bounds are not $[-1,1]$ is handled in [`DDPG.py`](https://github.com/sfujim/TD3/blob/385b33ac7de4767bab17eb02ade4a268d3e4e24f/DDPG.py#L15) (Fujimoto et al., 2018)[^2] as follows:
+```python
+class Actor(nn.Module):
+
+    ...
+
+	def forward(self, state):
+		a = F.relu(self.l1(state))
+		a = F.relu(self.l2(a))
+		return self.max_action * torch.tanh(self.l3(a)) # Scale from [-1,1] to [-action_high, action_high]
+```
+ On the other hand, in [`CleanRL's ddpg_continuous_action.py`](https://github.com/dosssman/cleanrl/blob/10b606e7bd9bd1b06e455e8ef542df2b7699a20c/cleanrl/ddpg_continuous_action.py#L98), the mean and the scale of the the action space are computed as `action_bias` and `action_scale` respectively.
+ Those scalars are in turn used to scale the output of a `tanh` activation function in the actor to the original action space range:
+```python
+class Actor(nn.Module):
+    def __init__(self, env):
+        ...
+        # action rescaling
+        self.register_buffer(
+            "action_scale", torch.tensor((env.action_space.high - env.action_space.low) / 2.0, dtype=torch.float32)
+        )
+        self.register_buffer(
+            "action_bias", torch.tensor((env.action_space.high + env.action_space.low) / 2.0, dtype=torch.float32)
+        )
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = torch.tanh(self.fc_mu(x))
+        return x * self.action_scale + self.action_bias # Scale from [-1,1] to [-action_low, action_high]
+```
+
+Additionally, when drawing exploration noise that is added to the actions produced by the actor, [`CleanRL's ddpg_continuous_action.py`](https://github.com/dosssman/cleanrl/blob/10b606e7bd9bd1b06e455e8ef542df2b7699a20c/cleanrl/ddpg_continuous_action.py#L175) centers the distribution the sampled from at `action_bias`, and the scale of the distribution is set to `action_scale * exploration_noise`.
+
+???+ info
+
+    Note that `Humanoid-v2`, `InvertedPendulum-v2`, `Pusher-v2` have action space bounds that are not the standard `[-1, 1]`. See below.
+    
+    ```
+    Ant-v2 Observation space: Box(-inf, inf, (111,), float64) Action space: Box(-1.0, 1.0, (8,), float32)
+    HalfCheetah-v2 Observation space: Box(-inf, inf, (17,), float64) Action space: Box(-1.0, 1.0, (6,), float32)
+    Hopper-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (3,), float32)
+    Humanoid-v2 Observation space: Box(-inf, inf, (376,), float64) Action space: Box(-0.4, 0.4, (17,), float32)
+    InvertedDoublePendulum-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (1,), float32)
+    InvertedPendulum-v2 Observation space: Box(-inf, inf, (4,), float64) Action space: Box(-3.0, 3.0, (1,), float32)
+    Pusher-v2 Observation space: Box(-inf, inf, (23,), float64) Action space: Box(-2.0, 2.0, (7,), float32)
+    Reacher-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (2,), float32)
+    Swimmer-v2 Observation space: Box(-inf, inf, (8,), float64) Action space: Box(-1.0, 1.0, (2,), float32)
+    Walker2d-v2 Observation space: Box(-inf, inf, (17,), float64) Action space: Box(-1.0, 1.0, (6,), float32)
+    ```
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/ddpg.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/ddpg.sh). Specifically, execute the following command:
+
+
+``` title="benchmark/ddpg.sh" linenums="1"
+--8<-- "benchmark/ddpg.sh::7"
+```
+
+
+Below are the average episodic returns for [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) (3 random seeds). To ensure the quality of the implementation, we compared the results against (Fujimoto et al., 2018)[^2].
+
+| Environment      | [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) | [`OurDDPG.py`](https://github.com/sfujim/TD3/blob/master/OurDDPG.py) (Fujimoto et al., 2018, Table 1)[^2]  | [`DDPG.py`](https://github.com/sfujim/TD3/blob/master/DDPG.py) using settings from (Lillicrap et al., 2016)[^1] in (Fujimoto et al., 2018, Table 1)[^2]    |
+| ----------- | ----------- | ----------- | ----------- |
+| HalfCheetah-v4       | 10374.07 ± 157.37      |8577.29  | 3305.60|
+| Walker2d-v4    | 1240.16 ± 390.10     |  3098.11 | 1843.85 |
+| Hopper-v4    | 1576.78 ± 818.98         |  1860.02 | 2020.46 |
+| InvertedPendulum-v4  |    642.68 ± 69.56    | 1000.00 ± 0.00  | 
+| Humanoid-v4  |  1699.56 ± 694.22      |  not available | 
+| Pusher-v4  |  -77.30 ± 38.78      |  not available | 
+
+
+
+???+ info
+
+    Note that [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) uses gym MuJoCo v4 environments while [`OurDDPG.py`](https://github.com/sfujim/TD3/blob/master/OurDDPG.py) (Fujimoto et al., 2018)[^2] uses the gym MuJoCo v1 environments.
+
+    Also note the performance of our `ddpg_continuous_action.py` seems to be worse than the reference implementation on Walker2d and Hopper. This is likely due to :material-github: [openai/gym#938](https://github.com/openai/baselines/issues/938). We would have a hard time reproducing gym MuJoCo v1 environments because they have been long deprecated.
+
+    One other thing could cause the performance difference: the original code reported the average episodic return using determinisitc evaluation (i.e., without exploration noise), see [`sfujim/TD3/main.py#L15-L32`](https://github.com/sfujim/TD3/blob/385b33ac7de4767bab17eb02ade4a268d3e4e24f/main.py#L15-L32), whereas we reported the episodic return during training and the policy gets updated between environments steps.
+
+Learning curves:
+
+``` title="benchmark/ddpg_plot.sh" linenums="1"
+--8<-- "benchmark/ddpg_plot.sh::9"
+```
+
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/ddpg.png">
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/ddpg-time.png">
+
+<iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/MuJoCo-CleanRL-s-DDPG--VmlldzoxNjkyMjc1" style="width:100%; height:500px" title="MuJoCo: CleanRL's DDPG"></iframe>
+
+
+
+## `ddpg_continuous_action_jax.py`
+
+The [ddpg_continuous_action_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) has the following features:
+
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [ddpg_continuous_action_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) is roughly 2.5-4x faster than  [ddpg_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py)
+* For continuous action space
+* Works with the `Box` observation space of low-level features
+* Works with the `Box` (continuous) action space
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[mujoco, jax]"
+    uv run python cleanrl/ddpg_continuous_action_jax.py --help
+    uv run python cleanrl/ddpg_continuous_action_jax.py --env-id Hopper-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-mujoco.txt
+    pip install -r requirements/requirements-jax.txt
+    python cleanrl/ddpg_continuous_action_jax.py --help
+    python cleanrl/ddpg_continuous_action_jax.py --env-id Hopper-v4
+    ```
+
+
+???+ warning
+
+    Note that JAX does not work in Windows :fontawesome-brands-windows:. The official [docs](https://github.com/google/jax#installation) recommends using Windows Subsystem for Linux (WSL) to install JAX.
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/ddpg/#explanation-of-the-logged-metrics) for `ddpg_continuous_action.py`.
+
+
+### Implementation details
+
+See [related docs](/rl-algorithms/ddpg/#implementation-details) for `ddpg_continuous_action.py`.
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/ddpg.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/ddpg.sh). Specifically, execute the following command:
+
+
+``` title="benchmark/ddpg.sh" linenums="1"
+--8<-- "benchmark/ddpg.sh:12:19"
+```
+
+Below are the average episodic returns for [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) (3 random seeds).
+
+
+{!benchmark/ddpg.md!}
+
+Learning curves:
+
+
+``` title="benchmark/ddpg_plot.sh" linenums="1"
+--8<-- "benchmark/ddpg_plot.sh:11:20"
+```
+
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/ddpg_jax.png">
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/ddpg_jax-time.png">
+
+
+???+ info
+
+    These are some previous experiments with TPUs. Note the results are very similar to the ones above, but the runtime can be different due to different hardware used.
+
+
+    Note that the experiments were conducted on different hardwares, so your mileage might vary. This inconsistency is because 1) re-running expeirments on the same hardware is computationally expensive and 2) requiring the same hardware is not inclusive nor feasible to other contributors who might have different hardwares.
+
+    That said, we roughly expect to see a 2-4x speed improvement from using [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) under the same hardware. And if you disable the `--capture_video` overhead, the speed improvement will be even higher.
+
+
+    | Environment      | [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) (RTX 3060 TI) | [`ddpg_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action_jax.py) (VM w/ TPU) | [`ddpg_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ddpg_continuous_action.py) (RTX 3060 TI) | [`OurDDPG.py`](https://github.com/sfujim/TD3/blob/master/OurDDPG.py) (Fujimoto et al., 2018, Table 1)[^2]    |
+    | ----------- | ----------- | ----------- | ----------- | ----------- |
+    | HalfCheetah |  9592.25 ± 135.10 | 9125.06 ± 1477.58  | 10210.57 ± 196.22      |8577.29  |
+    | Walker2d |  1083.15 ± 567.65  | 1303.82 ± 448.41 | 1661.14 ± 250.01     |  3098.11 | 
+    | Hopper |  1275.28 ± 209.60  | 1145.05 ± 41.95 | 1007.44 ± 148.29         |  1860.02 |    
+
+    Learning curves:
+
+    <div class="grid-container">
+    <img loading="lazy" src="../ddpg-jax/HalfCheetah-v2.png">
+    <img loading="lazy" src="../ddpg-jax/HalfCheetah-v2-time.png">
+
+    <img loading="lazy" src="../ddpg-jax/Walker2d-v2.png">
+    <img loading="lazy" src="../ddpg-jax/Walker2d-v2-time.png">
+
+    <img loading="lazy" src="../ddpg-jax/Hopper-v2.png">
+    <img loading="lazy" src="../ddpg-jax/Hopper-v2-time.png">
+    </div> 
+
+    Tracked experiments and game play videos:
+
+    <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/MuJoCo-CleanRL-s-DDPG-JAX--VmlldzoyMjQxMjE2" style="width:100%; height:500px" title="MuJoCo: CleanRL's DDPG + JAX"></iframe>
+
+
+[^1]:Lillicrap, T.P., Hunt, J.J., Pritzel, A., Heess, N.M., Erez, T., Tassa, Y., Silver, D., & Wierstra, D. (2016). Continuous control with deep reinforcement learning. CoRR, abs/1509.02971. https://arxiv.org/abs/1509.02971
+
+[^2]:Fujimoto, S., Hoof, H.V., & Meger, D. (2018). Addressing Function Approximation Error in Actor-Critic Methods. ArXiv, abs/1802.09477. https://arxiv.org/abs/1802.09477

cleanrl/docs/rl-algorithms/dqn.md

@@ -0,0 +1,396 @@
+# Deep Q-Learning (DQN)
+
+## Overview
+
+As an extension of the Q-learning, DQN's main technical contribution is the use of replay buffer and target network, both of which would help improve the stability of the algorithm.
+
+
+Original papers: 
+
+* [Human-level control through deep reinforcement learning
+](https://www.nature.com/articles/nature14236)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`dqn_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py), :material-file-document: [docs](/rl-algorithms/dqn/#dqn_ataripy) |  For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques. |
+| :material-github: [`dqn.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn.py), :material-file-document: [docs](/rl-algorithms/dqn/#dqnpy) | For classic control tasks like `CartPole-v1`. |
+| :material-github: [`dqn_atari_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari_jax.py), :material-file-document: [docs](/rl-algorithms/dqn/#dqn_atari_jaxpy) |  For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques. |
+| :material-github: [`dqn_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_jax.py), :material-file-document: [docs](/rl-algorithms/dqn/#dqn_jaxpy) | For classic control tasks like `CartPole-v1`. |
+
+
+Below are our single-file implementations of DQN:
+
+
+## `dqn_atari.py`
+
+The [dqn_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py) has the following features:
+
+* For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques.
+* Works with the Atari's pixel `Box` observation space of shape `(210, 160, 3)`
+* Works with the `Discrete` action space
+
+### Usage
+
+```bash
+uv pip install ".[atari]"
+python cleanrl/dqn_atari.py --env-id BreakoutNoFrameskip-v4
+python cleanrl/dqn_atari.py --env-id PongNoFrameskip-v4
+```
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[atari]"
+    uv run python cleanrl/dqn_atari.py --env-id BreakoutNoFrameskip-v4
+    uv run python cleanrl/dqn_atari.py --env-id PongNoFrameskip-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-atari.txt
+    python cleanrl/dqn_atari.py --env-id BreakoutNoFrameskip-v4
+    python cleanrl/dqn_atari.py --env-id PongNoFrameskip-v4
+    ```
+
+
+### Explanation of the logged metrics
+
+Running `python cleanrl/dqn_atari.py` will automatically record various metrics such as actor or value losses in Tensorboard. Below is the documentation for these metrics:
+
+* `charts/episodic_return`: episodic return of the game
+* `charts/SPS`: number of steps per second
+* `losses/td_loss`: the mean squared error (MSE) between the Q values at timestep $t$ and the Bellman update target estimated using the reward $r_t$ and the Q values at timestep $t+1$, thus minimizing the *one-step* temporal difference. Formally, it can be expressed by the equation below.
+$$
+    J(\theta^{Q}) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{D}} \big[ (Q(s, a) - y)^2 \big],
+$$
+with the Bellman update target is $y = r + \gamma \, Q^{'}(s', a')$ and the replay buffer is $\mathcal{D}$.
+* `losses/q_values`: implemented as `qf1(data.observations, data.actions).view(-1)`, it is the average Q values of the sampled data in the replay buffer; useful when gauging if under or over estimation happens.
+
+
+### Implementation details
+
+[dqn_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py) is based on (Mnih et al., 2015)[^1] but presents a few implementation differences:
+
+1. `dqn_atari.py` use slightly different hyperparameters. Specifically,
+    - `dqn_atari.py` uses the more popular Adam Optimizer with the `--learning-rate=1e-4` as follows:
+        ```python
+        optim.Adam(q_network.parameters(), lr=1e-4)
+        ```
+       whereas (Mnih et al., 2015)[^1] (Extended Data Table 1) uses the RMSProp optimizer with `--learning-rate=2.5e-4`, gradient momentum `0.95`, squared gradient momentum `0.95`, and min squared gradient `0.01` as follows:
+        ```python
+        optim.RMSprop(
+            q_network.parameters(),
+            lr=2.5e-4,
+            momentum=0.95,
+            # ... PyTorch's RMSprop does not directly support
+            # squared gradient momentum and min squared gradient
+            # so we are not sure what to put here.
+        )
+        ``` 
+    - `dqn_atari.py` uses `--learning-starts=80000` whereas (Mnih et al., 2015)[^1] (Extended Data Table 1) uses `--learning-starts=50000`.
+    - `dqn_atari.py` uses `--target-network-frequency=1000` whereas (Mnih et al., 2015)[^1] (Extended Data Table 1) uses `--target-network-frequency=10000`.
+    - `dqn_atari.py` uses `--total-timesteps=10000000` (i.e., 10M timesteps = 40M frames because of frame-skipping) whereas (Mnih et al., 2015)[^1] uses `--total-timesteps=50000000` (i.e., 50M timesteps = 200M frames) (See "Training details" under "METHODS" on page 6 and the related source code [run_gpu#L32](https://github.com/deepmind/dqn/blob/9d9b1d13a2b491d6ebd4d046740c511c662bbe0f/run_gpu#L32), [dqn/train_agent.lua#L81-L82](https://github.com/deepmind/dqn/blob/9d9b1d13a2b491d6ebd4d046740c511c662bbe0f/dqn/train_agent.lua#L81-L82), and [dqn/train_agent.lua#L165-L169](https://github.com/deepmind/dqn/blob/9d9b1d13a2b491d6ebd4d046740c511c662bbe0f/dqn/train_agent.lua#L165-L169)).
+    - `dqn_atari.py` uses `--end-e=0.01` (the final exploration epsilon) whereas (Mnih et al., 2015)[^1] (Extended Data Table 1) uses `--end-e=0.1`.
+    - `dqn_atari.py` uses `--exploration-fraction=0.1` whereas (Mnih et al., 2015)[^1] (Extended Data Table 1) uses `--exploration-fraction=0.02` (all corresponds to 250000 steps or 1M frames being the frame that epsilon is annealed to `--end-e=0.1` ).
+    - `dqn_atari.py` handles truncation and termination properly like (Mnih et al., 2015)[^1] by using SB3's replay buffer's `handle_timeout_termination=True`.
+2. `dqn_atari.py` use a self-contained evaluation scheme: `dqn_atari.py` reports the episodic returns obtained throughout training, whereas (Mnih et al., 2015)[^1] is trained with `--end-e=0.1` but reported episodic returns using a separate evaluation process with `--end-e=0.01` (See "Evaluation procedure" under "METHODS" on page 6).
+3. `dqn_atari.py` implements target network updates as Polyak updates. Compared to the original implementation in (Mnih et al., 2015)[^1], this version allows soft updates of the target network weights with `--tau` (update coefficient) values of less than 1 (i.e. `--tau=0.9`). Note that by default `--tau=1.0` is used to be consistent with (Mnih et al., 2015)[^1].
+4. `dqn_atari.py` uses the standard MSE loss function, whereas (Mnih et al., 2015)[^1] "...found it helpful to clip the error term from the update $r + \gamma \max_{a'}Q(s', a'; \theta^{-}_{i}) - Q(s, a; \theta_{i})$ to be between -1 and 1" (See "Training algorithm for deep Q-networks" under "METHODS" on page 7).
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/dqn.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/dqn.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fdqn.sh%23L8-L13&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for `dqn_atari.py`. 
+
+
+| Environment      | `dqn_atari.py` 10M steps | (Mnih et al., 2015)[^1] 50M steps | (Hessel et al., 2017, Figure 5)[^3] 
+| ----------- | ----------- | ----------- | ---- |
+| BreakoutNoFrameskip-v4      | 366.928 ± 39.89      |401.2 ± 26.9  | ~230 at 10M steps, ~300 at 50M steps
+| PongNoFrameskip-v4  | 20.25 ± 0.41     |  18.9 ± 1.3 |  ~20 10M steps, ~20 at 50M steps 
+| BeamRiderNoFrameskip-v4   | 6673.24 ± 1434.37        | 6846 ± 1619 | ~6000 10M steps, ~7000 at 50M steps 
+
+
+Note that we save computational time by reducing timesteps from 50M to 10M, but our `dqn_atari.py` scores the same or higher than (Mnih et al., 2015)[^1] in 10M steps.
+
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../dqn/BeamRiderNoFrameskip-v4.png">
+
+<img src="../dqn/BreakoutNoFrameskip-v4.png">
+
+<img src="../dqn/PongNoFrameskip-v4.png">
+</div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Atari-CleanRL-s-DQN--VmlldzoxNjk3NjYx" style="width:100%; height:500px" title="CleanRL DQN + Atari Tracked Experiments"></iframe>
+
+
+## `dqn.py`
+
+The [dqn.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn.py) has the following features:
+
+* Works with the `Box` observation space of low-level features
+* Works with the `Discrete` action space
+* Works with envs like `CartPole-v1`
+
+
+### Usage
+
+
+
+=== "poetry"
+
+    ```bash
+    uv run python cleanrl/dqn.py --env-id CartPole-v1
+    ```
+
+=== "pip"
+
+    ```bash
+    python cleanrl/dqn.py --env-id CartPole-v1
+    ```
+
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/dqn/#explanation-of-the-logged-metrics) for `dqn_atari.py`.
+
+### Implementation details
+
+The [dqn.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn.py) shares the same implementation details as [`dqn_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py) except the `dqn.py` runs with different hyperparameters and neural network architecture. Specifically,
+
+1. `dqn.py` uses a simpler neural network as follows:
+        ```python
+        self.network = nn.Sequential(
+            nn.Linear(np.array(env.single_observation_space.shape).prod(), 120),
+            nn.ReLU(),
+            nn.Linear(120, 84),
+            nn.ReLU(),
+            nn.Linear(84, env.single_action_space.n),
+        )
+        ```
+2. `dqn.py` runs with different hyperparameters:
+
+    ```bash
+    python dqn.py --total-timesteps 500000 \
+        --learning-rate 2.5e-4 \
+        --buffer-size 10000 \
+        --gamma 0.99 \
+        --target-network-frequency 500 \
+        --max-grad-norm 0.5 \
+        --batch-size 128 \
+        --start-e 1 \
+        --end-e 0.05 \
+        --exploration-fraction 0.5 \
+        --learning-starts 10000 \
+        --train-frequency 10
+    ```
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/dqn.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/dqn.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fdqn.sh%23L2-L6&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for `dqn.py`. 
+
+
+| Environment      | `dqn.py`  | 
+| ----------- | ----------- | 
+| CartPole-v1      | 488.69 ± 16.11      |
+| Acrobot-v1  | -91.54 ± 7.20     | 
+| MountainCar-v0   | -194.95 ± 8.48        | 
+
+
+Note that the DQN has no official benchmark on classic control environments, so we did not include a comparison. That said, our `dqn.py` was able to achieve near perfect scores in `CartPole-v1` and `Acrobot-v1`; further, it can obtain successful runs in the sparse environment `MountainCar-v0`.
+
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../dqn/CartPole-v1.png">
+
+<img src="../dqn/Acrobot-v1.png">
+
+<img src="../dqn/MountainCar-v0.png">
+</div>
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Classic-Control-CleanRL-s-DQN--VmlldzoxODE4Mjg1" style="width:100%; height:500px" title="CleanRL DQN Tracked Experiments"></iframe>
+
+
+
+## `dqn_atari_jax.py`
+
+
+The [dqn_atari_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari_jax.py) has the following features:
+
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [dqn_atari_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari_jax.py) is roughly 25%-50% faster than  [dqn_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py)
+* For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques.
+* Works with the Atari's pixel `Box` observation space of shape `(210, 160, 3)`
+* Works with the `Discrete` action space
+
+### Usage
+
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[atari, jax]"
+    uv pip install --upgrade "jax[cuda11_cudnn82]==0.4.8" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    uv run python cleanrl/dqn_atari_jax.py --env-id BreakoutNoFrameskip-v4
+    uv run python cleanrl/dqn_atari_jax.py --env-id PongNoFrameskip-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-atari.txt
+    pip install -r requirements/requirements-jax.txt
+    pip install --upgrade "jax[cuda]==0.3.17" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    python cleanrl/dqn_atari_jax.py --env-id BreakoutNoFrameskip-v4
+    python cleanrl/dqn_atari_jax.py --env-id PongNoFrameskip-v4
+    ```
+
+
+???+ warning
+
+    Note that JAX does not work in Windows :fontawesome-brands-windows:. The official [docs](https://github.com/google/jax#installation) recommends using Windows Subsystem for Linux (WSL) to install JAX.
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/dqn/#explanation-of-the-logged-metrics) for `dqn_atari.py`.
+
+### Implementation details
+
+See [related docs](/rl-algorithms/dqn/#implementation-details) for `dqn_atari.py`.
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/dqn.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/dqn.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fdqn.sh%23L23-L29&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+
+Below are the average episodic returns for [`dqn_atari_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari_jax.py) (3 random seeds).
+
+
+| Environment             | `dqn_atari_jax.py` 10M steps | `dqn_atari.py` 10M steps | (Mnih et al., 2015)[^1] 50M steps | (Hessel et al., 2017, Figure 5)[^3]  |
+| ----------------------- | ---------------------------- | ------------------------ | --------------------------------- | ------------------------------------ |
+| BreakoutNoFrameskip-v4  | 377.82 ± 34.91               | 366.928 ± 39.89          | 401.2 ± 26.9                      | ~230 at 10M steps, ~300 at 50M steps |
+| PongNoFrameskip-v4      | 20.43 ± 0.34                 | 20.25 ± 0.41             | 18.9 ± 1.3                        | ~20 10M steps, ~20 at 50M steps      |
+| BeamRiderNoFrameskip-v4 | 5938.13 ± 955.84             | 6673.24 ± 1434.37        | 6846 ± 1619                       | ~6000 10M steps, ~7000 at 50M steps  |
+
+
+???+ info
+    
+    We observe a speedup of `~25%` in ['dqn_atari_jax.py'](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari_jax.py) compared to ['dqn_atari.py'](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py). This could be because the training loop is tightly integrated with the experience collection loop. We run a training loop every `4` environment steps by default. So more time is utilised in collecting experience than training the network. We observe much more speed-ups in algorithms which run a training step for each environment step. E.g., [DDPG](/rl-algorithms/ddpg/#experiment-results_1)
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../dqn/jax/BeamRiderNoFrameskip-v4.png">
+<img src="../dqn/jax/BeamRiderNoFrameskip-v4-time.png">
+
+<img src="../dqn/jax/BreakoutNoFrameskip-v4.png">
+<img src="../dqn/jax/BreakoutNoFrameskip-v4-time.png">
+
+<img src="../dqn/jax/PongNoFrameskip-v4.png">
+<img src="../dqn/jax/PongNoFrameskip-v4-time.png">
+</div>
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Atari-CleanRL-s-DQN-JAX--VmlldzoyMzM3MDg1" style="width:100%; height:500px" title="CleanRL DQN + JAX + Atari Tracked Experiments"></iframe>
+
+
+
+## `dqn_jax.py`
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [dqn_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_jax.py) is roughly 50% faster than  [dqn.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn.py)
+* Works with the `Box` observation space of low-level features
+* Works with the `Discrete` action space
+* Works with envs like `CartPole-v1`
+
+### Usage
+
+```bash
+python cleanrl/dqn_jax.py --env-id CartPole-v1
+```
+
+=== "poetry"
+
+    ```bash
+    uv pip install --upgrade "jax[cuda11_cudnn82]==0.4.8" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    uv run python cleanrl/dqn_jax.py --env-id CartPole-v1
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-jax.txt
+    pip install --upgrade "jax[cuda]==0.3.17" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+    python cleanrl/dqn_jax.py --env-id CartPole-v1
+    ```
+
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/dqn/#explanation-of-the-logged-metrics) for `dqn_atari.py`.
+
+### Implementation details
+
+See [related docs](/rl-algorithms/dqn/#implementation-details_1) for `dqn.py`.
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/dqn.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/dqn.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fdqn.sh%23L15-L21&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for [`dqn_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_jax.py) (3 random seeds).
+
+
+
+| Environment    | `dqn_jax.py`   | `dqn.py`  | 
+| ----------- | ----------- | ----------- | 
+| CartPole-v1    |  498.38 ± 2.29 | 488.69 ± 16.11      |
+| Acrobot-v1 | -88.89 ± 1.56 | -91.54 ± 7.20     | 
+| MountainCar-v0 | -188.90 ± 11.78  | -194.95 ± 8.48        | 
+
+
+
+<div class="grid-container">
+<img src="../dqn/jax/CartPole-v1.png">
+<img src="../dqn/jax/CartPole-v1-time.png">
+
+<img src="../dqn/jax/Acrobot-v1.png">
+<img src="../dqn/jax/Acrobot-v1-time.png">
+
+<img src="../dqn/jax/MountainCar-v0.png">
+<img src="../dqn/jax/MountainCar-v0-time.png">
+</div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Classic-Control-CleanRL-s-DQN-JAX--VmlldzozMjM5Mjgx" style="width:100%; height:500px" title="CleanRL DQN + JAX Tracked Experiments"></iframe>
+
+
+
+
+[^1]:Mnih, V., Kavukcuoglu, K., Silver, D. et al. Human-level control through deep reinforcement learning. Nature 518, 529–533 (2015). https://doi.org/10.1038/nature14236
+[^2]:\[Proposal\] Formal API handling of truncation vs termination. https://github.com/openai/gym/issues/2510
+[^3]: Hessel, M., Modayil, J., Hasselt, H.V., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M.G., & Silver, D. (2018). Rainbow: Combining Improvements in Deep Reinforcement Learning. AAAI.

cleanrl/docs/rl-algorithms/ppg.md

@@ -0,0 +1,158 @@
+# Phasic Policy Gradient (PPG)
+
+## Overview
+
+PPG is a DRL algorithm that separates policy and value function training by introducing an auxiliary phase. The training proceeds by running PPO during the policy phase, saving all the experience in a replay buffer. Then the replay buffer is used to train the value function. This makes the algorithm considerably slower than PPO, but improves sample efficiency on Procgen benchmark.
+
+Original paper: 
+
+* [Phasic Policy Gradient](https://arxiv.org/abs/2009.04416)
+
+Reference resources:
+
+* [Code for the paper "Phasic Policy Gradient"](https://github.com/openai/phasic-policy-gradient) - by original authors from OpenAI
+
+The original code has multiple code level details that are not mentioned in the paper. We found these changes to be important for reproducing the results claimed by the paper.
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`ppg_procgen.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppg_procgen.py), :material-file-document: [docs](/rl-algorithms/ppg/#ppg_procgenpy) | For classic control tasks like `CartPole-v1`. |
+
+Below are our single-file implementations of PPG:
+
+## `ppg_procgen.py`
+
+`ppg_procgen.py` works with the Procgen benchmark, which uses 64x64 RGB image observations, and discrete actions
+
+### Usage
+
+=== "uv"
+
+    ```bash
+    uv pip install ".[procgen]"
+    uv run python cleanrl/ppg_procgen.py --help
+    uv run python cleanrl/ppg_procgen.py --env-id starpilot
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-procgen.txt
+    python cleanrl/ppg_procgen.py --help
+    python cleanrl/ppg_procgen.py --env-id starpilot
+    ```
+
+### Explanation of the logged metrics
+
+Running `python cleanrl/ppg_procgen.py` will automatically record various metrics such as actor or value losses in Tensorboard. Below is the documentation for these metrics:
+
+Same as PPO:
+
+* `charts/episodic_return`: episodic return of the game
+* `charts/episodic_length`: episodic length of the game
+* `charts/SPS`: number of steps per second (this is initially high but drops off after the auxiliary phase)
+* `charts/learning_rate`: the current learning rate (annealing is not done by default)
+* `losses/value_loss`: the mean value loss across all data points
+* `losses/policy_loss`: the mean policy loss across all data points
+* `losses/entropy`: the mean entropy value across all data points
+* `losses/old_approx_kl`: the approximate Kullback–Leibler divergence, measured by `(-logratio).mean()`, which corresponds to the k1 estimator in John Schulman’s blog post on [approximating KL](http://joschu.net/blog/kl-approx.html)
+* `losses/approx_kl`: better alternative to `olad_approx_kl` measured by `(logratio.exp() - 1) - logratio`, which corresponds to the k3 estimator in [approximating KL](http://joschu.net/blog/kl-approx.html)
+* `losses/clipfrac`: the fraction of the training data that triggered the clipped objective
+* `losses/explained_variance`: the explained variance for the value function
+
+PPG specific:
+
+* `losses/aux/kl_loss`: the mean value of the KL divergence when distilling the latest policy during the auxiliary phase.
+* `losses/aux/aux_value_loss`: the mean value loss on the auxiliary value head
+* `losses/aux/real_value_loss`: the mean value loss on the detached value head used to calculate the GAE returns during policy phase
+
+### Implementation details
+
+`ppg_procgen.py` includes the <TODO> level implementation details that are different from PPO:
+
+1. Full rollout sampling during auxiliary phase - (:material-github: [phasic_policy_gradient/ppg.py#L173](https://github.com/openai/phasic-policy-gradient/blob/c789b00be58aa704f7223b6fc8cd28a5aaa2e101/phasic_policy_gradient/ppg.py#L173)) - Instead of randomly sampling observations over the entire auxiliary buffer, PPG samples full rullouts from the buffer (Sets of 256 steps). This full rollout sampling is only done during the auxiliary phase. Note that the rollouts will still be at random starting points because PPO truncates the rollouts per env. This change gives a decent performance boost.
+
+1. Batch level advantage normalization - PPG normalizes the full batch of advantage values before PPO updates instead of advantage normalization on each minibatch. (:material-github: [phasic_policy_gradient/ppo.py#L70](https://github.com/openai/phasic-policy-gradient/blob/c789b00be58aa704f7223b6fc8cd28a5aaa2e101/phasic_policy_gradient/ppo.py#L70))
+
+1. Normalized network initialization - (:material-github: [phasic_policy_gradient/impala_cnn.py#L64](https://github.com/openai/phasic-policy-gradient/blob/c789b00be58aa704f7223b6fc8cd28a5aaa2e101/phasic_policy_gradient/impala_cnn.py#L64)) - PPG uses normalized initialization for all layers, with different scales. 
+    * Original PPO used orthogonal initialization of only the Policy head and Value heads with scale of 0.01 and 1. respectively.
+    * For PPG
+        * All weights are initialized with the default torch initialization (Kaiming Uniform)
+        * Each layer’s weights are divided by the L2 norm of the weights such that the weights of `input_channels` axis are individually normalized (axis 1 for linear layers and 1,2,3 for convolutional layers). Then the weights are multiplied by a scale factor.
+        * Scale factors for different layers
+            * Value head, Policy head, Auxiliary value head - 0.1
+            * Fully connected layer after last conv later - 1.4
+            * Convolutional layers - Approximately 0.638
+1. The Adam Optimizer's Epsilon Parameter -(:material-github: [phasic_policy_gradient/ppg.py#L239](https://github.com/openai/phasic-policy-gradient/blob/c789b00be58aa704f7223b6fc8cd28a5aaa2e101/phasic_policy_gradient/ppg.py#L239)) - Set to torch default of 1e-8 instead of 1e-5 which is used in PPO.
+1. Use the same `gamma` parameter in the `NormalizeReward` wrapper. Note that the original implementation from [openai/train-procgen](https://github.com/openai/train-procgen) uses the default `gamma=0.99` in [the `VecNormalize` wrapper](https://github.com/openai/train-procgen/blob/1a2ae2194a61f76a733a39339530401c024c3ad8/train_procgen/train.py#L43) but `gamma=0.999` as PPO's parameter. The mismatch between the `gamma`s is technically incorrect. See [#209](https://github.com/vwxyzjn/cleanrl/pull/209)
+
+Here are some additional notes:
+
+- All the default hyperparameters from the original PPG implementation are used. Except setting 64 for the number of environments.
+- The original PPG paper does not report results on easy environments, hence more hyperparameter tuning can give better results.
+- Skipping every alternate auxiliary phase gives similar performance on easy environments while saving compute.
+- Normalized network initialization scheme seems to matter a lot, but using layernorm with orthogonal initialization also works.
+- Using mixed precision for auxiliary phase also works well to save compute, but using on policy phase makes training unstable.
+
+
+Also, `ppg_procgen.py` differs from the original  `openai/phasic-policy-gradient` implementation in the following ways.
+
+- The original PPG code supports LSTM whereas the CleanRL code does not.
+- The original PPG code uses separate optimizers for policy and auxiliary phase, but we do not implement this as we found it to not make too much difference.
+- The original PPG code utilizes multiple GPUs but our implementation does not
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/ppg.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/ppg.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fppg.sh%23L3-L8&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+
+Below are the average episodic returns for `ppg_procgen.py`, and comparison with `ppg_procgen.py` on 25M timesteps.
+
+| Environment      | `ppg_procgen.py` | `ppo_procgen.py` | `openai/phasic-policy-gradient` (easy) |
+|------------------|------------------|------------------|----------------------------------------|
+| Starpilot (easy) | 34.82 ± 13.77    | 32.47 ± 11.21    | 42.01 ± 9.59                           |
+| Bossfight (easy) | 10.78 ± 1.90     | 9.63 ± 2.35      | 10.71 ± 2.05                           |
+| Bigfish (easy)   | 24.23 ± 10.73    | 16.80 ± 9.49     | 15.94 ± 10.80                          |
+
+
+???+ warning
+
+    Note that we have run the procgen experiments using the `easy` distribution for reducing the computational cost. However, the original paper's results were condcuted with the `hard` distribution mode. For convenience, in the learning curves below, we compared the performance of the original code base (`openai/phasic-policy-gradient` the purple curve) in the `easy` distribution. 
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../ppg/StarPilot.png">
+<img src="../ppg/comparison/StarPilot.png">
+
+<img src="../ppg/BossFight.png">
+<img src="../ppg/comparison/BossFight.png">
+
+<img src="../ppg/BigFish.png">
+<img src="../ppg/comparison/BigFish.png">
+</div>
+
+
+???+ info
+
+    Also note that our `ppo_procgen.py` which closely matches implementation details of `openai/baselines`' PPO which might not be the same as `openai/phasic-policy-gradient`'s PPO. We take the reported results from (Cobbe et al., 2020)[^1] and (Cobbe et al., 2021)[^2] and compared them in a [google sheet](https://docs.google.com/spreadsheets/d/1ZC_D2WPL6-PzhecM4ZFQWQ6nY6dkXeQDOIgRHVp1BNU/edit?usp=sharing) (screenshot shown below). As shown, the performance seems to diverge a bit. We also note that (Cobbe et al., 2020)[^1] used [`procgen==0.9.2`](https://github.com/openai/train-procgen/blob/1a2ae2194a61f76a733a39339530401c024c3ad8/environment.yml#L10) and (Cobbe et al., 2021)[^2] used [`procgen==0.10.4`](https://github.com/openai/phasic-policy-gradient/blob/7295473f0185c82f9eb9c1e17a373135edd8aacc/environment.yml#L10), which also could cause performance difference. It is for this reason, we ran our own `openai/phasic-policy-gradient` experiments on the `easy` distribution for comparison, but this does mean it's challenging to compare our results against those in the original PPG paper (Cobbe et al., 2021)[^2].
+
+    ![PPG's PPO compared to openai/baselines' PPO](../ppg/ppg-ppo.png)
+
+Tracked experiments and game play videos:
+
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Procgen-CleanRL-s-PPG--VmlldzoyMDc1MDMz" style="width:100%; height:500px" title="Procgen-CleanRL-s-PPG"></iframe>
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Procgen-CleanRL-s-PPG-vs-PPO-vs-openai-phasic-policy-gradient--VmlldzoyMDc1MDc3" style="width:100%; height:500px" title="Procgen-CleanRL-s-PPG-PPO-openai-phasic-policy-gradient"></iframe>
+
+
+[^1]: Cobbe, K., Hesse, C., Hilton, J., & Schulman, J. (2020, November). Leveraging procedural generation to benchmark reinforcement learning. In International conference on machine learning (pp. 2048-2056). PMLR.
+[^2]: Cobbe, K. W., Hilton, J., Klimov, O., & Schulman, J. (2021, July). Phasic policy gradient. In International Conference on Machine Learning (pp. 2020-2027). PMLR.
+

cleanrl/docs/rl-algorithms/ppo-isaacgymenvs.md

@@ -0,0 +1,259 @@
+<!--
+ SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ SPDX-License-Identifier: MIT
+
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+-->
+
+## `ppo_continuous_action_isaacgym.py`
+
+
+???+ warning
+
+    `ppo_continuous_action_isaacgym.py` is temporarily deprecated. Please checkout the code in [https://github.com/vwxyzjn/cleanrl/releases/tag/v1.0.0](https://github.com/vwxyzjn/cleanrl/releases/tag/v1.0.0)
+
+
+The [ppo_continuous_action_isaacgym.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py) has the following features:
+
+- Works with IsaacGymEnvs.
+- Works with the `Box` observation space of low-level features
+- Works with the `Box` (continuous) action space
+
+[IsaacGymEnvs](https://github.com/NVIDIA-Omniverse/IsaacGymEnvs) is a hardware-accelerated (or GPU-accelerated) robotics simulation environment based on `torch`, which allows us to run thousands of simulation environments at the same time, empowering RL agents to learn many MuJoCo-style robotics tasks in minutes instead of hours. When creating an environment with IsaacGymEnvs via `isaacgymenvs.make("Ant")`, it creates a vectorized environment which produces GPU tensors as observations and take GPU tensors as actions to execute.
+
+???+ info
+
+    Note that **Isaac Gym** is the underlying core physics engine, and **IssacGymEnvs** is a collection of environments built on Isaac Gym.
+
+???+ info
+
+    `ppo_continuous_action_isaacgym.py` works with most environments in IsaacGymEnvs but it does not work with the following environments yet:
+
+    * AnymalTerrain
+    * FrankaCabinet
+    * ShadowHandOpenAI_FF
+    * ShadowHandOpenAI_LSTM
+    * Trifinger
+    * Ingenuity Quadcopter
+
+    🔥 we need contributors to work on supporting and tuning our PPO implementation in these envs. If you are interested, please read our [contribution guide](https://github.com/vwxyzjn/cleanrl/blob/master/CONTRIBUTING.md) and reach out!
+
+### Usage
+
+The installation of `isaacgym` requires a bit of work since it's not a standard Python package.
+
+Please go to [https://developer.nvidia.com/isaac-gym](https://developer.nvidia.com/isaac-gym) to download and install the latest version of Issac Gym which should look like `IsaacGym_Preview_4_Package.tar.gz`. Put this `IsaacGym_Preview_4_Package.tar.gz` into the `~/Downloads/` folder. Make sure your python version is either 3.7, or 3.8 (3.9 _not_ supported yet).
+
+```bash
+# extract and move the content in `python` folder in the IsaacGym_Preview_4_Package.tar.gz
+# into the `cleanrl/ppo_continuous_action_isaacgym/isaacgym/` folder
+cp ~/Downloads/IsaacGym_Preview_4_Package.tar.gz IsaacGym_Preview_4_Package.tar.gz 
+stat IsaacGym_Preview_4_Package.tar.gz
+mkdir temp_isaacgym
+tar -xf IsaacGym_Preview_4_Package.tar.gz -C temp_isaacgym
+mv temp_isaacgym/isaacgym/python/* cleanrl/ppo_continuous_action_isaacgym/isaacgym
+rm -rf temp_isaacgym
+
+# if your global python version is not either 3.7 nor 3.8, you need to tell poetry specifically to use a 3.7 or 3.8 python
+# e.g., `poetry env use /home/costa/.pyenv/versions/3.7.8/bin/python`
+poetry install --with isaacgym
+# if you are using NVIDIA's 30xx GPU, you need to specifically install cuda 11.3 wheels
+# `uv pip install torch --upgrade --extra-index-url https://download.pytorch.org/whl/cu113`
+uv run python cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py --help
+uv run python cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py --env-id Ant
+```
+
+<script id="asciicast-510341" src="https://asciinema.org/a/510341.js" async></script>
+
+
+???+ warning
+
+    If you encounter the following installation error
+    
+    ```bash
+    Python.h: No such file or directory
+    #include <Python.h>
+    ```
+
+    or 
+
+    ```bash
+    libpython3.8.so.1.0: cannot open shared object file: No such file or directory
+    ```
+
+    It usually means your python distribution does not include the shared library files. If you are ubuntu, you can install the following packages:
+    
+    ```bash
+    sudo apt-get install libpython3.8-dev # or sudo apt-get install libpython3.7-dev
+    ```
+
+    If you are using [pyenv](https://github.com/pyenv/pyenv), you may try the following:
+    
+    ```bash
+    env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.7.8
+    ```
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/ppo/#explanation-of-the-logged-metrics) for `ppo.py`.
+
+Additionally, `charts/consecutive_successes` means the number of consecutive episodes that the agent has successfully manipulating the rubix cube to the desired state.
+
+### Implementation details
+
+[ppo_continuous_action_isaacgym.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py) is based on `ppo_continuous_action.py` (see related [docs](/rl-algorithms/ppo/#ppo_continuous_actionpy)), with a few modifications:
+
+1. **Different set of hyperparameters**: `ppo_continuous_action_isaacgym.py` uses hyperparameters primarily derived from [rl-games](https://github.com/Denys88/rl_games)' configuration (see [example](https://github.com/NVIDIA-Omniverse/IsaacGymEnvs/blob/main/isaacgymenvs/cfg/train/AntPPO.yaml)). The basic spirit is to run more `total_timesteps`, with larger `num_envs` and smaller `num_steps`.
+
+| arguments         | `ppo_continuous_action.py` | `ppo_continuous_action_isaacgym.py` | `ppo_continuous_action_isaacgym.py` (for `ShadowHand` and `AllegroHand`) |
+| ----------------- | -------------------------- | ----------------------------------- | ----------------------------------- |
+| --total-timesteps | 1000000                    | 30000000                            | 600000000                           |
+| --learning-rate   | 3e-4                       | 0.0026                              | 0.0026                              |
+| --num-envs        | 1                          | 4096                                | 8192                                |
+| --num-steps       | 2048                       | 16                                  | 8                                   |
+| --anneal-lr       | True                       | False                               | False                               |
+| --num-minibatches | 32                         | 2                                   | 4                                   |
+| --update-epochs   | 10                         | 4                                   | 5                                   |
+| --clip-vloss      | True                       | False                               | False                               |
+| --vf-coef         | 0.5                        | 2                                   | 2                                   |
+| --max-grad-norm   | 0.5                        | 1                                   | 1                                   |
+| --reward-scaler   | N/A                        | 1                                   | 0.01                                |
+
+1. **Slightly larger NN**: `ppo_continuous_action.py` uses the following NN:
+   ```python
+   self.critic = nn.Sequential(
+       layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)),
+       nn.Tanh(),
+       layer_init(nn.Linear(64, 64)),
+       nn.Tanh(),
+       layer_init(nn.Linear(64, 1), std=1.0),
+   )
+   self.actor_mean = nn.Sequential(
+       layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)),
+       nn.Tanh(),
+       layer_init(nn.Linear(64, 64)),
+       nn.Tanh(),
+       layer_init(nn.Linear(64, np.prod(envs.single_action_space.shape)), std=0.01),
+   )
+   ```
+   while `ppo_continuous_action_isaacgym.py` uses the following NN:
+   ```python
+   self.critic = nn.Sequential(
+       layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+       nn.Tanh(),
+       layer_init(nn.Linear(256, 256)),
+       nn.Tanh(),
+       layer_init(nn.Linear(256, 1), std=1.0),
+   )
+   self.actor_mean = nn.Sequential(
+       layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+       nn.Tanh(),
+       layer_init(nn.Linear(256, 256)),
+       nn.Tanh(),
+       layer_init(nn.Linear(256, np.prod(envs.single_action_space.shape)), std=0.01),
+   )
+   ```
+1. **No normalization and clipping**: `ppo_continuous_action_isaacgym.py` does _not_ do observation and reward normalization and clipping for simplicity. It does however optionally offer an option to scale the rewards via `--reward-scaler x`, which multiplies all the rewards obtained by `x` as an example.
+1. **Remove all CPU-related code**: `ppo_continuous_action_isaacgym.py` needs to remove all CPU-related code (e.g. `action.cpu().numpy()`). This is because almost everything in IsaacGymEnvs happens in GPU. To do this, the major modifications include the following:
+   1. Create a custom `RecordEpisodeStatisticsTorch` wrapper that records statstics using GPU tensors instead of `numpy` arrays.
+   1. Avoid transferring the tensors to CPU. The related code in `ppo_continuous_action.py` looks like
+   ```python
+   next_obs, reward, done, info = envs.step(action.cpu().numpy())
+   rewards[step] = torch.tensor(reward).to(device).view(-1)
+   next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(done).to(device)
+   ```
+   and the related code in `ppo_continuous_action_isaacgym.py` looks like
+   ```python
+   next_obs, rewards[step], next_done, info = envs.step(action)
+   ```
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/ppo.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/ppo.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Fppo.sh%23L61-L73&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+Below are the average episodic returns for `ppo_continuous_action_isaacgym.py`. To ensure the quality of the implementation, we compared the results against [Denys88/rl_games](https://github.com/Denys88/rl_games)' PPO and present the training time (units being `s (seconds), m (minutes)`). The hardware used is a NVIDIA RTX A6000 in a 24 core machine.
+
+| Environment (training time) | `ppo_continuous_action_isaacgym.py` | [Denys88/rl_games](https://github.com/Denys88/rl_games) |
+| --------------------------- | ----------------------------------- | ------------------------------------------------------- |
+| Cartpole (40s)              | 413.66 ± 120.93                     | 417.49 (30s)                                            |
+| Ant (240s)                  | 3953.30 ± 667.086                   | 5873.05                                                 |
+| Humanoid (350s)             | 2987.95 ± 257.60                    | 6254.73                                                 |
+| Anymal (317s)               | 29.34 ± 17.80                       | 62.76                                                   |
+| BallBalance (160s)          | 161.92 ± 89.20                      | 319.76                                                  |
+| AllegroHand (200m)          | 762.93 ± 427.92                     | 3479.85                                                 |
+| ShadowHand (130m)           | 427.16 ± 161.79                     | 5713.74                                                 |
+
+Learning curves:
+
+<div class="grid-container">
+<img src="../ppo/isaacgymenvs/Cartpole.png">
+<img src="../ppo/isaacgymenvs/Cartpole-time.png">
+<img src="../ppo/isaacgymenvs/Ant.png">
+<img src="../ppo/isaacgymenvs/Ant-time.png">
+<img src="../ppo/isaacgymenvs/Humanoid.png">
+<img src="../ppo/isaacgymenvs/Humanoid-time.png">
+<img src="../ppo/isaacgymenvs/BallBalance.png">
+<img src="../ppo/isaacgymenvs/BallBalance-time.png">
+<img src="../ppo/isaacgymenvs/Anymal.png">
+<img src="../ppo/isaacgymenvs/Anymal-time.png">
+<img src="../ppo/isaacgymenvs/AllegroHand.png">
+<img src="../ppo/isaacgymenvs/AllegroHand-time.png">
+<img src="../ppo/isaacgymenvs/AllegroHand-c.png">
+<img src="../ppo/isaacgymenvs/AllegroHand-c-time.png">
+<img src="../ppo/isaacgymenvs/ShadowHand.png">
+<img src="../ppo/isaacgymenvs/ShadowHand-time.png">
+<img src="../ppo/isaacgymenvs/ShadowHand-c.png">
+<img src="../ppo/isaacgymenvs/ShadowHand-c-time.png">
+</div>
+
+???+ info
+
+    Note `ppo_continuous_action_isaacgym.py`'s performance seems poor compared to [Denys88/rl_games](https://github.com/Denys88/rl_games)' PPO. This is likely due to a few reasons.
+
+    1. [Denys88/rl_games](https://github.com/Denys88/rl_games)' PPO uses different sets of tuned hyperparameters  and neural network architecture configuration for different tasks, whereas `ppo_continuous_action_isaacgym.py` only uses one neural network architecture and 2 set of hyperparameters (ignoring `--total-timesteps`).
+    1. `ppo_continuous_action_isaacgym.py` does not use observation normalization (because in my preliminary testing for some reasons it did not help).
+
+    While it should be possible to obtain higher scores with more tuning, the purpose of `ppo_continuous_action_isaacgym.py` is to hit a balance between simplicity and performance. I think `ppo_continuous_action_isaacgym.py` has relatively good performance with a concise codebase, which should be easy to modify and extend for practitioners.
+
+
+Tracked experiments and game play videos:
+
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/Isaac-Gym-CleanRL-s-PPO--VmlldzoyMzQzNzMz" style="width:100%; height:500px" title="Isaac-Gym-CleanRL-s-PPO"></iframe>
+
+
+Old Learning curves w/ Isaac Gym Preview 3 (no longer available in Nvidia's website for download):
+
+<div class="grid-container">
+<img src="../ppo/isaacgymenvs/old/Cartpole.png">
+<img src="../ppo/isaacgymenvs/old/Ant.png">
+<img src="../ppo/isaacgymenvs/old/Humanoid.png">
+<img src="../ppo/isaacgymenvs/old/BallBalance.png">
+<img src="../ppo/isaacgymenvs/old/Anymal.png">
+<img src="../ppo/isaacgymenvs/old/AllegroHand.png">
+<img src="../ppo/isaacgymenvs/old/ShadowHand.png">
+</div>
+
+???+ info
+
+    Note the `AllegroHand` and `ShadowHand` experiments used the following command `ppo_continuous_action_isaacgym.py --track --capture_video --num-envs 16384 --num-steps 8 --update-epochs 5 --reward-scaler 0.01 --total-timesteps 600000000 --record-video-step-frequency 3660`. Costa: I was able to run this during my internship at NVIDIA, but in my home setup, the computer has less GPU memory which makes it hard to replicate the results w/ `--num-envs 16384`.
+
+

cleanrl/docs/rl-algorithms/ppo-rnd.md

@@ -0,0 +1,111 @@
+# Random Network Distillation (RND)
+
+
+## Overview
+
+RND is an exploration bonus for RL methods that's easy to implement and enables significant progress in some hard exploration Atari games such as Montezuma's Revenge. We use [Proximal Policy Gradient](/rl-algorithms/ppo/#ppopy) as our RL method as used by original paper's [implementation](https://github.com/openai/random-network-distillation)
+
+
+Original paper: 
+
+* [Exploration by Random Network Distillation](https://arxiv.org/abs/1810.12894)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`ppo_rnd_envpool.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_rnd_envpool.py), :material-file-document: [docs](/rl-algorithms/ppo-rnd/#ppo_rnd_envpoolpy) | For Atari games, uses EnvPool. |
+
+
+Below are our single-file implementations of RND:
+
+## `ppo_rnd_envpool.py`
+
+The [ppo_rnd_envpool.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_rnd_envpool.py) has the following features:
+
+* Uses the blazing fast [Envpool](https://github.com/sail-sg/envpool) vectorized environment.
+* For playing Atari games. It uses convolutional layers and common atari-based pre-processing techniques.
+* Works with the Atari's pixel `Box` observation space of shape `(210, 160, 3)`
+* Works with the `Discerete` action space
+
+???+ warning
+
+    Note that `ppo_rnd_envpool.py` does not work in Windows :fontawesome-brands-windows: and MacOs :fontawesome-brands-apple:. See envpool's built wheels here: [https://pypi.org/project/envpool/#files](https://pypi.org/project/envpool/#files)
+
+???+ bug
+
+    EnvPool's vectorized environment **does not behave the same** as gym's vectorized environment, which causes a compatibility bug in our PPO implementation. When an action $a$ results in an episode termination or truncation, the environment generates $s_{last}$ as the terminated or truncated state; we then use $s_{new}$ to denote the initial state of the new episodes. Here is how the bahviors differ:
+
+    * Under the vectorized environment of `envpool<=0.6.4`, the `obs` in `obs, reward, done, info = env.step(action)` is the truncated state $s_{last}$
+    * Under the vectorized environment of `gym==0.23.1`, the `obs` in `obs, reward, done, info = env.step(action)` is the initial state $s_{new}$.
+
+    This causes the $s_{last}$ to be off by one. 
+    See [:material-github: sail-sg/envpool#194](https://github.com/sail-sg/envpool/issues/194) for more detail. However, it does not seem to impact performance, so we take a note here and await for the upstream fix.
+
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[envpool]"
+    uv run python cleanrl/ppo_rnd_envpool.py --help
+    uv run python cleanrl/ppo_rnd_envpool.py --env-id MontezumaRevenge-v5
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-envpool.txt
+    python cleanrl/ppo_rnd_envpool.py --help
+    python cleanrl/ppo_rnd_envpool.py --env-id MontezumaRevenge-v5
+    ```
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/ppo/#explanation-of-the-logged-metrics) for `ppo.py`.
+Below is the additional metric for RND:
+
+* `charts/episode_curiosity_reward`: episodic intrinsic rewards.
+* `losses/fwd_loss`: the prediction error between predict network and target network, can also be viewed as a proxy of the curiosity reward in that batch.
+
+### Implementation details
+
+[ppo_rnd_envpool.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_rnd_envpool.py) uses a customized `RecordEpisodeStatistics` to work with envpool but has the same other implementation details as `ppo_atari.py` (see [related docs](/rl-algorithms/ppo/#implementation-details_1)). Additionally, it has the following additional details:
+
+1. We initialize the normalization parameters by stepping a random agent in the environment by `args.num_steps * args.num_iterations_obs_norm_init`. `args.num_iterations_obs_norm_init=50` comes from the [original implementation](https://github.com/openai/random-network-distillation/blob/f75c0f1efa473d5109d487062fd8ed49ddce6634/run_atari.py#L69).
+1. We uses sticky action from [envpool](https://envpool.readthedocs.io/en/latest/env/atari.html?highlight=repeat_action_probability%20#options) to facilitate the exploration like done in the [original implementation](https://github.com/openai/random-network-distillation/blob/f75c0f1efa473d5109d487062fd8ed49ddce6634/atari_wrappers.py#L204).
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/rnd.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/rnd.sh). Specifically, execute the following command:
+
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Frnd.sh%23L3-L8&style=github&type=code&showBorder=on&showLineNumbers=on&showFileMeta=on&showFullPath=on&showCopy=on"></script>
+
+Below are the average episodic returns for `ppo_rnd_envpool.py`. To ensure the quality of the implementation, we compared the results against `openai/random-network-distillation`' PPO.
+
+| Environment      | `ppo_rnd_envpool.py` | (Burda et al., 2019, Figure 7)[^1] 2000M steps
+| ----------- | ----------- | ----------- |
+| MontezumaRevengeNoFrameSkip-v4      | 7100 (1 seed)    | 8152 (3 seeds)  |
+
+Note the MontezumaRevengeNoFrameSkip-v4 has same setting to MontezumaRevenge-v5.
+Our benchmark has one seed due to limited compute resource and extreme long run time (~250 hours).
+
+
+Learning curves:
+
+<div class="grid-container">
+    <img src="../ppo-rnd/MontezumaRevenge-v5.png">
+    <img src="../ppo-rnd/MontezumaRevenge-v5-time.png">
+</div>
+
+<div></div>
+
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/-MontezumaRevenge-CleanRL-s-PPO-RND--VmlldzoyNTIyNjc5" style="width:100%; height:1200px" title="MontezumaRevenge: CleanRL's PPO + RND"></iframe>
+
+
+[^1]:Burda, Yuri, et al. "Exploration by random network distillation." Seventh International Conference on Learning Representations. 2019.

cleanrl/docs/rl-algorithms/ppo-trxl.md

@@ -0,0 +1,184 @@
+# Tranformer-XL (PPO-TrXL)
+
+## Overview
+
+Real-world tasks may expose imperfect information (e.g. partial observability). Such tasks require an agent to leverage memory capabilities. One way to do this is to use recurrent neural networks (e.g. LSTM) as seen in :material-github: [`ppo_atari_lstm.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_atari_lstm.py), :material-file-document: [docs](/rl-algorithms/ppo/#ppo_atari_lstmpy). Here, Transformer-XL is used as episodic memory in Proximal Policy Optimization (PPO).
+
+Original Paper and Implementation
+
+* :material-file-document: [Memory Gym: Towards Endless Tasks to Benchmark Memory Capabilities of Agents](https://arxiv.org/abs/2309.17207)
+* :material-github: [neroRL](https://github.com/MarcoMeter/neroRL)
+* :material-github:  [Episodic Transformer Memory PPO](https://github.com/MarcoMeter/episodic-transformer-memory-ppo)
+* :material-github: [Endless Memory Gym](https://github.com/MarcoMeter/endless-memory-gym)
+* :material-play-circle: [Interactive Visualizations of Trained Agents](https://marcometer.github.io/)
+
+Related Publications and Repositories
+
+* :material-file-document: [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context](https://arxiv.org/abs/1901.02860)
+* :material-file-document: [Stabilizing Transformers for Reinforcement Learning](https://arxiv.org/abs/1910.06764)
+* :material-file-document: [Towards mental time travel: a hierarchical memory for reinforcement learning agents](https://arxiv.org/abs/2105.14039)
+* :material-file-document: [Grounded Language Learning Fast and Slow](https://arxiv.org/abs/2009.01719)
+* :material-github: [transformerXL_PPO_JAX](https://github.com/Reytuag/transformerXL_PPO_JAX)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`ppo_trxl.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_trxl/ppo_trxl.py), :material-file-document: [docs](/rl-algorithms/ppo-trxl#ppo_trxlpy) | For training on tasks like `Endless-MortarMayhem-v0`. |
+
+Below is our single-file implementation of PPO-TrXL:
+
+## `ppo_trxl.py`
+
+`ppo_trxl.py` has the following features:
+
+* Works with Memory Gym's environments (84x84 RGB image observation).
+* Works with Minigrid Memory (84x84 RGB image observation).
+* Works also with environments exposing only game state vector observations (e.g. Proof of Memory Environment).
+* Works with just single or multi-discrete action spaces.
+
+### Usage
+
+As the recommended way, the requirements default to PyTorch's CUDA packages.
+
+=== "poetry"
+
+    ```bash
+    cd cleanrl/ppo_trxl
+    poetry install
+    uv run python ppo_trxl.py --help
+    uv run python ppo_trxl.py --env-id Endless-MortarMayhem-v0
+    ```
+  
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-memory_gym.txt
+    python cleanrl/ppo_trxl/ppo_trxl.py --help
+    python cleanrl/ppo_trxl/ppo_trxl.py --env-id Endless-MortarMayhem-v0
+    ```
+
+### Explanation of the logged metrics
+
+* `episode/r_mean`: mean of the episodic return of the game
+* `episode/l_mean`: mean of the episode length of the game in steps
+* `episode/t_mean`: mean of the episode duration of the game in seconds
+* `episode/advantage_mean`: mean of all computed advantages
+* `episode/value_mean`: mean of all approximated values
+* `charts/SPS`: number of steps per second
+* `charts/learning_rate`: the current learning rate
+* `charts/entropy_coefficient`: the current entropy coefficient
+* `losses/value_loss`: the mean value loss across all data points
+* `losses/policy_loss`: the mean policy loss across all data points
+* `losses/entropy`: the mean entropy value across all data points
+* `losses/reconstruction_loss`: the mean observation reconstruction loss value across all data points
+* `losses/loss`: the mean of all summed losses across all data points
+* `losses/old_approx_kl`: the approximate Kullback–Leibler divergence, measured by `(-logratio).mean()`, which corresponds to the k1 estimator in John Schulman’s blog post on [approximating KL](http://joschu.net/blog/kl-approx.html)
+* `losses/approx_kl`: better alternative to `olad_approx_kl` measured by `(logratio.exp() - 1) - logratio`, which corresponds to the k3 estimator in [approximating KL](http://joschu.net/blog/kl-approx.html)
+* `losses/clipfrac`: the fraction of the training data that triggered the clipped objective
+* `losses/explained_variance`: the explained variance for the value function
+
+### Implementation details
+
+Most details are derived from [`ppo.py`](/rl-algorithms/ppo#ppopy). These are additional or differing details:
+
+1. The policy and value function share parameters.
+2. Multi-head attention is implemented so that all heads share parameters.
+3. Absolute positional encoding is used as default. Learned positional encodings are supported.
+4. Previously computed hidden states of the TrXL layers are cached and reused for up to `trxl_memory_length`. Only 1 hidden state is computed anew.
+5. TrXL layers adhere to pre-layer normalization.
+6. Support for multi-discrete action spaces.
+7. Support for an auxiliary observation reconstruction loss, which reconstructs TrXL's output to the fed visual observation.
+8. The learning rate and the entropy bonus coefficient linearly decay until reaching a lower threshold.
+
+### Experiment results
+
+Note: When training on potentially endless episodes, the cached hidden states demand a large GPU memory. To reproduce the following experiments a minimum of 40GB is required. One workaround is to cache the hidden states in the buffer with lower precision as bfloat16. This is under examination for future updates.
+
+|                              | PPO-TrXL    |
+|:-----------------------------|:------------|
+| MortarMayhem-Grid-v0         | 0.99 ± 0.00 |
+| MortarMayhem-v0              | 0.99 ± 0.00 |
+| Endless-MortarMayhem-v0      | 1.50 ± 0.02 |
+| MysteryPath-Grid-v0          | 0.97 ± 0.01 |
+| MysteryPath-v0               | 1.67 ± 0.02 |
+| Endless-MysteryPath-v0       | 1.84 ± 0.06 |
+| SearingSpotlights-v0         | 1.11 ± 0.08 |
+| Endless-SearingSpotlights-v0 | 1.60 ± 0.03 |
+
+Learning curves:
+
+
+<img src="../ppo-trxl/compare.png">
+
+
+Tracked experiments:
+
+<iframe src="https://api.wandb.ai/links/m-pleines/wo9m43hv" style="width:100%; height:500px" title="CleanRL-s-PPO-TrXL"></iframe>
+
+
+### Hyperparameters
+
+Memory Gym Environments
+
+Please refer to the defaults in [`ppo_trxl.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_trxl/ppo_trxl.py) and the single modifications as found in [`benchmark/ppo_trxl.sh`](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/ppo_trxl.sh)
+
+ProofofMemory-v0
+```bash
+uv run python ppo_trxl.py \
+  --env_id ProofofMemory-v0 \
+  --total_timesteps 25000 \
+  --num_envs 16 \
+  --num_steps 128 \
+  --num_minibatches 8 \
+  --update_epochs 4 \
+  --trxl_num_layers 4 \
+  --trxl_num_heads 1 \
+  --trxl_dim 64 \
+  --trxl_memory_length 16 \
+  --trxl_positional_encoding none \
+  --vf_coef 0.1 \
+  --max_grad_norm 0.5 \
+  --init_lr 3.0e-4 \
+  --init_ent_coef 0.001 \
+  --clip_coef 0.2
+```
+
+MiniGrid-MemoryS9-v0
+```bash
+uv run python ppo_trxl.py \
+  --env_id MiniGrid-MemoryS9-v0 \
+  --total_timesteps 2048000 \
+  --num_envs 16 \
+  --num_steps 256 \
+  --trxl_num_layers 2 \
+  --trxl_num_heads 4 \
+  --trxl_dim 256 \
+  --trxl_memory_length 64 \
+  --max_grad_norm 0.25 \
+  --anneal_steps 4096000
+  --clip_coef 0.2
+```
+
+### Enjoy pre-trained models
+
+Use [`cleanrl/ppo_trxl/enjoy.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_trxl/enjoy.py) to watch pre-trained agents.
+You can retrieve pre-trained models from [huggingface](https://huggingface.co/LilHairdy/cleanrl_memory_gym).
+Note that Memory Gym environments are usually rendered using the `debug_rgb_array` render mode, which shows ground truth information about the current task that the agent cannot observe.
+
+
+Run models from the hub:
+```bash
+python cleanrl/ppo_trxl/enjoy.py --hub --name Endless-MortarMayhem-v0_12.nn
+python cleanrl/ppo_trxl/enjoy.py --hub --name Endless-MysterPath-v0_11.nn
+python cleanrl/ppo_trxl/enjoy.py --hub --name Endless-SearingSpotlights-v0_30.nn
+python cleanrl/ppo_trxl/enjoy.py --hub --name MiniGrid-MemoryS9-v0_10.nn
+python cleanrl/ppo_trxl/enjoy.py --hub --name ProofofMemory-v0_1.nn
+```
+
+
+Run local models (or download them from the hub manually):
+```bash
+python cleanrl/ppo_trxl/enjoy.py --name Your.cleanrl_model
+```

cleanrl/docs/rl-algorithms/ppo/ppo_atari_envpool_xla_jax/atari_hns.md

@@ -0,0 +1,59 @@
+| Environment         |   CleanRL ppo_atari_envpool_xla_jax.py |   openai/baselines' PPO |
+|:--------------------|---------------------------------------:|------------------------:|
+| Alien-v5            |                            0.219853    |             0.191542    |
+| Amidar-v5           |                            0.356735    |             0.315461    |
+| Assault-v5          |                           10.6075      |             7.36794     |
+| Asterix-v5          |                            0.377642    |             0.39187     |
+| Asteroids-v5        |                            0.0203601   |             0.0160295   |
+| Atlantis-v5         |                          242.083       |           190.667       |
+| BankHeist-v5        |                            1.59491     |             1.59851     |
+| BattleZone-v5       |                            0.648278    |             0.51552     |
+| BeamRider-v5        |                            0.125822    |             0.143463    |
+| Berzerk-v5          |                            0.382584    |             0.304512    |
+| Bowling-v5          |                            0.152385    |             0.284618    |
+| Boxing-v5           |                            7.66295     |             7.77164     |
+| Breakout-v5         |                           14.9339      |            13.4441      |
+| Centipede-v5        |                            0.0825898   |             0.160915    |
+| ChopperCommand-v5   |                            0.721451    |             0.0186007   |
+| CrazyClimber-v5     |                            4.2051      |             4.0279      |
+| Defender-v5         |                            3.07092     |             2.98276     |
+| DemonAttack-v5      |                           12.465       |             6.60937     |
+| DoubleDunk-v5       |                            4.56009     |             4.36364     |
+| Enduro-v5           |                            1.4675      |             1.23315     |
+| FishingDerby-v5     |                            2.13815     |             2.1809      |
+| Freeway-v5          |                            1.1185      |             1.11205     |
+| Frostbite-v5        |                            0.196544    |             0.201265    |
+| Gopher-v5           |                            5.1566      |             1.22603     |
+| Gravitar-v5         |                            0.304855    |             0.21953     |
+| Hero-v5             |                            0.792007    |             0.837516    |
+| IceHockey-v5        |                            0.519077    |             0.535946    |
+| Jamesbond-v5        |                            1.73523     |             1.78046     |
+| Kangaroo-v5         |                            2.4236      |             1.2536      |
+| Krull-v5            |                            7.29433     |             6.62758     |
+| KungFuMaster-v5     |                            1.17164     |             1.28383     |
+| MontezumaRevenge-v5 |                            5.05722e-05 |             0           |
+| MsPacman-v5         |                            0.324235    |             0.271832    |
+| NameThisGame-v5     |                            0.547252    |             0.594366    |
+| Phoenix-v5          |                            2.04392     |             1.22382     |
+| Pitfall-v5          |                            0.0342621   |             0.0340544   |
+| Pong-v5             |                            1.16173     |             1.16443     |
+| PrivateEye-v5       |                            0.00107307  |            -5.30276e-05 |
+| Qbert-v5            |                            1.22388     |             1.06233     |
+| Riverraid-v5        |                            0.440997    |             0.502486    |
+| RoadRunner-v5       |                            2.46769     |             5.14629     |
+| Robotank-v5         |                            1.36598     |             1.42268     |
+| Seaquest-v5         |                            0.0276666   |             0.040157    |
+| Skiing-v5           |                            0.189151    |             0.250475    |
+| Solaris-v5          |                            0.100747    |             0.0768074   |
+| SpaceInvaders-v5    |                            0.666901    |             0.571875    |
+| StarGunner-v5       |                            5.51553     |             4.198       |
+| Surround-v5         |                            0.427541    |             0.237518    |
+| Tennis-v5           |                            0.564862    |             0.908756    |
+| TimePilot-v5        |                            1.59937     |             1.32888     |
+| Tutankham-v5        |                            1.45338     |             1.19416     |
+| UpNDown-v5          |                           38.4992      |            11.5527      |
+| Venture-v5          |                            0           |             0.097076    |
+| VideoPinball-v5     |                           18.9358      |            11.7083      |
+| WizardOfWor-v5      |                            1.35567     |             1.0638      |
+| YarsRevenge-v5      |                            1.04117     |             0.0999445   |
+| Zaxxon-v5           |                            0.654571    |             0.694391    |

cleanrl/docs/rl-algorithms/ppo/ppo_atari_envpool_xla_jax/atari_returns.md

@@ -0,0 +1,59 @@
+| Environment         |   CleanRL ppo_atari_envpool_xla_jax.py |   openai/baselines' PPO |
+|:--------------------|---------------------------------------:|------------------------:|
+| Alien-v5            |                         1744.76        |          1549.42        |
+| Amidar-v5           |                          617.137       |           546.406       |
+| Assault-v5          |                         5734.04        |          4050.78        |
+| Asterix-v5          |                         3341.9         |          3459.9         |
+| Asteroids-v5        |                         1669.3         |          1467.19        |
+| Atlantis-v5         |                            3.92929e+06 |             3.09748e+06 |
+| BankHeist-v5        |                         1192.68        |          1195.34        |
+| BattleZone-v5       |                        24937.9         |         20314.3         |
+| BeamRider-v5        |                         2447.84        |          2740.02        |
+| Berzerk-v5          |                         1082.72        |           887.019       |
+| Bowling-v5          |                           44.0681      |            62.2634      |
+| Boxing-v5           |                           92.0554      |            93.3596      |
+| Breakout-v5         |                          431.795       |           388.891       |
+| Centipede-v5        |                         2910.69        |          3688.16        |
+| ChopperCommand-v5   |                         5555.84        |           933.333       |
+| CrazyClimber-v5     |                       116114           |        111675           |
+| Defender-v5         |                        51439.2         |         50045.1         |
+| DemonAttack-v5      |                        22824.8         |         12173.9         |
+| DoubleDunk-v5       |                           -8.56781     |            -9           |
+| Enduro-v5           |                         1262.79        |          1061.12        |
+| FishingDerby-v5     |                           21.6222      |            23.8876      |
+| Freeway-v5          |                           33.1075      |            32.9167      |
+| Frostbite-v5        |                          904.346       |           924.5         |
+| Gopher-v5           |                        11369.6         |          2899.57        |
+| Gravitar-v5         |                         1141.95        |           870.755       |
+| Hero-v5             |                        24628.3         |         25984.5         |
+| IceHockey-v5        |                           -4.91917     |            -4.71505     |
+| Jamesbond-v5        |                          504.105       |           516.489       |
+| Kangaroo-v5         |                         7281.59        |          3791.5         |
+| Krull-v5            |                         9384.7         |          8672.95        |
+| KungFuMaster-v5     |                        26594.5         |         29116.1         |
+| MontezumaRevenge-v5 |                            0.240385    |             0           |
+| MsPacman-v5         |                         2461.62        |          2113.44        |
+| NameThisGame-v5     |                         5442.67        |          5713.89        |
+| Phoenix-v5          |                        14008.5         |          8693.21        |
+| Pitfall-v5          |                           -0.0801282   |            -1.47059     |
+| Pong-v5             |                           20.309       |            20.4043      |
+| PrivateEye-v5       |                           99.5283      |            21.2121      |
+| Qbert-v5            |                        16430.7         |         14283.4         |
+| Riverraid-v5        |                         8297.21        |          9267.48        |
+| RoadRunner-v5       |                        19342.2         |         40325           |
+| Robotank-v5         |                           15.45        |            16           |
+| Seaquest-v5         |                         1230.02        |          1754.44        |
+| Skiing-v5           |                       -14684.3         |        -13901.7         |
+| Solaris-v5          |                         2353.62        |          2088.12        |
+| SpaceInvaders-v5    |                         1162.16        |          1017.65        |
+| StarGunner-v5       |                        53535.9         |         40906           |
+| Surround-v5         |                           -2.94558     |            -6.08095     |
+| Tennis-v5           |                          -15.0446      |            -9.71429     |
+| TimePilot-v5        |                         6224.87        |          5775.53        |
+| Tutankham-v5        |                          238.419       |           197.929       |
+| UpNDown-v5          |                       430177           |        129459           |
+| Venture-v5          |                            0           |           115.278       |
+| VideoPinball-v5     |                        42975.3         |         32777.4         |
+| WizardOfWor-v5      |                         6247.83        |          5024.03        |
+| YarsRevenge-v5      |                        56696.7         |          8238.44        |
+| Zaxxon-v5           |                         6015.8         |          6379.79        |

cleanrl/docs/rl-algorithms/rpo.md

@@ -0,0 +1,389 @@
+# Robust Policy Optimization (RPO)
+
+## Overview
+
+RPO leverages a method of perturbing the distribution representing actions. The goal is to encourage high-entropy actions and provide a better representation of the action space. The method consists of a simple modification on top of the objective of the PPO algorithm. In the RPO algorithm, the mean of the action distribution is perturbed using a random number drawn from a Uniform distribution.
+
+Original paper: 
+
+* [Robust Policy Optimization in Deep Reinforcement Learning](https://arxiv.org/abs/2212.07536)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`rpo_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/rpo_continuous_action.py), :material-file-document: [docs](/rl-algorithms/rpo/#rpo_continuous_actionpy) | For classic control tasks like Gym `Pendulum-v1`, and dm_control. |
+
+Below are our single-file implementations of RPO:
+
+## `rpo_continuous_action.py`
+
+`rpo_continuous_action.py` works with Gym (Gymnasium), dm_control, Mujoco environments with continuous action and vector observations.
+
+The [rpo_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/rpo_continuous_action.py) has the following features (similar to [ppo_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo_continuous_action.py)):
+
+* For continuous action space. Also implemented Mujoco-specific code-level optimizations
+* Works with the `Box` observation space of low-level features
+* Works with the `Box` (continuous) action space
+* adding experimental support for [Gymnasium](https://gymnasium.farama.org/)
+* 🧪 support `dm_control` environments via [Shimmy](https://github.com/Farama-Foundation/Shimmy)
+
+### Usage
+
+```bash
+# mujoco v4 environments
+uv pip install ".[mujoco]"
+python cleanrl/rpo_continuous_action.py --help
+python cleanrl/rpo_continuous_action.py --env-id Walker2d-v4
+# NOTE: we recommend using --rpo-alpha 0.01 for Ant Hopper InvertedDoublePendulum Reacher Pusher
+python cleanrl/rpo_continuous_action.py --env-id Ant-v4 --rpo-alpha 0.01
+# dm_control v4 environments
+uv pip install ".[mujoco, dm_control]"
+python cleanrl/rpo_continuous_action.py --env-id dm_control/cartpole-balance-v0
+# BipedalWalker-v3 experiment (hack)
+uv pip install .
+uv pip install box2d-py==2.3.5
+python cleanrl/rpo_continuous_action.py --env-id BipedalWalker-v3
+```
+
+
+=== "poetry"
+
+    ```bash
+    # mujoco v4 environments
+    uv pip install ".[mujoco]"
+    python cleanrl/rpo_continuous_action.py --help
+    python cleanrl/rpo_continuous_action.py --env-id Hopper-v4
+    # NOTE: we recommend using --rpo-alpha 0.01 for Ant Hopper InvertedDoublePendulum Reacher Pusher
+    python cleanrl/rpo_continuous_action.py --env-id Ant-v4 --rpo-alpha 0.01
+    # dm_control environments
+    uv pip install ".[mujoco, dm_control]"
+    python cleanrl/rpo_continuous_action.py --env-id dm_control/cartpole-balance-v0
+    # BipedalWalker-v3 experiment (hack)
+    uv pip install box2d-py==2.3.5
+    uv run python cleanrl/rpo_continuous_action.py --env-id BipedalWalker-v3
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-mujoco.txt
+    python cleanrl/rpo_continuous_action.py --help
+    python cleanrl/rpo_continuous_action.py --env-id Hopper-v4
+    # NOTE: we recommend using --rpo-alpha 0.01 for Ant Hopper InvertedDoublePendulum Reacher Pusher
+    python cleanrl/rpo_continuous_action.py --env-id Ant-v4 --rpo-alpha 0.01
+    pip install -r requirements/requirements-dm_control.txt
+    python cleanrl/rpo_continuous_action.py --env-id dm_control/cartpole-balance-v0
+    pip install box2d-py==2.3.5
+    python cleanrl/rpo_continuous_action.py --env-id BipedalWalker-v3
+    ```
+
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/ppo/#explanation-of-the-logged-metrics) for `ppo.py`.
+
+### Implementation details
+[rpo_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/rpo_continuous_action.py) has the same implementation details as `ppo_continuous_action.py` (see related [docs](/rl-algorithms/ppo/#ppo_continuous_actionpy)) but with a few lines of code differences.
+
+```python hl_lines="30-34"
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 1), std=1.0),
+        )
+        self.actor_mean = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, np.prod(envs.single_action_space.shape)), std=0.01),
+        )
+        self.actor_logstd = nn.Parameter(torch.zeros(1, np.prod(envs.single_action_space.shape)))
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        action_mean = self.actor_mean(x)
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        if action is None:
+            action = probs.sample()
+        else: # new to RPO
+            # sample again to add stochasticity, for the policy update
+            z = torch.FloatTensor(action_mean.shape).uniform_(-self.rpo_alpha, self.rpo_alpha)
+            action_mean = action_mean + z
+            probs = Normal(action_mean, action_std)
+        
+```
+
+???+ note 
+
+    RPO usages the same PPO-specific hyperparameters. In benchmarking results, we run both algorithms for 8M timesteps.
+    RPO has one additional hyperparameter, `rpo_alpha`, which determines the amount of random perturbation on the action mean. 
+    We set a default value of `rpo_alpha=0.5` at which RPO is strictly equal to or better than the default PPO in 93% of environments tested (all 48/48 dm_control, 2/2 Gym, 7/11 mujoco_v4. Total 57 out of 61 environments tested.).
+    With finetuning `rpo_alpha=0.01` on four mujoco environments, namely, Ant, InvertedDoublePendulum, Reacher, and Pusher, RPO is strictly equal to or better than the default PPO in all tested environments.
+
+### Experiment results
+
+To run benchmark experiments, see  [benchmark/rpo.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/rpo.sh). Specifically, execute the following command:
+<script src="https://emgithub.com/embed.js?target=https%3A%2F%2Fgithub.com%2Fvwxyzjn%2Fcleanrl%2Fblob%2Fmaster%2Fbenchmark%2Frpo.sh%23L1-L6&style=github&showBorder=on&showLineNumbers=on&showFileMeta=on&showCopy=on"></script>
+
+???+ note "Result tables, learning curves"
+
+    === "dm_control"
+
+        Results on all dm_control environments. The PPO and RPO run for 8M timesteps, and results are computed over 10 random seeds.
+
+        |                                       | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:--------------------------------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | dm_control/acrobot-swingup-v0         | 26.87 ± 7.93                                                 | 42.97 ± 2.71                                  |
+        | dm_control/acrobot-swingup_sparse-v0  | 1.70 ± 0.88                                                  | 3.31 ± 0.84                                   |
+        | dm_control/ball_in_cup-catch-v0       | 935.26 ± 12.57                                               | 939.75 ± 10.18                                |
+        | dm_control/cartpole-balance-v0        | 790.36 ± 17.64                                               | 795.12 ± 10.49                                |
+        | dm_control/cartpole-balance_sparse-v0 | 986.04 ± 9.93                                                | 988.56 ± 4.28                                 |
+        | dm_control/cartpole-swingup-v0        | 590.21 ± 16.72                                               | 613.46 ± 10.91                                |
+        | dm_control/cartpole-swingup_sparse-v0 | 240.14 ± 299.93                                              | 525.49 ± 185.96                               |
+        | dm_control/cartpole-two_poles-v0      | 216.31 ± 4.03                                                | 218.31 ± 7.30                                 |
+        | dm_control/cartpole-three_poles-v0    | 160.03 ± 2.52                                                | 159.97 ± 2.28                                 |
+        | dm_control/cheetah-run-v0             | 472.14 ± 99.62                                               | 565.51 ± 58.03                                |
+        | dm_control/dog-stand-v0               | 332.06 ± 23.66                                               | 501.22 ± 131.98                               |
+        | dm_control/dog-walk-v0                | 124.92 ± 23.13                                               | 166.39 ± 44.65                                |
+        | dm_control/dog-trot-v0                | 79.89 ± 12.30                                                | 115.39 ± 29.68                                |
+        | dm_control/dog-run-v0                 | 69.07 ± 8.17                                                 | 104.27 ± 24.44                                |
+        | dm_control/dog-fetch-v0               | 28.34 ± 4.87                                                 | 43.58 ± 6.88                                  |
+        | dm_control/finger-spin-v0             | 630.06 ± 252.99                                              | 848.67 ± 25.21                                |
+        | dm_control/finger-turn_easy-v0        | 237.76 ± 78.10                                               | 450.88 ± 133.54                               |
+        | dm_control/finger-turn_hard-v0        | 83.76 ± 28.96                                                | 259.99 ± 144.83                               |
+        | dm_control/fish-upright-v0            | 559.72 ± 65.79                                               | 803.21 ± 28.36                                |
+        | dm_control/fish-swim-v0               | 80.42 ± 9.18                                                 | 140.33 ± 49.10                                |
+        | dm_control/hopper-stand-v0            | 3.26 ± 1.65                                                  | 404.39 ± 198.17                               |
+        | dm_control/hopper-hop-v0              | 6.48 ± 18.92                                                 | 62.60 ± 87.29                                 |
+        | dm_control/humanoid-stand-v0          | 20.76 ± 29.35                                                | 140.43 ± 57.27                                |
+        | dm_control/humanoid-walk-v0           | 8.92 ± 18.01                                                 | 77.00 ± 53.00                                 |
+        | dm_control/humanoid-run-v0            | 5.44 ± 9.16                                                  | 24.00 ± 19.54                                 |
+        | dm_control/humanoid-run_pure_state-v0 | 1.13 ± 0.11                                                  | 3.24 ± 2.41                                   |
+        | dm_control/humanoid_CMU-stand-v0      | 4.64 ± 0.37                                                  | 4.32 ± 0.33                                   |
+        | dm_control/humanoid_CMU-run-v0        | 0.88 ± 0.09                                                  | 0.80 ± 0.09                                   |
+        | dm_control/manipulator-bring_ball-v0  | 0.42 ± 0.14                                                  | 0.44 ± 0.23                                   |
+        | dm_control/manipulator-bring_peg-v0   | 0.95 ± 0.43                                                  | 1.07 ± 1.01                                   |
+        | dm_control/manipulator-insert_ball-v0 | 41.24 ± 27.27                                                | 43.63 ± 12.77                                 |
+        | dm_control/manipulator-insert_peg-v0  | 40.72 ± 15.95                                                | 44.87 ± 26.55                                 |
+        | dm_control/pendulum-swingup-v0        | 472.19 ± 385.47                                              | 774.30 ± 21.03                                |
+        | dm_control/point_mass-easy-v0         | 534.23 ± 264.35                                              | 653.73 ± 23.14                                |
+        | dm_control/point_mass-hard-v0         | 129.75 ± 61.18                                               | 185.81 ± 36.25                                |
+        | dm_control/quadruped-walk-v0          | 247.29 ± 90.48                                               | 602.64 ± 223.23                               |
+        | dm_control/quadruped-run-v0           | 171.50 ± 37.90                                               | 367.98 ± 117.18                               |
+        | dm_control/quadruped-escape-v0        | 23.11 ± 10.48                                                | 68.50 ± 27.81                                 |
+        | dm_control/quadruped-fetch-v0         | 183.71 ± 25.14                                               | 216.32 ± 17.44                                |
+        | dm_control/reacher-easy-v0            | 773.01 ± 56.70                                               | 716.89 ± 50.07                                |
+        | dm_control/reacher-hard-v0            | 637.84 ± 81.15                                               | 576.81 ± 48.25                                |
+        | dm_control/stacker-stack_2-v0         | 58.02 ± 11.04                                                | 70.95 ± 16.84                                 |
+        | dm_control/stacker-stack_4-v0         | 73.84 ± 14.48                                                | 65.54 ± 18.06                                 |
+        | dm_control/swimmer-swimmer6-v0        | 164.22 ± 18.44                                               | 159.60 ± 39.52                                |
+        | dm_control/swimmer-swimmer15-v0       | 161.02 ± 24.56                                               | 153.91 ± 28.08                                |
+        | dm_control/walker-stand-v0            | 439.24 ± 210.22                                              | 734.74 ± 142.52                               |
+        | dm_control/walker-walk-v0             | 305.74 ± 92.15                                               | 787.11 ± 125.97                               |
+        | dm_control/walker-run-v0              | 128.18 ± 91.52                                               | 391.56 ± 119.75                               |
+                
+        Learning curves:
+        ![](../rpo/dm_control_all_ppo_rpo_8M.png)
+
+        Tracked experiments: 
+        
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-dm_control-Part-1--VmlldzozMjU4NTE4" style="width:100%; height:500px" title="dm_control-CleanRL-s-RPO-part-1"></iframe>
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-dm_control-Part-2--VmlldzozMjU4NjYy" style="width:100%; height:500px" title="dm_control-CleanRL-s-RPO-part-2"></iframe>
+
+
+    
+    
+    === "MuJoCo v4"
+
+        |                     | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:--------------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | HumanoidStandup-v4  | 109325.87 ± 16161.71                                         | 150972.11 ± 6926.19                           |
+        | Humanoid-v4         | 583.17 ± 27.88                                               | 799.44 ± 170.85                               |
+        | InvertedPendulum-v4 | 888.83 ± 34.66                                               | 879.81 ± 35.52                                |
+        | Walker2d-v4         | 2872.92 ± 690.53                                             | 3665.48 ± 278.61                              |
+
+        Learning curves:
+        ![](../rpo/mujoco_v4_part1.png)
+
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-Mujoco_v4-Part-1--VmlldzozMjU3ODIz" style="width:100%; height:500px" title="RPO-mujoco-v4-part1"></iframe>
+
+        
+        The following environments require tuning of `alpha` (Algorithm 1, line 13, paper: https://arxiv.org/pdf/2212.07536.pdf). As described in the paper, this variable should be tuned for environments tested. A larger value means more randomness, whereas a smaller value indicates less randomness. Some mujoco environments require a smaller `alpha=0.01` value to achieve a reasonable performance compared to `alpha=0.5` for the rest of the environments. This version (`alpha=0.01`) of runs is indicated as `rpo_continuous_action_alpha_0_01` in the table and learning curves.
+
+        |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action_alpha_0_01 ({'tag': ['pr-331']})   |
+        |:--------------------------|:-------------------------------------------------------------|:---------------------------------------------------------|
+        | Ant-v4                    | 1824.17 ± 905.78                                             | 2702.91 ± 683.53                                         |
+        | HalfCheetah-v4            | 2637.19 ± 1068.49                                            | 2716.51 ± 1314.93                                        |
+        | Hopper-v4                 | 2741.42 ± 269.11                                             | 2334.22 ± 441.89                                         |
+        | InvertedDoublePendulum-v4 | 5626.22 ± 289.23                                             | 5409.03 ± 318.68                                         |
+        | Reacher-v4                | -4.65 ± 0.96                                                 | -3.93 ± 0.19                                             |
+        | Swimmer-v4                | 124.88 ± 22.24                                               | 129.97 ± 12.02                                           |
+        | Pusher-v4                 | -30.35 ± 6.43                                                | -31.48 ± 9.83                                            |
+
+        Learning curves:
+        ![](../rpo/mujoco_v4_part2.png)
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-Mujoco_v4-Part-2--VmlldzozMjU3OTM4" style="width:100%; height:500px" title="RPO-mujoco-v4-part2"></iframe>
+        
+
+        Results with `rpo_alpha=0.5` (not tuned) on the tuned environments:
+
+        |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:--------------------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | Ant-v4                    | 1774.42 ± 819.08                                             | -7.99 ± 2.47                                  |
+        | HalfCheetah-v4            | 2667.34 ± 1109.99                                            | 2163.57 ± 790.16                              |
+        | Hopper-v4                 | 2761.77 ± 286.88                                             | 1557.18 ± 206.74                              |
+        | InvertedDoublePendulum-v4 | 5644.00 ± 353.46                                             | 296.97 ± 15.95                                |
+        | Reacher-v4                | -4.67 ± 0.88                                                 | -66.35 ± 0.66                                 |
+        | Swimmer-v4                | 124.52 ± 22.10                                               | 117.82 ± 10.07                                |
+        | Pusher-v4                 | -30.62 ± 6.80                                                | -276.32 ± 26.99                               |
+
+        Learning curves:
+        ![](../rpo/mujoco_v4_part2_0_5.png)
+
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-alpha-0-5-on-Mujoco_v4-Part-2--VmlldzozMjU4MTM1" style="width:100%; height:500px" title="RPO-mujoco-v4-0-5-part-2"></iframe>
+
+ 
+    
+    === "MuJoCo v2"
+
+        |                     | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:--------------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | HumanoidStandup-v2  | 109118.07 ± 19422.20                                         | 156848.90 ± 11414.50                          |
+        | Humanoid-v2         | 588.22 ± 43.80                                               | 717.37 ± 97.18                                |
+        | InvertedPendulum-v2 | 867.64 ± 19.97                                               | 866.60 ± 27.06                                |
+        | Walker2d-v2         | 3220.99 ± 923.84                                             | 4150.51 ± 348.03                              |
+
+        Learning curves:
+        ![](../rpo/mujoco_v2_part1.png)
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-Mujoco_v2-Part-1--VmlldzozMjU4Mjc5" style="width:100%; height:500px" title="RPO-mujoco-v2-part1"></iframe>
+
+        The following environments require tuning of `alpha` (Algorithm 1, line 13, paper: https://arxiv.org/pdf/2212.07536.pdf). As described in the paper, this variable should be tuned for environments tested. A larger value means more randomness, whereas a smaller value indicates less randomness. Some mujoco environments require a smaller `alpha=0.01` value to achieve a reasonable performance compared to `alpha=0.5` for the rest of the environments. This version (`alpha=0.01`) of runs is indicated as `rpo_continuous_action_alpha_0_01` in the table and learning curves.
+
+        |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action_alpha_0_01 ({'tag': ['pr-331']})   |
+        |:--------------------------|:-------------------------------------------------------------|:---------------------------------------------------------|
+        | Ant-v2                    | 2412.35 ± 949.44                                             | 3084.95 ± 759.51                                         |
+        | HalfCheetah-v2            | 2717.27 ± 1269.85                                            | 2707.91 ± 1215.21                                        |
+        | Hopper-v2                 | 2387.39 ± 645.41                                             | 2272.78 ± 588.66                                         |
+        | InvertedDoublePendulum-v2 | 5630.91 ± 377.93                                             | 5661.29 ± 316.04                                         |
+        | Reacher-v2                | -4.61 ± 0.53                                                 | -4.24 ± 0.25                                             |
+        | Swimmer-v2                | 132.07 ± 9.92                                                | 141.37 ± 8.70                                            |
+        | Pusher-v2                 | -33.93 ± 8.55                                                | -26.22 ± 2.52                                            |
+                
+        
+        Learning curves:
+        ![](../rpo/mujoco_v2_part2.png)
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-Mujoco_v2-Part-2--VmlldzozMjU4MzI1" style="width:100%; height:500px" title="RPO-mujoco-v2-part1"></iframe>
+
+        Results with `rpo_alpha=0.5` (not tuned) on the tuned environments:
+
+        |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:--------------------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | Ant-v2                    | 2495.65 ± 991.65                                             | -7.81 ± 3.57                                  |
+        | HalfCheetah-v2            | 2722.03 ± 1231.28                                            | 2605.06 ± 1183.30                             |
+        | Hopper-v2                 | 2356.83 ± 650.91                                             | 1609.79 ± 164.16                              |
+        | InvertedDoublePendulum-v2 | 5675.31 ± 244.34                                             | 274.78 ± 16.40                                |
+        | Reacher-v2                | -4.67 ± 0.48                                                 | -66.55 ± 0.20                                 |
+        | Swimmer-v2                | 131.53 ± 9.94                                                | 114.34 ± 3.95                                 |
+        | Pusher-v2                 | -33.46 ± 8.41                                                | -275.09 ± 15.65                               |
+
+        Learning curves:
+        ![](../rpo/mujoco_v2_part2_0_5.png)
+
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-alpha-0-5-on-Mujoco_v2-Part-2--VmlldzozMjU4MzQ0" style="width:100%; height:500px" title="RPO-mujoco-v2-0-5-part-2s"></iframe>
+
+        
+
+    
+    === "Gym(Gymnasium)"
+
+        Results on two continuous gym environments. The PPO and RPO run for 8M timesteps, and results are computed over 10 random seeds.
+
+
+        |                  | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+        |:-----------------|:-------------------------------------------------------------|:----------------------------------------------|
+        | Pendulum-v1      | -1141.98 ± 135.55                                            | -151.08 ± 3.73                                |
+        | BipedalWalker-v3 | 172.12 ± 96.05                                               | 227.11 ± 18.23                                |
+
+        Learning curves:
+        ![](../rpo/gym.png)
+
+        Tracked experiments:     
+
+        <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-on-Gym-Gymnasium---VmlldzozMjU3NzUy" style="width:100%; height:500px" title="RPO-gymnasium"></iframe>
+
+
+
+???+ failure 
+
+    Failure case of `rpo_alpha=0.5`:
+
+    Overall, we observed that `rpo_alpha=0.5` is strictly equal to or better than the default PPO in 93% of environments tested (all 48/48 dm_control, 2/2 Gym, 7/11 mujoco_v4. Total 57 out of 61 environments tested). 
+
+    Here are the failure cases:
+    `Mujoco v4 and v2: Ant InvertedDoublePendulum  Reacher Pusher`
+
+    |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+    |:--------------------------|:-------------------------------------------------------------|:----------------------------------------------|
+    | Ant-v4                    | 1831.63 ± 867.71                                             | -10.43 ± 8.16                                 |
+    | InvertedDoublePendulum-v4 | 5490.71 ± 261.50                                             | 303.36 ± 13.39                                |
+    | Reacher-v4                | -4.58 ± 0.73                                                 | -66.62 ± 0.56                                 |
+    | Pusher-v4                 | -30.63 ± 6.42                                                | -276.11 ± 26.52                               |
+
+    Learning curves:
+    ![](../rpo/mujoco_v4_failure_0_5.png)
+
+    Tracked experiments:     
+
+    <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-alpha-0-5-s-failure-cases-on-Mujoco_v4--VmlldzozMjU4MTYy" style="width:100%; height:500px" title="RPO-mujoco-v4-failure-cases"></iframe>
+
+
+
+    |                           | ppo_continuous_action_8M ({'tag': ['v1.0.0-13-gcbd83f6']})   | rpo_continuous_action ({'tag': ['pr-331']})   |
+    |:--------------------------|:-------------------------------------------------------------|:----------------------------------------------|
+    | Ant-v2                    | 2493.50 ± 993.24                                             | -7.26 ± 2.28                                  |
+    | InvertedDoublePendulum-v2 | 5568.37 ± 401.65                                             | 278.94 ± 15.34                                |
+    | Reacher-v2                | -4.62 ± 0.47                                                 | -66.61 ± 0.23                                 |
+    | Pusher-v2                 | -33.51 ± 8.47                                                | -276.01 ± 15.93                               |
+
+
+    Learning curves:
+    ![](../rpo/mujoco_v2_failure_0_5.png)
+
+
+    Tracked experiments:     
+
+    <iframe loading="lazy" src="https://wandb.ai/openrlbenchmark/cleanrl/reports/RPO-alpha-0-5-s-failure-cases-on-Mujoco_v2--VmlldzozMjU4MjQ1" style="width:100%; height:500px" title="RPO-mujoco-v4-failure-cases"></iframe>
+
+
+    However, tuning of `rpo_alpha` (`rpo_alpha=0.01` on failed cases) helps RPO to overcome the failure, and it performs strictly equal to or better than the default PPO in all (100%) of tested environments.
+

cleanrl/docs/rl-algorithms/sac.md

@@ -0,0 +1,413 @@
+# Soft Actor-Critic (SAC)
+
+## Overview
+
+The Soft Actor-Critic (SAC) algorithm extends the DDPG algorithm by 1) using a stochastic policy, which in theory can express multi-modal optimal policies.
+This also enables the use of 2) *entropy regularization* based on the stochastic policy's entropy. It serves as a built-in, state-dependent exploration heuristic for the agent, instead of relying on non-correlated noise processes as in [DDPG](/rl-algorithms/ddpg/), or [TD3](/rl-algorithms/td3/)
+Additionally, it incorporates the 3) usage of two *Soft Q-network* to reduce the overestimation bias issue in Q-network-based methods.
+
+Original papers:
+The SAC algorithm's initial proposal, and later updates and improvements can be chronologically traced through the following publications:
+
+* [Reinforcement Learning with Deep Energy-Based Policies](https://arxiv.org/abs/1702.08165)
+* [Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor](https://arxiv.org/abs/1801.01290)
+* [Composable Deep Reinforcement Learning for Robotic Manipulation](https://arxiv.org/abs/1803.06773)
+* [Soft Actor-Critic Algorithms and Applications](https://arxiv.org/abs/1812.05905)
+* [Soft Actor-Critic for Discrete Action Settings](https://arxiv.org/abs/1910.07207) (No peer review, preprint only)
+
+Reference resources:
+
+* :material-github: [haarnoja/sac](https://github.com/haarnoja/sac)
+* :material-github: [openai/spinningup](https://github.com/openai/spinningup/tree/master/spinup/algos/tf1/sac)
+* :material-github: [pranz24/pytorch-soft-actor-critic](https://github.com/pranz24/pytorch-soft-actor-critic)
+* :material-github: [DLR-RM/stable-baselines3](https://github.com/DLR-RM/stable-baselines3/tree/master/stable_baselines3/sac)
+* :material-github: [denisyarats/pytorch_sac](https://github.com/denisyarats/pytorch_sac)
+* :material-github: [haarnoja/softqlearning](https://github.com/haarnoja/softqlearning)
+* :material-github: [rail-berkeley/softlearning](https://github.com/rail-berkeley/softlearning)
+* :material-github: [p-christ/Deep-Reinforcement-Learning-Algorithms-with-PyTorch](https://github.com/p-christ/Deep-Reinforcement-Learning-Algorithms-with-PyTorch)
+* :material-github: [toshikwa/sac-discrete.pytorch](https://github.com/toshikwa/sac-discrete.pytorch)
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`sac_continuous_actions.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py), :material-file-document: [docs](/rl-algorithms/sac/#sac_continuous_actionpy) | For continuous action spaces |
+| :material-github: [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py), :material-file-document: [docs](/rl-algorithms/sac/#sac_ataripy) | For discrete action spaces |
+
+Below are our single-file implementations of SAC:
+
+## `sac_continuous_action.py`
+
+The [sac_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) has the following features:
+
+* For continuous action spaces.
+* Works with the `Box` observation space of low-level features.
+* Works with the `Box` (continuous) action space.
+* Numerically stable stochastic policy based on :material-github: [openai/spinningup](https://github.com/openai/spinningup/tree/master/spinup/algos/tf1/sac) and [pranz24/pytorch-soft-actor-critic](https://github.com/pranz24/pytorch-soft-actor-critic) implementations.
+* Supports automatic entropy coefficient $\alpha$ tuning, enabled by default.
+
+### Usage for continuous action spaces
+
+=== "poetry"
+
+    ```bash
+    poetry install
+    uv pip install ".[mujoco]"
+    uv run python cleanrl/sac_continuous_action.py --help
+    uv run python cleanrl/sac_continuous_action.py --env-id Hopper-v4
+    uv run python cleanrl/sac_continuous_action.py --env-id Hopper-v4 --autotune False --alpha 0.2 ## Without Automatic entropy coef. tuning
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-mujoco.txt
+    python cleanrl/sac_continuous_action.py --help
+    python cleanrl/sac_continuous_action.py --env-id Mujoco-v4
+    python cleanrl/sac_continuous_action.py --env-id Hopper-v4 --autotune False --alpha 0.2 ## Without Automatic entropy coef. tuning
+    ```
+
+### Explanation of the logged metrics
+
+Running python cleanrl/sac_continuous_action.py will automatically record various metrics such as actor or value losses in Tensorboard. Below is the documentation for these metrics:
+
+* `charts/episodic_return`: the episodic return of the game during training
+
+* `charts/SPS`: number of steps per second
+
+* `losses/qf1_loss`, `losses/qf2_loss`: for each Soft Q-value network $Q_{\theta_i}$, $i \in \{1,2\}$, this metric holds the mean squared error (MSE) between the soft Q-value estimate $Q_{\theta_i}(s, a)$ and the *entropy regularized* Bellman update target estimated as $r_t + \gamma \, Q_{\theta_{i}^{'}}(s', a') + \alpha \, \mathcal{H} \big[ \pi(a' \vert s') \big]$.
+
+More formally, the Soft Q-value loss for the $i$-th network is obtained by:
+
+$$
+    J(\theta^{Q}_{i}) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{D}} \big[ (Q_{\theta_i}(s, a) - y)^2 \big]
+$$
+
+with the *entropy regularized*, *Soft Bellman update target*:
+$$
+    y = r(s, a) + \gamma ({\color{orange} \min_{\theta_{1,2}}Q_{\theta_i^{'}}(s',a')} - \alpha \, \text{log} \pi( \cdot \vert s'))
+$$ where $a' \sim \pi( \cdot \vert s')$, $\text{log} \pi( \cdot \vert s')$ approximates the entropy of the policy, and $\mathcal{D}$ is the replay buffer storing samples of the agent during training.
+
+Here, $\min_{\theta_{1,2}}Q_{\theta_i^{'}}(s',a')$ takes the minimum *Soft Q-value network* estimate between the two target Q-value networks $Q_{\theta_1^{'}}$ and $Q_{\theta_2^{'}}$ for the next state and action pair, so as to reduce over-estimation bias.
+
+* `losses/qf_loss`: averages `losses/qf1_loss` and `losses/qf2_loss` for comparison with algorithms using a single Q-value network.
+
+* `losses/actor_loss`: Given the stochastic nature of the policy in SAC, the actor (or policy) objective is formulated so as to maximize the likelihood of actions $a \sim \pi( \cdot \vert s)$ that would result in high Q-value estimate $Q(s, a)$. Additionally, the policy objective encourages the policy to maintain its entropy high enough to help explore, discover, and capture multi-modal optimal policies.
+
+The policy's objective function can thus be defined as:
+
+$$
+    \text{max}_{\phi} \, J_{\pi}(\phi) = \mathbb{E}_{s \sim \mathcal{D}} \Big[ \text{min}_{i=1,2} Q_{\theta_i}(s, a) - \alpha \, \text{log}\pi_{\phi}(a \vert s) \Big]
+$$
+
+where the action is sampled using the reparameterization trick[^1]: $a = \mu_{\phi}(s) + \epsilon \, \sigma_{\phi}(s)$ with $\epsilon \sim \mathcal{N}(0, 1)$, $\text{log} \pi_{\phi}( \cdot \vert s')$ approximates the entropy of the policy, and $\mathcal{D}$ is the replay buffer storing samples of the agent during training.
+
+* `losses/alpha`: $\alpha$ coefficient for *entropy regularization* of the policy.
+
+* `losses/alpha_loss`: In the policy's objective defined above, the coefficient of the *entropy bonus* $\alpha$ is kept fixed all across the training.
+As suggested by the authors in Section 5 of the [*Soft Actor-Critic And Applications*](https://arxiv.org/abs/1812.05905) paper, the original purpose of augmenting the standard reward with the entropy of the policy is to *encourage exploration* of not well enough explored states (thus high entropy).
+Conversely, for states where the policy has already learned a near-optimal policy, it would be preferable to reduce the entropy bonus of the policy, so that it does not *become sub-optimal due to the entropy maximization incentive*.
+
+Therefore, having a fixed value for $\alpha$ does not fit this desideratum of matching the entropy bonus with the knowledge of the policy at an arbitrary state during its training.
+
+To mitigate this, the authors proposed a method to dynamically adjust $\alpha$ as the policy is trained, which is as follows:
+
+$$
+    \alpha^{*}_t = \text{argmin}_{\alpha_t} \mathbb{E}_{a_t \sim \pi^{*}_t} \big[ -\alpha_t \, \text{log}\pi^{*}_t(a_t \vert s_t; \alpha_t) - \alpha_t \mathcal{H} \big],
+$$
+
+where $\mathcal{H}$ represents the *target entropy*, the desired lower bound for the expected entropy of the policy over the trajectory distribution induced by the latter.
+As a heuristic for the *target entropy*, the authors use the dimension of the action space of the task.
+
+### Implementation details
+
+CleanRL's [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) implementation is based on :material-github: [openai/spinningup](https://github.com/openai/spinningup/tree/master/spinup/algos/pytorch/sac).
+
+1. [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) uses a *numerically stable* estimation method for the standard deviation $\sigma$ of the policy, which squashes it into a range of reasonable values for a standard deviation:
+
+    ```python hl_lines="1-2 19-21"
+    LOG_STD_MAX = 2
+    LOG_STD_MIN = -5
+
+    class Actor(nn.Module):
+        def __init__(self, env):
+            super(Actor, self).__init__()
+            self.fc1 = nn.Linear(np.array(env.single_observation_space.shape).prod(), 256)
+            self.fc2 = nn.Linear(256, 256)
+            self.fc_mean = nn.Linear(256, np.prod(env.single_action_space.shape))
+            self.fc_logstd = nn.Linear(256, np.prod(env.single_action_space.shape))
+            # action rescaling
+            self.action_scale = torch.FloatTensor((env.action_space.high - env.action_space.low) / 2.0)
+            self.action_bias = torch.FloatTensor((env.action_space.high + env.action_space.low) / 2.0)
+
+        def forward(self, x):
+            x = F.relu(self.fc1(x))
+            x = F.relu(self.fc2(x))
+            mean = self.fc_mean(x)
+            log_std = self.fc_logstd(x)
+            log_std = torch.tanh(log_std)
+            log_std = LOG_STD_MIN + 0.5 * (LOG_STD_MAX - LOG_STD_MIN) * (log_std + 1)  # From SpinUp / Denis Yarats
+
+            return mean, log_std
+
+        def get_action(self, x):
+            mean, log_std = self(x)
+            std = log_std.exp()
+            normal = torch.distributions.Normal(mean, std)
+            x_t = normal.rsample()  # for reparameterization trick (mean + std * N(0,1))
+            y_t = torch.tanh(x_t)
+            action = y_t * self.action_scale + self.action_bias
+            log_prob = normal.log_prob(x_t)
+            # Enforcing Action Bound
+            log_prob -= torch.log(self.action_scale * (1 - y_t.pow(2)) + 1e-6)
+            log_prob = log_prob.sum(1, keepdim=True)
+            mean = torch.tanh(mean) * self.action_scale + self.action_bias
+            return action, log_prob, mean
+
+        def to(self, device):
+            self.action_scale = self.action_scale.to(device)
+            self.action_bias = self.action_bias.to(device)
+            return super(Actor, self).to(device)
+    ```
+
+    Note that unlike :material-github: [openai/spinningup](https://github.com/openai/spinningup/tree/master/spinup/algos/tf1/sac)'s implementation which uses `LOG_STD_MIN = -20`, CleanRL's uses `LOG_STD_MIN = -5` instead.
+
+2. [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) uses different learning rates for the policy and the Soft Q-value networks optimization.
+
+    ```python
+        parser.add_argument("--policy-lr", type=float, default=3e-4,
+            help="the learning rate of the policy network optimizer")
+        parser.add_argument("--q-lr", type=float, default=1e-3,
+            help="the learning rate of the Q network network optimizer")
+    ```
+
+    while [openai/spinningup](https://github.com/openai/spinningup/blob/038665d62d569055401d91856abb287263096178/spinup/algos/tf1/sac/sac.py#L44)'s uses a single learning rate of `lr=1e-3` for both components.
+
+    Note that in case it is used, the *automatic entropy coefficient* $\alpha$'s tuning shares the `q-lr` learning rate:
+
+    ```python hl_lines="6"
+        # Automatic entropy tuning
+        if args.autotune:
+            target_entropy = -torch.prod(torch.Tensor(envs.single_action_space.shape).to(device)).item()
+            log_alpha = torch.zeros(1, requires_grad=True, device=device)
+            alpha = log_alpha.exp().item()
+            a_optimizer = optim.Adam([log_alpha], lr=args.q_lr)
+        else:
+            alpha = args.alpha
+    ```
+
+3. [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) uses `--batch-size=256` while :material-github: [openai/spinningup](https://github.com/openai/spinningup/blob/038665d62d569055401d91856abb287263096178/spinup/algos/tf1/sac/sac.py#L44)'s uses `--batch-size=100` by default.
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/sac.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/sac.sh). Specifically, execute the following command:
+
+``` title="benchmark/sac.sh" linenums="1"
+--8<-- "benchmark/sac.sh::7"
+```
+
+The table below compares the results of CleanRL's [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) with the [latest published results](https://arxiv.org/abs/1812.05905) by the original authors of the SAC algorithm.
+
+???+ info
+    Note that the results table above references the *training episodic return* for [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py), the results of [Soft Actor-Critic Algorithms and Applications](https://arxiv.org/abs/1812.05905) reference *evaluation episodic return* obtained by running the policy in the deterministic mode.
+
+| Environment      | [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) |[SAC: Algorithms and Applications](https://arxiv.org/abs/1812.05905) @ 1M steps|
+| --------------- | ------------------ | ---------------- |
+| HalfCheetah-v2  | 9634.89 ± 1423.73       | ~11,250          |
+| Walker2d-v2     | 3591.45 ± 911.33         | ~4,800           |
+| Hopper-v2       | 2310.46 ± 342.82         | ~3,250           |
+| InvertedPendulum-v4 | 909.37 ± 55.66                                                        | N/A |
+| Humanoid-v4         | 4996.29 ± 686.40                                                      | ~4500
+| Pusher-v4           | -22.45 ± 0.51                                                         | N/A |
+
+Learning curves:
+
+``` title="benchmark/sac_plot.sh" linenums="1"
+--8<-- "benchmark/sac_plot.sh::9"
+```
+
+
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/sac.png">
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/sac-time.png">
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/MuJoCo-CleanRL-s-SAC--VmlldzoxNzI1NDM0" style="width:100%; height:1200px" title="MuJoCo: CleanRL's SAC"></iframe>
+
+## `sac_atari.py`
+
+The [sac_atari.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) has the following features:
+
+* For discrete action spaces.
+* Works with the `Box` observation space of low-level features.
+* Works with the `Discrete` action space.
+* Improved stability and wall-clock efficiency through updates only every n-th step.
+* Supports automatic entropy coefficient $\alpha$ tuning, enabled by default.
+
+### Usage for discrete action spaces
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[atari]"
+    uv run python cleanrl/sac_atari.py.py --env-id PongNoFrameskip-v4
+    uv run python cleanrl/sac_atari.py.py --env-id PongNoFrameskip-v4 --autotune False --alpha 0.2
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-atari.txt
+    python cleanrl/sac_atari.py.py --env-id PongNoFrameskip-v4
+    python cleanrl/sac_atari.py.py --env-id PongNoFrameskip-v4 --autotune False --alpha 0.2
+    ```
+
+### Explanation of the logged metrics
+
+The metrics logged by `python cleanrl/sac_atari.py` are the same as the ones logged by `python cleanrl/sac_continuous_action.py` (see the [related docs](/rl-algorithms/sac/#explanation-of-the-logged-metrics)). However, the computations for the objectives differ in some details highlighted below:
+
+* `losses/qf1_loss`, `losses/qf2_loss`: for each Soft Q-value network $Q_{\theta_i}$, $i \in \{1,2\}$, this metric holds the mean squared error (MSE) between the soft Q-value estimate $Q_{\theta_i}(s, a)$ and the *entropy regularized* Bellman update target estimated as $r_t + \gamma \, Q_{\theta_{i}^{'}}(s', a') + \alpha \, \mathcal{H} \big[ \pi(a' \vert s') \big]$.
+
+SAC-discrete is able to exploit the discrete action space by using the full action distribution to calculate the Soft Q-targets instead of relying on a Monte Carlo approximation from a single Q-value. The new Soft Q-target is stated below with differences to the [continuous SAC target](/rl-algorithms/sac/#explanation-of-the-logged-metrics) highlighted in orange:
+$$
+    y = r(s, a) + \gamma \, {\color{orange}\pi (a | s^\prime)^{\mathsf T}} \Big(\min_{\theta_{1,2}} {\color{orange}Q_{\theta_i^{'}}(s')} - \alpha \, \log \pi( \cdot \vert s')\Big)~,
+$$
+
+Note how in the discrete setting the Q-function $Q_{\theta_i^{'}}(s')$ is a mapping $Q:S \rightarrow \mathbb R^{|\mathcal A|}$ that only takes states as inputs and outputs Q-values for all actions. Using all this available information and additionally weighing the target by the corresponding action selection probability reduces variance of the gradient.
+
+* `losses/actor_loss`: Given the stochastic nature of the policy in SAC, the actor (or policy) objective is formulated so as to maximize the likelihood of actions $a \sim \pi( \cdot \vert s)$ that would result in high Q-value estimate $Q(s, a)$. Additionally, the policy objective encourages the policy to maintain its entropy high enough to help explore, discover, and capture multi-modal optimal policies.
+
+SAC-discrete uses an action probability-weighted (highlighted in orange) objective given as:
+
+$$
+    \text{max}_{\phi} \, J_{\pi}(\phi) = \mathbb{E}_{s \sim \mathcal{D}} \bigg[ {\color{orange}\pi (a | s)^{\mathsf T}} \Big( \text{min}_{i=1,2} {\color{orange} Q_{\theta_i}(s)} - \alpha \, \log\pi_{\phi}(a \vert s) \Big) \bigg]
+$$
+
+Unlike for continuous action spaces, there is *no need for the reparameterization trick* due to using a Categorical policy. Similar to the critic objective, the Q-function $Q_{\theta_i}(s)$ is a function from states to real numbers and does not require actions as inputs.
+
+* `losses/alpha_loss`: In the policy's objective defined above, the coefficient of the *entropy bonus* $\alpha$ is kept fixed all across the training.
+As suggested by the authors in Section 5 of the [*Soft Actor-Critic And Applications*](https://arxiv.org/abs/1812.05905) paper, the original purpose of augmenting the standard reward with the entropy of the policy is to *encourage exploration* of not well enough explored states (thus high entropy).
+Conversely, for states where the policy has already learned a near-optimal policy, it would be preferable to reduce the entropy bonus of the policy, so that it does not *become sub-optimal due to the entropy maximization incentive*.
+
+In SAC-discrete, it is possible to weigh the target for the entropy coefficient by the policy's action selection probabilities to reduce gradient variance. This is the same trick that was already used in the critic and actor objectives, with differences to the regular SAC objective marked in orange:
+
+$$
+    \alpha^{*}_t = \text{argmin}_{\alpha_t} \mathbb{E}_{a_t \sim \pi^{*}_t} \, {\color{orange}\pi (a | s)^{\mathsf T}}\big[ -\alpha_t \, \log\pi^{*}_t(a_t \vert s_t; \alpha_t) - \alpha_t \tau \mathcal{H} \big],
+$$
+
+Since SAC-discrete uses a Categorical policy in a discrete action space, a different entropy target is required. The author uses the *maximum entropy Categorical distribution* (assigning uniform probability to all available actions) scaled by a factor of $\tau~.$
+
+### Implementation details
+
+[`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) uses the wrappers highlighted in the "9 Atari implementation details" in [The 37 Implementation Details of Proximal Policy Optimization](https://iclr-blog-track.github.io/2022/03/25/ppo-implementation-details/), which are as follows:
+
+1. The Use of `NoopResetEnv` (:material-github: [common/atari_wrappers.py#L12](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L12))
+2. The Use of `MaxAndSkipEnv` (:material-github: [common/atari_wrappers.py#L97](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L97))
+3. The Use of `EpisodicLifeEnv` (:material-github: [common/atari_wrappers.py#L61](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L61))
+4. The Use of `FireResetEnv` (:material-github: [common/atari_wrappers.py#L41](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L41))
+5. The Use of `WarpFrame` (Image transformation) [common/atari_wrappers.py#L134](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L134)
+6. The Use of `ClipRewardEnv` (:material-github: [common/atari_wrappers.py#L125](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L125))
+7. The Use of `FrameStack` (:material-github: [common/atari_wrappers.py#L188](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/atari_wrappers.py#L188))
+8. Shared Nature-CNN network for the policy and value functions (:material-github: [common/policies.py#L157](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/policies.py#L157), [common/models.py#L15-L26](https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/models.py#L15-L26))
+9. Scaling the Images to Range [0, 1] (:material-github: [common/models.py#L19](https://github.com/openai/baselines/blob/9b68103b737ac46bc201dfb3121cfa5df2127e53/baselines/common/models.py#L19))
+
+Other noteworthy implementation details apart from the Atari wrapping are as follows:
+
+1. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) initializes the weights of its networks using He initialization (named after its author Kaiming He) from the paper ["Delving Deep into Rectifiers:
+Surpassing Human-Level Performance on ImageNet Classification"](https://arxiv.org/pdf/1502.01852.pdf). The corresponding function in PyTorch is `kaiming_normal_`, its documentation can be found [here](https://pytorch.org/docs/stable/nn.init.html). In essence, it means the weights of each layer are initialized according to a Normal distribution with mean $\mu=0$ and
+
+    $$
+        \sigma = \frac{\text{gain}}{\sqrt{\text{fan}}}~,
+    $$
+
+    where $\text{fan}$ is the number of input neurons to the layer and $\text{gain}$ is a constant set to $\sqrt{2}$ for `ReLU` layers.
+
+2. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) uses the Adam[^2] optimizer with an increased $\epsilon$-parameter to improve its stability. This results in an increase in the denominator of the update rule:
+
+    $$
+        \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}
+    $$
+
+    Here $\hat{m}_t$ is the bias-corrected first moment and $\hat{v}_t$ the bias-corrected second raw moment.
+
+3. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) uses the action selection probabilities of the policy in multiple places to *reduce the variance of gradient estimates*. The target for the Soft Q-value estimate is weighted accordingly:
+
+    ```python hl_lines="7"
+    # CRITIC training
+    with torch.no_grad():
+        _, next_state_log_pi, next_state_action_probs = actor.get_action(data.next_observations)
+        qf1_next_target = qf1_target(data.next_observations)
+        qf2_next_target = qf2_target(data.next_observations)
+        # we can use the action probabilities instead of MC sampling to estimate the expectation
+        min_qf_next_target = next_state_action_probs * (
+            torch.min(qf1_next_target, qf2_next_target) - alpha * next_state_log_pi
+        )
+    ```
+
+    A similar action-probability weighting can be used for the actor gradient:
+
+    ```python hl_lines="7"
+    _, log_pi, action_probs = actor.get_action(data.observations)
+    with torch.no_grad():
+        qf1_values = qf1(data.observations)
+        qf2_values = qf2(data.observations)
+        min_qf_values = torch.min(qf1_values, qf2_values)
+    # no need for reparameterization, the expectation can be calculated for discrete actions
+    actor_loss = (action_probs * ((alpha * log_pi) - min_qf_values)).mean()
+    ```
+
+    Lastly, this variance reduction scheme is also used when automatic entropy tuning is enabled:
+
+    ```python hl_lines="3"
+    if args.autotune:
+        # reuse action probabilities for temperature loss
+        alpha_loss = (action_probs.detach() * (-log_alpha.exp() * (log_pi + target_entropy).detach())).mean()
+
+        a_optimizer.zero_grad()
+        alpha_loss.backward()
+        a_optimizer.step()
+        alpha = log_alpha.exp().item()
+    ```
+
+4. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) uses `--target-entropy-scale=0.89` while the [SAC-discrete paper](https://arxiv.org/abs/1910.07207) uses `--target-entropy-scale=0.98` due to improved stability when training for more than 100k steps. Tuning this parameter to the environment at hand is advised and can lead to significant performance gains.
+
+5. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) performs learning updates only on every $n^{\text{th}}$ step. This leads to improved stability and prevents the agent's performance from degenerating during longer training runs.  
+Note the difference to [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py): [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) updates every $n^{\text{th}}$ environment step and does a single update of actor and critic on every update step. [`sac_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_continuous_action.py) updates the critic every step and the actor every $n^{\text{th}}$ step. It then compensates for the delayed actor updates by performing $n$ actor update steps.
+
+6. [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) handles truncation and termination properly like (Mnih et al., 2015)[^3] by using SB3's replay buffer's `handle_timeout_termination=True`.
+
+### Atari experiment results for SAC-discrete
+
+Run benchmarks for :material-github: [benchmark/sac_atari.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/sac_atari.sh) by executing:
+
+<script src="https://emgithub.com/embed-v2.js?target=https%3A%2F%2Fgithub.com%2Ftimoklein%2Fcleanrl%2Fblob%2Fsac-discrete%2Fbenchmark%2Fsac_atari.sh&style=github&type=code&showBorder=on&showLineNumbers=on&showFileMeta=on&showFullPath=on&showCopy=on"></script>
+
+The table below compares the results of CleanRL's [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) with the [original paper results](https://arxiv.org/abs/1910.07207).
+
+???+ info
+    Note that the results table above references the *training episodic return* for [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) without evaluation mode.
+
+| Environment      | [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) 100k steps |[SAC for Discrete Action Settings](https://arxiv.org/abs/1910.07207) 100k steps| [`sac_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/sac_atari.py) 5M steps | [`dqn_atari.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/dqn_atari.py) 10M steps
+| --------------- | ------------------ | ---------------- | ---------------- | ---------------- |
+| PongNoFrameskip-v4  | ~ -20.21 ± 0.62       | -20.98 ± 0.0        |   ~19.24 ± 1.81  |     20.25 ± 0.41   |
+| BreakoutNoFrameskip-v4     | ~2.33 ± 1.28         | -           | ~343.66 ± 93.34  |  366.928 ± 39.89  |
+| BeamRiderNoFrameskip-v4       | ~396.15 ± 155.81         | 432.1 ± 44.0           |   ~8658.97 ± 1554.66 |    6673.24 ± 1434.37   |
+
+Learning curves:
+
+<div class="grid-container">
+    <img src="../sac/PongNoFrameskip-v4.png">
+    <img src="../sac/BreakoutNoFrameskip-v4.png">
+    <img src="../sac/BeamRiderNoFrameskip-v4.png">
+</div>
+
+<div></div>
+
+
+Tracked experiments:
+
+<iframe src="https://wandb.ai/openrlbenchmark/cleanrl/reports/Atari-CleanRL-s-SAC-discrete--VmlldzoyNzgxMTI2" style="border:none;height:1024px;width:100%"></iframe>
+
+[^1]:Diederik P Kingma, Max Welling (2016). Auto-Encoding Variational Bayes. ArXiv, abs/1312.6114. https://arxiv.org/abs/1312.6114
+
+[^2]:Diederik P Kingma, Jimmy Lei Ba (2015). Adam: A Method for Stochastic Optimization. ArXiv, abs/1412.6980. https://arxiv.org/abs/1412.6980
+
+[^3]:Mnih, V., Kavukcuoglu, K., Silver, D. et al. Human-level control through deep reinforcement learning. Nature 518, 529–533 (2015). https://doi.org/10.1038/nature14236

cleanrl/docs/rl-algorithms/td3.md

@@ -0,0 +1,260 @@
+# Twin Delayed Deep Deterministic Policy Gradient (TD3)
+
+
+## Overview
+
+TD3 is a popular DRL algorithm for continuous control. It extends DDPG with three techniques: 1) Clipped Double Q-Learning, 2) Delayed Policy Updates, and 3) Target Policy Smoothing Regularization. With these three techniques TD3 shows significantly better performance compared to DDPG.
+
+
+Original paper: 
+
+* [Addressing Function Approximation Error in Actor-Critic Methods](https://arxiv.org/abs/1802.09477)
+
+Reference resources:
+
+* :material-github: [sfujim/TD3](https://github.com/sfujim/TD3)
+* [Twin Delayed DDPG | Spinning Up in Deep RL](https://spinningup.openai.com/en/latest/algorithms/td3.html)
+
+## Implemented Variants
+
+
+| Variants Implemented      | Description |
+| ----------- | ----------- |
+| :material-github: [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py), :material-file-document: [docs](/rl-algorithms/td3/#td3_continuous_actionpy) | For continuous action space |
+| :material-github: [`td3_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action_jax.py), :material-file-document: [docs](/rl-algorithms/td3/#td3_continuous_action_jaxpy) | For continuous action space |
+
+Below are our single-file implementations of TD3:
+
+## `td3_continuous_action.py`
+
+The [td3_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) has the following features:
+
+* For continuous action space
+* Works with the `Box` observation space of low-level features
+* Works with the `Box` (continuous) action space
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[mujoco]"
+    uv run python cleanrl/td3_continuous_action.py --help
+    uv run python cleanrl/td3_continuous_action.py --env-id Hopper-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-mujoco.txt
+    python cleanrl/td3_continuous_action.py --help
+    python cleanrl/td3_continuous_action.py --env-id Hopper-v4
+    ```
+
+### Explanation of the logged metrics
+
+Running `python cleanrl/td3_continuous_action.py` will automatically record various metrics such as various losses in Tensorboard. Below are the documentation for these metrics:
+
+* `charts/episodic_return`: episodic return of the game
+* `charts/SPS`: number of steps per second
+* `losses/qf1_loss`: the MSE between the Q values at timestep $t$ and the target Q values at timestep $t+1$, which minimizes temporal difference. 
+* `losses/actor_loss`: implemented as `-qf1(data.observations, actor(data.observations)).mean()`; it is the *negative* average Q values calculated based on the 1) observations and the 2) actions computed by the actor based on these observations. By minimizing `actor_loss`, the optimizer updates the actors parameter using the following gradient (Fujimoto et al., 2018, Algorithm 1)[^2]:
+
+$$ \nabla_{\phi} J(\phi)=\left.N^{-1} \sum \nabla_{a} Q_{\theta_{1}}(s, a)\right|_{a=\pi_{\phi}(s)} \nabla_{\phi} \pi_{\phi}(s) $$
+
+* `losses/qf1_values`: implemented as `qf1(data.observations, data.actions).view(-1); it is the average Q values of the sampled data in the replay buffer; useful when gauging if under or over estimations happen
+
+
+### Implementation details
+
+Our [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) is based on the [`TD3.py`](https://github.com/sfujim/TD3/blob/master/TD3.py) from :material-github: [sfujim/TD3](https://github.com/sfujim/TD3). Our [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) presents the following implementation differences.
+
+1. [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) uses a two separate objects `qf1` and `qf2` to represents the two Q functions in the Clipped Double Q-learning architecture, whereas  [`TD3.py`](https://github.com/sfujim/TD3/blob/master/TD3.py)  (Fujimoto et al., 2018)[^2] uses a single `Critic` class that contains both Q networks. That said, these two implementations are virtually the same.
+
+2. [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) also adds support for handling continuous environments where the lower and higher bounds of the action space are not $[-1,1]$, or are asymmetric.
+The case where the bounds are not $[-1,1]$ is handled in [`TD3.py`](https://github.com/sfujim/TD3/blob/385b33ac7de4767bab17eb02ade4a268d3e4e24f/TD3.py#L28) (Fujimoto et al., 2018)[^2] as follows:
+```python
+class Actor(nn.Module):
+
+    ...
+
+	def forward(self, state):
+		a = F.relu(self.l1(state))
+		a = F.relu(self.l2(a))
+		return self.max_action * torch.tanh(self.l3(a)) # Scale from [-1,1] to [-action_high, action_high]
+```
+ On the other hand, in [`CleanRL's td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py), the mean and the scale of the action space are computed as `action_bias` and `action_scale` respectively.
+ Those scalars are in turn used to scale the output of a `tanh` activation function in the actor to the original action space range:
+```python
+class Actor(nn.Module):
+    def __init__(self, env):
+        ...
+        # action rescaling
+        self.register_buffer("action_scale", torch.FloatTensor((env.action_space.high - env.action_space.low) / 2.0))
+        self.register_buffer("action_bias", torch.FloatTensor((env.action_space.high + env.action_space.low) / 2.0))
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = torch.tanh(self.fc_mu(x))
+        return x * self.action_scale + self.action_bias # Scale from [-1,1] to [-action_low, action_high]
+```
+
+Additionally, when drawing exploration noise that is added to the actions produced by the actor, [`CleanRL's td3_continuous_action.py`](https://github.com/dosssman/cleanrl/blob/10b606e7bd9bd1b06e455e8ef542df2b7699a20c/cleanrl/td3_continuous_action.py#L180) centers the distribution the sampled from at `action_bias`, and the scale of the distribution is set to `action_scale * exploration_noise`.
+
+???+ info
+
+    Note that `Humanoid-v2`, `InvertedPendulum-v2`, `Pusher-v2` have action space bounds that are not the standard `[-1, 1]`. See below and :material-github: [PR #196](https://github.com/vwxyzjn/cleanrl/issues/196)
+
+    ```
+    Ant-v2 Observation space: Box(-inf, inf, (111,), float64) Action space: Box(-1.0, 1.0, (8,), float32)
+    HalfCheetah-v2 Observation space: Box(-inf, inf, (17,), float64) Action space: Box(-1.0, 1.0, (6,), float32)
+    Hopper-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (3,), float32)
+    Humanoid-v2 Observation space: Box(-inf, inf, (376,), float64) Action space: Box(-0.4, 0.4, (17,), float32)
+    InvertedDoublePendulum-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (1,), float32)
+    InvertedPendulum-v2 Observation space: Box(-inf, inf, (4,), float64) Action space: Box(-3.0, 3.0, (1,), float32)
+    Pusher-v2 Observation space: Box(-inf, inf, (23,), float64) Action space: Box(-2.0, 2.0, (7,), float32)
+    Reacher-v2 Observation space: Box(-inf, inf, (11,), float64) Action space: Box(-1.0, 1.0, (2,), float32)
+    Swimmer-v2 Observation space: Box(-inf, inf, (8,), float64) Action space: Box(-1.0, 1.0, (2,), float32)
+    Walker2d-v2 Observation space: Box(-inf, inf, (17,), float64) Action space: Box(-1.0, 1.0, (6,), float32)
+    ```
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/td3.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/td3.sh). Specifically, execute the following command:
+
+``` title="benchmark/td3.sh" linenums="1"
+--8<-- "benchmark/td3.sh::7"
+```
+
+
+Below are the average episodic returns for [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) (3 random seeds). To ensure the quality of the implementation, we compared the results against (Fujimoto et al., 2018)[^2].
+
+| Environment      | [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) | [`TD3.py`](https://github.com/sfujim/TD3/blob/master/TD3.py) (Fujimoto et al., 2018, Table 1)[^2]  |
+| ----------- | ----------- | ----------- | 
+| HalfCheetah-v4      |   9583.22 ± 126.09      |9636.95 ± 859.065  |
+| Walker2d-v4   |         4057.59 ± 658.78     |  4682.82 ± 539.64 | 
+| Hopper-v4   |           3134.61 ± 360.18        |  3564.07 ± 114.74 | 
+| InvertedPendulum-v4 |   968.99 ± 25.80    | 1000.00 ± 0.00  | 
+| Humanoid-v4 |           5035.36 ± 21.67      |  not available | 
+| Pusher-v4 |             -30.92 ± 1.05      |  not available | 
+
+
+
+???+ info
+
+    Note that [`td3_continuous_action.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py) uses gym MuJoCo v4 environments while [`TD3.py`](https://github.com/sfujim/TD3/blob/master/TD3.py) (Fujimoto et al., 2018)[^2] uses the gym MuJoCo v1 environments.
+
+    Also note the performance of our `td3_continuous_action.py` seems to be worse than the reference implementation on Walker2d. This is likely due to :material-github: [openai/gym#938](https://github.com/openai/baselines/issues/938). We would have a hard time reproducing gym MuJoCo v1 environments because they have been long deprecated.
+
+    One other thing could cause the performance difference: the original code reported the average episodic return using determinisitc evaluation (i.e., without exploration noise), see [`sfujim/TD3/main.py#L15-L32`](https://github.com/sfujim/TD3/blob/385b33ac7de4767bab17eb02ade4a268d3e4e24f/main.py#L15-L32), whereas we reported the episodic return during training and the policy gets updated between environments steps.
+
+Learning curves:
+
+``` title="benchmark/td3_plot.sh" linenums="1"
+--8<-- "benchmark/td3_plot.sh::9"
+```
+
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/td3.png">
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/td3-time.png">
+
+Tracked experiments and game play videos:
+
+<iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/MuJoCo-CleanRL-s-TD3--VmlldzoxNjk4Mzk5" style="width:100%; height:500px" title="MuJoCo: CleanRL's TD3"></iframe>
+
+
+
+
+## `td3_continuous_action_jax.py`
+
+The [td3_continuous_action_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action_jax.py) has the following features:
+
+* Uses [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Optax](https://github.com/deepmind/optax) instead of `torch`.  [td3_continuous_action_jax.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action_jax.py) is roughly 2.5-4x faster than  [td3_continuous_action.py](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action.py)
+* For continuous action space
+* Works with the `Box` observation space of low-level features
+* Works with the `Box` (continuous) action space
+
+### Usage
+
+=== "poetry"
+
+    ```bash
+    uv pip install ".[mujoco, jax]"
+    uv run python cleanrl/td3_continuous_action_jax.py --help
+    uv run python cleanrl/td3_continuous_action_jax.py --env-id Hopper-v4
+    ```
+
+=== "pip"
+
+    ```bash
+    pip install -r requirements/requirements-mujoco.txt  
+    pip install -r requirements/requirements-jax.txt
+    python cleanrl/td3_continuous_action_jax.py --help
+    python cleanrl/td3_continuous_action_jax.py --env-id Hopper-v4
+    ```
+
+### Explanation of the logged metrics
+
+See [related docs](/rl-algorithms/td3/#explanation-of-the-logged-metrics) for `td3_continuous_action.py`.
+
+
+### Implementation details
+
+See [related docs](/rl-algorithms/td3/#implementation-details) for `td3_continuous_action.py`.
+
+
+### Experiment results
+
+To run benchmark experiments, see :material-github: [benchmark/td3.sh](https://github.com/vwxyzjn/cleanrl/blob/master/benchmark/td3.sh). Specifically, execute the following command:
+
+``` title="benchmark/td3.sh" linenums="1"
+--8<-- "benchmark/td3.sh:12:19"
+```
+
+Below are the average episodic returns for [`td3_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action_jax.py) (3 random seeds).
+
+{!benchmark/td3.md!}
+
+Learning curves:
+
+
+``` title="benchmark/td3_plot.sh" linenums="1"
+--8<-- "benchmark/td3_plot.sh:11:20"
+```
+
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/td3.png">
+<img loading="lazy" src="https://huggingface.co/datasets/cleanrl/benchmark/resolve/main/benchmark/pr-424/td3-time.png">
+
+???+ info
+
+    These are some previous experiments with TPUs. Note the results are very similar to the ones above, but the runtime can be different due to different hardware used.
+
+    Note that the experiments were conducted on different hardwares, so your mileage might vary. This inconsistency is because 1) re-running expeirments on the same hardware is computationally expensive and 2) requiring the same hardware is not inclusive nor feasible to other contributors who might have different hardwares.
+
+    That said, we roughly expect to see a 2-4x speed improvement from using [`td3_continuous_action_jax.py`](https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/td3_continuous_action_jax.py) under the same hardware. And if you disable the `--capture_video` overhead, the speed improvement will be even higher.
+
+    Learning curves:
+
+
+    <div class="grid-container">
+    <img loading="lazy" src="../td3-jax/HalfCheetah-v2.png">
+    <img loading="lazy" src="../td3-jax/HalfCheetah-v2-time.png">
+
+    <img loading="lazy" src="../td3-jax/Walker2d-v2.png">
+    <img loading="lazy" src="../td3-jax/Walker2d-v2-time.png">
+
+    <img loading="lazy" src="../td3-jax/Hopper-v2.png">
+    <img loading="lazy" src="../td3-jax/Hopper-v2-time.png">
+    </div>
+
+
+
+    Tracked experiments and game play videos:
+
+    <iframe src="https://wandb.ai/openrlbenchmark/openrlbenchmark/reports/MuJoCo-CleanRL-s-TD3-JAX--VmlldzoyMzU1OTA4" style="width:100%; height:500px" title="MuJoCo: CleanRL's TD3 + JAX"></iframe>
+
+
+
+[^1]:Lillicrap, T.P., Hunt, J.J., Pritzel, A., Heess, N.M., Erez, T., Tassa, Y., Silver, D., & Wierstra, D. (2016). Continuous control with deep reinforcement learning. CoRR, abs/1509.02971. https://arxiv.org/abs/1509.02971
+
+[^2]:Fujimoto, S., Hoof, H.V., & Meger, D. (2018). Addressing Function Approximation Error in Actor-Critic Methods. ArXiv, abs/1802.09477. https://arxiv.org/abs/1802.09477

cleanrl/docs/stylesheets/extra.css

@@ -0,0 +1,6 @@
+.grid-container {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    image-rendering: -webkit-optimize-contrast;
+    grid-gap: 50px;
+}

cleanrl/envs/__init__.py

@@ -0,0 +1,4 @@
+"""Environment utilities package"""
+from .common import Difficulty
+
+__all__ = ["Difficulty"]

cleanrl/envs/common.py

@@ -0,0 +1,11 @@
+"""
+Common utilities and enums for environments
+"""
+from enum import Enum
+
+
+class Difficulty(Enum):
+    """Difficulty levels for environments"""
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"

cleanrl/requirements/requirements-atari.txt

@@ -0,0 +1,295 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-atari.txt --extra atari
+-e .
+absl-py==1.4.0
+    # via tensorboard
+ale-py==0.8.1
+    # via cleanrl
+appdirs==1.4.4
+    # via wandb
+autorom==0.4.2
+    # via cleanrl
+autorom-accept-rom-license==0.6.1
+    # via autorom
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via
+    #   autorom
+    #   autorom-accept-rom-license
+    #   wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via
+    #   cleanrl
+    #   shimmy
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   ale-py
+    #   gym
+    #   gymnasium
+    #   markdown
+importlib-resources==5.12.0
+    # via
+    #   ale-py
+    #   autorom
+    #   autorom-accept-rom-license
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   ale-py
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   opencv-python
+    #   shimmy
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+opencv-python==4.7.0.72
+    # via cleanrl
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   autorom
+    #   autorom-accept-rom-license
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shimmy==1.1.0
+    # via cleanrl
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   autorom
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   ale-py
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   ale-py
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via
+    #   importlib-metadata
+    #   importlib-resources

cleanrl/requirements/requirements-cloud.txt

@@ -0,0 +1,291 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-cloud.txt --extra cloud
+-e .
+absl-py==1.4.0
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+awscli==1.31.0
+    # via cleanrl
+boto3==1.33.0
+    # via cleanrl
+botocore==1.33.0
+    # via
+    #   awscli
+    #   boto3
+    #   s3transfer
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   awscli
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+docutils==0.16
+    # via awscli
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+jmespath==1.0.1
+    # via
+    #   boto3
+    #   botocore
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+python-dateutil==2.8.2
+    # via botocore
+pyyaml==6.0.1
+    # via
+    #   awscli
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via
+    #   awscli
+    #   google-auth
+s3transfer==0.8.0
+    # via
+    #   awscli
+    #   boto3
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+    #   python-dateutil
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   botocore
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements-dm_control.txt

@@ -0,0 +1,315 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-dm_control.txt --extra dm_control
+-e .
+absl-py==1.4.0
+    # via
+    #   dm-control
+    #   dm-env
+    #   labmaze
+    #   mujoco
+    #   tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+dm-control==1.0.11
+    # via cleanrl
+dm-env==1.6
+    # via dm-control
+dm-tree==0.1.8
+    # via
+    #   dm-control
+    #   dm-env
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+glfw==1.12.0
+    # via
+    #   dm-control
+    #   mujoco
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via
+    #   cleanrl
+    #   shimmy
+h5py==3.8.0
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+labmaze==1.0.6
+    # via dm-control
+lxml==4.9.3
+    # via dm-control
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+mujoco==2.3.3
+    # via
+    #   cleanrl
+    #   dm-control
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   dm-control
+    #   dm-env
+    #   gym
+    #   gymnasium
+    #   h5py
+    #   imageio
+    #   labmaze
+    #   moviepy
+    #   mujoco
+    #   scipy
+    #   shimmy
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   dm-control
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyopengl==3.1.6
+    # via
+    #   dm-control
+    #   mujoco
+pyparsing==3.0.9
+    # via dm-control
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   dm-control
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+scipy==1.10.1
+    # via dm-control
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   dm-control
+    #   labmaze
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shimmy==1.1.0
+    # via cleanrl
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   dm-control
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements-docs.txt

@@ -0,0 +1,365 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-docs.txt --extra docs
+-e .
+absl-py==1.4.0
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via
+    #   mkdocs
+    #   wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   mkdocs
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+cycler==0.11.0
+    # via matplotlib
+dataclasses==0.6
+    # via expt
+decorator==4.4.2
+    # via moviepy
+dill==0.3.6
+    # via multiprocess
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+expt==0.4.1
+    # via openrlbenchmark
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fonttools==4.38.0
+    # via matplotlib
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+ghp-import==2.1.0
+    # via mkdocs
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+    #   mkdocs
+    #   openrlbenchmark
+jinja2==3.1.2
+    # via
+    #   mkdocs
+    #   mkdocs-material
+    #   torch
+kiwisolver==1.4.4
+    # via matplotlib
+markdown==3.3.7
+    # via
+    #   markdown-include
+    #   mkdocs
+    #   mkdocs-material
+    #   pymdown-extensions
+    #   tensorboard
+markdown-include==0.7.2
+    # via cleanrl
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+matplotlib==3.5.3
+    # via
+    #   expt
+    #   seaborn
+    #   tueplots
+mergedeep==1.3.4
+    # via mkdocs
+mkdocs==1.4.3
+    # via mkdocs-material
+mkdocs-material==8.5.11
+    # via cleanrl
+mkdocs-material-extensions==1.1.1
+    # via mkdocs-material
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+multiprocess==0.70.14
+    # via
+    #   expt
+    #   openrlbenchmark
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   expt
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   matplotlib
+    #   moviepy
+    #   pandas
+    #   scipy
+    #   seaborn
+    #   tensorboard
+    #   tueplots
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+openrlbenchmark==0.1.1b4
+    # via cleanrl
+packaging==23.1
+    # via
+    #   huggingface-hub
+    #   matplotlib
+    #   mkdocs
+pandas==1.3.5
+    # via
+    #   expt
+    #   seaborn
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via
+    #   imageio
+    #   matplotlib
+pip==22.3.1
+    # via openrlbenchmark
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via
+    #   mkdocs-material
+    #   rich
+pymdown-extensions==9.11
+    # via mkdocs-material
+pyparsing==3.0.9
+    # via matplotlib
+python-dateutil==2.8.2
+    # via
+    #   ghp-import
+    #   matplotlib
+    #   pandas
+pytz==2023.3
+    # via pandas
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   mkdocs
+    #   pre-commit
+    #   pymdown-extensions
+    #   pyyaml-env-tag
+    #   wandb
+pyyaml-env-tag==0.1
+    # via mkdocs
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   mkdocs-material
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   openrlbenchmark
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+scipy==1.10.1
+    # via expt
+seaborn==0.12.2
+    # via openrlbenchmark
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+    #   python-dateutil
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tabulate==0.9.0
+    # via openrlbenchmark
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   openrlbenchmark
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+tueplots==0.0.4
+    # via openrlbenchmark
+typeguard==2.13.3
+    # via expt
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via
+    #   cleanrl
+    #   openrlbenchmark
+watchdog==3.0.0
+    # via mkdocs
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0
+    # via importlib-metadata

cleanrl/requirements/requirements-envpool.txt

@@ -0,0 +1,309 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-envpool.txt --extra envpool
+-e .
+absl-py==1.4.0
+    # via
+    #   dm-env
+    #   tensorboard
+appdirs==1.4.4
+    # via wandb
+bitmath==1.3.3.1
+    # via hbutils
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+chardet==4.0.0
+    # via hbutils
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via
+    #   treevalue
+    #   wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+dill==0.3.6
+    # via treevalue
+distlib==0.3.6
+    # via virtualenv
+dm-env==1.6
+    # via envpool
+dm-tree==0.1.8
+    # via dm-env
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+enum-tools==0.9.0.post1
+    # via treevalue
+envpool==0.6.6
+    # via cleanrl
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+graphviz==0.20.1
+    # via treevalue
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via
+    #   cleanrl
+    #   envpool
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+hbutils==0.8.6
+    # via treevalue
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   dm-env
+    #   envpool
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   opencv-python
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+opencv-python==4.7.0.72
+    # via cleanrl
+packaging==23.1
+    # via
+    #   envpool
+    #   hbutils
+    #   huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via
+    #   enum-tools
+    #   rich
+pytimeparse==1.1.8
+    # via hbutils
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   hbutils
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+treevalue==1.4.10
+    # via envpool
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+types-protobuf==4.23.0.1
+    # via envpool
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   enum-tools
+    #   envpool
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   enum-tools
+    #   envpool
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements-jax.txt

@@ -0,0 +1,358 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-jax.txt --extra jax
+-e .
+absl-py==1.4.0
+    # via
+    #   chex
+    #   optax
+    #   orbax
+    #   tensorboard
+appdirs==1.4.4
+    # via wandb
+cached-property==1.5.2
+    # via orbax
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+chex==0.1.5
+    # via
+    #   cleanrl
+    #   optax
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   pytest
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+dm-tree==0.1.8
+    # via chex
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+etils==0.9.0
+    # via orbax
+exceptiongroup==1.1.1
+    # via pytest
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+flax==0.6.8
+    # via
+    #   cleanrl
+    #   orbax
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+importlib-resources==5.12.0
+    # via orbax
+iniconfig==2.0.0
+    # via pytest
+jax==0.4.8
+    # via
+    #   chex
+    #   cleanrl
+    #   flax
+    #   optax
+    #   orbax
+jaxlib==0.4.7
+    # via
+    #   chex
+    #   cleanrl
+    #   optax
+    #   orbax
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+ml-dtypes==0.2.0 ; python_full_version < '3.10'
+    # via
+    #   jax
+    #   jaxlib
+ml-dtypes==0.5.1 ; python_full_version >= '3.10'
+    # via
+    #   jax
+    #   jaxlib
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+msgpack==1.0.5
+    # via flax
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   chex
+    #   flax
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   jax
+    #   jaxlib
+    #   ml-dtypes
+    #   moviepy
+    #   opt-einsum
+    #   optax
+    #   orbax
+    #   scipy
+    #   tensorboard
+    #   tensorstore
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+opt-einsum==3.3.0
+    # via jax
+optax==0.1.4
+    # via
+    #   cleanrl
+    #   flax
+orbax==0.1.0
+    # via flax
+packaging==23.1
+    # via
+    #   huggingface-hub
+    #   pytest
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pluggy==1.0.0
+    # via pytest
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pytest==7.3.1
+    # via orbax
+pyyaml==6.0.1
+    # via
+    #   flax
+    #   huggingface-hub
+    #   orbax
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   flax
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+scipy==1.10.1
+    # via
+    #   cleanrl
+    #   jax
+    #   jaxlib
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+tensorstore==0.1.28
+    # via
+    #   flax
+    #   orbax
+tomli==2.0.1
+    # via pytest
+toolz==0.12.0
+    # via chex
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   flax
+    #   gymnasium
+    #   huggingface-hub
+    #   optax
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   flax
+    #   gymnasium
+    #   huggingface-hub
+    #   optax
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via
+    #   importlib-metadata
+    #   importlib-resources

cleanrl/requirements/requirements-memory_gym.txt

@@ -0,0 +1,180 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file ../../requirements/requirements-memory_gym.txt
+-e .
+absl-py==2.3.1
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+backports-shutil-get-terminal-size==1.0.0
+    # via reprint
+certifi==2025.6.15
+    # via
+    #   requests
+    #   sentry-sdk
+charset-normalizer==3.4.2
+    # via requests
+click==8.2.1
+    # via wandb
+cloudpickle==3.1.1
+    # via gymnasium
+colorama==0.4.6
+    # via
+    #   click
+    #   reprint
+    #   tyro
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.16
+    # via tyro
+einops==0.7.0
+    # via ppo-trxl
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.18.0
+    # via torch
+fsspec==2025.5.1
+    # via torch
+gitdb==4.0.12
+    # via gitpython
+gitpython==3.1.44
+    # via wandb
+grpcio==1.73.1
+    # via tensorboard
+gymnasium==0.29.0
+    # via
+    #   memory-gym
+    #   minigrid
+idna==3.10
+    # via requests
+jinja2==3.1.6
+    # via torch
+markdown==3.8.2
+    # via tensorboard
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==3.0.2
+    # via
+    #   jinja2
+    #   werkzeug
+mdurl==0.1.2
+    # via markdown-it-py
+memory-gym==1.0.2
+    # via ppo-trxl
+minigrid==2.5.0
+    # via ppo-trxl
+mpmath==1.3.0
+    # via sympy
+networkx==3.4.2 ; python_full_version < '3.11'
+    # via torch
+networkx==3.5 ; python_full_version >= '3.11'
+    # via torch
+numpy==2.2.6 ; python_full_version < '3.11'
+    # via
+    #   gymnasium
+    #   minigrid
+    #   opencv-python
+    #   tensorboard
+numpy==2.3.1 ; python_full_version >= '3.11'
+    # via
+    #   gymnasium
+    #   minigrid
+    #   opencv-python
+    #   tensorboard
+nvidia-cublas-cu11==11.11.3.6 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu11
+    #   nvidia-cusolver-cu11
+    #   torch
+nvidia-cuda-cupti-cu11==11.8.87 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu11==11.8.89 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu11==11.8.89 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu11==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu11==10.9.0.58 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu11==10.3.0.86 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu11==11.4.1.48 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu11==11.7.5.86 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nccl-cu11==2.21.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvtx-cu11==11.8.86 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+opencv-python==4.11.0.86
+    # via ppo-trxl
+packaging==25.0
+    # via tensorboard
+protobuf==4.25.8
+    # via
+    #   tensorboard
+    #   wandb
+psutil==7.0.0
+    # via wandb
+pygame==2.4.0
+    # via
+    #   memory-gym
+    #   minigrid
+pygments==2.19.2
+    # via rich
+pyyaml==6.0.2
+    # via wandb
+reprint==0.6.0
+    # via ppo-trxl
+requests==2.32.4
+    # via wandb
+rich==14.0.0
+    # via tyro
+sentry-sdk==2.32.0
+    # via wandb
+setproctitle==1.3.6
+    # via wandb
+setuptools==80.9.0
+    # via
+    #   tensorboard
+    #   torch
+    #   triton
+    #   wandb
+shtab==1.7.2
+    # via tyro
+six==1.17.0
+    # via
+    #   docker-pycreds
+    #   reprint
+    #   tensorboard
+smmap==5.0.2
+    # via gitdb
+sympy==1.14.0
+    # via torch
+tensorboard==2.19.0
+    # via ppo-trxl
+tensorboard-data-server==0.7.2
+    # via tensorboard
+torch==2.7.1+cu118
+    # via
+    #   ppo-trxl
+    #   torchaudio
+torchaudio==2.7.1+cu118
+    # via ppo-trxl
+triton==3.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.14.1
+    # via
+    #   gymnasium
+    #   rich
+    #   torch
+    #   tyro
+tyro==0.8.14
+    # via ppo-trxl
+urllib3==2.5.0
+    # via
+    #   requests
+    #   sentry-sdk
+wandb==0.16.6
+    # via ppo-trxl
+werkzeug==3.1.3
+    # via tensorboard

cleanrl/requirements/requirements-mujoco.txt

@@ -0,0 +1,275 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-mujoco.txt --extra mujoco
+-e .
+absl-py==1.4.0
+    # via
+    #   mujoco
+    #   tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+glfw==1.12.0
+    # via mujoco
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via
+    #   cleanrl
+    #   moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+mujoco==2.3.3
+    # via cleanrl
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   mujoco
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyopengl==3.1.6
+    # via mujoco
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements-optuna.txt

@@ -0,0 +1,316 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-optuna.txt --extra optuna
+-e .
+absl-py==1.4.0
+    # via tensorboard
+alembic==1.10.4
+    # via optuna
+appdirs==1.4.4
+    # via wandb
+bottle==0.12.25
+    # via optuna-dashboard
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+cmaes==0.10.0
+    # via optuna
+colorama==0.4.4
+    # via
+    #   click
+    #   colorlog
+    #   rich
+    #   tqdm
+    #   tyro
+colorlog==6.7.0
+    # via optuna
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+greenlet==2.0.2 ; platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'
+    # via sqlalchemy
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   alembic
+    #   gym
+    #   gymnasium
+    #   markdown
+importlib-resources==5.12.0 ; python_full_version < '3.9'
+    # via alembic
+jinja2==3.1.2
+    # via torch
+joblib==1.2.0
+    # via scikit-learn
+mako==1.2.4
+    # via alembic
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   mako
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   cmaes
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   optuna
+    #   scikit-learn
+    #   scipy
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+optuna==3.3.0
+    # via
+    #   cleanrl
+    #   optuna-dashboard
+optuna-dashboard==0.7.3
+    # via cleanrl
+packaging==23.1
+    # via
+    #   huggingface-hub
+    #   optuna
+    #   optuna-dashboard
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   optuna
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+scikit-learn==1.0.2
+    # via optuna-dashboard
+scipy==1.10.1
+    # via scikit-learn
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sqlalchemy==2.0.13
+    # via
+    #   alembic
+    #   optuna
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+threadpoolctl==3.1.0
+    # via scikit-learn
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   optuna
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   alembic
+    #   cleanrl
+    #   gymnasium
+    #   huggingface-hub
+    #   sqlalchemy
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   alembic
+    #   cleanrl
+    #   gymnasium
+    #   huggingface-hub
+    #   sqlalchemy
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via
+    #   importlib-metadata
+    #   importlib-resources

cleanrl/requirements/requirements-pettingzoo.txt

@@ -0,0 +1,280 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-pettingzoo.txt --extra pettingzoo
+-e .
+absl-py==1.4.0
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via
+    #   cleanrl
+    #   pettingzoo
+    #   supersuit
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+multi-agent-ale-py==0.1.11
+    # via cleanrl
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   multi-agent-ale-py
+    #   pettingzoo
+    #   tensorboard
+    #   tinyscaler
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pettingzoo==1.18.1
+    # via
+    #   cleanrl
+    #   supersuit
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+supersuit==3.4.0
+    # via cleanrl
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+tinyscaler==1.2.5
+    # via supersuit
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements-procgen.txt

@@ -0,0 +1,287 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements-procgen.txt --extra procgen
+-e .
+absl-py==1.4.0
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cffi==1.15.1
+    # via gym3
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   procgen
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+glcontext==2.3.7
+    # via moderngl
+glfw==1.12.0
+    # via gym3
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via
+    #   cleanrl
+    #   procgen
+gym-notices==0.0.8
+    # via gym
+gym3==0.3.3
+    # via procgen
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via
+    #   gym3
+    #   moviepy
+imageio-ffmpeg==0.3.0
+    # via
+    #   gym3
+    #   moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moderngl==5.8.2
+    # via gym3
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   gym
+    #   gym3
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   procgen
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+procgen==0.10.7
+    # via cleanrl
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pycparser==2.21
+    # via cffi
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/requirements/requirements.txt

@@ -0,0 +1,264 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --no-hashes --output-file requirements/requirements.txt
+-e .
+absl-py==1.4.0
+    # via tensorboard
+appdirs==1.4.4
+    # via wandb
+cachetools==5.3.0
+    # via google-auth
+certifi==2023.5.7
+    # via
+    #   requests
+    #   sentry-sdk
+cfgv==3.3.1
+    # via pre-commit
+charset-normalizer==3.1.0
+    # via requests
+click==8.1.3
+    # via wandb
+cloudpickle==2.2.1
+    # via
+    #   gym
+    #   gymnasium
+colorama==0.4.4
+    # via
+    #   click
+    #   rich
+    #   tqdm
+    #   tyro
+commonmark==0.9.1
+    # via rich
+decorator==4.4.2
+    # via moviepy
+distlib==0.3.6
+    # via virtualenv
+docker-pycreds==0.4.0
+    # via wandb
+docstring-parser==0.15
+    # via tyro
+farama-notifications==0.0.4
+    # via gymnasium
+filelock==3.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   triton
+    #   virtualenv
+fsspec==2025.3.0 ; python_full_version < '3.9'
+    # via torch
+fsspec==2025.5.1 ; python_full_version >= '3.9'
+    # via torch
+gitdb==4.0.10
+    # via gitpython
+gitpython==3.1.31
+    # via wandb
+google-auth==2.18.0
+    # via
+    #   google-auth-oauthlib
+    #   tensorboard
+google-auth-oauthlib==0.4.6
+    # via tensorboard
+grpcio==1.54.0
+    # via tensorboard
+gym==0.23.1
+    # via cleanrl
+gym-notices==0.0.8
+    # via gym
+gymnasium==0.29.1
+    # via cleanrl
+huggingface-hub==0.11.1
+    # via cleanrl
+identify==2.5.24
+    # via pre-commit
+idna==3.4
+    # via requests
+imageio==2.28.1
+    # via moviepy
+imageio-ffmpeg==0.3.0
+    # via moviepy
+importlib-metadata==5.2.0 ; python_full_version < '3.10'
+    # via
+    #   gym
+    #   gymnasium
+    #   markdown
+jinja2==3.1.2
+    # via torch
+markdown==3.3.7
+    # via tensorboard
+markupsafe==2.1.2
+    # via
+    #   jinja2
+    #   werkzeug
+moviepy==1.0.3
+    # via cleanrl
+mpmath==1.3.0
+    # via sympy
+networkx==3.1 ; python_full_version < '3.9'
+    # via torch
+networkx==3.2.1 ; python_full_version == '3.9.*'
+    # via torch
+networkx==3.4.2 ; python_full_version >= '3.10'
+    # via torch
+nodeenv==1.7.0
+    # via pre-commit
+numpy==1.24.4
+    # via
+    #   gym
+    #   gymnasium
+    #   imageio
+    #   moviepy
+    #   tensorboard
+nvidia-cublas-cu12==12.1.3.1 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cuda-runtime-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cudnn-cu12==9.1.0.70 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cufft-cu12==11.0.2.54 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-curand-cu12==10.3.2.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusolver-cu12==11.4.5.107 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-cusparse-cu12==12.1.0.106 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-nccl-cu12==2.20.5 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+nvidia-nvjitlink-cu12==12.4.127 ; python_full_version < '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvjitlink-cu12==12.6.85 ; python_full_version >= '3.9' and platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+nvidia-nvtx-cu12==12.1.105 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+oauthlib==3.2.2
+    # via requests-oauthlib
+packaging==23.1
+    # via huggingface-hub
+pathtools==0.1.2
+    # via wandb
+pillow==9.5.0
+    # via imageio
+platformdirs==3.5.0
+    # via virtualenv
+pre-commit==2.21.0
+proglog==0.1.10
+    # via moviepy
+protobuf==3.20.3
+    # via
+    #   tensorboard
+    #   wandb
+psutil==5.9.5
+    # via wandb
+pyasn1==0.5.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.3.0
+    # via google-auth
+pygame==2.1.0
+    # via cleanrl
+pygments==2.15.1
+    # via rich
+pyyaml==6.0.1
+    # via
+    #   huggingface-hub
+    #   pre-commit
+    #   wandb
+requests==2.30.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   requests-oauthlib
+    #   tensorboard
+    #   wandb
+requests-oauthlib==1.3.1
+    # via google-auth-oauthlib
+rich==11.2.0
+    # via
+    #   cleanrl
+    #   tyro
+rsa==4.7.2
+    # via google-auth
+sentry-sdk==1.22.2
+    # via wandb
+setproctitle==1.3.2
+    # via wandb
+setuptools==67.7.2
+    # via
+    #   nodeenv
+    #   tensorboard
+    #   wandb
+shtab==1.6.4
+    # via tyro
+six==1.16.0
+    # via
+    #   docker-pycreds
+    #   google-auth
+smmap==5.0.0
+    # via gitdb
+sympy==1.12.1 ; python_full_version < '3.9'
+    # via torch
+sympy==1.14.0 ; python_full_version >= '3.9'
+    # via torch
+tenacity==8.2.3
+    # via cleanrl
+tensorboard==2.11.2
+    # via cleanrl
+tensorboard-data-server==0.6.1
+    # via tensorboard
+tensorboard-plugin-wit==1.8.1
+    # via tensorboard
+torch==2.4.1
+    # via cleanrl
+tqdm==4.65.0
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   proglog
+triton==3.0.0 ; platform_machine == 'x86_64' and sys_platform == 'linux'
+    # via torch
+typing-extensions==4.13.2 ; python_full_version < '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+typing-extensions==4.14.1 ; python_full_version >= '3.9'
+    # via
+    #   gymnasium
+    #   huggingface-hub
+    #   torch
+    #   tyro
+    #   wandb
+tyro==0.5.10
+    # via cleanrl
+urllib3==1.26.15
+    # via
+    #   google-auth
+    #   requests
+    #   sentry-sdk
+virtualenv==20.21.0
+    # via pre-commit
+wandb==0.13.11
+    # via cleanrl
+werkzeug==2.2.3
+    # via tensorboard
+wheel==0.40.0
+    # via tensorboard
+zipp==3.15.0 ; python_full_version < '3.10'
+    # via importlib-metadata

cleanrl/tests/test_atari.py

@@ -0,0 +1,17 @@
+import subprocess
+
+
+def test_ppo():
+    subprocess.run(
+        "python cleanrl/ppo_atari.py --num-envs 1 --num-steps 64 --total-timesteps 256",
+        shell=True,
+        check=True,
+    )
+
+
+def test_ppo_lstm():
+    subprocess.run(
+        "python cleanrl/ppo_atari_lstm.py --num-envs 4 --num-steps 64 --total-timesteps 256",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_atari_gymnasium.py

@@ -0,0 +1,73 @@
+import subprocess
+
+
+def test_dqn():
+    subprocess.run(
+        "python cleanrl/dqn_atari.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_dqn_eval():
+    subprocess.run(
+        "python cleanrl/dqn_atari.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_qdagger_dqn_atari_impalacnn():
+    subprocess.run(
+        "python cleanrl/qdagger_dqn_atari_impalacnn.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4 --teacher-steps 16 --offline-steps 16 --teacher-eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_qdagger_dqn_atari_impalacnn_eval():
+    subprocess.run(
+        "python cleanrl/qdagger_dqn_atari_impalacnn.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4 --teacher-steps 16 --offline-steps 16 --teacher-eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_atari():
+    subprocess.run(
+        "python cleanrl/c51_atari.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_atari_eval():
+    subprocess.run(
+        "python cleanrl/c51_atari.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_rainbow_atari():
+    subprocess.run(
+        "python cleanrl/rainbow_atari.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_rainbow_atari_eval():
+    subprocess.run(
+        "python cleanrl/rainbow_atari.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_sac():
+    subprocess.run(
+        "python cleanrl/sac_atari.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_atari_jax_gymnasium.py

@@ -0,0 +1,49 @@
+import subprocess
+
+
+def test_dqn_jax():
+    subprocess.run(
+        "python cleanrl/dqn_atari_jax.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_dqn_jax_eval():
+    subprocess.run(
+        "python cleanrl/dqn_atari_jax.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_qdagger_dqn_atari_jax_impalacnn():
+    subprocess.run(
+        "python cleanrl/qdagger_dqn_atari_jax_impalacnn.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4 --teacher-steps 16 --offline-steps 16 --teacher-eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_qdagger_dqn_atari_jax_impalacnn_eval():
+    subprocess.run(
+        "python cleanrl/qdagger_dqn_atari_jax_impalacnn.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4 --teacher-steps 16 --offline-steps 16 --teacher-eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_atari_jax():
+    subprocess.run(
+        "python cleanrl/c51_atari_jax.py --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_atari_jax_eval():
+    subprocess.run(
+        "python cleanrl/c51_atari_jax.py --save-model --learning-starts 10 --total-timesteps 16 --buffer-size 10 --batch-size 4",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_atari_multigpu.py

@@ -0,0 +1,9 @@
+import subprocess
+
+
+def test_ppo_multigpu():
+    subprocess.run(
+        "torchrun --standalone --nnodes=1 --nproc_per_node=2 cleanrl/ppo_atari_multigpu.py --num-envs 8 --num-steps 32 --total-timesteps 256",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_classic_control.py

@@ -0,0 +1,9 @@
+import subprocess
+
+
+def test_ppo():
+    subprocess.run(
+        "python cleanrl/ppo.py --num-envs 1 --num-steps 64 --total-timesteps 256",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_classic_control_gymnasium.py

@@ -0,0 +1,25 @@
+import subprocess
+
+
+def test_dqn():
+    subprocess.run(
+        "python cleanrl/dqn.py --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51():
+    subprocess.run(
+        "python cleanrl/c51.py --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_eval():
+    subprocess.run(
+        "python cleanrl/c51.py --save-model --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_classic_control_jax_gymnasium.py

@@ -0,0 +1,25 @@
+import subprocess
+
+
+def test_dqn_jax():
+    subprocess.run(
+        "python cleanrl/dqn_jax.py --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_jax():
+    subprocess.run(
+        "python cleanrl/c51_jax.py --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )
+
+
+def test_c51_jax_eval():
+    subprocess.run(
+        "python cleanrl/c51_jax.py --save-model --learning-starts 200 --total-timesteps 205",
+        shell=True,
+        check=True,
+    )

cleanrl/tests/test_enjoy.py

@@ -0,0 +1,25 @@
+import subprocess
+
+
+def test_dqn():
+    subprocess.run(
+        "python enjoy.py --exp-name dqn --env CartPole-v1 --eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_dqn_atari():
+    subprocess.run(
+        "python enjoy.py --exp-name dqn_atari --env BreakoutNoFrameskip-v4 --eval-episodes 1",
+        shell=True,
+        check=True,
+    )
+
+
+def test_dqn_jax():
+    subprocess.run(
+        "python enjoy.py --exp-name dqn_jax --env CartPole-v1 --eval-episodes 1",
+        shell=True,
+        check=True,
+    )