Add files using upload-large-folder tool

README.md

@@ -0,0 +1,382 @@
+<h1 align="center"> RAGEN: Training Agents by Reinforcing Reasoning </h1>
+
+
+<p align="center"><img src="public/ragen_logo.jpeg" width="300px" alt="RAGEN icon" /></p>
+
+
+
+<p align="center" style="font-size: 18px;">
+  <strong>RAGEN</strong> (<b>R</b>easoning <b>AGEN</b>t, pronounced like "region") leverages reinforcement learning (RL) to train <br>
+  <strong>LLM reasoning agents</strong> in interactive, stochastic environments.<br>
+  <em>We strongly believe in the future of RL + LLM + Agents. The release is a minimally viable leap forward.</em>
+</p>
+
+
+<p align="center">
+  <a href="https://ragen-ai.github.io/"><img src="https://img.shields.io/badge/📝_HomePage-FF5722?style=for-the-badge&logoColor=white" alt="Blog"></a>
+  <a href="https://arxiv.org/abs/2504.20073"><img src="https://img.shields.io/badge/📄_Paper-EA4335?style=for-the-badge&logoColor=white" alt="Paper"></a>
+  <a href="https://ragen-doc.readthedocs.io/"><img src="https://img.shields.io/badge/📚_Documentation-4285F4?style=for-the-badge&logoColor=white" alt="Documentation"></a>
+  <a href="https://x.com/wzihanw/status/1915052871474712858"><img src="https://img.shields.io/badge/🔍_Post-34A853?style=for-the-badge&logoColor=white" alt="Post"></a>
+  <a href="https://api.wandb.ai/links/zihanwang-ai-northwestern-university/a8er8l7b"><img src="https://img.shields.io/badge/🧪_Experiment_Log-AB47BC?style=for-the-badge&logoColor=white" alt="Experiment Log"></a>
+
+</p>
+
+**2025.5.8 Update:**
+We now release the official [Documentation](https://ragen-doc.readthedocs.io/) for RAGEN. The documentation will be continuously updated and improved to provide a comprehensive and up-to-date guidance.
+
+**2025.5.2 Update:**
+We now release a [tracking document](https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing) to log minor updates in the RAGEN codebase. 
+
+
+**2025.4.20 Update:**
+
+Our RAGEN [paper](https://arxiv.org/abs/2504.20073) is out!
+
+We've further streamlined the RAGEN codebase (v0423) to improve development.
+1. Architecture: Restructured veRL as a submodule for better co-development
+2. Modularity: Divided RAGEN into three components—Environment Manager, Context Manager, and Agent Proxy, making it significantly simpler to add new environments (details below), track environmental dynamics, and run multiple experiments
+
+
+**2025.4.16 Update:**
+
+We recently noticed that a [third-party website](https://ragen-ai.com) has been created using our project's name and content. While we appreciate the interest in the project, we'd like to clarify that this GitHub repository is the official and primary source for all code, updates, and documentation.
+If we launch an official website in the future, it will be explicitly linked here.
+
+Thank you for your support and understanding!
+
+
+**2025.3.13 Update:**
+
+
+We are recently refactoring RAGEN code to help you better develop your own idea on the codebase. Please checkout our [developing branch](https://github.com/ZihanWang314/RAGEN/tree/main-new). The first version decomposes RAGEN and veRL for better co-development, taking the latter as a submodule rather than a static directory.
+
+**2025.3.8 Update:**
+
+1. In previous veRL implementation, there is a [KL term issue](https://github.com/volcengine/verl/pull/179/files), which has been fixed in recent versions.
+2. We find evidence from multiple sources that PPO could be more stable than GRPO training in [Open-Reasoner-Zero](https://x.com/rosstaylor90/status/1892664646890312125), [TinyZero](https://github.com/Jiayi-Pan/TinyZero), and [Zhihu](https://www.zhihu.com/search?type=content&q=%E6%97%A0%E5%81%8FGRPO). We have changed the default advantage estimator to GAE (using PPO) and aim to find more stable while efficient RL optimization methods in later versions.
+
+**2025.1.27:**
+
+We are thrilled to release RAGEN! Check out our post [here](https://x.com/wzihanw/status/1884092805598826609).
+
+
+## Overview
+
+<!--
+Reinforcement Learning (RL) with rule-based rewards has shown promise in enhancing reasoning capabilities of large language models (LLMs). However, existing approaches have primarily focused on static, single-turn tasks like math reasoning and coding. Extending these methods to agent scenarios introduces two fundamental challenges:
+
+1. **Multi-turn Interactions**: Agents must perform sequential decision-making and react to environment feedback
+2. **Stochastic Environments**: Uncertainty where identical actions can lead to different outcomes
+
+RAGEN addresses these challenges through:
+- A Markov Decision Process (MDP) formulation for agent tasks
+- State-Thinking-Actions-Reward Policy Optimization (StarPO) algorithm that optimizes entire trajectory distributions
+- Progressive reward normalization strategies to handle diverse, complex environments
+-->
+
+Reinforcement Learning (RL) with rule-based rewards has shown promise in enhancing reasoning capabilities of large language models (LLMs). However, existing approaches have primarily focused on static, single-turn tasks like math reasoning and coding. Extending these methods to agent scenarios introduces two fundamental challenges:
+
+1. **Multi-turn Interactions**: Agents must perform sequential decision-making and react to environment feedback
+2. **Stochastic Environments**: Uncertainty where identical actions can lead to different outcomes
+
+To address these challenges, we propose a general RL framework: **StarPO** (**S**tate-**T**hinking-**A**ctions-**R**eward **P**olicy **O**ptimization), a comprehensive RL framework that provides a unified approach for training multi-turn, trajectory-level agents with flexible control over reasoning processes, reward assignment mechanisms, and prompt-rollout structures. 
+Building upon StarPO, we introduce **RAGEN**, a modular agent training and evaluation system that implements the complete training loop, including rollout generation, reward calculation, and trajectory optimization. RAGEN serves as a robust research infrastructure for systematically analyzing LLM agent training dynamics in multi-turn and stochastic environments.
+
+## Algorithm
+
+RAGEN introduces a reinforcement learning framework to train reasoning-capable LLM agents that can operate in interactive, stochastic environments. 
+
+<p align="center"><img src="public/starpo_logo.png" width="800px" alt="StarPO Framework" /></p>
+<p align="center" style="font-size: 16px; max-width: 800px; margin: 0 auto;">
+The StarPO (State-Thinking-Action-Reward Policy Optimization) framework with two interleaved stages: <b>rollout stage</b> and <b>update stage</b>. LLM iteratively generates reasoning-guided actions to interact with the environment to obtain trajectory-level rewards for LLM update to jointly   optimize reasoning and action strategies.
+</p>
+
+The framework consists of two key components:
+
+### > MDP Formulation 
+We formulate agent-environment interactions as Markov Decision Processes (MDPs) where states and actions are token sequences, allowing LLMs to reason over environment dynamics. At time t, state $s_t$ transitions to the next state through action $a_t$ following a transition function. The policy generates actions given the trajectory history. The objective is to maximize expected cumulative rewards across multiple interaction turns.
+
+### > StarPO: Reinforcing Reasoning via Trajectory-Level Optimization
+StarPO is a general RL framework for optimizing entire multi-turn interaction trajectories for LLM agents.
+The algorithm alternates between two phases:
+
+#### Rollout Stage: Reasoning-Interaction Trajectories
+Given an initial state, the LLM generates multiple trajectories. At each step, the model receives the trajectory history and generates a reasoning-guided action: `<think>...</think><ans> action </ans>`. The environment receives the action and returns feedback (reward and next state).
+
+#### Update Stage: Multi-turn Trajectory Optimization 
+After generating trajectories, we train LLMs to optimize expected rewards. Instead of step-by-step optimization, StarPO optimizes entire trajectories using importance sampling. This approach enables long-horizon reasoning while maintaining computational efficiency. 
+StarPO supports multiple optimization strategies: 
+- PPO: We estimate token-level advantages using a value function over trajectories
+- GRPO: We assign normalized reward to the full trajectory
+
+Rollout and update stages interleave in StarPO, enabling both online and offline learning.
+
+<!--
+### > Reward Normalization Strategies 
+We implement three progressive normalization strategies to stabilize training: 
+1. **ARPO**: Preserves raw rewards directly 
+2. **BRPO**: Normalizes rewards across each training batch using batch statistics
+3. **GRPO**: Normalizes within prompt groups to balance learning across varying task difficulties
+-->
+
+## Environment Setup
+For detailed setup instructions, please check our [documentation](https://ragen-doc.readthedocs.io/). Here's a quick start guide:
+
+```bash
+# Setup environment for RAGEN
+bash scripts/setup_ragen.sh
+```
+
+If this fails, you can follow the manual setup instructions in `scripts/setup_ragen.md`.
+
+## Training Models
+Here's how to train models with RAGEN:
+
+### Export variables and train
+We provide default configuration in `config/base.yaml`. This file includes symbolic links to:
+- `config/ppo_trainer.yaml` 
+- `config/envs.yaml`
+
+The base configuration automatically inherits all contents from these two config files, creating a unified configuration system.
+
+To train:
+
+```bash
+python train.py --config-name base
+```
+
+
+### Parameter efficient training with LoRA
+
+### Saving compute
+By default our code is runnable on A100 80GB machines. If you are using machine with lower memory (e.g. RTX 4090), please consider adapting below parameters, like follows (performance might change due to smaller batch size and shorter context length):
+```bash
+python train.py \
+  micro_batch_size_per_gpu=1 \ 
+  ppo_mini_batch_size=8 \ 
+  actor_rollout_ref.rollout.max_model_len=2048 \ 
+  actor_rollout_ref.rollout.response_length=128 
+```
+
+#### Parameter efficient training with LoRA
+We provide a default configuration with LoRA enabled in `config/base-lora.yaml`. To customize the LoRA settings, see the the `lora` section at the top of the configuration file. The current settings are:
+
+```yaml
+lora rank: 64
+lora alpha: 64
+actor learning rate: 1e-5
+critic learning rate: 1e-4
+```
+
+<!--
+## Supervised Finetuning (Optional)
+For supervised finetuning with LoRA:
+
+1. Create supervised finetuning data:
+```bash
+bash sft/generate_data.sh <env_type>
+```
+
+2. Finetune the model:
+```bash
+bash sft/finetune_lora.sh <env_type> <num_gpus> <save_path>
+```
+
+3. Merge LoRA weights with the base model:
+```bash
+python sft/utils/merge_lora.py \
+    --base_model_name <base_model_name> \
+    --lora_model_path <lora_model_path> \
+    --output_path <output_path>
+```
+-->
+
+## Visualization
+Please check the `val/generations` metric in your wandb dashboard to see the trajectories generated by the model throughout training. Check this [relevant issue](https://github.com/RAGEN-AI/RAGEN/issues/84) for more information. 
+
+
+## Performance
+
+We evaluate RAGEN across multiple environments. Below are results Qwen-2.5-0.5B-Instruct on Sokoban, Frozenlake, and Bandit. 
+- No KL loss or KL penalty was applied during training
+- We selectively retained only the top 25% of trajectories that successfully completed their respective tasks
+
+<p align="center" style="display: flex; justify-content: center; align-items: center; flex-direction: column; gap: 20px; max-width: 500px; margin: 0 auto;">
+    <img src="public/exp1.png" width="250px" alt="Bandit" />
+    <img src="public/exp2.png" width="250px"  alt="Simple Sokoban" />
+    <img src="public/exp3.png" width="250px"  alt="Frozen lake" />
+</p>
+
+We demonstrate RAGEN's robust generalization ability by training on simple Sokoban environments (6×6 with 1 box) and successfully evaluating performance on:
+- Larger Sokoban environments (8×8 with 2 boxes)
+- Simple Sokoban with alternative grid vocabulary representations
+- FrozenLake environments
+
+<p align="center" style="display: flex; justify-content: center; align-items: center; flex-direction: column; gap: 20px; max-width: 500px; margin: 0 auto;">
+    <img src="public/exp4.png" width="250px" alt="Larger Sokoban" />
+    <img src="public/exp5.png" width="250px"  alt="Sokoban with Different Grid Vocabulary" />
+    <img src="public/exp6.png" width="250px"  alt="Frozen lake" />
+</p>
+
+Key observations:
+- By using no KL and filtering out failed trajectories, we can achieve better and stable performance
+- Generalization results highlight RAGEN's capacity to transfer learned policies across varying environment complexities, representations, and domains.
+
+## Evaluation
+RAGEN provides a easy way to evaluate a model:
+```bash
+python -m ragen.llm_agent.agent_proxy --config-name <eval_config>
+```
+The proxy now loads `config/eval.yaml` by default, which only keeps the rollout-specific knobs required for evaluation. You can still point to any other file via `--config-name`. Each evaluation config supports an `output` block so you can control where rollouts are stored and which fields are persisted:
+
+```yaml
+output:
+  dir: results/eval
+  filename: val_rollouts.pkl
+  append_timestamp: true   # include run timestamp in the file name
+  keep_batch_keys: ["rm_scores", "responses"]   # set to null to keep everything
+  keep_non_tensor_keys: null
+  keep_meta_info: true
+```
+
+With this configuration the proxy filters the `DataProto` before saving (handy if you want to drop large tensors such as log-probs) and places the artifact directly under `results/eval`.  
+You only need to set model and environment to evaluate in `config/<eval_config>.yaml`.  
+To limit how many previous turns the model sees during evaluation, you can set `agent_proxy.max_context_window` in your config file.
+
+
+<!--
+## Example Trajectories
+
+Visualization of agent reasoning on the Sokoban task:
+
+<p align="center" style="display: flex; justify-content: center; gap: 10px;">
+    <img src="./public/step_1.png" width="200px" alt="Step 1" />
+    <img src="./public/step_2.png" width="200px" alt="Step 2" />
+</p>
+
+The visualizations show how the agent reasons through sequential steps to solve the puzzle.
+
+## Case Studies
+We provide several case studies showing the model's behavior:
+- [Reward hacking](https://github.com/ZihanWang314/agent-r1/blob/main/cases/reward_hacking.txt)
+- [Challenging moments](https://github.com/ZihanWang314/agent-r1/blob/main/cases/suck_moment.txt)
+
+More case studies will be added to showcase both successful reasoning patterns and failure modes.
+-->
+
+## Modular System Design of RAGEN
+
+We implement RAGEN as a modular system: there are three main modules: **Environment State Manager** (`ragen/llm_agent/es_manager.py`), **Context Manager** (`ragen/llm_agent/ctx_manager.py`), and **Agent Proxy** (`ragen/llm_agent/agent_proxy.py`).
+
+- Environment State Manager (**es_manager**):
+  - Supports multiple environments (different environments, same environment different seeds, same environment same seed)
+  - Training seeds are controlled via `seed.train` in the config. The manager increments this seed each reset so runs are deterministic.
+  - Records states of each environment during rollout
+  - Processes actions from **ctx_manager**, executes step, and returns action results (observations) to **ctx_manager** in a batch-wise manner
+- Context Manager (**ctx_manager**):
+  - Parses raw agent tokens into structured actions for the **es_manager**
+  - Formats observation from **es_manager**, parses and formulates them for following rollout of agent.
+  - Supports a `max_context_window` hyperparameter, which limits how many previous turns of interaction history are retained in the model’s input. 
+  - Gathers final rollout trajectories and compiles them into tokens, attention masks, reward scores, and loss masks for llm updating.
+- Agent Proxy (**agent_proxy**): Serves as the interface for executing single or multi-round rollouts
+
+## Adding Custom Environments
+
+To add a new environment to our framework:
+
+1. Implement an OpenAI Gym-compatible environment in `ragen/env/new_env/env.py` with these required methods:
+   - `step(action)`: Process actions and return next state
+   - `reset(seed)`: Initialize environment with new seed
+   - `render()`: Return current state observation
+   - `close()`: Clean up resources
+
+2. Define environment configuration in `ragen/env/new_env/config.py`
+
+3. Register your environment in `config/envs.yaml`:
+   ```yaml
+   custom_envs:
+     - NewEnvironment # Tag
+       - env_type: new_env  # Must match environment class name
+       - max_actions_per_traj: 50  # Example value
+       - env_instruction: "Your environment instructions here"
+       - env_config: {}  # Configuration options from config.py
+   ```
+
+4. Add the environment tag to the `es_manager` section in `config/base.yaml`
+
+## Using RAGEN with dstack
+
+[dstackai/dstack](https://github.com/dstackai/dstack) is an open-source container orchestrator that simplifies distributed training across cloud providers and on-premises environments
+without the need to use K8S or Slurm.
+
+### 1. Create fleet
+
+Before submitting distributed training jobs, create a `dstack` [fleet](https://dstack.ai/docs/concepts/fleets).
+
+### 2. Run a Ray cluster task
+
+Once the fleet is created, define and apply a Ray cluster task:
+
+```shell
+$ dstack apply -f examples/distributed-training/ray-ragen/.dstack.yml
+```
+
+You can find the task configuration example at [`examples/distributed-training/ray-ragen/.dstack.yml`](https://github.com/dstackai/dstack/blob/master/examples/distributed-training/ray-ragen/.dstack.yml).
+
+The `dstack apply` command will provision the Ray cluster with all dependencies and forward the Ray dashboard port to `localhost:8265`.
+
+
+### 3. Submit a training job
+
+Now you can submit a training job locally to the Ray cluster:
+
+```shell
+$ RAY_ADDRESS=http://localhost:8265
+$ ray job submit \
+    ...
+```
+
+See the full [RAGEN+Ray example](https://dstack.ai/examples/distributed-training/ray-ragen/).
+
+For more details on how `dstack` can be used for distributed training, check out the [Clusters](https://dstack.ai/docs/guides/clusters/) guide.
+
+## Feedback
+We welcome all forms of feedback! Please raise an issue for bugs, questions, or suggestions. This helps our team address common problems efficiently and builds a more productive community.
+
+## Awesome work powered or inspired by RAGEN
+ - [ROLL](https://github.com/alibaba/ROLL): An Efficient and User-Friendly Scaling Library for Reinforcement Learning with Large Language Models
+ - [VAGEN](https://github.com/RAGEN-AI/VAGEN): Training Visual Agents with multi-turn reinforcement learning
+ - [Search-R1](https://github.com/PeterGriffinJin/Search-R1): Train your LLMs to reason and call a search engine with reinforcement learning
+ - [ZeroSearch](https://github.com/Alibaba-nlp/ZeroSearch): Incentivize the Search Capability of LLMs without Searching
+ - [Agent-R1](https://github.com/0russwest0/Agent-R1): Training Powerful LLM Agents with End-to-End Reinforcement Learning
+ - [OpenManus-RL](https://github.com/OpenManus/OpenManus-RL): A live stream development of RL tunning for LLM agents
+ - [MetaSpatial](https://github.com/PzySeere/MetaSpatial): Reinforcing 3D Spatial Reasoning in VLMs for the Metaverse
+ - [s3](https://github.com/pat-jj/s3): Efficient Yet Effective Search Agent Training via Reinforcement Learning
+
+
+## Contributors
+
+[**Zihan Wang**\*](https://zihanwang314.github.io/), [**Kangrui Wang**\*](https://jameskrw.github.io/), [**Qineng Wang**\*](https://qinengwang-aiden.github.io/), [**Pingyue Zhang**\*](https://williamzhangsjtu.github.io/), [**Linjie Li**\*](https://scholar.google.com/citations?user=WR875gYAAAAJ&hl=en), [**Zhengyuan Yang**](https://zyang-ur.github.io/), [**Xing Jin**](https://openreview.net/profile?id=~Xing_Jin3), [**Kefan Yu**](https://www.linkedin.com/in/kefan-yu-22723a25b/en/), [**Minh Nhat Nguyen**](https://www.linkedin.com/in/menhguin/?originalSubdomain=sg), [**Licheng Liu**](https://x.com/liulicheng10), [**Eli Gottlieb**](https://www.linkedin.com/in/eli-gottlieb1/), [**Yiping Lu**](https://2prime.github.io), [**Kyunghyun Cho**](https://kyunghyuncho.me/), [**Jiajun Wu**](https://jiajunwu.com/), [**Li Fei-Fei**](https://profiles.stanford.edu/fei-fei-li), [**Lijuan Wang**](https://www.microsoft.com/en-us/research/people/lijuanw/), [**Yejin Choi**](https://homes.cs.washington.edu/~yejin/), [**Manling Li**](https://limanling.github.io/)
+
+*:Equal Contribution.
+
+## Acknowledgements
+We thank the [DeepSeek](https://github.com/deepseek-ai/DeepSeek-R1) team for providing the DeepSeek-R1 model and early conceptual inspirations. We are grateful to the [veRL](https://github.com/volcengine/verl) team for their infrastructure support. We thank the [TinyZero](https://github.com/Jiayi-Pan/TinyZero) team for their discoveries that informed our initial exploration. We would like to appreciate insightful discussions with Han Liu, Xinyu Xing, Li Erran Li, John Schulman, Akari Asai, Eiso Kant, Lu Lu, Runxin Xu, Huajian Xin, Zijun Liu, Weiyi Liu, Weimin Wu, Yibo Wen, Jiarui Liu, Lorenzo Xiao, Ishan Mukherjee, Anabella Isaro, Haosen Sun, How-Yeh Wan, Lester Xue, Matthew Khoriaty, Haoxiang Sun, Jiajun Liu.
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ragen-ai/ragen&type=Date)](https://www.star-history.com/#ragen-ai/ragen&Date)
+
+## Citation
+If you find RAGEN useful, we would appreciate it if you consider citing our work:
+```md
+@misc{ragen,
+      title={RAGEN: Understanding Self-Evolution in LLM Agents via Multi-Turn Reinforcement Learning}, 
+      author={Zihan Wang and Kangrui Wang and Qineng Wang and Pingyue Zhang and Linjie Li and Zhengyuan Yang and Xing Jin and Kefan Yu and Minh Nhat Nguyen and Licheng Liu and Eli Gottlieb and Yiping Lu and Kyunghyun Cho and Jiajun Wu and Li Fei-Fei and Lijuan Wang and Yejin Choi and Manling Li},
+      year={2025},
+      eprint={2504.20073},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2504.20073}, 
+}
+```

cases/suck_moment.txt

@@ -0,0 +1,66 @@
+[Cumulative Observations]:
+ # 	 # 	 # 	 # 	 # 	 # 	
+ # 	 _ 	 P 	 # 	 # 	 # 	
+ # 	 _ 	 X 	 # 	 # 	 # 	
+ # 	 _ 	 O 	 _ 	 _ 	 # 	
+ # 	 _ 	 _ 	 _ 	 # 	 # 	
+ # 	 # 	 # 	 # 	 # 	 # 	
+Decide the next action:
+Always output: <think> [Your thoughts] </think> <answer> [your answer] </answer> with no extra test. Strictly follow this format. <|im_end|>
+<|im_start|>assistant
+<think> I need to move and place boxes to target with optimal solutions first.</th>
+<suck> Let's start by placing the boxes one by one from right to left on all the floor squares. </suck><|im_end|>
+ <|im_start|>user
+Action is invalid. You stay in the same position. The observation is: 
+ # 	 # 	 # 	 # 	 # 	 # 	
+ # 	 _ 	 P 	 # 	 # 	 # 	
+ # 	 _ 	 X 	 # 	 # 	 # 	
+ # 	 _ 	 O 	 _ 	 _ 	 # 	
+ # 	 _ 	 _ 	 _ 	 # 	 # 	
+ # 	 # 	 # 	 # 	 # 	 # 	
+reward: -0.1
+done: False
+<|im_end|>
+<|im_start|>assistant
+<think> Next, I should place them on the squares that are reserved as targets.</th>
+<suck> Move all boxes with target orientations from left to right. </suck><|im_end|>
+ <|im_start|>user
+Action is invalid. You stay in the same position. The observation is: 
+ # 	 # 	 # 	 # 	 # 	 # 	
+ # 	 _ 	 P 	 # 	 # 	 # 	
+ # 	 _ 	 X 	 # 	 # 	 # 	
+ # 	 _ 	 O 	 _ 	 _ 	 # 	
+ # 	 _ 	 _ 	 _ 	 # 	 # 	
+ # 	 # 	 # 	 # 	 # 	 # 	
+reward: -0.1
+done: False
+<|im_end|>
+<|im_start|>assistant
+<think> Move all boxes with target orientations from right to left. </th>
+<suck> Choose square with boxes on top as target and move all the manifests. </suck><|im_end|>
+ <|im_start|>user
+Action is invalid. You stay in the same position. The observation is: 
+ # 	 # 	 # 	 # 	 # 	 # 	
+ # 	 _ 	 P 	 # 	 # 	 # 	
+ # 	 _ 	 X 	 # 	 # 	 # 	
+ # 	 _ 	 O 	 _ 	 _ 	 # 	
+ # 	 _ 	 _ 	 _ 	 # 	 # 	
+ # 	 # 	 # 	 # 	 # 	 # 	
+reward: -0.1
+done: False
+<|im_end|>
+<|im_start|>assistant
+<think> I need to find a way to make the placements. First, I will prioritize boxes with target orientations based on their height.</th>
+<suck> Compute the height of all boxes as status. Then prioritize the upward moves. </suck>
+<suck> For each upward move, use the strategy S which naturally generates the target of the upper one.</suck>
+<suck> But now I just need to move those up as indicated. </suck>
+<suck> Remember to use the<|im_end|>
+ <|im_start|>user
+Action is invalid. You stay in the same position. The observation is: 
+ # 	 # 	 # 	 # 	 # 	 # 	
+ # 	 _ 	 P 	 # 	 # 	 # 	
+ # 	 _ 	 X 	 # 	 # 	 # 	
+ # 	 _ 	 O 	 _ 	 _ 	 # 	
+ # 	 _ 	 _ 	 _ 	 # 	 # 	
+ # 	 # 	 # 	 # 	 # 	 # 	
+reward: -0.1

cleanrl/.dockerignore

@@ -0,0 +1,10 @@
+*.mp4
+*.pyc
+*.pyo
+*.log
+*.json
+**/wandb
+**/runs
+**/videos
+.git
+*.tfevents.*

cleanrl/.gitpod.Dockerfile

@@ -0,0 +1,20 @@
+FROM gitpod/workspace-full-vnc:latest
+USER gitpod
+RUN if ! grep -q "export PIP_USER=no" "$HOME/.bashrc"; then printf '%s\n' "export PIP_USER=no" >> "$HOME/.bashrc"; fi
+
+# install ubuntu dependencies
+ENV DEBIAN_FRONTEND=noninteractive 
+RUN sudo apt-get update && \
+    sudo apt-get -y install xvfb ffmpeg git build-essential python-opengl
+
+# install python dependencies
+RUN mkdir cleanrl_utils && touch cleanrl_utils/__init__.py
+RUN pip install uv --upgrade
+RUN uv config virtualenvs.in-project true
+
+# install mujoco_py
+RUN sudo apt-get -y install wget unzip software-properties-common \
+    libgl1-mesa-dev \
+    libgl1-mesa-glx \
+    libglew-dev \
+    libosmesa6-dev patchelf

cleanrl/.gitpod.yml

@@ -0,0 +1,26 @@
+image:
+  file: .gitpod.Dockerfile
+
+tasks:
+  - init: uv pip install .
+
+# vscode:
+#   extensions:
+#     - learnpack.learnpack-vscode
+    
+github:
+  prebuilds:
+    # enable for the master/default branch (defaults to true)
+    master: true
+    # enable for all branches in this repo (defaults to false)
+    branches: true
+    # enable for pull requests coming from this repo (defaults to true)
+    pullRequests: true
+    # enable for pull requests coming from forks (defaults to false)
+    pullRequestsFromForks: true
+    # add a "Review in Gitpod" button as a comment to pull requests (defaults to true)
+    addComment: false
+    # add a "Review in Gitpod" button to pull requests (defaults to false)
+    addBadge: false
+    # add a label once the prebuild is ready to pull requests (defaults to false)
+    addLabel: prebuilt-in-gitpod

cleanrl/.pre-commit-config.yaml

@@ -0,0 +1,78 @@
+repos:
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.20.0
+    hooks:
+      - id: pyupgrade
+        args: 
+          - --py37-plus
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        args:
+          - --profile=black
+          - --skip-glob=wandb/**/*
+          - --thirdparty=wandb
+  - repo: https://github.com/python/black
+    rev: 25.1.0
+    hooks:
+      - id: black
+        args:
+          - --line-length=127
+          - --exclude=wandb
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.1
+    hooks:
+      - id: codespell
+        args:
+          - --ignore-words-list=nd,reacher,thist,ths,magent,ba,Meger
+          - --skip=docs/css/termynal.css,docs/js/termynal.js,docs/get-started/CleanRL_Huggingface_Integration_Demo.ipynb
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.7.19
+    hooks:
+      - id: uv-export
+        name: uv-export requirements.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements.txt"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-atari.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-atari.txt", "--extra", "atari"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-mujoco.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-mujoco.txt", "--extra", "mujoco"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-dm_control.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-dm_control.txt", "--extra", "dm_control"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-procgen.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-procgen.txt", "--extra", "procgen"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-envpool.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-envpool.txt", "--extra", "envpool"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-pettingzoo.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-pettingzoo.txt", "--extra", "pettingzoo"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-jax.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-jax.txt", "--extra", "jax"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-optuna.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-optuna.txt", "--extra", "optuna"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-docs.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-docs.txt", "--extra", "docs"]
+        stages: [manual]
+      - id: uv-export
+        name: uv-export requirements-cloud.txt
+        args: ["--no-hashes", "--output-file", "requirements/requirements-cloud.txt", "--extra", "cloud"]
+        stages: [manual]
+      # requirements-memory-gym.txt must be hand updated,
+      #   `cd cleanrl/ppo_trxl`, `uv export --no-hashes --output-file ../../requirements/requirements-memory_gym.txt`

cleanrl/CHANGES_RL_README.md

@@ -0,0 +1,64 @@
+# Classic RL for RAGEN (DQN/PPO)
+
+This note summarizes the changes and how to run the small-MLP RL baselines (DQN/PPO) on RAGEN environments without changing environment internals or interfaces.
+
+## What Changed
+
+- Added gymnasium-compatible wrappers that convert text observations into fixed-size numeric vectors purely from observable text, preserving the original env API semantics:
+  - `cleanrl/cleanrl/ragen_wrappers.py`
+    - `BanditWrapper`: hashes text observation into a small one-hot vector; episodes remain single-step (no custom episode shaping).
+    - `FrozenLakeWrapper`: parses the grid from text into one-hot cells + normalized player pos. Shape is inferred by reading the first observable reset; no access to internal config.
+    - `SokobanWrapper`: parses the room from text into one-hot cells. Shape is inferred at first observable reset; no access to internal config.
+
+- Small-MLP agents using standard RL:
+  - `cleanrl/cleanrl/dqn_bandit.py`: DQN for Bandit (discrete, single-step feedback), uses a small MLP and epsilon-greedy with replay + target network.
+  - `cleanrl/cleanrl/ppo_frozenlake.py`: PPO for FrozenLake (episodic grid nav, discrete actions), simple MLP actor-critic with GAE.
+  - `cleanrl/cleanrl/ppo_sokoban.py`: PPO for Sokoban (grid puzzle, discrete actions), larger MLP actor-critic.
+
+These implementations only use the text returned by `reset`/`step` and the reward/done/info. They do not modify wrappers of the environments shipped in `ragen/env/*` nor rely on hidden rules.
+
+## Why These Algorithms
+
+- Bandit: DQN fits discrete action selection with value learning and works well with a small feature encoder; PPO is possible but overkill for single-step returns.
+- FrozenLake: PPO handles sparse/delayed rewards with on-policy updates and advantage estimation across rollouts.
+- Sokoban: PPO scales better with longer horizons and stochastic exploration; larger MLP helps with the higher-dimensional state encoding.
+
+## Usage
+
+From repo root:
+
+- Bandit (DQN):
+  - `python cleanrl/cleanrl/dqn_bandit.py --total-timesteps 100000 --seed 1`
+
+- FrozenLake (PPO):
+  - `python cleanrl/cleanrl/ppo_frozenlake.py --total-timesteps 1000000 --num-envs 8 --grid-size 4 --is-slippery True`
+
+- Sokoban (PPO):
+  - `python cleanrl/cleanrl/ppo_sokoban.py --total-timesteps 5000000 --num-envs 8 --dim-room "(6, 6)" --num-boxes 1`
+
+TensorBoard:
+- `tensorboard --logdir runs/`
+
+Optional W&B tracking (all scripts):
+- `--track --wandb-project-name RAGEN-RL --wandb-entity <team>`
+
+## Notes and Assumptions
+
+- Action mapping: environments use 1-indexed actions; wrappers map to 0-indexed `Discrete` spaces and back on `step`.
+- Observation sizes are derived from text alone at runtime. We avoid accessing env config objects to respect the “no hidden info” constraint.
+- Vectorized rollout: PPO scripts use `gym.vector.SyncVectorEnv`; DQN runs with a single env for simplicity (can be extended).
+- We keep environment episodes as defined by the original envs. Bandit remains single-step; PPO variants rely on the environment’s termination.
+
+## File Index
+
+- Wrappers: `cleanrl/cleanrl/ragen_wrappers.py`
+- DQN (Bandit): `cleanrl/cleanrl/dqn_bandit.py`
+- PPO (FrozenLake): `cleanrl/cleanrl/ppo_frozenlake.py`
+- PPO (Sokoban): `cleanrl/cleanrl/ppo_sokoban.py`
+
+## Next Steps (Optional)
+
+- Add simple CNN encoders over 2D grids (FrozenLake/Sokoban) to better capture spatial structure.
+- Support prioritized replay in DQN and double-DQN for Bandit.
+- Curriculum or map randomization sweeps for FrozenLake; tuned entropy schedule for Sokoban.
+

cleanrl/INTEGRATION_SUMMARY.md

@@ -0,0 +1,186 @@
+# Ultrahorizon 环境集成总结
+
+## 🎯 任务目标
+
+**纯粹的 RL 高分任务**：训练智能体在 Ultrahorizon 网格环境中获得最高分数，而不需要理解或推理世界规则。
+
+## 📊 环境特性
+
+### 观测空间（全局观测）
+- **维度**: 605维特征向量
+- **组成**:
+  - 位置 (2): 当前 x, y 坐标归一化
+  - 能量 (1): 当前能量/20
+  - 分数 (1): 当前分数（可为负）
+  - 步数 (1): 当前步数/30
+  - **完整网格状态 (600)**: 10×10 网格的全局观测，每个格子 one-hot 编码 (A-E, X)
+
+### 动作空间
+- **4个离散动作**: 上(0), 下(1), 左(2), 右(3)
+
+### Episode 特性
+- **长度**: 20-30 步
+  - 最小: 20步（能量耗尽，每步消耗1能量，初始20能量）
+  - 最大: 30步（达到最大步数限制）
+- **终止条件**:
+  1. 能量耗尽 (energy = 0)
+  2. 达到最大步数 (steps = 30)
+  3. 无效移动（出界或已终止）
+
+### 奖励设计
+- **成功移动**: reward = 当前分数 - 上一步分数（分数变化）
+- **无效移动**: reward = -10（重罚，避免浪费步数）
+- **目标**: 最大化累积奖励 = 最大化最终分数
+
+## 🔑 关键设计决策
+
+### 1. 全局观测 vs 局部观测
+✅ **使用全局观测**
+- 智能体可以看到整个 10×10 网格
+- 有利于规划最优路径
+- 符合环境允许全局观测的特性
+
+### 2. 奖励函数
+✅ **分数变化作为奖励**
+- 直接优化目标：最大化分数
+- 不需要理解字母效果的内在规则
+- 智能体通过试错学习哪些移动能获得高分
+
+### 3. Episode 长度处理
+✅ **自然终止**
+- 不使用固定长度截断
+- 让环境自然终止（能量或步数）
+- Episode 长度在 20-30 步之间变化
+
+## 📁 文件结构
+
+```
+cleanrl/
+├── envs/
+│   ├── __init__.py
+│   └── common.py                    # Difficulty 枚举
+├── Ultrahorizon_grid_env.py         # 原始环境
+├── ultrahorizon_gym_wrapper.py      # Gymnasium 包装器
+├── cleanrl/
+│   ├── ppo_atari.py                 # 原始 PPO
+│   └── ppo_ultrahorizon.py          # 适配的 PPO
+└── INTEGRATION_SUMMARY.md           # 本文件
+```
+
+## 🚀 使用方法
+
+### 快速开始
+```bash
+cd /Users/harryis/why_code/ICML_Memory/cleanrl
+python cleanrl/ppo_ultrahorizon.py --difficulty EASY
+```
+
+### 推荐配置
+
+#### EASY 难度
+```bash
+python cleanrl/ppo_ultrahorizon.py \
+    --difficulty EASY \
+    --num-envs 8 \
+    --total-timesteps 500000 \
+    --learning-rate 3e-4
+```
+
+#### HARD 难度
+```bash
+python cleanrl/ppo_ultrahorizon.py \
+    --difficulty HARD \
+    --num-envs 8 \
+    --total-timesteps 1000000 \
+    --learning-rate 2.5e-4
+```
+
+## 🧠 神经网络架构
+
+```
+输入: 605维观测向量
+  ↓
+Linear(605 → 256) + ReLU
+  ↓
+Linear(256 → 256) + ReLU
+  ↓
+Linear(256 → 128) + ReLU
+  ↓
+├─→ Actor: Linear(128 → 4)    # 策略网络
+└─→ Critic: Linear(128 → 1)   # 价值网络
+```
+
+## 📈 预期行为
+
+### 学习过程
+1. **初期**: 随机探索，学习避免无效移动
+2. **中期**: 学习哪些字母倾向于给正分，哪些给负分
+3. **后期**: 优化路径，最大化累积分数
+
+### 性能指标
+- **Episode Return**: 累积奖励（应逐渐增加）
+- **Episode Length**: 20-30 步（受能量限制）
+- **Policy Loss**: 策略梯度损失
+- **Value Loss**: 价值函数损失
+
+## ⚙️ 超参数建议
+
+| 参数 | EASY | MEDIUM | HARD |
+|------|------|--------|------|
+| learning_rate | 3e-4 | 2.5e-4 | 2.5e-4 |
+| num_envs | 8 | 8 | 8 |
+| total_timesteps | 500K | 750K | 1M |
+| num_steps | 128 | 128 | 128 |
+| ent_coef | 0.01 | 0.01 | 0.005 |
+
+## 🔍 调试建议
+
+### 检查学习是否正常
+```python
+# 查看 episode return 是否增长
+tensorboard --logdir runs/
+
+# 关注指标:
+# - charts/episodic_return (应该上升)
+# - charts/episodic_length (应该在 20-30 之间)
+# - losses/entropy (初期高，后期降低)
+```
+
+### 常见问题
+
+**Q: Episode return 不增长？**
+- 检查学习率是否过大或过小
+- 增加探索（提高 ent_coef）
+- 确保奖励信号正确（检查分数变化）
+
+**Q: Episode 过早终止？**
+- 检查是否频繁触发无效移动
+- 可能需要调整网络架构或学习率
+
+**Q: 训练不稳定？**
+- 降低学习率
+- 增加 num_envs 以稳定梯度
+- 检查奖励尺度是否合理
+
+## 🎓 与原始 PPO Atari 的对比
+
+| 特性 | PPO Atari | PPO Ultrahorizon |
+|------|-----------|------------------|
+| **任务类型** | 视觉游戏 | 网格探索 |
+| **观测** | 84×84×4 图像 | 605维特征向量 |
+| **观测范围** | 屏幕内容 | **全局网格** |
+| **网络** | CNN | MLP |
+| **Episode长度** | 变化大 | **固定20-30步** |
+| **奖励** | 游戏分数 | **分数变化** |
+| **目标** | 玩游戏 | **纯粹高分** |
+
+## ✅ 核心 PPO 算法保持不变
+
+- GAE (Generalized Advantage Estimation)
+- Clipped Surrogate Objective
+- Value Function Clipping
+- Entropy Regularization
+- Learning Rate Annealing
+- Advantage Normalization
+
+所有这些标准 PPO 组件都完整保留，只是适配了不同的环境接口。

cleanrl/LICENSE

@@ -0,0 +1,316 @@
+MIT License
+
+Copyright (c) 2019 CleanRL developers
+
+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.
+
+
+--------------------------------------------------------------------------------
+
+Code in `cleanrl/ppo_procgen.py` and `cleanrl/ppg_procgen.py` are adapted from https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/models/impala_cnn_torch.py
+
+**NOTE: the original repo did not fill out the copyright section in their license
+so the following copyright notice is copied as is per the license requirement.
+See https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/LICENSE#L190
+
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+--------------------------------------------------------------------------------
+Code in `cleanrl/ddpg_continuous_action.py` and `cleanrl/td3_continuous_action.py` are adapted from https://github.com/sfujim/TD3
+
+
+MIT License
+
+Copyright (c) 2020 Scott Fujimoto
+
+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.
+
+--------------------------------------------------------------------------------
+Code in `cleanrl/sac_continuous_action.py` is inspired and adapted from [haarnoja/sac](https://github.com/haarnoja/sac), [openai/spinningup](https://github.com/openai/spinningup), [pranz24/pytorch-soft-actor-critic](https://github.com/pranz24/pytorch-soft-actor-critic), [DLR-RM/stable-baselines3](https://github.com/DLR-RM/stable-baselines3), and [denisyarats/pytorch_sac](https://github.com/denisyarats/pytorch_sac).
+
+- [haarnoja/sac](https://github.com/haarnoja/sac/blob/8258e33633c7e37833cc39315891e77adfbe14b2/LICENSE.txt)
+
+COPYRIGHT
+
+All contributions by the University of California:
+Copyright (c) 2017, 2018 The Regents of the University of California (Regents)
+All rights reserved.
+
+All other contributions:
+Copyright (c) 2017, 2018, the respective contributors
+All rights reserved.
+
+SAC uses a shared copyright model: each contributor holds copyright over
+their contributions to the SAC codebase. The project versioning records all such
+contribution and copyright details. If a contributor wants to further mark
+their specific copyright on a particular contribution, they should indicate
+their copyright solely in the commit message of the change when it is
+committed.
+
+LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+CONTRIBUTION AGREEMENT
+
+By contributing to the SAC repository through pull-request, comment,
+or otherwise, the contributor releases their content to the
+license and copyright terms herein.
+
+- [openai/spinningup](https://github.com/openai/spinningup/blob/038665d62d569055401d91856abb287263096178/LICENSE)
+
+The MIT License
+
+Copyright (c) 2018 OpenAI (http://openai.com)
+
+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.
+
+- [DLR-RM/stable-baselines3](https://github.com/DLR-RM/stable-baselines3/blob/44e53ff8115e8f4bff1d5218f10c8c7d1a4cfc12/LICENSE)
+
+The MIT License
+
+Copyright (c) 2019 Antonin Raffin
+
+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.
+
+- [denisyarats/pytorch_sac](https://github.com/denisyarats/pytorch_sac/blob/81c5b536d3a1c5616b2531e446450df412a064fb/LICENSE)
+
+MIT License
+
+Copyright (c) 2019 Denis Yarats
+
+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.
+
+- [pranz24/pytorch-soft-actor-critic](https://github.com/pranz24/pytorch-soft-actor-critic/blob/master/LICENSE)
+
+MIT License
+
+Copyright (c) 2018 Pranjal Tandon
+
+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.
+
+
+---------------------------------------------------------------------------------
+The CONTRIBUTING.md is adopted from https://github.com/entity-neural-network/incubator/blob/2a0c38b30828df78c47b0318c76a4905020618dd/CONTRIBUTING.md
+and https://github.com/Stable-Baselines-Team/stable-baselines3-contrib/blob/master/CONTRIBUTING.md
+
+MIT License
+
+Copyright (c) 2021 Entity Neural Network developers
+
+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.
+
+
+
+MIT License
+
+Copyright (c) 2020 Stable-Baselines Team
+
+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.
+
+
+---------------------------------------------------------------------------------
+The cleanrl/ppo_continuous_action_isaacgym.py is contributed by Nvidia
+
+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.
+
+--------------------------------------------------------------------------------
+
+Code in `cleanrl/qdagger_dqn_atari_impalacnn.py` and `cleanrl/qdagger_dqn_atari_jax_impalacnn.py` are adapted from https://github.com/google-research/reincarnating_rl
+
+**NOTE: the original repo did not fill out the copyright section in their license
+so the following copyright notice is copied as is per the license requirement.
+See https://github.com/google-research/reincarnating_rl/blob/a1d402f48a9f8658ca6aa0ddf416ab391745ff2c/LICENSE#L189
+
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

cleanrl/QUICKSTART_ULTRAHORIZON.md

@@ -0,0 +1,116 @@
+# Quick Start: Training PPO on Ultrahorizon
+
+## 快速开始指南
+
+### 1. 测试环境包装器
+
+首先测试 Gymnasium 包装器是否正常工作：
+
+```bash
+cd /Users/harryis/why_code/ICML_Memory/cleanrl
+python ultrahorizon_gym_wrapper.py
+```
+
+这将运行一个简单的测试，创建环境、重置并执行几个随机动作。
+
+### 2. 训练 PPO 智能体
+
+#### 简单模式（EASY）训练：
+
+```bash
+python cleanrl/ppo_ultrahorizon.py --difficulty EASY --total-timesteps 500000
+```
+
+#### 困难模式（HARD）训练：
+
+```bash
+python cleanrl/ppo_ultrahorizon.py --difficulty HARD --total-timesteps 1000000
+```
+
+#### 使用更多并行环境加速训练：
+
+```bash
+python cleanrl/ppo_ultrahorizon.py \
+    --difficulty MEDIUM \
+    --num-envs 8 \
+    --total-timesteps 1000000 \
+    --learning-rate 3e-4
+```
+
+### 3. 监控训练过程
+
+启动 TensorBoard 查看训练指标：
+
+```bash
+tensorboard --logdir runs/
+```
+
+然后在浏览器中打开 `http://localhost:6006`
+
+### 4. 主要参数说明
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| `--difficulty` | EASY | 环境难度：EASY, MEDIUM, HARD |
+| `--total-timesteps` | 1000000 | 总训练步数 |
+| `--learning-rate` | 2.5e-4 | 学习率 |
+| `--num-envs` | 4 | 并行环境数量 |
+| `--num-steps` | 128 | 每次rollout的步数 |
+| `--seed` | 1 | 随机种子 |
+| `--cuda` | True | 是否使用GPU |
+
+### 5. 文件结构
+
+```
+cleanrl/
+├── envs/
+│   ├── __init__.py              # 环境包初始化
+│   └── common.py                # Difficulty 枚举定义
+├── Ultrahorizon_grid_env.py     # 原始环境（你提供的）
+├── ultrahorizon_gym_wrapper.py  # Gymnasium 包装器
+├── cleanrl/
+│   ├── ppo_atari.py            # 原始 PPO Atari 实现
+│   └── ppo_ultrahorizon.py     # PPO Ultrahorizon 实现（新）
+├── ULTRAHORIZON_README.md       # 详细文档
+└── QUICKSTART_ULTRAHORIZON.md   # 本文件
+```
+
+### 6. 关键修改点
+
+从 `ppo_atari.py` 到 `ppo_ultrahorizon.py` 的主要变化：
+
+1. **环境包装器**：使用 `make_ultrahorizon_env()` 替代 `make_env()`
+2. **神经网络**：使用 MLP 替代 CNN
+   - Atari: Conv2D layers → 处理图像
+   - Ultrahorizon: Linear layers → 处理特征向量
+3. **观察空间**：605维特征向量（位置、能量、分数、步数、网格状态）
+4. **动作空间**：4个离散动作（上下左右）
+
+### 7. 预期训练时间
+
+- **EASY 模式**：约 10-20 分钟（500K steps，4 envs，GPU）
+- **MEDIUM 模式**：约 20-40 分钟（1M steps，4 envs，GPU）
+- **HARD 模式**：约 30-60 分钟（1M steps，4 envs，GPU）
+
+### 8. 常见问题
+
+**Q: 训练很慢怎么办？**
+- 增加 `--num-envs` 参数（如 8 或 16）
+- 确保使用 GPU：`--cuda True`
+- 减少 `--total-timesteps`
+
+**Q: 内存不足？**
+- 减少 `--num-envs`（如 2 或 1）
+- 使用 CPU：`--cuda False`
+
+**Q: 如何保存模型？**
+- 目前代码没有自动保存，可以在训练循环中添加模型保存逻辑
+- 或者使用 Weights & Biases：`--track --wandb-project-name "your-project"`
+
+### 9. 下一步
+
+- 调整超参数以获得更好的性能
+- 尝试不同的难度级别
+- 修改奖励函数以更好地引导学习
+- 添加模型保存和加载功能
+- 实现评估脚本来测试训练好的模型

cleanrl/README_convert.md

@@ -0,0 +1,140 @@
+# 测试结果转换工具
+
+这个工具可以将PPO训练过程中保存的测试结果从one-hot向量格式转换为更直观的10x10字母矩阵格式，方便LLM分析。
+
+## 功能
+
+- 将observation中的one-hot编码转换回字母（A-E, X）
+- 重建10x10的网格地图
+- 将归一化的位置坐标转换回实际坐标
+- 在网格中标记agent的当前位置（用@表示）
+- 保留所有原始的统计信息和轨迹数据
+
+## 使用方法
+
+### 1. 转换单个文件
+
+```bash
+python convert_test_results.py /path/to/test_iter_732.json
+```
+
+这会在同一目录下生成 `test_iter_732_readable.json`
+
+### 2. 指定输出文件
+
+```bash
+python convert_test_results.py /path/to/test_iter_732.json -o /path/to/output.json
+```
+
+### 3. 批量转换目录中的所有测试文件
+
+```bash
+python convert_test_results.py /path/to/runs/directory -a
+```
+
+这会递归查找所有 `test_iter_*.json` 文件并转换它们。
+
+### 4. 自定义批量转换的文件模式
+
+```bash
+python convert_test_results.py /path/to/runs/directory -a -p "test_*.json"
+```
+
+## 示例
+
+### 转换EASY难度的所有测试结果
+
+```bash
+python convert_test_results.py runs/Ultrahorizon-v0__ppo_ultrahorizon__1_EASY__1761810199 -a
+```
+
+### 转换特定的测试文件
+
+```bash
+python convert_test_results.py runs/Ultrahorizon-v0__ppo_ultrahorizon__1_EASY__1761810199/test_iter_732.json
+```
+
+## 输出格式
+
+转换后的JSON文件包含：
+
+```json
+{
+  "iteration": 732,
+  "global_step": 1497088,
+  "training_progress": 0.1,
+  "test_results": {
+    "episode_returns": [...],
+    "episode_lengths": [...],
+    "final_scores": [...],
+    "mean_return": 123.45,
+    "trajectories": [
+      {
+        "actions": [0, 1, 2, ...],
+        "rewards": [1.0, -0.5, ...],
+        "dones": [false, false, ...],
+        "observations": [
+          {
+            "step": 0,
+            "position": {"x": 5, "y": 3},
+            "energy": 20.0,
+            "score": 0.0,
+            "steps": 0.0,
+            "grid": [
+              ["A", "B", "C", ...],
+              ["D", "E", "X", ...],
+              ...
+            ],
+            "grid_string": "  0 1 2 3 4 5 6 7 8 9\n  -------------------\n0|A B C D E X A B C D \n1|E X A B C D E X A B \n...",
+            "action": "right",
+            "reward": 1.0
+          },
+          ...
+        ]
+      }
+    ]
+  }
+}
+```
+
+## 网格可视化
+
+每个observation都包含 `grid_string` 字段，显示10x10的网格：
+
+```
+  0 1 2 3 4 5 6 7 8 9
+  -------------------
+0|A B C D E X A B C D 
+1|E X A B C D E X A B 
+2|C D E X A B C D E X 
+3|A B C D E @ A B C D   <- @ 表示agent位置
+4|E X A B C D E X A B 
+5|C D E X A B C D E X 
+6|A B C D E X A B C D 
+7|E X A B C D E X A B 
+8|C D E X A B C D E X 
+9|A B C D E X A B C D 
+```
+
+## 观察向量结构
+
+原始observation是605维向量：
+- **位置 (2维)**: x, y 坐标，归一化到 [0, 1]
+- **能量 (1维)**: 归一化到 [0, 1]，原始范围约为 [0, 20]
+- **分数 (1维)**: 当前累积分数
+- **步数 (1维)**: 归一化到 [0, 1]，原始范围为 [0, 30]
+- **网格状态 (600维)**: 10x10网格，每个格子6维one-hot编码（A, B, C, D, E, X）
+
+## 动作映射
+
+- 0: up (向上)
+- 1: down (向下)
+- 2: left (向左)
+- 3: right (向右)
+
+## 注意事项
+
+1. 转换后的文件会比原始文件大，因为包含了可读的字符串表示
+2. 网格坐标系：y=0在顶部，y=9在底部
+3. agent位置用 `@` 标记在grid_string中
+4. 所有原始数据（actions, rewards, dones）都会保留

cleanrl/ULTRAHORIZON_README.md

@@ -0,0 +1,164 @@
+# Ultrahorizon Grid Environment Integration with CleanRL PPO
+
+This integration adapts the Ultrahorizon grid environment to work with CleanRL's PPO implementation.
+
+## Files Created
+
+1. **`envs/common.py`** - Common utilities including the `Difficulty` enum
+2. **`ultrahorizon_gym_wrapper.py`** - Gymnasium wrapper that converts the async text-based Ultrahorizon environment into a synchronous gym-compatible interface
+3. **`cleanrl/ppo_ultrahorizon.py`** - PPO implementation adapted for the Ultrahorizon environment
+
+## Key Differences from PPO Atari
+
+### Environment
+- **Atari**: Image-based observations (84x84x4 frames), various discrete actions
+- **Ultrahorizon**: Feature vector observations (605-dimensional), 4 discrete actions (up/down/left/right)
+
+### Neural Network Architecture
+- **Atari**: Convolutional Neural Network (CNN) for processing images
+- **Ultrahorizon**: Multi-Layer Perceptron (MLP) for processing feature vectors
+
+### Observation Space
+The observation vector (605 dimensions) contains:
+- **Position** (2): x, y coordinates normalized to [0, 1]
+- **Energy** (1): Current energy normalized by initial energy (20)
+- **Score** (1): Current score (can be negative)
+- **Steps** (1): Current step count normalized by max steps (30)
+- **Grid State** (600): 10x10 grid with one-hot encoded letters (A-E, X) = 10×10×6
+
+### Action Space
+- 0: Move up
+- 1: Move down
+- 2: Move left
+- 3: Move right
+
+## Usage
+
+### Basic Training
+
+```bash
+cd /Users/harryis/why_code/ICML_Memory/cleanrl
+python cleanrl/ppo_ultrahorizon.py --difficulty EASY
+```
+
+### Training with Custom Parameters
+
+```bash
+python cleanrl/ppo_ultrahorizon.py \
+    --difficulty HARD \
+    --total-timesteps 1000000 \
+    --learning-rate 3e-4 \
+    --num-envs 8 \
+    --num-steps 128
+```
+
+### Available Arguments
+
+- `--difficulty`: Environment difficulty (EASY, MEDIUM, HARD)
+- `--total-timesteps`: Total training timesteps (default: 1000000)
+- `--learning-rate`: Learning rate (default: 2.5e-4)
+- `--num-envs`: Number of parallel environments (default: 4)
+- `--num-steps`: Steps per rollout (default: 128)
+- `--seed`: Random seed (default: 1)
+- `--track`: Enable Weights & Biases tracking
+- `--cuda`: Enable CUDA (default: True)
+
+### With Weights & Biases Tracking
+
+```bash
+python cleanrl/ppo_ultrahorizon.py \
+    --track \
+    --wandb-project-name "ultrahorizon-ppo" \
+    --wandb-entity "your-entity"
+```
+
+## Testing the Wrapper
+
+You can test the Gymnasium wrapper independently:
+
+```bash
+cd /Users/harryis/why_code/ICML_Memory/cleanrl
+python ultrahorizon_gym_wrapper.py
+```
+
+This will run a simple test that creates the environment, resets it, and takes a few random actions.
+
+## Implementation Details
+
+### Reward Structure
+The reward at each step is based on the score change in the environment. The agent learns to:
+- Maximize score by discovering the hidden effects of letters A-E
+- Manage energy efficiently (each move costs 1 energy)
+- Navigate the grid strategically
+
+### Episode Termination
+An episode terminates when:
+- Energy reaches 0
+- Maximum steps (30) are reached
+- An invalid move is attempted
+
+### Synchronous Wrapper
+Since the original Ultrahorizon environment uses async methods, the wrapper uses `asyncio.run()` to convert async calls to synchronous ones, making it compatible with CleanRL's synchronous training loop.
+
+## Requirements
+
+Make sure you have the following dependencies installed:
+
+```bash
+pip install gymnasium torch numpy tensorboard tyro
+```
+
+For the Ultrahorizon environment, you'll also need:
+```bash
+pip install openai pyyaml
+```
+
+## Monitoring Training
+
+Training metrics are logged to TensorBoard:
+
+```bash
+tensorboard --logdir runs/
+```
+
+Key metrics to monitor:
+- `charts/episodic_return`: Episode returns over time
+- `charts/episodic_length`: Episode lengths
+- `losses/policy_loss`: Policy gradient loss
+- `losses/value_loss`: Value function loss
+- `losses/entropy`: Policy entropy (exploration)
+- `charts/learning_rate`: Current learning rate (if annealing)
+
+## Troubleshooting
+
+### Import Errors
+If you encounter import errors, make sure you're running the script from the correct directory:
+```bash
+cd /Users/harryis/why_code/ICML_Memory/cleanrl
+python cleanrl/ppo_ultrahorizon.py
+```
+
+### CUDA Out of Memory
+If you encounter CUDA memory issues, try:
+- Reducing `--num-envs` (e.g., from 8 to 4)
+- Reducing `--num-steps` (e.g., from 128 to 64)
+- Using `--cuda False` to train on CPU
+
+### Slow Training
+The environment involves async operations which may slow down training. Consider:
+- Increasing `--num-envs` to parallelize more
+- Using a faster machine or GPU
+- Reducing the observation space dimensionality if needed
+
+## Comparison with Original PPO Atari
+
+| Feature | PPO Atari | PPO Ultrahorizon |
+|---------|-----------|------------------|
+| Observation | 84×84×4 images | 605-dim feature vector |
+| Network | CNN | MLP |
+| Actions | Game-specific | 4 directions |
+| Default envs | 8 | 4 |
+| Total timesteps | 10M | 1M |
+| Clip coefficient | 0.1 | 0.2 |
+
+The main algorithmic components (PPO loss, GAE, value clipping) remain identical to the original implementation.

cleanrl/cleanrl/noisy_dqn_2048_refined.py

@@ -0,0 +1,806 @@
+# NoisyNet DQN (dueling CNN) for RAGEN 2048
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, Tuple
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+import json
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+# 引用你提供的 env 和 config
+from ragen.env.game_2048.env import Game2048Env
+from ragen.env.game_2048.config import Game2048EnvConfig
+
+
+class Game2048Wrapper(gym.Env):
+    metadata = {"render_modes": ["text"]}
+
+    def __init__(self, env: Game2048Env, n_channels: int = 16):
+        super().__init__()
+        self._env = env
+        self._n_channels = int(n_channels)
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._n_channels, 4, 4), dtype=np.float32)
+        self.action_space = self._env.action_space
+        self._last_info: Dict[str, Any] | None = None
+
+    def _encode_grid(self, grid: np.ndarray) -> np.ndarray:
+        grid_flat = grid.flatten()
+        with np.errstate(divide='ignore'):
+            power_grid = np.log2(grid_flat, where=(grid_flat > 0)).astype(int)
+            power_grid[grid_flat == 0] = 0
+            power_grid = np.clip(power_grid, 0, self._n_channels - 1)
+            one_hot = np.eye(self._n_channels)[power_grid]
+            obs = one_hot.reshape(4, 4, self._n_channels).transpose(2, 0, 1)
+        return obs.astype(np.float32)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs, info = self._env.reset(seed=seed, options=options)
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        # augment info with max_tile for downstream logging
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+        return obs, ret_info
+
+    def step(self, action: int):
+        text_obs, reward, done, info = self._env.step(int(action))
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+            
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, ret_info
+
+
+    def get_action_mask(self) -> np.ndarray:
+        if self._last_info is None:
+            return np.ones((4,), dtype=bool)
+        mask = self._last_info.get('action_mask', None)
+        if mask is None:
+            return np.ones((4,), dtype=bool)
+        return np.asarray(mask, dtype=bool)
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "2048-RL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Game2048NoisyDQN"
+    total_timesteps: int = 1_000_000
+    learning_rate: float = 1e-4
+    gamma: float = 0.997
+    batch_size: int = 512
+    buffer_size: int = 2400_000
+    target_network_frequency: int = 15000
+    train_frequency: int = 4
+    learning_starts: int = 20_000
+
+    # Epsilon-greedy (used lightly for warmup; noisy nets handle exploration)
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.8
+
+    # Model
+    dueling: bool = True
+    # reward_transform 和 clip 参数不再使用，由环境 config 控制
+    
+    # n-step and PER
+    n_step: int = 10
+    per_alpha: float = 0.5
+    per_beta_start: float = 0.4
+    per_beta_frames: int = 1_000_000
+    per_eps: float = 1e-6
+
+    # Env config
+    two_prob: float = 0.9
+    max_steps_env: int = 1000
+
+    # Eval config
+    eval_splits: int = 2
+    eval_episodes: int = 200
+
+
+def make_env(run_name: str, seed: int, args: Args, capture_video: bool = False):
+    # 显式开启 use_log_reward=True，尽管 config 默认可能已为 True
+    cfg = Game2048EnvConfig(size=4, two_prob=args.two_prob, use_log_reward=True)
+    base = Game2048Env(cfg)
+    env = Game2048Wrapper(base)
+    env = gym.wrappers.TimeLimit(env, max_episode_steps=args.max_steps_env)
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+    if capture_video:
+        env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+    return env
+
+
+class NoisyLinear(nn.Module):
+    def __init__(self, in_features: int, out_features: int, std_init: float = 0.5):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight_mu = nn.Parameter(torch.empty(out_features, in_features))
+        self.weight_sigma = nn.Parameter(torch.empty(out_features, in_features))
+        self.register_buffer('weight_epsilon', torch.empty(out_features, in_features))
+        self.bias_mu = nn.Parameter(torch.empty(out_features))
+        self.bias_sigma = nn.Parameter(torch.empty(out_features))
+        self.register_buffer('bias_epsilon', torch.empty(out_features))
+        self.std_init = std_init / np.sqrt(in_features)
+        self.reset_parameters()
+        self.reset_noise()
+
+    def reset_parameters(self):
+        mu_range = 1 / np.sqrt(self.in_features)
+        self.weight_mu.data.uniform_(-mu_range, mu_range)
+        self.weight_sigma.data.fill_(self.std_init)
+        self.bias_mu.data.uniform_(-mu_range, mu_range)
+        self.bias_sigma.data.fill_(self.std_init)
+
+    def reset_noise(self):
+        epsilon_in = torch.randn(self.in_features, device=self.weight_mu.device)
+        epsilon_out = torch.randn(self.out_features, device=self.weight_mu.device)
+        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))
+        self.bias_epsilon.copy_(epsilon_out)
+
+    def forward(self, x):
+        if self.training:
+            w = self.weight_mu + self.weight_sigma * self.weight_epsilon
+            b = self.bias_mu + self.bias_sigma * self.bias_epsilon
+        else:
+            w = self.weight_mu
+            b = self.bias_mu
+        return torch.nn.functional.linear(x, w, b)
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    if isinstance(layer, NoisyLinear):
+        nn.init.orthogonal_(layer.weight_mu, std)
+        nn.init.constant_(layer.bias_mu, bias_const)
+        layer.weight_sigma.data.fill_(layer.std_init)
+        layer.bias_sigma.data.fill_(layer.std_init)
+    else:
+        nn.init.orthogonal_(layer.weight, std)
+        nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QConvNoisy(nn.Module):
+    def __init__(self, obs_shape: Tuple[int, int, int], act_dim: int, dueling: bool = True):
+        super().__init__()
+        c, h, w = obs_shape
+        self.dueling = dueling
+        self._act_dim = act_dim
+        self.features = nn.Sequential(
+            layer_init(nn.Conv2d(c, 64, 2, 1, 0)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 128, 2, 1, 1)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(128, 128, 2, 1, 0)),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+        # compute fc_in via dummy
+        with torch.no_grad():
+            dummy = torch.zeros(1, c, h, w)
+            fc_in = int(self.features(dummy).shape[1])
+        if self.dueling:
+            self.adv_head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, act_dim), std=0.01),
+            )
+            self.val_head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, 1), std=0.01),
+            )
+        else:
+            self.head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, act_dim), std=0.01),
+            )
+
+    def reset_noise(self):
+        for m in self.modules():
+            if isinstance(m, NoisyLinear):
+                m.reset_noise()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)
+        if self.dueling:
+            adv = self.adv_head(x)
+            val = self.val_head(x)
+            q = val + adv - adv.mean(dim=1, keepdim=True)
+            return q
+        else:
+            q = self.head(x)
+            return q
+
+
+class SumTree:
+    def __init__(self, capacity: int):
+        self.capacity = 1
+        while self.capacity < capacity:
+            self.capacity *= 2
+        self.tree = np.zeros(2 * self.capacity, dtype=np.float32)
+        self.size = 0
+        self.ptr = 0
+
+    def add(self, p: float):
+        idx = self.ptr + self.capacity
+        self.update(idx, p)
+        self.ptr = (self.ptr + 1) % self.capacity
+        self.size = min(self.size + 1, self.capacity)
+        return idx
+
+    def update(self, idx: int, p: float):
+        change = p - self.tree[idx]
+        self.tree[idx] = p
+        idx //= 2
+        while idx >= 1:
+            self.tree[idx] += change
+            idx //= 2
+
+    def total(self) -> float:
+        return float(self.tree[1])
+
+    def get(self, s: float) -> int:
+        idx = 1
+        while idx < self.capacity:
+            left = 2 * idx
+            if s <= self.tree[left]:
+                idx = left
+            else:
+                s -= self.tree[left]
+                idx = left + 1
+        return idx
+
+
+class PrioritizedReplayBuffer:
+    def __init__(self, capacity: int, obs_shape: Tuple[int, int, int], alpha: float = 0.6, eps: float = 1e-6):
+        self.capacity = capacity
+        self.alpha = alpha
+        self.eps = eps
+        self.tree = SumTree(capacity)
+        self.obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.next_obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.act_buf = np.zeros((capacity,), dtype=np.int64)
+        self.rew_buf = np.zeros((capacity,), dtype=np.float32)
+        self.done_buf = np.zeros((capacity,), dtype=np.float32)
+        self.max_prio = 1.0
+
+    def _store_index(self) -> int:
+        idx_leaf = self.tree.add(self.max_prio ** self.alpha)
+        idx = (idx_leaf - self.tree.capacity) % self.capacity
+        return idx, idx_leaf
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        idx, idx_leaf = self._store_index()
+        self.obs_buf[idx] = obs
+        self.next_obs_buf[idx] = next_obs
+        self.act_buf[idx] = act
+        self.rew_buf[idx] = rew
+        self.done_buf[idx] = 1.0 if done else 0.0
+        return idx_leaf
+
+    def can_sample(self, batch_size: int) -> bool:
+        return self.tree.size >= batch_size
+
+    def sample(self, batch_size: int, beta: float):
+        total_p = self.tree.total()
+        if (not np.isfinite(total_p)) or (total_p <= 0.0):
+            size = max(1, self.tree.size)
+            idxs = np.random.randint(0, size, size=batch_size)
+            idx_leaves = (idxs + self.tree.capacity).astype(np.int64)
+            weights = np.ones((batch_size,), dtype=np.float32)
+            return (
+                self.obs_buf[idxs],
+                self.act_buf[idxs],
+                self.rew_buf[idxs],
+                self.done_buf[idxs],
+                self.next_obs_buf[idxs],
+                idx_leaves,
+                weights,
+            )
+        seg = total_p / float(batch_size)
+        idx_leaves = []
+        idxs = []
+        priorities = []
+        for i in range(batch_size):
+            a = seg * i
+            b = seg * (i + 1)
+            s = np.random.uniform(a, b)
+            idx_leaf = self.tree.get(s)
+            idx = (idx_leaf - self.tree.capacity) % self.capacity
+            p = float(self.tree.tree[idx_leaf])
+            idx_leaves.append(idx_leaf)
+            idxs.append(idx)
+            priorities.append(p)
+        probs = np.asarray(priorities, dtype=np.float32) / float(total_p)
+        probs = np.clip(probs, 1e-12, None)
+        weights = (self.tree.size * probs) ** (-beta)
+        weights = weights / (weights.max() + 1e-8)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+            np.asarray(idx_leaves, dtype=np.int64),
+            np.asarray(weights, dtype=np.float32),
+        )
+
+    def update_priorities(self, idx_leaves: np.ndarray, td_errors: np.ndarray):
+        td = np.abs(td_errors)
+        td = np.where(np.isfinite(td), td, self.eps)
+        td = np.clip(td + self.eps, self.eps, 1e3)
+        self.max_prio = max(self.max_prio, float(td.max()))
+        for idx_leaf, p in zip(idx_leaves, td):
+            self.tree.update(int(idx_leaf), float(p) ** self.alpha)
+
+
+class NStepBuffer:
+    def __init__(self, n: int, gamma: float):
+        self.n = int(max(1, n))
+        self.gamma = float(gamma)
+        self.states = []
+        self.actions = []
+        self.rewards = []
+        self.dones = []
+        self.next_states = []
+
+    def push(self, s, a, r, d, next_s):
+        self.states.append(s)
+        self.actions.append(a)
+        self.rewards.append(r)
+        self.dones.append(d)
+        self.next_states.append(next_s)
+        if len(self.states) >= self.n:
+            return self._pop()
+        return None
+
+    def _pop(self):
+        m = min(self.n, len(self.states))
+        R = 0.0
+        cut = m
+        for i in range(m):
+            R += (self.gamma ** i) * self.rewards[i]
+            if self.dones[i]:
+                cut = i + 1
+                break
+        s0 = self.states[0]
+        a0 = self.actions[0]
+        dN = any(self.dones[: cut])
+        last_idx = cut - 1
+        sN = self.next_states[last_idx]
+        self.states.pop(0)
+        self.actions.pop(0)
+        self.rewards.pop(0)
+        self.dones.pop(0)
+        self.next_states.pop(0)
+        return s0, a0, R, dN, sN
+
+    def flush(self):
+        out = []
+        while len(self.states) > 0:
+            out_tr = self._pop()
+            if out_tr is not None:
+                out.append(out_tr)
+        return out
+
+
+def augment_transition(obs, action, reward, done, next_obs):
+    """
+    利用 2048 的旋转和镜像对称性，将 1 条经验扩展为 8 条。
+    """
+    augmented_data = []
+    
+    curr_obs = obs.copy()
+    curr_next_obs = next_obs.copy()
+    curr_action = action
+    
+    rot_90_map = {0: 3, 1: 0, 2: 1, 3: 2}
+    flip_map = {0: 0, 1: 3, 2: 2, 3: 1}
+    
+    for _ in range(4):
+        # 1. 添加当前旋转状态
+        augmented_data.append((curr_obs, curr_action, reward, done, curr_next_obs))
+        
+        # 2. 添加当前旋转状态的【水平翻转】版本
+        flip_obs = np.flip(curr_obs, axis=2)
+        flip_next_obs = np.flip(curr_next_obs, axis=2)
+        flip_action = flip_map[curr_action]
+        augmented_data.append((flip_obs, flip_action, reward, done, flip_next_obs))
+
+        # 3. 旋转90度
+        curr_obs = np.rot90(curr_obs, k=1, axes=(1, 2))
+        curr_next_obs = np.rot90(curr_next_obs, k=1, axes=(1, 2))
+        curr_action = rot_90_map[curr_action]
+
+    return augmented_data
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    try:
+        wandb.define_metric("global_step")
+        for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+            wandb.define_metric(prefix, step_metric="global_step")
+    except Exception:
+        pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(run_name, args.seed, args, args.capture_video)
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    policy_net = QConvNoisy(obs_shape, act_dim, dueling=args.dueling).to(device)
+    target_net = QConvNoisy(obs_shape, act_dim, dueling=args.dueling).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+
+    rb = PrioritizedReplayBuffer(args.buffer_size, obs_shape, alpha=args.per_alpha, eps=args.per_eps)
+    nbuf = NStepBuffer(args.n_step, args.gamma)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes: int, step_tag: int):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, info = env_eval.reset(seed=args.seed + 100000 + collected)
+                current_info = info or {}
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or args.max_steps_env
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+                        mask = torch.tensor(mask_np, device=device, dtype=torch.bool).unsqueeze(0)
+                        masked_q = torch.where(mask, q, torch.full_like(q, -1e9))
+                        action = int(torch.argmax(masked_q, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    
+                    # === Eval: 使用 Raw Reward 进行统计 (Pre-regularization) ===
+                    raw_r = info.get('raw_reward', reward) if info else reward
+                    traj_rewards.append(float(raw_r))
+                    
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    current_info = info or {}
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+
+    def epsilon_by_step(t: int):
+        return args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    global_step = 0
+    start_time = time.time()
+
+    obs, info = env.reset(seed=args.seed)
+    current_info = info or {}
+    
+    # 记录当前 episode 的原始分数累积
+    ep_return = 0.0
+    ep_len = 0
+    # 记录该 episode 内每步的累计分数，用于 score_mean 和 final_score
+    ep_scores = []
+    
+    # 滑动窗口记录最近的 success 和 return (raw)
+    ep_success_window = deque(maxlen=100)
+    ep_return_window = deque(maxlen=100)
+    
+    # 仅用于 PPO charts 的 step_reward 分布 (这里记录 Log Reward 用于观察训练稳定性)
+    step_reward_window = deque(maxlen=2048)
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        with torch.no_grad():
+            q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+            mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+            mask = torch.tensor(mask_np, device=device, dtype=torch.bool).unsqueeze(0)
+            masked_q = torch.where(mask, q_values, torch.full_like(q_values, -1e9))
+            action_greedy = int(torch.argmax(masked_q, dim=1).item())
+            if (global_step < args.learning_starts) and (np.random.rand() < 0.5):
+                valid = np.where(mask_np)[0]
+                if len(valid) > 0:
+                    action = int(np.random.choice(valid))
+                else:
+                    action = int(np.random.randint(0, act_dim))
+            else:
+                action = action_greedy
+
+        next_obs, reward, terminated, truncated, info = env.step(action)
+        done = bool(terminated) or bool(truncated)
+
+        # === 训练用 Reward (已正则化) ===
+        # 环境配置了 use_log_reward=True，所以这里的 reward 已经是 log scale
+        train_r = float(reward)
+        
+        # 将经验推入 N-step Buffer
+        n_out = nbuf.push(obs.astype(np.float32), int(action), float(train_r), bool(done), next_obs.astype(np.float32))
+        if n_out is not None:
+            s0, a0, Rn, dN, sN = n_out
+            
+            # === 数据增强 (8x) ===
+            aug_batch = augment_transition(s0, a0, Rn, dN, sN)
+            for sample in aug_batch:
+                _s, _a, _r, _d, _ns = sample
+                rb.add(_s, _a, _r, _d, _ns)
+
+        obs = next_obs
+        current_info = info or {}
+        
+        # === Logging 用 Reward (Raw Score) ===
+        # 优先使用 info['raw_reward']，如果没有则回退 (理论上一定有)
+        raw_r = float(info.get('raw_reward', reward))
+        ep_return += raw_r
+        # 记录累计分数轨迹
+        try:
+            ep_scores.append(float(info.get('score', 0.0)))
+        except Exception:
+            pass
+        
+        try:
+            step_reward_window.append(float(train_r))
+        except Exception:
+            pass
+        ep_len += 1
+        global_step += 1
+
+        if (global_step > args.learning_starts) and rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0):
+            frac = min(1.0, global_step / float(max(1, args.per_beta_frames)))
+            beta = args.per_beta_start + (1.0 - args.per_beta_start) * frac
+
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs, idx_leaves, weights = rb.sample(args.batch_size, beta)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+            b_w = torch.tensor(weights, dtype=torch.float32, device=device)
+
+            with torch.no_grad():
+                next_actions = policy_net(b_next_obs).argmax(dim=1)
+                next_q = target_net(b_next_obs).gather(1, next_actions.view(-1, 1)).squeeze(1)
+                target_q = b_rew + (args.gamma ** args.n_step) * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            td_error = target_q - current_q
+            per_loss = torch.abs(td_error).detach().cpu().numpy()
+            loss_unreduced = torch.nn.functional.smooth_l1_loss(current_q, target_q, reduction='none')
+            loss = (b_w * loss_unreduced).mean()
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            policy_net.reset_noise()
+            target_net.reset_noise()
+
+            rb.update_priorities(idx_leaves, td_error.detach().cpu().numpy())
+
+            if args.track:
+                try:
+                    import wandb
+                    try:
+                        avg_reward_val = float(np.mean(step_reward_window)) if len(step_reward_window) > 0 else 0.0
+                    except Exception:
+                        avg_reward_val = 0.0
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "train/value_loss": None,
+                        "train/policy_loss": None,
+                        "train/entropy": None,
+                        "losses/explained_variance": None,
+                        "charts/avg_reward": avg_reward_val,
+                        "charts/avg_value": None,
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        if done:
+            succ = bool((info or {}).get('success', False))
+            max_tile = int((info or {}).get('max_tile', 0))
+            # 计算该局的 score_mean 和 final_score
+            try:
+                score_mean = float(np.mean(ep_scores)) if len(ep_scores) > 0 else 0.0
+            except Exception:
+                score_mean = 0.0
+            try:
+                final_score = float(ep_scores[-1]) if len(ep_scores) > 0 else 0.0
+            except Exception:
+                final_score = 0.0
+            
+            # 更新滑动窗口
+            ep_success_window.append(1.0 if succ else 0.0)
+            ep_return_window.append(float(ep_return)) # Raw Score
+            
+            # 处理 N-step buffer 剩余部分 (同样做 augmentation)
+            for out_tr in nbuf.flush():
+                s0, a0, Rn, dN, sN = out_tr
+                aug_batch = augment_transition(s0, a0, Rn, dN, sN)
+                for sample in aug_batch:
+                    _s, _a, _r, _d, _ns = sample
+                    rb.add(_s, _a, _r, _d, _ns)
+            
+            try:
+                if max_tile is not None:
+                    print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, max_tile={int(max_tile)}, success={succ}")
+                else:
+                    print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, success={succ}")
+            except Exception:
+                pass
+                
+            if args.track:
+                try:
+                    import wandb
+                    # 计算 avg_episode_return (Raw)
+                    avg_ep_ret = float(np.mean(ep_return_window)) if len(ep_return_window) > 0 else 0.0
+                    
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "rollout/episodic_return": float(ep_return),
+                        "rollout/episodic_length": int(ep_len),
+                        "rollout/success": float(1.0 if succ else 0.0),
+                        "rollout/max_tile": int(max_tile),
+                        # 新增：每局按步均值的累计分与最终累计分
+                        "rollout/score_mean": score_mean,
+                        "rollout/final_score": final_score,
+                        "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                        # mirror PPO charts/* keys
+                        "charts/episodic_return": float(ep_return),
+                        "charts/episodic_length": int(ep_len),
+                        "charts/success": float(1.0 if succ else 0.0),
+                        "charts/max_tile": int(max_tile),
+                        # 新增：charts 前缀版本
+                        "charts/score_mean": score_mean,
+                        "charts/final_score": final_score,
+                        "charts/avg_episode_return": avg_ep_ret,
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs, info = env.reset()
+            current_info = info or {}
+            ep_return, ep_len = 0.0, 0
+            ep_scores = []
+
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        if (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    return make_env(run_name, args.seed + 9999, args, False)
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    env.close()

cleanrl/cleanrl/ppg_procgen.py

@@ -0,0 +1,480 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppg/#ppg_procgenpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from procgen import ProcgenEnv
+from torch import distributions as td
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "starpilot"
+    """the id of the environment"""
+    total_timesteps: int = int(25e6)
+    """total timesteps of the experiments"""
+    learning_rate: float = 5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 64
+    """the number of parallel game environments"""
+    num_steps: int = 256
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = False
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.999
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 8
+    """the number of mini-batches"""
+    adv_norm_fullbatch: bool = True
+    """Toggle full batch advantage normalization as used in PPG code"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # PPG specific arguments
+    n_iteration: int = 32
+    """N_pi: the number of policy update in the policy phase """
+    e_policy: int = 1
+    """E_pi: the number of policy update in the policy phase """
+    v_value: int = 1
+    """E_V: the number of policy update in the policy phase """
+    e_auxiliary: int = 6
+    """E_aux:the K epochs to update the policy"""
+    beta_clone: float = 1.0
+    """the behavior cloning coefficient"""
+    num_aux_rollouts: int = 4
+    """the number of mini batch in the auxiliary phase"""
+    n_aux_grad_accum: int = 1
+    """the number of gradient accumulation in mini batch"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+    num_phases: int = 0
+    """the number of phases (computed in runtime)"""
+    aux_batch_rollouts: int = 0
+    """the number of rollouts in the auxiliary phase (computed in runtime)"""
+
+
+def layer_init_normed(layer, norm_dim, scale=1.0):
+    with torch.no_grad():
+        layer.weight.data *= scale / layer.weight.norm(dim=norm_dim, p=2, keepdim=True)
+        layer.bias *= 0
+    return layer
+
+
+def flatten01(arr):
+    return arr.reshape((-1, *arr.shape[2:]))
+
+
+def unflatten01(arr, targetshape):
+    return arr.reshape((*targetshape, *arr.shape[1:]))
+
+
+def flatten_unflatten_test():
+    a = torch.rand(400, 30, 100, 100, 5)
+    b = flatten01(a)
+    c = unflatten01(b, a.shape[:2])
+    assert torch.equal(a, c)
+
+
+# taken from https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/models/impala_cnn_torch.py
+class ResidualBlock(nn.Module):
+    def __init__(self, channels, scale):
+        super().__init__()
+        # scale = (1/3**0.5 * 1/2**0.5)**0.5 # For default IMPALA CNN this is the final scale value in the PPG code
+        scale = np.sqrt(scale)
+        conv0 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+        self.conv0 = layer_init_normed(conv0, norm_dim=(1, 2, 3), scale=scale)
+        conv1 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+        self.conv1 = layer_init_normed(conv1, norm_dim=(1, 2, 3), scale=scale)
+
+    def forward(self, x):
+        inputs = x
+        x = nn.functional.relu(x)
+        x = self.conv0(x)
+        x = nn.functional.relu(x)
+        x = self.conv1(x)
+        return x + inputs
+
+
+class ConvSequence(nn.Module):
+    def __init__(self, input_shape, out_channels, scale):
+        super().__init__()
+        self._input_shape = input_shape
+        self._out_channels = out_channels
+        conv = nn.Conv2d(in_channels=self._input_shape[0], out_channels=self._out_channels, kernel_size=3, padding=1)
+        self.conv = layer_init_normed(conv, norm_dim=(1, 2, 3), scale=1.0)
+        nblocks = 2  # Set to the number of residual blocks
+        scale = scale / np.sqrt(nblocks)
+        self.res_block0 = ResidualBlock(self._out_channels, scale=scale)
+        self.res_block1 = ResidualBlock(self._out_channels, scale=scale)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = nn.functional.max_pool2d(x, kernel_size=3, stride=2, padding=1)
+        x = self.res_block0(x)
+        x = self.res_block1(x)
+        assert x.shape[1:] == self.get_output_shape()
+        return x
+
+    def get_output_shape(self):
+        _c, h, w = self._input_shape
+        return (self._out_channels, (h + 1) // 2, (w + 1) // 2)
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        h, w, c = envs.single_observation_space.shape
+        shape = (c, h, w)
+        conv_seqs = []
+        chans = [16, 32, 32]
+        scale = 1 / np.sqrt(len(chans))  # Not fully sure about the logic behind this but its used in PPG code
+        for out_channels in chans:
+            conv_seq = ConvSequence(shape, out_channels, scale=scale)
+            shape = conv_seq.get_output_shape()
+            conv_seqs.append(conv_seq)
+
+        encodertop = nn.Linear(in_features=shape[0] * shape[1] * shape[2], out_features=256)
+        encodertop = layer_init_normed(encodertop, norm_dim=1, scale=1.4)
+        conv_seqs += [
+            nn.Flatten(),
+            nn.ReLU(),
+            encodertop,
+            nn.ReLU(),
+        ]
+        self.network = nn.Sequential(*conv_seqs)
+        self.actor = layer_init_normed(nn.Linear(256, envs.single_action_space.n), norm_dim=1, scale=0.1)
+        self.critic = layer_init_normed(nn.Linear(256, 1), norm_dim=1, scale=0.1)
+        self.aux_critic = layer_init_normed(nn.Linear(256, 1), norm_dim=1, scale=0.1)
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x.permute((0, 3, 1, 2)) / 255.0)  # "bhwc" -> "bchw"
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden.detach())
+
+    def get_value(self, x):
+        return self.critic(self.network(x.permute((0, 3, 1, 2)) / 255.0))  # "bhwc" -> "bchw"
+
+    # PPG logic:
+    def get_pi_value_and_aux_value(self, x):
+        hidden = self.network(x.permute((0, 3, 1, 2)) / 255.0)
+        return Categorical(logits=self.actor(hidden)), self.critic(hidden.detach()), self.aux_critic(hidden)
+
+    def get_pi(self, x):
+        return Categorical(logits=self.actor(self.network(x.permute((0, 3, 1, 2)) / 255.0)))
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    args.num_phases = int(args.num_iterations // args.n_iteration)
+    args.aux_batch_rollouts = int(args.num_envs * args.n_iteration)
+    assert args.v_value == 1, "Multiple value epoch (v_value != 1) is not supported yet"
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    flatten_unflatten_test()  # Try not to mess with the flatten unflatten logic
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = ProcgenEnv(num_envs=args.num_envs, env_name=args.env_id, num_levels=0, start_level=0, distribution_mode="easy")
+    envs = gym.wrappers.TransformObservation(envs, lambda obs: obs["rgb"])
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space["rgb"]
+    envs.is_vector_env = True
+    envs = gym.wrappers.RecordEpisodeStatistics(envs)
+    if args.capture_video:
+        envs = gym.wrappers.RecordVideo(envs, f"videos/{run_name}")
+    envs = gym.wrappers.NormalizeReward(envs, gamma=args.gamma)
+    envs = gym.wrappers.TransformReward(envs, lambda reward: np.clip(reward, -10, 10))
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-8)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    aux_obs = torch.zeros(
+        (args.num_steps, args.aux_batch_rollouts) + envs.single_observation_space.shape, dtype=torch.uint8
+    )  # Saves lot system RAM
+    aux_returns = torch.zeros((args.num_steps, args.aux_batch_rollouts))
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for phase in range(1, args.num_phases + 1):
+
+        # POLICY PHASE
+        for update in range(1, args.n_iteration + 1):
+            # Annealing the rate if instructed to do so.
+            if args.anneal_lr:
+                frac = 1.0 - (update - 1.0) / args.num_iterations
+                lrnow = frac * args.learning_rate
+                optimizer.param_groups[0]["lr"] = lrnow
+
+            for step in range(0, args.num_steps):
+                global_step += 1 * args.num_envs
+                obs[step] = next_obs
+                dones[step] = next_done
+
+                # ALGO LOGIC: action logic
+                with torch.no_grad():
+                    action, logprob, _, value = agent.get_action_and_value(next_obs)
+                    values[step] = value.flatten()
+                actions[step] = action
+                logprobs[step] = logprob
+
+                # TRY NOT TO MODIFY: execute the game and log data.
+                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)
+
+                for item in info:
+                    if "episode" in item.keys():
+                        print(f"global_step={global_step}, episodic_return={item['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", item["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", item["episode"]["l"], global_step)
+                        break
+
+            # bootstrap value if not done
+            with torch.no_grad():
+                next_value = agent.get_value(next_obs).reshape(1, -1)
+                advantages = torch.zeros_like(rewards).to(device)
+                lastgaelam = 0
+                for t in reversed(range(args.num_steps)):
+                    if t == args.num_steps - 1:
+                        nextnonterminal = 1.0 - next_done
+                        nextvalues = next_value
+                    else:
+                        nextnonterminal = 1.0 - dones[t + 1]
+                        nextvalues = values[t + 1]
+                    delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                    advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+                returns = advantages + values
+
+            # flatten the batch
+            b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+            b_logprobs = logprobs.reshape(-1)
+            b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+            b_advantages = advantages.reshape(-1)
+            b_returns = returns.reshape(-1)
+            b_values = values.reshape(-1)
+
+            # PPG code does full batch advantage normalization
+            if args.adv_norm_fullbatch:
+                b_advantages = (b_advantages - b_advantages.mean()) / (b_advantages.std() + 1e-8)
+
+            # Optimizing the policy and value network
+            b_inds = np.arange(args.batch_size)
+            clipfracs = []
+            for epoch in range(args.e_policy):
+                np.random.shuffle(b_inds)
+                for start in range(0, args.batch_size, args.minibatch_size):
+                    end = start + args.minibatch_size
+                    mb_inds = b_inds[start:end]
+
+                    _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                    logratio = newlogprob - b_logprobs[mb_inds]
+                    ratio = logratio.exp()
+
+                    with torch.no_grad():
+                        # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                        old_approx_kl = (-logratio).mean()
+                        approx_kl = ((ratio - 1) - logratio).mean()
+                        clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                    mb_advantages = b_advantages[mb_inds]
+
+                    # Policy loss
+                    pg_loss1 = -mb_advantages * ratio
+                    pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                    pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                    # Value loss
+                    newvalue = newvalue.view(-1)
+                    if args.clip_vloss:
+                        v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                        v_clipped = b_values[mb_inds] + torch.clamp(
+                            newvalue - b_values[mb_inds],
+                            -args.clip_coef,
+                            args.clip_coef,
+                        )
+                        v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                        v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                        v_loss = 0.5 * v_loss_max.mean()
+                    else:
+                        v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                    entropy_loss = entropy.mean()
+                    loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                    optimizer.zero_grad()
+                    loss.backward()
+                    nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                    optimizer.step()
+
+                if args.target_kl is not None and approx_kl > args.target_kl:
+                    break
+
+            y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+            var_y = np.var(y_true)
+            explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+            # TRY NOT TO MODIFY: record rewards for plotting purposes
+            writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+            writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+            writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+            writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+            writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+            writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+            writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+            writer.add_scalar("losses/explained_variance", explained_var, global_step)
+            print("SPS:", int(global_step / (time.time() - start_time)))
+            writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+            # PPG Storage - Rollouts are saved without flattening for sampling full rollouts later:
+            storage_slice = slice(args.num_envs * (update - 1), args.num_envs * update)
+            aux_obs[:, storage_slice] = obs.cpu().clone().to(torch.uint8)
+            aux_returns[:, storage_slice] = returns.cpu().clone()
+
+        # AUXILIARY PHASE
+        aux_inds = np.arange(args.aux_batch_rollouts)
+
+        # Build the old policy on the aux buffer before distilling to the network
+        aux_pi = torch.zeros((args.num_steps, args.aux_batch_rollouts, envs.single_action_space.n))
+        for i, start in enumerate(range(0, args.aux_batch_rollouts, args.num_aux_rollouts)):
+            end = start + args.num_aux_rollouts
+            aux_minibatch_ind = aux_inds[start:end]
+            m_aux_obs = aux_obs[:, aux_minibatch_ind].to(torch.float32).to(device)
+            m_obs_shape = m_aux_obs.shape
+            m_aux_obs = flatten01(m_aux_obs)
+            with torch.no_grad():
+                pi_logits = agent.get_pi(m_aux_obs).logits.cpu().clone()
+            aux_pi[:, aux_minibatch_ind] = unflatten01(pi_logits, m_obs_shape[:2])
+            del m_aux_obs
+
+        for auxiliary_update in range(1, args.e_auxiliary + 1):
+            print(f"aux epoch {auxiliary_update}")
+            np.random.shuffle(aux_inds)
+            for i, start in enumerate(range(0, args.aux_batch_rollouts, args.num_aux_rollouts)):
+                end = start + args.num_aux_rollouts
+                aux_minibatch_ind = aux_inds[start:end]
+                try:
+                    m_aux_obs = aux_obs[:, aux_minibatch_ind].to(device)
+                    m_obs_shape = m_aux_obs.shape
+                    m_aux_obs = flatten01(m_aux_obs)  # Sample full rollouts for PPG instead of random indexes
+                    m_aux_returns = aux_returns[:, aux_minibatch_ind].to(torch.float32).to(device)
+                    m_aux_returns = flatten01(m_aux_returns)
+
+                    new_pi, new_values, new_aux_values = agent.get_pi_value_and_aux_value(m_aux_obs)
+
+                    new_values = new_values.view(-1)
+                    new_aux_values = new_aux_values.view(-1)
+                    old_pi_logits = flatten01(aux_pi[:, aux_minibatch_ind]).to(device)
+                    old_pi = Categorical(logits=old_pi_logits)
+                    kl_loss = td.kl_divergence(old_pi, new_pi).mean()
+
+                    real_value_loss = 0.5 * ((new_values - m_aux_returns) ** 2).mean()
+                    aux_value_loss = 0.5 * ((new_aux_values - m_aux_returns) ** 2).mean()
+                    joint_loss = aux_value_loss + args.beta_clone * kl_loss
+
+                    loss = (joint_loss + real_value_loss) / args.n_aux_grad_accum
+                    loss.backward()
+
+                    if (i + 1) % args.n_aux_grad_accum == 0:
+                        nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                        optimizer.step()
+                        optimizer.zero_grad()  # This cannot be outside, else gradients won't accumulate
+
+                except RuntimeError as e:
+                    raise Exception(
+                        "if running out of CUDA memory, try a higher --n-aux-grad-accum, which trades more time for less gpu memory"
+                    ) from e
+
+                del m_aux_obs, m_aux_returns
+        writer.add_scalar("losses/aux/kl_loss", kl_loss.mean().item(), global_step)
+        writer.add_scalar("losses/aux/aux_value_loss", aux_value_loss.item(), global_step)
+        writer.add_scalar("losses/aux/real_value_loss", real_value_loss.item(), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo.py

@@ -0,0 +1,312 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppopy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "CartPole-v1"
+    """the id of the environment"""
+    total_timesteps: int = 500000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 4
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        return env
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+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 = 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, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_2048.py

@@ -0,0 +1,514 @@
+# PPO (CNN actor-critic) for RAGEN 2048, matching NoisyNet DQN args and wandb logging
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, Tuple
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import tyro
+import json
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+# env and config
+from ragen.env.game_2048.env import Game2048Env
+from ragen.env.game_2048.config import Game2048EnvConfig
+
+
+class Game2048Wrapper(gym.Env):
+    metadata = {"render_modes": ["text"]}
+
+    def __init__(self, env: Game2048Env, n_channels: int = 16):
+        super().__init__()
+        self._env = env
+        self._n_channels = int(n_channels)
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._n_channels, 4, 4), dtype=np.float32)
+        self.action_space = self._env.action_space
+        self._last_info: Dict[str, Any] | None = None
+
+    def _encode_grid(self, grid: np.ndarray) -> np.ndarray:
+        grid_flat = grid.flatten()
+        with np.errstate(divide='ignore'):
+            power_grid = np.log2(grid_flat, where=(grid_flat > 0)).astype(int)
+            power_grid[grid_flat == 0] = 0
+            power_grid = np.clip(power_grid, 0, self._n_channels - 1)
+            one_hot = np.eye(self._n_channels)[power_grid]
+            obs = one_hot.reshape(4, 4, self._n_channels).transpose(2, 0, 1)
+        return obs.astype(np.float32)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs, info = self._env.reset(seed=seed, options=options)
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+        return obs, ret_info
+
+    def step(self, action: int):
+        text_obs, reward, done, info = self._env.step(int(action))
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, ret_info
+
+    def get_action_mask(self) -> np.ndarray:
+        if self._last_info is None:
+            return np.ones((4,), dtype=bool)
+        mask = self._last_info.get('action_mask', None)
+        if mask is None:
+            return np.ones((4,), dtype=bool)
+        return np.asarray(mask, dtype=bool)
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    # mirror DQN args for wandb compatibility
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "2048-RL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm identifiers
+    env_id: str = "Game2048PPO"
+    total_timesteps: int = 3_000_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.997
+
+    # DQN-only args kept for wandb/backward-compat (unused here)
+    batch_size: int = 512
+    buffer_size: int = 2400_000
+    target_network_frequency: int = 15000
+    train_frequency: int = 4
+    learning_starts: int = 20_000
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.8
+    dueling: bool = True
+    n_step: int = 10
+    per_alpha: float = 0.5
+    per_beta_start: float = 0.4
+    per_beta_frames: int = 1_000_000
+    per_eps: float = 1e-6
+
+    # Env config
+    two_prob: float = 0.9
+    max_steps_env: int = 1000
+
+    # Eval config
+    eval_splits: int = 1
+    eval_episodes: int = 400
+
+    # PPO specific
+    num_steps: int = 256
+    num_minibatches: int = 8
+    update_epochs: int = 4
+    gae_lambda: float = 0.95
+    clip_coef: float = 0.2
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    anneal_lr: bool = True
+
+
+def make_env(run_name: str, seed: int, args: Args, capture_video: bool = False):
+    cfg = Game2048EnvConfig(size=4, two_prob=args.two_prob, use_log_reward=True)
+    base = Game2048Env(cfg)
+    env = Game2048Wrapper(base)
+    env = gym.wrappers.TimeLimit(env, max_episode_steps=args.max_steps_env)
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+    if capture_video:
+        env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+    return env
+
+
+class ActorCriticCNN(nn.Module):
+    def __init__(self, obs_shape: Tuple[int, int, int], act_dim: int):
+        super().__init__()
+        c, h, w = obs_shape
+        self.features = nn.Sequential(
+            nn.Conv2d(c, 64, 2, 1, 0),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 2, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, 2, 1, 0),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+        with torch.no_grad():
+            fc_in = int(self.features(torch.zeros(1, *obs_shape)).shape[1])
+        self.pi = nn.Sequential(
+            nn.Linear(fc_in, 512), nn.ReLU(), nn.Linear(512, act_dim)
+        )
+        self.v = nn.Sequential(
+            nn.Linear(fc_in, 512), nn.ReLU(), nn.Linear(512, 1)
+        )
+
+    def get_value(self, x):
+        x = self.features(x)
+        return self.v(x).squeeze(-1)
+
+    def get_action_and_value(self, x, action=None, action_mask=None):
+        x = self.features(x)
+        logits = self.pi(x)
+        if action_mask is not None:
+            mask = action_mask.bool()
+            logits = torch.where(mask, logits, torch.full_like(logits, -1e9))
+        probs = torch.distributions.Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.v(x).squeeze(-1)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    try:
+        wandb.define_metric("global_step")
+        for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+            wandb.define_metric(prefix, step_metric="global_step")
+    except Exception:
+        pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(run_name, args.seed, args, args.capture_video)
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    agent = ActorCriticCNN(obs_shape, act_dim).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # Storage
+    num_steps = args.num_steps
+    obs = np.zeros((num_steps,) + obs_shape, dtype=np.float32)
+    actions = np.zeros((num_steps,), dtype=np.int64)
+    logprobs = np.zeros((num_steps,), dtype=np.float32)
+    rewards = np.zeros((num_steps,), dtype=np.float32)
+    dones = np.zeros((num_steps,), dtype=np.float32)
+    values = np.zeros((num_steps,), dtype=np.float32)
+    masks_buf = np.zeros((num_steps, act_dim), dtype=bool)
+
+    global_step = 0
+    start_time = time.time()
+
+    next_obs, info = env.reset(seed=args.seed)
+    current_info = info or {}
+    next_done = False
+
+    ep_return = 0.0
+    ep_len = 0
+    ep_success_window = deque(maxlen=100)
+    ep_return_window = deque(maxlen=100)
+    step_reward_window = deque(maxlen=2048)
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes: int, step_tag: int):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, info = env_eval.reset(seed=args.seed + 100000 + collected)
+                current_info = info or {}
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or args.max_steps_env
+                while not done:
+                    with torch.no_grad():
+                        s = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                        mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+                        mask = torch.tensor(mask_np, dtype=torch.bool, device=device).unsqueeze(0)
+                        logits = agent_model.pi(agent_model.features(s))
+                        logits = torch.where(mask, logits, torch.full_like(logits, -1e9))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    raw_r = info.get('raw_reward', reward) if info else reward
+                    traj_rewards.append(float(raw_r))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    current_info = info or {}
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    num_updates = args.total_timesteps // num_steps
+
+    for update in range(1, num_updates + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (update - 1.0) / float(max(1, num_updates))
+            lrnow = args.learning_rate * frac
+            for pg in optimizer.param_groups:
+                pg['lr'] = lrnow
+
+        for step in range(num_steps):
+            obs[step] = next_obs
+            dones[step] = float(next_done)
+            with torch.no_grad():
+                s = torch.tensor(next_obs, dtype=torch.float32, device=device).unsqueeze(0)
+                mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+                masks_buf[step] = mask_np
+                mask = torch.tensor(mask_np, dtype=torch.bool, device=device).unsqueeze(0)
+                a, lp, ent, val = agent.get_action_and_value(s, action_mask=mask)
+            action = int(a.item())
+            next_obs, reward, terminated, truncated, info = env.step(action)
+            done = bool(terminated) or bool(truncated)
+
+            rewards[step] = float(reward)  # training reward (log-scale per env)
+            actions[step] = action
+            logprobs[step] = float(lp.item())
+            values[step] = float(val.item())
+
+            # logging raw reward for charts
+            raw_r = float((info or {}).get('raw_reward', reward))
+            ep_return += raw_r
+            try:
+                step_reward_window.append(float(reward))
+            except Exception:
+                pass
+            ep_len += 1
+            global_step += 1
+
+            if done:
+                succ = bool((info or {}).get('success', False))
+                max_tile = int((info or {}).get('max_tile', 0))
+                ep_success_window.append(1.0 if succ else 0.0)
+                ep_return_window.append(float(ep_return))
+                try:
+                    if max_tile is not None:
+                        print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, max_tile={int(max_tile)}, success={succ}")
+                    else:
+                        print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, success={succ}")
+                except Exception:
+                    pass
+                if args.track:
+                    try:
+                        import wandb
+                        avg_ep_ret = float(np.mean(ep_return_window)) if len(ep_return_window) > 0 else 0.0
+                        wandb.log({
+                            "global_step": int(global_step),
+                            "rollout/episodic_return": float(ep_return),
+                            "rollout/episodic_length": int(ep_len),
+                            "rollout/success": float(1.0 if succ else 0.0),
+                            "rollout/max_tile": int(max_tile),
+                            "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                            "charts/episodic_return": float(ep_return),
+                            "charts/episodic_length": int(ep_len),
+                            "charts/success": float(1.0 if succ else 0.0),
+                            "charts/max_tile": int(max_tile),
+                            "charts/avg_episode_return": avg_ep_ret,
+                        }, step=global_step)
+                    except Exception:
+                        pass
+                next_obs, info = env.reset()
+                current_info = info or {}
+                ep_return, ep_len = 0.0, 0
+            else:
+                current_info = info or {}
+                next_done = False
+
+            if global_step % 1000 == 0:
+                sps = int(global_step / (time.time() - start_time))
+                sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+                print(f"Step {global_step} | SPS: {sps} | SR@100: {sr100:.3f}")
+
+            if (global_step % eval_every_steps == 0):
+                try:
+                    def eval_thunk():
+                        return make_env(run_name, args.seed + 9999, args, False)
+                    collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                    if args.track:
+                        try:
+                            import wandb
+                            mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                            if mpath.exists():
+                                with mpath.open("r") as mf:
+                                    metrics = json.load(mf)
+                                wandb.log({
+                                    "eval/success_rate": metrics.get("success_rate"),
+                                    "eval/avg_return": metrics.get("avg_return"),
+                                    "eval/std_return": metrics.get("std_return"),
+                                    "eval/episodes": metrics.get("episodes"),
+                                }, step=global_step)
+                        except Exception:
+                            pass
+                    print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+                except Exception as e:
+                    print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+        # Compute GAE
+        with torch.no_grad():
+            s = torch.tensor(next_obs, dtype=torch.float32, device=device).unsqueeze(0)
+            next_value = agent.get_value(s).item()
+        advantages = np.zeros_like(rewards)
+        lastgaelam = 0.0
+        for t in reversed(range(num_steps)):
+            if t == num_steps - 1:
+                nextnonterminal = 1.0 - next_done
+                nextvalues = next_value
+            else:
+                nextnonterminal = 1.0 - dones[t + 1]
+                nextvalues = values[t + 1]
+            delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+            advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+        returns = advantages + values
+
+        # Flatten
+        b_obs = torch.tensor(obs, dtype=torch.float32, device=device)
+        b_actions = torch.tensor(actions, dtype=torch.int64, device=device)
+        b_logprobs = torch.tensor(logprobs, dtype=torch.float32, device=device)
+        b_returns = torch.tensor(returns, dtype=torch.float32, device=device)
+        b_values = torch.tensor(values, dtype=torch.float32, device=device)
+        b_advantages = torch.tensor(advantages, dtype=torch.float32, device=device)
+        b_masks = torch.tensor(masks_buf, dtype=torch.bool, device=device)
+
+        b_advantages = (b_advantages - b_advantages.mean()) / (b_advantages.std() + 1e-8)
+
+        # PPO epochs
+        batch_size = num_steps
+        minibatch_size = batch_size // args.num_minibatches
+        inds = np.arange(batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(inds)
+            for start in range(0, batch_size, minibatch_size):
+                end = start + minibatch_size
+                mb_inds = inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(
+                    b_obs[mb_inds], action=b_actions[mb_inds], action_mask=b_masks[mb_inds]
+                )
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+                with torch.no_grad():
+                    approx_kl = ((ratio - 1) - logratio).mean().item()
+                mb_adv = b_advantages[mb_inds]
+                pg_loss1 = -mb_adv * ratio
+                pg_loss2 = -mb_adv * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                v_clipped = b_values[mb_inds] + torch.clamp(
+                    newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef
+                )
+                v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                v_loss = 0.5 * v_loss_max
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + args.vf_coef * v_loss
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    try:
+                        avg_reward_val = float(np.mean(step_reward_window)) if len(step_reward_window) > 0 else 0.0
+                    except Exception:
+                        avg_reward_val = 0.0
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "train/value_loss": float(v_loss.item()),
+                        "train/policy_loss": float(pg_loss.item()),
+                        "train/entropy": float(entropy_loss.item()),
+                        "losses/explained_variance": None,
+                        "charts/avg_reward": avg_reward_val,
+                        "charts/avg_value": float(b_values.mean().item()) if b_values.numel() > 0 else None,
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                        "charts/epsilon": None,
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+    env.close()

cleanrl/cleanrl/ppo_atari.py

@@ -0,0 +1,329 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_ataripy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl_utils.atari_wrappers import (  # isort:skip
+    ClipRewardEnv,
+    EpisodicLifeEnv,
+    FireResetEnv,
+    MaxAndSkipEnv,
+    NoopResetEnv,
+)
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "BreakoutNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env = NoopResetEnv(env, noop_max=30)
+        env = MaxAndSkipEnv(env, skip=4)
+        env = EpisodicLifeEnv(env)
+        if "FIRE" in env.unwrapped.get_action_meanings():
+            env = FireResetEnv(env)
+        env = ClipRewardEnv(env)
+        env = gym.wrappers.ResizeObservation(env, (84, 84))
+        env = gym.wrappers.GrayScaleObservation(env)
+        env = gym.wrappers.FrameStack(env, 4)
+        return env
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(4, 32, 8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(64 * 7 * 7, 512)),
+            nn.ReLU(),
+        )
+        self.actor = layer_init(nn.Linear(512, envs.single_action_space.n), std=0.01)
+        self.critic = layer_init(nn.Linear(512, 1), std=1)
+
+    def get_value(self, x):
+        return self.critic(self.network(x / 255.0))
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x / 255.0)
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_atari_envpool.py

@@ -0,0 +1,344 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_atari_envpoolpy
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+import envpool
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Breakout-v5"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+class RecordEpisodeStatistics(gym.Wrapper):
+    def __init__(self, env, deque_size=100):
+        super().__init__(env)
+        self.num_envs = getattr(env, "num_envs", 1)
+        self.episode_returns = None
+        self.episode_lengths = None
+
+    def reset(self, **kwargs):
+        observations = super().reset(**kwargs)
+        self.episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        self.lives = np.zeros(self.num_envs, dtype=np.int32)
+        self.returned_episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.returned_episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        return observations
+
+    def step(self, action):
+        observations, rewards, dones, infos = super().step(action)
+        self.episode_returns += infos["reward"]
+        self.episode_lengths += 1
+        self.returned_episode_returns[:] = self.episode_returns
+        self.returned_episode_lengths[:] = self.episode_lengths
+        self.episode_returns *= 1 - infos["terminated"]
+        self.episode_lengths *= 1 - infos["terminated"]
+        infos["r"] = self.returned_episode_returns
+        infos["l"] = self.returned_episode_lengths
+        return (
+            observations,
+            rewards,
+            dones,
+            infos,
+        )
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(4, 32, 8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(64 * 7 * 7, 512)),
+            nn.ReLU(),
+        )
+        self.actor = layer_init(nn.Linear(512, envs.single_action_space.n), std=0.01)
+        self.critic = layer_init(nn.Linear(512, 1), std=1)
+
+    def get_value(self, x):
+        return self.critic(self.network(x / 255.0))
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x / 255.0)
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = envpool.make(
+        args.env_id,
+        env_type="gym",
+        num_envs=args.num_envs,
+        episodic_life=True,
+        reward_clip=True,
+        seed=args.seed,
+    )
+    envs.num_envs = args.num_envs
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space
+    envs = RecordEpisodeStatistics(envs)
+    assert isinstance(envs.action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    avg_returns = deque(maxlen=20)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, next_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(next_done).to(device)
+
+            for idx, d in enumerate(next_done):
+                if d and info["lives"][idx] == 0:
+                    print(f"global_step={global_step}, episodic_return={info['r'][idx]}")
+                    avg_returns.append(info["r"][idx])
+                    writer.add_scalar("charts/avg_episodic_return", np.average(avg_returns), global_step)
+                    writer.add_scalar("charts/episodic_return", info["r"][idx], global_step)
+                    writer.add_scalar("charts/episodic_length", info["l"][idx], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_atari_envpool_xla_jax.py

@@ -0,0 +1,452 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_atari_envpool_xla_jaxpy
+import os
+import random
+import time
+from dataclasses import dataclass
+from typing import Sequence
+
+import envpool
+import flax
+import flax.linen as nn
+import gym
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import tyro
+from flax.linen.initializers import constant, orthogonal
+from flax.training.train_state import TrainState
+from torch.utils.tensorboard import SummaryWriter
+
+# Fix weird OOM https://github.com/google/jax/discussions/6332#discussioncomment-1279991
+os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.6"
+# Fix CUDNN non-determinisim; https://github.com/google/jax/issues/4823#issuecomment-952835771
+os.environ["TF_XLA_FLAGS"] = "--xla_gpu_autotune_level=2 --xla_gpu_deterministic_reductions"
+os.environ["TF_CUDNN DETERMINISTIC"] = "1"
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Breakout-v5"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+class Network(nn.Module):
+    @nn.compact
+    def __call__(self, x):
+        x = jnp.transpose(x, (0, 2, 3, 1))
+        x = x / (255.0)
+        x = nn.Conv(
+            32,
+            kernel_size=(8, 8),
+            strides=(4, 4),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = nn.Conv(
+            64,
+            kernel_size=(4, 4),
+            strides=(2, 2),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = nn.Conv(
+            64,
+            kernel_size=(3, 3),
+            strides=(1, 1),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = x.reshape((x.shape[0], -1))
+        x = nn.Dense(512, kernel_init=orthogonal(np.sqrt(2)), bias_init=constant(0.0))(x)
+        x = nn.relu(x)
+        return x
+
+
+class Critic(nn.Module):
+    @nn.compact
+    def __call__(self, x):
+        return nn.Dense(1, kernel_init=orthogonal(1), bias_init=constant(0.0))(x)
+
+
+class Actor(nn.Module):
+    action_dim: Sequence[int]
+
+    @nn.compact
+    def __call__(self, x):
+        return nn.Dense(self.action_dim, kernel_init=orthogonal(0.01), bias_init=constant(0.0))(x)
+
+
+@flax.struct.dataclass
+class AgentParams:
+    network_params: flax.core.FrozenDict
+    actor_params: flax.core.FrozenDict
+    critic_params: flax.core.FrozenDict
+
+
+@flax.struct.dataclass
+class Storage:
+    obs: jnp.array
+    actions: jnp.array
+    logprobs: jnp.array
+    dones: jnp.array
+    values: jnp.array
+    advantages: jnp.array
+    returns: jnp.array
+    rewards: jnp.array
+
+
+@flax.struct.dataclass
+class EpisodeStatistics:
+    episode_returns: jnp.array
+    episode_lengths: jnp.array
+    returned_episode_returns: jnp.array
+    returned_episode_lengths: jnp.array
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    key = jax.random.PRNGKey(args.seed)
+    key, network_key, actor_key, critic_key = jax.random.split(key, 4)
+
+    # env setup
+    envs = envpool.make(
+        args.env_id,
+        env_type="gym",
+        num_envs=args.num_envs,
+        episodic_life=True,
+        reward_clip=True,
+        seed=args.seed,
+    )
+    envs.num_envs = args.num_envs
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space
+    envs.is_vector_env = True
+    episode_stats = EpisodeStatistics(
+        episode_returns=jnp.zeros(args.num_envs, dtype=jnp.float32),
+        episode_lengths=jnp.zeros(args.num_envs, dtype=jnp.int32),
+        returned_episode_returns=jnp.zeros(args.num_envs, dtype=jnp.float32),
+        returned_episode_lengths=jnp.zeros(args.num_envs, dtype=jnp.int32),
+    )
+    handle, recv, send, step_env = envs.xla()
+
+    def step_env_wrappeed(episode_stats, handle, action):
+        handle, (next_obs, reward, next_done, info) = step_env(handle, action)
+        new_episode_return = episode_stats.episode_returns + info["reward"]
+        new_episode_length = episode_stats.episode_lengths + 1
+        episode_stats = episode_stats.replace(
+            episode_returns=(new_episode_return) * (1 - info["terminated"]) * (1 - info["TimeLimit.truncated"]),
+            episode_lengths=(new_episode_length) * (1 - info["terminated"]) * (1 - info["TimeLimit.truncated"]),
+            # only update the `returned_episode_returns` if the episode is done
+            returned_episode_returns=jnp.where(
+                info["terminated"] + info["TimeLimit.truncated"], new_episode_return, episode_stats.returned_episode_returns
+            ),
+            returned_episode_lengths=jnp.where(
+                info["terminated"] + info["TimeLimit.truncated"], new_episode_length, episode_stats.returned_episode_lengths
+            ),
+        )
+        return episode_stats, handle, (next_obs, reward, next_done, info)
+
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    def linear_schedule(count):
+        # anneal learning rate linearly after one training iteration which contains
+        # (args.num_minibatches * args.update_epochs) gradient updates
+        frac = 1.0 - (count // (args.num_minibatches * args.update_epochs)) / args.num_iterations
+        return args.learning_rate * frac
+
+    network = Network()
+    actor = Actor(action_dim=envs.single_action_space.n)
+    critic = Critic()
+    network_params = network.init(network_key, np.array([envs.single_observation_space.sample()]))
+    agent_state = TrainState.create(
+        apply_fn=None,
+        params=AgentParams(
+            network_params,
+            actor.init(actor_key, network.apply(network_params, np.array([envs.single_observation_space.sample()]))),
+            critic.init(critic_key, network.apply(network_params, np.array([envs.single_observation_space.sample()]))),
+        ),
+        tx=optax.chain(
+            optax.clip_by_global_norm(args.max_grad_norm),
+            optax.inject_hyperparams(optax.adam)(
+                learning_rate=linear_schedule if args.anneal_lr else args.learning_rate, eps=1e-5
+            ),
+        ),
+    )
+    network.apply = jax.jit(network.apply)
+    actor.apply = jax.jit(actor.apply)
+    critic.apply = jax.jit(critic.apply)
+
+    # ALGO Logic: Storage setup
+    storage = Storage(
+        obs=jnp.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape),
+        actions=jnp.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape, dtype=jnp.int32),
+        logprobs=jnp.zeros((args.num_steps, args.num_envs)),
+        dones=jnp.zeros((args.num_steps, args.num_envs)),
+        values=jnp.zeros((args.num_steps, args.num_envs)),
+        advantages=jnp.zeros((args.num_steps, args.num_envs)),
+        returns=jnp.zeros((args.num_steps, args.num_envs)),
+        rewards=jnp.zeros((args.num_steps, args.num_envs)),
+    )
+
+    @jax.jit
+    def get_action_and_value(
+        agent_state: TrainState,
+        next_obs: np.ndarray,
+        next_done: np.ndarray,
+        storage: Storage,
+        step: int,
+        key: jax.random.PRNGKey,
+    ):
+        """sample action, calculate value, logprob, entropy, and update storage"""
+        hidden = network.apply(agent_state.params.network_params, next_obs)
+        logits = actor.apply(agent_state.params.actor_params, hidden)
+        # sample action: Gumbel-softmax trick
+        # see https://stats.stackexchange.com/questions/359442/sampling-from-a-categorical-distribution
+        key, subkey = jax.random.split(key)
+        u = jax.random.uniform(subkey, shape=logits.shape)
+        action = jnp.argmax(logits - jnp.log(-jnp.log(u)), axis=1)
+        logprob = jax.nn.log_softmax(logits)[jnp.arange(action.shape[0]), action]
+        value = critic.apply(agent_state.params.critic_params, hidden)
+        storage = storage.replace(
+            obs=storage.obs.at[step].set(next_obs),
+            dones=storage.dones.at[step].set(next_done),
+            actions=storage.actions.at[step].set(action),
+            logprobs=storage.logprobs.at[step].set(logprob),
+            values=storage.values.at[step].set(value.squeeze()),
+        )
+        return storage, action, key
+
+    @jax.jit
+    def get_action_and_value2(
+        params: flax.core.FrozenDict,
+        x: np.ndarray,
+        action: np.ndarray,
+    ):
+        """calculate value, logprob of supplied `action`, and entropy"""
+        hidden = network.apply(params.network_params, x)
+        logits = actor.apply(params.actor_params, hidden)
+        logprob = jax.nn.log_softmax(logits)[jnp.arange(action.shape[0]), action]
+        # normalize the logits https://gregorygundersen.com/blog/2020/02/09/log-sum-exp/
+        logits = logits - jax.scipy.special.logsumexp(logits, axis=-1, keepdims=True)
+        logits = logits.clip(min=jnp.finfo(logits.dtype).min)
+        p_log_p = logits * jax.nn.softmax(logits)
+        entropy = -p_log_p.sum(-1)
+        value = critic.apply(params.critic_params, hidden).squeeze()
+        return logprob, entropy, value
+
+    @jax.jit
+    def compute_gae(
+        agent_state: TrainState,
+        next_obs: np.ndarray,
+        next_done: np.ndarray,
+        storage: Storage,
+    ):
+        storage = storage.replace(advantages=storage.advantages.at[:].set(0.0))
+        next_value = critic.apply(
+            agent_state.params.critic_params, network.apply(agent_state.params.network_params, next_obs)
+        ).squeeze()
+        lastgaelam = 0
+        for t in reversed(range(args.num_steps)):
+            if t == args.num_steps - 1:
+                nextnonterminal = 1.0 - next_done
+                nextvalues = next_value
+            else:
+                nextnonterminal = 1.0 - storage.dones[t + 1]
+                nextvalues = storage.values[t + 1]
+            delta = storage.rewards[t] + args.gamma * nextvalues * nextnonterminal - storage.values[t]
+            lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            storage = storage.replace(advantages=storage.advantages.at[t].set(lastgaelam))
+        storage = storage.replace(returns=storage.advantages + storage.values)
+        return storage
+
+    @jax.jit
+    def update_ppo(
+        agent_state: TrainState,
+        storage: Storage,
+        key: jax.random.PRNGKey,
+    ):
+        b_obs = storage.obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = storage.logprobs.reshape(-1)
+        b_actions = storage.actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = storage.advantages.reshape(-1)
+        b_returns = storage.returns.reshape(-1)
+
+        def ppo_loss(params, x, a, logp, mb_advantages, mb_returns):
+            newlogprob, entropy, newvalue = get_action_and_value2(params, x, a)
+            logratio = newlogprob - logp
+            ratio = jnp.exp(logratio)
+            approx_kl = ((ratio - 1) - logratio).mean()
+
+            if args.norm_adv:
+                mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+            # Policy loss
+            pg_loss1 = -mb_advantages * ratio
+            pg_loss2 = -mb_advantages * jnp.clip(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+            pg_loss = jnp.maximum(pg_loss1, pg_loss2).mean()
+
+            # Value loss
+            v_loss = 0.5 * ((newvalue - mb_returns) ** 2).mean()
+
+            entropy_loss = entropy.mean()
+            loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+            return loss, (pg_loss, v_loss, entropy_loss, jax.lax.stop_gradient(approx_kl))
+
+        ppo_loss_grad_fn = jax.value_and_grad(ppo_loss, has_aux=True)
+        for _ in range(args.update_epochs):
+            key, subkey = jax.random.split(key)
+            b_inds = jax.random.permutation(subkey, args.batch_size, independent=True)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+                (loss, (pg_loss, v_loss, entropy_loss, approx_kl)), grads = ppo_loss_grad_fn(
+                    agent_state.params,
+                    b_obs[mb_inds],
+                    b_actions[mb_inds],
+                    b_logprobs[mb_inds],
+                    b_advantages[mb_inds],
+                    b_returns[mb_inds],
+                )
+                agent_state = agent_state.apply_gradients(grads=grads)
+        return agent_state, loss, pg_loss, v_loss, entropy_loss, approx_kl, key
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = envs.reset()
+    next_done = np.zeros(args.num_envs)
+
+    @jax.jit
+    def rollout(agent_state, episode_stats, next_obs, next_done, storage, key, handle, global_step):
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            storage, action, key = get_action_and_value(agent_state, next_obs, next_done, storage, step, key)
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            episode_stats, handle, (next_obs, reward, next_done, _) = step_env_wrappeed(episode_stats, handle, action)
+            storage = storage.replace(rewards=storage.rewards.at[step].set(reward))
+        return agent_state, episode_stats, next_obs, next_done, storage, key, handle, global_step
+
+    for iteration in range(1, args.num_iterations + 1):
+        iteration_time_start = time.time()
+        agent_state, episode_stats, next_obs, next_done, storage, key, handle, global_step = rollout(
+            agent_state, episode_stats, next_obs, next_done, storage, key, handle, global_step
+        )
+        storage = compute_gae(agent_state, next_obs, next_done, storage)
+        agent_state, loss, pg_loss, v_loss, entropy_loss, approx_kl, key = update_ppo(
+            agent_state,
+            storage,
+            key,
+        )
+        avg_episodic_return = np.mean(jax.device_get(episode_stats.returned_episode_returns))
+        print(f"global_step={global_step}, avg_episodic_return={avg_episodic_return}")
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/avg_episodic_return", avg_episodic_return, global_step)
+        writer.add_scalar(
+            "charts/avg_episodic_length", np.mean(jax.device_get(episode_stats.returned_episode_lengths)), global_step
+        )
+        writer.add_scalar("charts/learning_rate", agent_state.opt_state[1].hyperparams["learning_rate"].item(), global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/loss", loss.item(), global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+        writer.add_scalar(
+            "charts/SPS_update", int(args.num_envs * args.num_steps / (time.time() - iteration_time_start)), global_step
+        )
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_atari_envpool_xla_jax_scan.py

@@ -0,0 +1,522 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_atari_envpool_xla_jaxpy
+import os
+import random
+import time
+from dataclasses import dataclass
+from functools import partial
+from typing import Sequence
+
+import envpool
+import flax
+import flax.linen as nn
+import gym
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import tyro
+from flax.linen.initializers import constant, orthogonal
+from flax.training.train_state import TrainState
+from torch.utils.tensorboard import SummaryWriter
+
+# Fix weird OOM https://github.com/google/jax/discussions/6332#discussioncomment-1279991
+os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.6"
+# Fix CUDNN non-determinisim; https://github.com/google/jax/issues/4823#issuecomment-952835771
+os.environ["TF_XLA_FLAGS"] = "--xla_gpu_autotune_level=2 --xla_gpu_deterministic_reductions"
+os.environ["TF_CUDNN DETERMINISTIC"] = "1"
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    upload_model: bool = False
+    """whether to upload the saved model to huggingface"""
+    hf_entity: str = ""
+    """the user or org name of the model repository from the Hugging Face Hub"""
+
+    # Algorithm specific arguments
+    env_id: str = "Breakout-v5"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, seed, num_envs):
+    def thunk():
+        envs = envpool.make(
+            env_id,
+            env_type="gym",
+            num_envs=num_envs,
+            episodic_life=True,
+            reward_clip=True,
+            seed=seed,
+        )
+        envs.num_envs = num_envs
+        envs.single_action_space = envs.action_space
+        envs.single_observation_space = envs.observation_space
+        envs.is_vector_env = True
+        return envs
+
+    return thunk
+
+
+class Network(nn.Module):
+    @nn.compact
+    def __call__(self, x):
+        x = jnp.transpose(x, (0, 2, 3, 1))
+        x = x / (255.0)
+        x = nn.Conv(
+            32,
+            kernel_size=(8, 8),
+            strides=(4, 4),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = nn.Conv(
+            64,
+            kernel_size=(4, 4),
+            strides=(2, 2),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = nn.Conv(
+            64,
+            kernel_size=(3, 3),
+            strides=(1, 1),
+            padding="VALID",
+            kernel_init=orthogonal(np.sqrt(2)),
+            bias_init=constant(0.0),
+        )(x)
+        x = nn.relu(x)
+        x = x.reshape((x.shape[0], -1))
+        x = nn.Dense(512, kernel_init=orthogonal(np.sqrt(2)), bias_init=constant(0.0))(x)
+        x = nn.relu(x)
+        return x
+
+
+class Critic(nn.Module):
+    @nn.compact
+    def __call__(self, x):
+        return nn.Dense(1, kernel_init=orthogonal(1), bias_init=constant(0.0))(x)
+
+
+class Actor(nn.Module):
+    action_dim: Sequence[int]
+
+    @nn.compact
+    def __call__(self, x):
+        return nn.Dense(self.action_dim, kernel_init=orthogonal(0.01), bias_init=constant(0.0))(x)
+
+
+@flax.struct.dataclass
+class AgentParams:
+    network_params: flax.core.FrozenDict
+    actor_params: flax.core.FrozenDict
+    critic_params: flax.core.FrozenDict
+
+
+@flax.struct.dataclass
+class Storage:
+    obs: jnp.array
+    actions: jnp.array
+    logprobs: jnp.array
+    dones: jnp.array
+    values: jnp.array
+    advantages: jnp.array
+    returns: jnp.array
+    rewards: jnp.array
+
+
+@flax.struct.dataclass
+class EpisodeStatistics:
+    episode_returns: jnp.array
+    episode_lengths: jnp.array
+    returned_episode_returns: jnp.array
+    returned_episode_lengths: jnp.array
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    key = jax.random.PRNGKey(args.seed)
+    key, network_key, actor_key, critic_key = jax.random.split(key, 4)
+
+    # env setup
+    envs = make_env(args.env_id, args.seed, args.num_envs)()
+    episode_stats = EpisodeStatistics(
+        episode_returns=jnp.zeros(args.num_envs, dtype=jnp.float32),
+        episode_lengths=jnp.zeros(args.num_envs, dtype=jnp.int32),
+        returned_episode_returns=jnp.zeros(args.num_envs, dtype=jnp.float32),
+        returned_episode_lengths=jnp.zeros(args.num_envs, dtype=jnp.int32),
+    )
+    handle, recv, send, step_env = envs.xla()
+
+    def step_env_wrappeed(episode_stats, handle, action):
+        handle, (next_obs, reward, next_done, info) = step_env(handle, action)
+        new_episode_return = episode_stats.episode_returns + info["reward"]
+        new_episode_length = episode_stats.episode_lengths + 1
+        episode_stats = episode_stats.replace(
+            episode_returns=(new_episode_return) * (1 - info["terminated"]) * (1 - info["TimeLimit.truncated"]),
+            episode_lengths=(new_episode_length) * (1 - info["terminated"]) * (1 - info["TimeLimit.truncated"]),
+            # only update the `returned_episode_returns` if the episode is done
+            returned_episode_returns=jnp.where(
+                info["terminated"] + info["TimeLimit.truncated"], new_episode_return, episode_stats.returned_episode_returns
+            ),
+            returned_episode_lengths=jnp.where(
+                info["terminated"] + info["TimeLimit.truncated"], new_episode_length, episode_stats.returned_episode_lengths
+            ),
+        )
+        return episode_stats, handle, (next_obs, reward, next_done, info)
+
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    def linear_schedule(count):
+        # anneal learning rate linearly after one training iteration which contains
+        # (args.num_minibatches * args.update_epochs) gradient updates
+        frac = 1.0 - (count // (args.num_minibatches * args.update_epochs)) / args.num_iterations
+        return args.learning_rate * frac
+
+    network = Network()
+    actor = Actor(action_dim=envs.single_action_space.n)
+    critic = Critic()
+    network_params = network.init(network_key, np.array([envs.single_observation_space.sample()]))
+    agent_state = TrainState.create(
+        apply_fn=None,
+        params=AgentParams(
+            network_params,
+            actor.init(actor_key, network.apply(network_params, np.array([envs.single_observation_space.sample()]))),
+            critic.init(critic_key, network.apply(network_params, np.array([envs.single_observation_space.sample()]))),
+        ),
+        tx=optax.chain(
+            optax.clip_by_global_norm(args.max_grad_norm),
+            optax.inject_hyperparams(optax.adam)(
+                learning_rate=linear_schedule if args.anneal_lr else args.learning_rate, eps=1e-5
+            ),
+        ),
+    )
+    network.apply = jax.jit(network.apply)
+    actor.apply = jax.jit(actor.apply)
+    critic.apply = jax.jit(critic.apply)
+
+    @jax.jit
+    def get_action_and_value(
+        agent_state: TrainState,
+        next_obs: np.ndarray,
+        key: jax.random.PRNGKey,
+    ):
+        """sample action, calculate value, logprob, entropy, and update storage"""
+        hidden = network.apply(agent_state.params.network_params, next_obs)
+        logits = actor.apply(agent_state.params.actor_params, hidden)
+        # sample action: Gumbel-softmax trick
+        # see https://stats.stackexchange.com/questions/359442/sampling-from-a-categorical-distribution
+        key, subkey = jax.random.split(key)
+        u = jax.random.uniform(subkey, shape=logits.shape)
+        action = jnp.argmax(logits - jnp.log(-jnp.log(u)), axis=1)
+        logprob = jax.nn.log_softmax(logits)[jnp.arange(action.shape[0]), action]
+        value = critic.apply(agent_state.params.critic_params, hidden)
+        return action, logprob, value.squeeze(1), key
+
+    @jax.jit
+    def get_action_and_value2(
+        params: flax.core.FrozenDict,
+        x: np.ndarray,
+        action: np.ndarray,
+    ):
+        """calculate value, logprob of supplied `action`, and entropy"""
+        hidden = network.apply(params.network_params, x)
+        logits = actor.apply(params.actor_params, hidden)
+        logprob = jax.nn.log_softmax(logits)[jnp.arange(action.shape[0]), action]
+        # normalize the logits https://gregorygundersen.com/blog/2020/02/09/log-sum-exp/
+        logits = logits - jax.scipy.special.logsumexp(logits, axis=-1, keepdims=True)
+        logits = logits.clip(min=jnp.finfo(logits.dtype).min)
+        p_log_p = logits * jax.nn.softmax(logits)
+        entropy = -p_log_p.sum(-1)
+        value = critic.apply(params.critic_params, hidden).squeeze()
+        return logprob, entropy, value
+
+    def compute_gae_once(carry, inp, gamma, gae_lambda):
+        advantages = carry
+        nextdone, nextvalues, curvalues, reward = inp
+        nextnonterminal = 1.0 - nextdone
+
+        delta = reward + gamma * nextvalues * nextnonterminal - curvalues
+        advantages = delta + gamma * gae_lambda * nextnonterminal * advantages
+        return advantages, advantages
+
+    compute_gae_once = partial(compute_gae_once, gamma=args.gamma, gae_lambda=args.gae_lambda)
+
+    @jax.jit
+    def compute_gae(
+        agent_state: TrainState,
+        next_obs: np.ndarray,
+        next_done: np.ndarray,
+        storage: Storage,
+    ):
+        next_value = critic.apply(
+            agent_state.params.critic_params, network.apply(agent_state.params.network_params, next_obs)
+        ).squeeze()
+
+        advantages = jnp.zeros((args.num_envs,))
+        dones = jnp.concatenate([storage.dones, next_done[None, :]], axis=0)
+        values = jnp.concatenate([storage.values, next_value[None, :]], axis=0)
+        _, advantages = jax.lax.scan(
+            compute_gae_once, advantages, (dones[1:], values[1:], values[:-1], storage.rewards), reverse=True
+        )
+        storage = storage.replace(
+            advantages=advantages,
+            returns=advantages + storage.values,
+        )
+        return storage
+
+    def ppo_loss(params, x, a, logp, mb_advantages, mb_returns):
+        newlogprob, entropy, newvalue = get_action_and_value2(params, x, a)
+        logratio = newlogprob - logp
+        ratio = jnp.exp(logratio)
+        approx_kl = ((ratio - 1) - logratio).mean()
+
+        if args.norm_adv:
+            mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+        # Policy loss
+        pg_loss1 = -mb_advantages * ratio
+        pg_loss2 = -mb_advantages * jnp.clip(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+        pg_loss = jnp.maximum(pg_loss1, pg_loss2).mean()
+
+        # Value loss
+        v_loss = 0.5 * ((newvalue - mb_returns) ** 2).mean()
+
+        entropy_loss = entropy.mean()
+        loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+        return loss, (pg_loss, v_loss, entropy_loss, jax.lax.stop_gradient(approx_kl))
+
+    ppo_loss_grad_fn = jax.value_and_grad(ppo_loss, has_aux=True)
+
+    @jax.jit
+    def update_ppo(
+        agent_state: TrainState,
+        storage: Storage,
+        key: jax.random.PRNGKey,
+    ):
+        def update_epoch(carry, unused_inp):
+            agent_state, key = carry
+            key, subkey = jax.random.split(key)
+
+            def flatten(x):
+                return x.reshape((-1,) + x.shape[2:])
+
+            # taken from: https://github.com/google/brax/blob/main/brax/training/agents/ppo/train.py
+            def convert_data(x: jnp.ndarray):
+                x = jax.random.permutation(subkey, x)
+                x = jnp.reshape(x, (args.num_minibatches, -1) + x.shape[1:])
+                return x
+
+            flatten_storage = jax.tree_map(flatten, storage)
+            shuffled_storage = jax.tree_map(convert_data, flatten_storage)
+
+            def update_minibatch(agent_state, minibatch):
+                (loss, (pg_loss, v_loss, entropy_loss, approx_kl)), grads = ppo_loss_grad_fn(
+                    agent_state.params,
+                    minibatch.obs,
+                    minibatch.actions,
+                    minibatch.logprobs,
+                    minibatch.advantages,
+                    minibatch.returns,
+                )
+                agent_state = agent_state.apply_gradients(grads=grads)
+                return agent_state, (loss, pg_loss, v_loss, entropy_loss, approx_kl, grads)
+
+            agent_state, (loss, pg_loss, v_loss, entropy_loss, approx_kl, grads) = jax.lax.scan(
+                update_minibatch, agent_state, shuffled_storage
+            )
+            return (agent_state, key), (loss, pg_loss, v_loss, entropy_loss, approx_kl, grads)
+
+        (agent_state, key), (loss, pg_loss, v_loss, entropy_loss, approx_kl, grads) = jax.lax.scan(
+            update_epoch, (agent_state, key), (), length=args.update_epochs
+        )
+        return agent_state, loss, pg_loss, v_loss, entropy_loss, approx_kl, key
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = envs.reset()
+    next_done = jnp.zeros(args.num_envs, dtype=jax.numpy.bool_)
+
+    # based on https://github.dev/google/evojax/blob/0625d875262011d8e1b6aa32566b236f44b4da66/evojax/sim_mgr.py
+    def step_once(carry, step, env_step_fn):
+        agent_state, episode_stats, obs, done, key, handle = carry
+        action, logprob, value, key = get_action_and_value(agent_state, obs, key)
+
+        episode_stats, handle, (next_obs, reward, next_done, _) = env_step_fn(episode_stats, handle, action)
+        storage = Storage(
+            obs=obs,
+            actions=action,
+            logprobs=logprob,
+            dones=done,
+            values=value,
+            rewards=reward,
+            returns=jnp.zeros_like(reward),
+            advantages=jnp.zeros_like(reward),
+        )
+        return ((agent_state, episode_stats, next_obs, next_done, key, handle), storage)
+
+    def rollout(agent_state, episode_stats, next_obs, next_done, key, handle, step_once_fn, max_steps):
+        (agent_state, episode_stats, next_obs, next_done, key, handle), storage = jax.lax.scan(
+            step_once_fn, (agent_state, episode_stats, next_obs, next_done, key, handle), (), max_steps
+        )
+        return agent_state, episode_stats, next_obs, next_done, storage, key, handle
+
+    rollout = partial(rollout, step_once_fn=partial(step_once, env_step_fn=step_env_wrappeed), max_steps=args.num_steps)
+
+    for iteration in range(1, args.num_iterations + 1):
+        iteration_time_start = time.time()
+        agent_state, episode_stats, next_obs, next_done, storage, key, handle = rollout(
+            agent_state, episode_stats, next_obs, next_done, key, handle
+        )
+        global_step += args.num_steps * args.num_envs
+        storage = compute_gae(agent_state, next_obs, next_done, storage)
+        agent_state, loss, pg_loss, v_loss, entropy_loss, approx_kl, key = update_ppo(
+            agent_state,
+            storage,
+            key,
+        )
+        avg_episodic_return = np.mean(jax.device_get(episode_stats.returned_episode_returns))
+        print(f"global_step={global_step}, avg_episodic_return={avg_episodic_return}")
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/avg_episodic_return", avg_episodic_return, global_step)
+        writer.add_scalar(
+            "charts/avg_episodic_length", np.mean(jax.device_get(episode_stats.returned_episode_lengths)), global_step
+        )
+        writer.add_scalar("charts/learning_rate", agent_state.opt_state[1].hyperparams["learning_rate"].item(), global_step)
+        writer.add_scalar("losses/value_loss", v_loss[-1, -1].item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss[-1, -1].item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss[-1, -1].item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl[-1, -1].item(), global_step)
+        writer.add_scalar("losses/loss", loss[-1, -1].item(), global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+        writer.add_scalar(
+            "charts/SPS_update", int(args.num_envs * args.num_steps / (time.time() - iteration_time_start)), global_step
+        )
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        with open(model_path, "wb") as f:
+            f.write(
+                flax.serialization.to_bytes(
+                    [
+                        vars(args),
+                        [
+                            agent_state.params.network_params,
+                            agent_state.params.actor_params,
+                            agent_state.params.critic_params,
+                        ],
+                    ]
+                )
+            )
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.ppo_envpool_jax_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=(Network, Actor, Critic),
+        )
+        for idx, episodic_return in enumerate(episodic_returns):
+            writer.add_scalar("eval/episodic_return", episodic_return, idx)
+
+        if args.upload_model:
+            from cleanrl_utils.huggingface import push_to_hub
+
+            repo_name = f"{args.env_id}-{args.exp_name}-seed{args.seed}"
+            repo_id = f"{args.hf_entity}/{repo_name}" if args.hf_entity else repo_name
+            push_to_hub(args, episodic_returns, repo_id, "PPO", f"runs/{run_name}", f"videos/{run_name}-eval")
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_atari_lstm.py

@@ -0,0 +1,375 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_atari_lstmpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl_utils.atari_wrappers import (  # isort:skip
+    ClipRewardEnv,
+    EpisodicLifeEnv,
+    FireResetEnv,
+    MaxAndSkipEnv,
+    NoopResetEnv,
+)
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "BreakoutNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env = NoopResetEnv(env, noop_max=30)
+        env = MaxAndSkipEnv(env, skip=4)
+        env = EpisodicLifeEnv(env)
+        if "FIRE" in env.unwrapped.get_action_meanings():
+            env = FireResetEnv(env)
+        env = ClipRewardEnv(env)
+        env = gym.wrappers.ResizeObservation(env, (84, 84))
+        env = gym.wrappers.GrayScaleObservation(env)
+        env = gym.wrappers.FrameStack(env, 1)
+        return env
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(1, 32, 8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(64 * 7 * 7, 512)),
+            nn.ReLU(),
+        )
+        self.lstm = nn.LSTM(512, 128)
+        for name, param in self.lstm.named_parameters():
+            if "bias" in name:
+                nn.init.constant_(param, 0)
+            elif "weight" in name:
+                nn.init.orthogonal_(param, 1.0)
+        self.actor = layer_init(nn.Linear(128, envs.single_action_space.n), std=0.01)
+        self.critic = layer_init(nn.Linear(128, 1), std=1)
+
+    def get_states(self, x, lstm_state, done):
+        hidden = self.network(x / 255.0)
+
+        # LSTM logic
+        batch_size = lstm_state[0].shape[1]
+        hidden = hidden.reshape((-1, batch_size, self.lstm.input_size))
+        done = done.reshape((-1, batch_size))
+        new_hidden = []
+        for h, d in zip(hidden, done):
+            h, lstm_state = self.lstm(
+                h.unsqueeze(0),
+                (
+                    (1.0 - d).view(1, -1, 1) * lstm_state[0],
+                    (1.0 - d).view(1, -1, 1) * lstm_state[1],
+                ),
+            )
+            new_hidden += [h]
+        new_hidden = torch.flatten(torch.cat(new_hidden), 0, 1)
+        return new_hidden, lstm_state
+
+    def get_value(self, x, lstm_state, done):
+        hidden, _ = self.get_states(x, lstm_state, done)
+        return self.critic(hidden)
+
+    def get_action_and_value(self, x, lstm_state, done, action=None):
+        hidden, lstm_state = self.get_states(x, lstm_state, done)
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden), lstm_state
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    next_lstm_state = (
+        torch.zeros(agent.lstm.num_layers, args.num_envs, agent.lstm.hidden_size).to(device),
+        torch.zeros(agent.lstm.num_layers, args.num_envs, agent.lstm.hidden_size).to(device),
+    )  # hidden and cell states (see https://youtu.be/8HyCNIVRbSU)
+
+    for iteration in range(1, args.num_iterations + 1):
+        initial_lstm_state = (next_lstm_state[0].clone(), next_lstm_state[1].clone())
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value, next_lstm_state = agent.get_action_and_value(next_obs, next_lstm_state, next_done)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(
+                next_obs,
+                next_lstm_state,
+                next_done,
+            ).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_dones = dones.reshape(-1)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        assert args.num_envs % args.num_minibatches == 0
+        envsperbatch = args.num_envs // args.num_minibatches
+        envinds = np.arange(args.num_envs)
+        flatinds = np.arange(args.batch_size).reshape(args.num_steps, args.num_envs)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(envinds)
+            for start in range(0, args.num_envs, envsperbatch):
+                end = start + envsperbatch
+                mbenvinds = envinds[start:end]
+                mb_inds = flatinds[:, mbenvinds].ravel()  # be really careful about the index
+
+                _, newlogprob, entropy, newvalue, _ = agent.get_action_and_value(
+                    b_obs[mb_inds],
+                    (initial_lstm_state[0][:, mbenvinds], initial_lstm_state[1][:, mbenvinds]),
+                    b_dones[mb_inds],
+                    b_actions.long()[mb_inds],
+                )
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_bandit.py

@@ -0,0 +1,335 @@
+# PPO implementation for RAGEN Bandit environment
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = True
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "Subagent"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Bandit"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 32
+    """the number of parallel game environments"""
+    num_steps: int = 512
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed):
+    def thunk():
+        config = BanditEnvConfig()
+        env = BanditEnv(config)
+        env = BanditWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = np.array(envs.single_observation_space.shape).prod()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed + i) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_bandit_small.py

@@ -0,0 +1,343 @@
+# PPO with small MLP for RAGEN Bandit using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen.env.base import BaseDiscreteActionEnv
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Bandit"
+    total_timesteps: int = 50_000
+    learning_rate: float = 3e-4
+    num_envs: int = 16
+    num_steps: int = 16
+    anneal_lr: bool = True
+    gamma: float = 0.0  # single-step bandit; no bootstrapping
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Model size
+    hidden_size: int = 32
+    feature_dim_per_name: int = 16  # BanditWrapper setting
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+
+def make_env(idx, run_name, seed, feature_dim_per_name: int, capture_video=False):
+    def thunk():
+        cfg = BanditEnvConfig()
+        env = BanditEnv(cfg)
+        env = BanditWrapper(env, feature_dim_per_name=feature_dim_per_name)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs, hidden: int):
+        super().__init__()
+        obs_shape = int(np.array(envs.single_observation_space.shape).prod())
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.feature_dim_per_name, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs, hidden=args.hidden_size).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    eval_out_dir = Path(f"runs/{run_name}/trajectories")
+    eval_out_dir.mkdir(parents=True, exist_ok=True)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 200000 + collected)
+                traj_rewards = []
+                done = False
+                while not done:
+                    with torch.no_grad():
+                        logits = agent_model.actor(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_rewards.append(float(reward))
+                    done = bool(terminated) or bool(truncated)
+                    state = next_state
+                ep_ret = float(sum(traj_rewards))
+                f.write(json.dumps({"episode_return": ep_ret}) + "\n")
+                summary_returns.append(ep_ret)
+                collected += 1
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    eval_splits = 2
+    eval_episodes = 4000
+    eval_every_iters = max(1, (args.total_timesteps // args.batch_size) // eval_splits)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Anneal LR
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+        # Since gamma=0 for bandit, GAE simplifies but we keep general code
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        # periodic evaluation collection
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.feature_dim_per_name, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=eval_episodes, step_tag=global_step)
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/ppo_blackjack_refine.py

@@ -0,0 +1,436 @@
+# PPO for RAGEN Blackjack - Final Fixed Version
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, List
+import json
+import sys
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+# 确保能找到 ragen 模块
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+try:
+    from ragen.env.blackjack.env import BlackjackEnv, hand_sum, usable_ace
+    from ragen.env.blackjack.config import BlackjackEnvConfig
+except ImportError:
+    # Fallback for standalone testing if ragen is not installed
+    print("Warning: ragen module not found, using mocks for imports logic check only.")
+    pass
+
+class BlackjackWrapper(gym.Env):
+    """
+    Direct State Access Wrapper.
+    直接读取环境内部状态，效率最高且无 Bug。
+    """
+    metadata = {"render_modes": ["ansi", "human", "text"]}
+
+    def __init__(self):
+        super().__init__()
+        cfg = BlackjackEnvConfig(render_mode='text')
+        self._env = BlackjackEnv(cfg)
+        # Observation: [Player Sum, Dealer Card, Usable Ace]
+        self.observation_space = gym.spaces.Box(low=0.0, high=32.0, shape=(3,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def _get_obs(self):
+        p_hand = self._env.player
+        d_hand = self._env.dealer
+        p_sum = hand_sum(p_hand)
+        d_show = d_hand[0] if d_hand else 0 
+        u_ace = 1.0 if usable_ace(p_hand) else 0.0
+        if p_sum > 30: p_sum = 30.0
+        return np.array([float(p_sum), float(d_show), u_ace], dtype=np.float32)
+
+    def get_text_observation(self):
+        """
+        生成与真实环境反馈完全一致的文本描述。
+        """
+        p_hand = self._env.player
+        d_hand = self._env.dealer
+        p_sum = hand_sum(p_hand)
+        # 庄家显示的牌
+        d_show = d_hand[0] if d_hand else "Unknown"
+        
+        # 构建 Usable Ace 描述 (根据你的示例)
+        u_ace_str = "You possess a usable Ace." if usable_ace(p_hand) else "No usable ace."
+        
+        # 严格对齐 Target Format
+        text = (
+            "=== Blackjack Game State ===\n"
+            f"Your Hand: {p_hand} (Total: {p_sum}).\n"
+            f"Note: {u_ace_str}\n"
+            f"Dealer's Visible Card: {d_show}.\n\n"
+            "Available Actions:\n"
+            "- Action 1: Stick (Stop)\n"
+            "- Action 2: Hit (Add card)"
+        )
+        return text
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        self._env.reset(seed=seed) 
+        return self._get_obs(), {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1  
+        _, reward, done, info = self._env.step(mapped)
+        obs = self._get_obs()
+        info = info or {}
+        return obs, float(reward), bool(done), False, info
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = False
+    wandb_project_name: str = "ragen_blackjack"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    env_id: str = "Blackjack"
+    total_timesteps: int = 1000_000 
+    learning_rate: float = 5e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.85 
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01 
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    eval_splits: int = 2
+    eval_episodes: int = 10000
+
+
+def make_env(idx, run_name, seed, capture_video=False):
+    def thunk():
+        env = BlackjackWrapper()
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=32)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = int(np.array(envs.single_observation_space.shape).prod())
+        hidden = 128
+        self.feature_extractor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+        )
+        self.critic = layer_init(nn.Linear(hidden, 1), std=1.0)
+        self.actor = layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01)
+
+    def get_value(self, x):
+        h = self.feature_extractor(x)
+        return self.critic(h)
+
+    def get_action_and_value(self, x, action=None):
+        h = self.feature_extractor(x)
+        logits = self.actor(h)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(h)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+    print(f"Using device: {device}")
+
+    # Envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    running_returns = np.zeros(args.num_envs, dtype=np.float32)
+    
+    # --- 修复后的 Eval 函数 (包含文本保存) ---
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 100000 + collected)
+                
+                # 初始化轨迹数据，同时保存数字状态和文本状态
+                traj_states = [state.tolist()]
+                # 注意：必须调用 env.get_text_observation()，因为 env 是被 TimeLimit 包裹的，
+                # 所以要访问 wrapper 方法可能需要 env.unwrapped.get_text_observation()，
+                # 但 make_env 中我们直接用了 BlackjackWrapper，TimeLimit 应该会透传 getattr，
+                # 如果报错改为 env.unwrapped.get_text_observation()
+                try:
+                    init_text = env.get_text_observation()
+                except AttributeError:
+                    init_text = env.unwrapped.get_text_observation()
+                    
+                traj_text_states = [init_text]
+                
+                traj_actions = []
+                traj_rewards = []
+                traj_success = []
+                done = False
+                while not done:
+                    with torch.no_grad():
+                        state_tensor = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                        hidden = agent_model.feature_extractor(state_tensor)
+                        logits = agent_model.actor(hidden)
+                        action = int(torch.argmax(logits, dim=1).item())
+                    
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    
+                    state = next_state
+                    traj_states.append(state.tolist())
+                    
+                    # 只有未结束时，或者为了完整性，我们通常把每一步后的状态也存下来
+                    if not (terminated or truncated):
+                        try:
+                            curr_text = env.get_text_observation()
+                        except AttributeError:
+                            curr_text = env.unwrapped.get_text_observation()
+                        traj_text_states.append(curr_text)
+                    
+                    done = bool(terminated) or bool(truncated)
+                
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states, 
+                    "text_states": traj_text_states,  # <--- 关键：保存文本状态
+                    "actions": traj_actions, 
+                    "rewards": traj_rewards,
+                    "success": traj_success, 
+                    "episode_return": ep_ret, 
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        return {"success_rate": np.mean(summary_success), "avg_return": np.mean(summary_returns)}
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+    recent_winrates = deque(maxlen=50)
+    winrate_ema = None
+
+    for iteration in range(1, args.num_iterations + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        iter_outcomes: List[int] = []
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            running_returns += reward
+            for i in range(args.num_envs):
+                if terminations[i] or truncations[i]:
+                    final_ret = running_returns[i]
+                    if final_ret > 0: iter_outcomes.append(1)
+                    elif final_ret < 0: iter_outcomes.append(-1)
+                    else: iter_outcomes.append(0)
+                    running_returns[i] = 0.0
+
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+                with torch.no_grad():
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+                
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef)
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+                
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        
+        if len(iter_outcomes) > 0:
+            total = len(iter_outcomes)
+            wr = iter_outcomes.count(1) / total
+            dr = iter_outcomes.count(0) / total
+            lr = iter_outcomes.count(-1) / total
+            recent_winrates.append(wr)
+            if winrate_ema is None: winrate_ema = wr
+            else: winrate_ema = 0.1 * wr + 0.9 * winrate_ema
+        else:
+            wr = dr = lr = 0.0
+        
+        print(f"[{progress:5.1f}%] Iter {iteration:4d} | Rew: {rewards.mean().item():.3f} | WR: {wr:.3f} | LR: {lr:.3f} | DR: {dr:.3f}")
+
+        if args.track:
+            import wandb
+            wandb.log({
+                "charts/avg_reward": float(rewards.mean().item()),
+                "charts/win_rate": wr,
+                "charts/draw_rate": dr,
+                "charts/loss_rate": lr,
+                "global_step": global_step,
+            })
+
+        if iteration == 1 or iteration % eval_every_iters == 0:
+            print(f"Running evaluation...")
+            try:
+                def eval_thunk():
+                    return make_env(0, run_name, args.seed + 9999, False)()
+                metrics = collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    wandb.log({"eval/success_rate": metrics["success_rate"], "global_step": global_step})
+            except Exception as e:
+                print(f"Eval failed: {e}")
+                import traceback
+                traceback.print_exc()
+
+    envs.close()

cleanrl/cleanrl/ppo_continuous_action.py

@@ -0,0 +1,353 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_continuous_actionpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.normal import Normal
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    upload_model: bool = False
+    """whether to upload the saved model to huggingface"""
+    hf_entity: str = ""
+    """the user or org name of the model repository from the Hugging Face Hub"""
+
+    # Algorithm specific arguments
+    env_id: str = "HalfCheetah-v4"
+    """the id of the environment"""
+    total_timesteps: int = 1000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments"""
+    num_steps: int = 2048
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 32
+    """the number of mini-batches"""
+    update_epochs: int = 10
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.0
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, gamma):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.FlattenObservation(env)  # deal with dm_control's Dict observation space
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env = gym.wrappers.ClipAction(env)
+        env = gym.wrappers.NormalizeObservation(env)
+        env = gym.wrappers.TransformObservation(env, lambda obs: np.clip(obs, -10, 10))
+        env = gym.wrappers.NormalizeReward(env, gamma=gamma)
+        env = gym.wrappers.TransformReward(env, lambda reward: np.clip(reward, -10, 10))
+        return env
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+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()
+        return action, probs.log_prob(action).sum(1), probs.entropy().sum(1), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.gamma) for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        torch.save(agent.state_dict(), model_path)
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.ppo_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=Agent,
+            device=device,
+            gamma=args.gamma,
+        )
+        for idx, episodic_return in enumerate(episodic_returns):
+            writer.add_scalar("eval/episodic_return", episodic_return, idx)
+
+        if args.upload_model:
+            from cleanrl_utils.huggingface import push_to_hub
+
+            repo_name = f"{args.env_id}-{args.exp_name}-seed{args.seed}"
+            repo_id = f"{args.hf_entity}/{repo_name}" if args.hf_entity else repo_name
+            push_to_hub(args, episodic_returns, repo_id, "PPO", f"runs/{run_name}", f"videos/{run_name}-eval")
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_rubikscube.py

@@ -0,0 +1,517 @@
+# PPO with small MLP for RAGEN Rubik's Cube 2x2 using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+import re
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.rubikscube.env import RubiksCube2x2Env
+from ragen.env.rubikscube.config import RubiksCube2x2Config
+
+
+class RubiksCubeWrapper(gym.Env):
+    """
+    Adapter to use ragen RubiksCube2x2Env with Gymnasium vector API.
+    - Converts text observation to one-hot vector of 24 stickers x 6 colors.
+    - Maps agent actions [0..11] to env actions [1..12].
+    - Exposes proper observation_space and action_space.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: RubiksCube2x2Env):
+        super().__init__()
+        self._env = env
+        # 24 stickers, 6 colors -> one-hot size 144
+        self._colors = ['W', 'O', 'G', 'R', 'B', 'Y']
+        self._color_to_idx = {c: i for i, c in enumerate(self._colors)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(24 * len(self._colors),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(12)
+        # precompile regex to extract 4 letters within [X, X]\n [X, X]
+        # Lines look like: "Up (U):    [W, W]\n       [W, W]"
+        self._face_pat = re.compile(r"\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])\n\s*\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])")
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # Extract the six face blocks in the order U, L, F, R, B, D as rendered
+        faces_order = ["Up (U):", "Left (L):", "Front (F):", "Right (R):", "Back (B):", "Down (D):"]
+        onehots: List[int] = []
+        # Build a map from header to its block text
+        lines = text_obs.splitlines()
+        # Collect blocks starting after header line and including the next line for second row
+        i = 0
+        blocks: List[str] = []
+        while i < len(lines):
+            line = lines[i]
+            for header in faces_order:
+                if line.startswith(header):
+                    # Join current line's bracketed pair and the next line (which contains the second pair)
+                    # Remove the "Header:" prefix to keep only the bracket portions
+                    content = line[len(header):].strip()
+                    next_line = lines[i + 1] if i + 1 < len(lines) else ""
+                    block = f"{content}\n{next_line}"
+                    blocks.append(block)
+                    break
+            i += 1
+        # Fallback: if regex fails, return zeros
+        if len(blocks) != 6:
+            return np.zeros(24 * len(self._colors), dtype=np.float32)
+        stickers: List[int] = []
+        for blk in blocks:
+            m = self._face_pat.search(blk)
+            if not m:
+                return np.zeros(24 * len(self._colors), dtype=np.float32)
+            # order: 0,1,2,3 per render() doc
+            c0, c1, c2, c3 = m.group(1), m.group(2), m.group(3), m.group(4)
+            stickers.extend([c0, c1, c2, c3])
+        # stickers now length 24; convert to one-hot
+        grid = np.zeros((24, len(self._colors)), dtype=np.float32)
+        for idx, ch in enumerate(stickers):
+            cidx = self._color_to_idx.get(ch, None)
+            if cidx is not None:
+                grid[idx, cidx] = 1.0
+        return grid.reshape(-1)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1  # 0..11 -> 1..12
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "RubiksCube2x2"
+    total_timesteps: int = 1000_000
+    learning_rate: float = 2.5e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Rubik specific
+    scramble_depth: int = 3
+    max_steps_env: int = 6
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    eval_splits: int = 20
+    eval_episodes: int = 10000
+
+
+def make_env(idx, run_name, seed, scramble_depth, max_steps_env, capture_video=False):
+    def thunk():
+        config = RubiksCube2x2Config(scramble_depth=scramble_depth, max_steps=max_steps_env, render_mode='text')
+        env = RubiksCube2x2Env(config)
+        env = RubiksCubeWrapper(env)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps_env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = int(np.array(envs.single_observation_space.shape).prod())
+        hidden = 128
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.scramble_depth, args.max_steps_env, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    # eval helper similar to FrozenLake: collect greedy eval trajectories and write metrics.json
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 100000 + collected)
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or int(args.max_steps_env)
+                while not done:
+                    with torch.no_grad():
+                        logits = agent_model.actor(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(state.tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    # training loop
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+    for iteration in range(1, args.num_iterations + 1):
+        # Anneal LR
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        # accumulate per-iteration episode successes
+        iter_successes = []
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            # Episode stats logging similar to FrozenLake
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    # prefer success from info; fallback to ep return > 0
+                    if "success" in infos:
+                        succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    else:
+                        try:
+                            succ_arr = (np.asarray(r_arr) > 0).astype(float)
+                        except Exception:
+                            succ_arr = np.zeros_like(mask, dtype=float)
+                    # collect iteration successes for training success rate
+                    try:
+                        for s in np.asarray(succ_arr)[mask]:
+                            iter_successes.append(float(s))
+                    except Exception:
+                        pass
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # GAE
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        # metrics
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        train_success_rate = float(np.mean(iter_successes)) if len(iter_successes) else 0.0
+        print(f"Iter {iteration:4d}/{args.num_iterations} | SPS: {sps:5d} | R: {rewards.mean().item():6.3f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "charts/progress": float(100.0 * iteration / max(1, args.num_iterations)),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "losses/value_loss": float(v_loss.item()),
+                    "losses/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "train/clipfrac": float(np.mean(clipfracs)) if len(clipfracs) else 0.0,
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "charts/SPS": int(sps),
+                    "train/success_rate": train_success_rate,
+                    "charts/train_success_rate": train_success_rate,
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        # periodic evaluation collection
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.scramble_depth, args.max_steps_env, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import json as _json
+                        from pathlib import Path as _Path
+                        mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = _json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at global_step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/wandb/latest-run/files/code/cleanrl/dqn_bandit.py

@@ -0,0 +1,344 @@
+# DQN implementation for RAGEN Bandit Environment
+# Adapted from dqn_atari.py for single-step bandit problem
+import os
+import random
+import sys
+import time
+from dataclasses import dataclass
+
+# Add parent directory to path to import the wrapper
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+
+
+# Define BanditWrapper locally to avoid dependency issues
+class BanditWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Bandit environment to make it compatible with DQN.
+    Converts single-step Bandit to multi-step environment.
+    
+    State representation: [arm0_count, arm0_avg_reward, arm1_count, arm1_avg_reward]
+    This allows the agent to learn which arm is better based on historical performance.
+    """
+    def __init__(self, env, steps_per_episode=10):
+        super().__init__(env)
+        # State: [arm0_pulls, arm0_avg_reward, arm1_pulls, arm1_avg_reward]
+        self.observation_space = gym.spaces.Box(low=0, high=1000, shape=(4,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+        self.steps_per_episode = steps_per_episode
+        self.current_step = 0
+        self._arm_counts = [0, 0]
+        self._arm_rewards = [0.0, 0.0]
+        
+    def reset(self, **kwargs):
+        # Filter out 'options' parameter that gymnasium passes but RAGEN doesn't support
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        self.env.reset(seed=seed, mode=mode)
+        
+        # Reset step counter but keep arm statistics for learning
+        self.current_step = 0
+        
+        # Return current state based on accumulated history
+        state = self._get_state()
+        return state, {}
+    
+    def _get_state(self):
+        """Get current state representation."""
+        return np.array([
+            self._arm_counts[0],
+            self._arm_rewards[0] / max(1, self._arm_counts[0]),
+            self._arm_counts[1],
+            self._arm_rewards[1] / max(1, self._arm_counts[1]),
+        ], dtype=np.float32)
+    
+    def step(self, action):
+        # Map action from 0,1 to 1,2 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        obs, reward, done, info = self.env.step(ragen_action)
+        
+        # Update statistics for the chosen arm
+        self._arm_counts[action] += 1
+        self._arm_rewards[action] += reward
+        self.current_step += 1
+        
+        # Episode ends after N steps (not after single step)
+        terminated = (self.current_step >= self.steps_per_episode)
+        truncated = False
+        
+        # Debug: print when episode ends
+        if terminated and self._arm_counts[0] + self._arm_counts[1] < 100:
+            print(f"DEBUG: Episode ended at step {self.current_step}, arm_counts: {self._arm_counts}")
+        
+        # Reset the underlying Bandit env but keep our statistics
+        if not terminated:
+            self.env.reset()
+        
+        state = self._get_state()
+        return state, reward, terminated, truncated, info
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+
+    # Algorithm specific arguments
+    env_id: str = "Bandit"
+    """the id of the environment"""
+    total_timesteps: int = 100000
+    """total timesteps of the experiments"""
+    learning_rate: float = 1e-3
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments (DQN typically uses 1)"""
+    buffer_size: int = 10000
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma (0.99 for multi-step bandit)"""
+    tau: float = 1.0
+    """the target network update rate"""
+    target_network_frequency: int = 500
+    """the timesteps it takes to update the target network"""
+    batch_size: int = 32
+    """the batch size of sample from the reply memory"""
+    start_e: float = 1.0
+    """the starting epsilon for exploration"""
+    end_e: float = 0.05
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.5
+    """the fraction of `total-timesteps` it takes from start-e to go end-e"""
+    learning_starts: int = 1000
+    """timestep to start learning"""
+    train_frequency: int = 1
+    """the frequency of training"""
+    steps_per_episode: int = 10
+    """number of steps per episode for multi-step bandit"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed, steps_per_episode):
+    def thunk():
+        config = BanditEnvConfig()
+        env = BanditEnv(config)
+        env = BanditWrapper(env, steps_per_episode=steps_per_episode)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    """
+    Q-Network for Bandit environment.
+    Input: [arm0_pulls, arm0_avg_reward, arm1_pulls, arm1_avg_reward]
+    Output: Q-values for each arm
+    """
+    def __init__(self, env):
+        super().__init__()
+        obs_shape = np.array(env.single_observation_space.shape).prod()
+        self.network = nn.Sequential(
+            nn.Linear(obs_shape, 128),
+            nn.ReLU(),
+            nn.Linear(128, 128),
+            nn.ReLU(),
+            nn.Linear(128, env.single_action_space.n),
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+
+def linear_schedule(start_e: float, end_e: float, duration: int, t: int):
+    slope = (end_e - start_e) / duration
+    return max(slope * t + start_e, end_e)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    assert args.num_envs == 1, "vectorized envs are not supported at the moment"
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed + i, args.steps_per_episode) 
+         for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.Adam(q_network.parameters(), lr=args.learning_rate)
+    target_network = QNetwork(envs).to(device)
+    target_network.load_state_dict(q_network.state_dict())
+
+    # Use simple replay buffer (no special memory optimization needed for bandit)
+    from cleanrl_utils.buffers import ReplayBuffer
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        optimize_memory_usage=False,
+        handle_timeout_termination=False,
+    )
+    
+    start_time = time.time()
+    
+    # Track episode returns
+    episode_returns = []
+    recent_episode_returns = []
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in range(args.total_timesteps):
+        # ALGO LOGIC: put action logic here
+        epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+        if random.random() < epsilon:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            q_values = q_network(torch.Tensor(obs).to(device))
+            actions = torch.argmax(q_values, dim=1).cpu().numpy()
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                if info and "episode" in info:
+                    episode_return = info['episode']['r']
+                    episode_length = info['episode']['l']
+                    episode_returns.append(episode_return)
+                    recent_episode_returns.append(episode_return)
+                    if len(recent_episode_returns) > 10:
+                        recent_episode_returns.pop(0)
+                    writer.add_scalar("charts/episodic_return", episode_return, global_step)
+                    writer.add_scalar("charts/episodic_length", episode_length, global_step)
+                    
+                    # Debug: print episode completion
+                    if global_step % 1000 == 0:
+                        print(f"  → Episode completed! Return: {episode_return:.3f}, Length: {episode_length}")
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            if global_step % args.train_frequency == 0:
+                data = rb.sample(args.batch_size)
+                with torch.no_grad():
+                    target_max, _ = target_network(data.next_observations).max(dim=1)
+                    td_target = data.rewards.flatten() + args.gamma * target_max * (1 - data.dones.flatten())
+                old_val = q_network(data.observations).gather(1, data.actions).squeeze()
+                loss = F.mse_loss(td_target, old_val)
+
+                if global_step % 100 == 0:
+                    writer.add_scalar("losses/td_loss", loss, global_step)
+                    writer.add_scalar("losses/q_values", old_val.mean().item(), global_step)
+                    writer.add_scalar("charts/epsilon", epsilon, global_step)
+                    
+                    # Console output with key metrics
+                    sps = int(global_step / (time.time() - start_time))
+                    progress = 100 * global_step / args.total_timesteps
+                    avg_episode_return = np.mean(recent_episode_returns) if recent_episode_returns else 0.0
+                    
+                    print(f"[{progress:5.1f}%] Step {global_step:6d}/{args.total_timesteps} | "
+                          f"SPS: {sps:5d} | "
+                          f"EpRet: {avg_episode_return:7.3f} | "
+                          f"Loss: {loss.item():.4f} | "
+                          f"Q-val: {old_val.mean().item():.4f} | "
+                          f"Eps: {epsilon:.3f}")
+                    
+                    writer.add_scalar("charts/SPS", sps, global_step)
+                    if recent_episode_returns:
+                        writer.add_scalar("charts/avg_episodic_return", avg_episode_return, global_step)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            # update target network
+            if global_step % args.target_network_frequency == 0:
+                for target_network_param, q_network_param in zip(target_network.parameters(), q_network.parameters()):
+                    target_network_param.data.copy_(
+                        args.tau * q_network_param.data + (1.0 - args.tau) * target_network_param.data
+                    )
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        torch.save(q_network.state_dict(), model_path)
+        print(f"model saved to {model_path}")
+
+    envs.close()
+    writer.close()
+    
+    print("\n" + "="*60)
+    print("Training Complete!")
+    print("="*60)
+    if episode_returns:
+        print(f"Final Average Episode Return (last 10): {np.mean(recent_episode_returns):.3f}")
+        print(f"Overall Average Episode Return: {np.mean(episode_returns):.3f}")
+        print(f"Best Episode Return: {max(episode_returns):.3f}")
+    print("="*60)

cleanrl/cleanrl/wandb/latest-run/files/config.yaml

@@ -0,0 +1,145 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/dqn_bandit.py
+        e:
+            jbqdicudyaaspbdzq2z1959r4qyohhsf:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-bandit
+                codePath: cleanrl/dqn_bandit.py
+                codePathLocal: dqn_bandit.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "31724965888"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/dqn_bandit.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T04:56:47.687990Z"
+                writerId: jbqdicudyaaspbdzq2z1959r4qyohhsf
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+batch_size:
+    value: 32
+buffer_size:
+    value: 10000
+capture_video:
+    value: false
+cuda:
+    value: true
+end_e:
+    value: 0.05
+env_id:
+    value: Bandit
+exp_name:
+    value: dqn_bandit
+exploration_fraction:
+    value: 0.5
+gamma:
+    value: 0.99
+learning_rate:
+    value: 0.001
+learning_starts:
+    value: 1000
+num_envs:
+    value: 1
+save_model:
+    value: false
+seed:
+    value: 1
+start_e:
+    value: 1
+steps_per_episode:
+    value: 10
+target_network_frequency:
+    value: 500
+tau:
+    value: 1
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 100000
+track:
+    value: true
+train_frequency:
+    value: 1
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-bandit

cleanrl/cleanrl/wandb/latest-run/files/output.log

@@ -0,0 +1,49 @@
+DEBUG: Episode ended at step 10, arm_counts: [6, 4]
+DEBUG: Episode ended at step 10, arm_counts: [9, 11]
+DEBUG: Episode ended at step 10, arm_counts: [12, 18]
+DEBUG: Episode ended at step 10, arm_counts: [20, 20]
+DEBUG: Episode ended at step 10, arm_counts: [25, 25]
+DEBUG: Episode ended at step 10, arm_counts: [33, 27]
+DEBUG: Episode ended at step 10, arm_counts: [37, 33]
+DEBUG: Episode ended at step 10, arm_counts: [41, 39]
+DEBUG: Episode ended at step 10, arm_counts: [45, 45]
+[  1.1%] Step   1100/100000 | SPS:  2447 | EpRet:   0.000 | Loss: 0.5871 | Q-val: -1.5165 | Eps: 0.979
+[  1.2%] Step   1200/100000 | SPS:  2143 | EpRet:   0.000 | Loss: 2.2378 | Q-val: -1.1003 | Eps: 0.977
+[  1.3%] Step   1300/100000 | SPS:  1942 | EpRet:   0.000 | Loss: 2.8699 | Q-val: -0.4089 | Eps: 0.975
+[  1.4%] Step   1400/100000 | SPS:  1794 | EpRet:   0.000 | Loss: 0.4940 | Q-val: -1.8337 | Eps: 0.973
+[  1.5%] Step   1500/100000 | SPS:  1652 | EpRet:   0.000 | Loss: 7.6582 | Q-val: -3.1953 | Eps: 0.972
+[  1.6%] Step   1600/100000 | SPS:  1266 | EpRet:   0.000 | Loss: 2.2227 | Q-val: -2.6707 | Eps: 0.970
+[  1.7%] Step   1700/100000 | SPS:  1113 | EpRet:   0.000 | Loss: 27.5951 | Q-val: -5.2100 | Eps: 0.968
+[  1.8%] Step   1800/100000 | SPS:   774 | EpRet:   0.000 | Loss: 2.7080 | Q-val: -2.7679 | Eps: 0.966
+[  1.9%] Step   1900/100000 | SPS:   685 | EpRet:   0.000 | Loss: 11.6545 | Q-val: -5.6619 | Eps: 0.964
+[  2.0%] Step   2000/100000 | SPS:   688 | EpRet:   0.000 | Loss: 2.5694 | Q-val: -4.9087 | Eps: 0.962
+[  2.1%] Step   2100/100000 | SPS:   696 | EpRet:   0.000 | Loss: 1.4418 | Q-val: -3.4358 | Eps: 0.960
+[  2.2%] Step   2200/100000 | SPS:   704 | EpRet:   0.000 | Loss: 3.4676 | Q-val: -3.2345 | Eps: 0.958
+[  2.3%] Step   2300/100000 | SPS:   711 | EpRet:   0.000 | Loss: 4.6980 | Q-val: -4.6280 | Eps: 0.956
+[  2.4%] Step   2400/100000 | SPS:   718 | EpRet:   0.000 | Loss: 4.4856 | Q-val: -3.7042 | Eps: 0.954
+[  2.5%] Step   2500/100000 | SPS:   724 | EpRet:   0.000 | Loss: 16.9031 | Q-val: -1.1285 | Eps: 0.953
+[  2.6%] Step   2600/100000 | SPS:   730 | EpRet:   0.000 | Loss: 0.8887 | Q-val: 0.1586 | Eps: 0.951
+[  2.7%] Step   2700/100000 | SPS:   736 | EpRet:   0.000 | Loss: 0.4255 | Q-val: -0.1371 | Eps: 0.949
+[  2.8%] Step   2800/100000 | SPS:   741 | EpRet:   0.000 | Loss: 0.1293 | Q-val: -0.6650 | Eps: 0.947
+[  2.9%] Step   2900/100000 | SPS:   745 | EpRet:   0.000 | Loss: 1.3904 | Q-val: -1.6370 | Eps: 0.945
+[  3.0%] Step   3000/100000 | SPS:   749 | EpRet:   0.000 | Loss: 0.3428 | Q-val: -0.7361 | Eps: 0.943
+[  3.1%] Step   3100/100000 | SPS:   753 | EpRet:   0.000 | Loss: 0.2346 | Q-val: 0.5201 | Eps: 0.941
+[  3.2%] Step   3200/100000 | SPS:   756 | EpRet:   0.000 | Loss: 0.7521 | Q-val: -0.1650 | Eps: 0.939
+[  3.3%] Step   3300/100000 | SPS:   729 | EpRet:   0.000 | Loss: 0.4594 | Q-val: 0.0121 | Eps: 0.937
+[  3.4%] Step   3400/100000 | SPS:   698 | EpRet:   0.000 | Loss: 0.5089 | Q-val: 0.7252 | Eps: 0.935
+[  3.5%] Step   3500/100000 | SPS:   667 | EpRet:   0.000 | Loss: 2.0388 | Q-val: 0.8035 | Eps: 0.933
+[  3.6%] Step   3600/100000 | SPS:   619 | EpRet:   0.000 | Loss: 1.6456 | Q-val: 2.8996 | Eps: 0.932
+[  3.7%] Step   3700/100000 | SPS:   564 | EpRet:   0.000 | Loss: 0.3920 | Q-val: 2.0191 | Eps: 0.930
+[  3.8%] Step   3800/100000 | SPS:   517 | EpRet:   0.000 | Loss: 1.0114 | Q-val: 1.1074 | Eps: 0.928
+[  3.9%] Step   3900/100000 | SPS:   477 | EpRet:   0.000 | Loss: 1.5410 | Q-val: 1.7671 | Eps: 0.926
+[  4.0%] Step   4000/100000 | SPS:   448 | EpRet:   0.000 | Loss: 0.4592 | Q-val: 1.6611 | Eps: 0.924
+[  4.1%] Step   4100/100000 | SPS:   419 | EpRet:   0.000 | Loss: 0.5028 | Q-val: 1.8597 | Eps: 0.922
+[  4.2%] Step   4200/100000 | SPS:   399 | EpRet:   0.000 | Loss: 1.5164 | Q-val: 1.6604 | Eps: 0.920
+[  4.3%] Step   4300/100000 | SPS:   376 | EpRet:   0.000 | Loss: 2.9306 | Q-val: 1.3875 | Eps: 0.918
+[  4.4%] Step   4400/100000 | SPS:   363 | EpRet:   0.000 | Loss: 0.6109 | Q-val: 2.2573 | Eps: 0.916
+[  4.5%] Step   4500/100000 | SPS:   345 | EpRet:   0.000 | Loss: 1.7421 | Q-val: 1.6360 | Eps: 0.914
+Traceback (most recent call last):
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/dqn_bandit.py", line 253, in <module>
+    q_values = q_network(torch.Tensor(obs).to(device))
+                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+KeyboardInterrupt

cleanrl/cleanrl/wandb/latest-run/files/requirements.txt

@@ -0,0 +1,304 @@
+setuptools==80.9.0
+wheel==0.45.1
+pip==25.2
+zipp==3.23.0
+verl==0.2.0.dev0
+ragen==0.1
+triton==3.2.0
+nvidia-cusparselt-cu12==0.6.2
+mpmath==1.3.0
+typing_extensions==4.15.0
+sympy==1.13.1
+nvidia-nvtx-cu12==12.4.127
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nccl-cu12==2.21.5
+nvidia-curand-cu12==10.3.5.147
+nvidia-cufft-cu12==11.2.1.3
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cublas-cu12==12.4.5.8
+networkx==3.5
+MarkupSafe==2.1.5
+fsspec==2025.9.0
+filelock==3.19.1
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cudnn-cu12==9.1.0.70
+Jinja2==3.1.6
+nvidia-cusolver-cu12==11.6.1.9
+torch==2.6.0+cu124
+einops==0.8.1
+flash_attn==2.7.4.post1
+pytz==2025.2
+pyperclip==1.11.0
+pylatexenc==2.10
+pyjnius==1.7.0
+py-cpuinfo==9.0.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+gym-notices==0.1.0
+flatbuffers==25.9.23
+fastrlock==0.8.3
+Farama-Notifications==0.0.4
+cymem==2.0.11
+antlr4-python3-runtime==4.9.3
+xxhash==3.6.0
+wrapt==2.0.0
+Werkzeug==3.1.3
+websockets==15.0.1
+wcwidth==0.2.14
+wasabi==1.1.3
+uvloop==0.22.1
+urllib3==2.5.0
+tzdata==2025.2
+typing-inspection==0.4.2
+traitlets==5.14.3
+tqdm==4.67.1
+threadpoolctl==3.6.0
+tabulate==0.9.0
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8
+sniffio==1.3.1
+smmap==5.0.2
+six==1.17.0
+shellingham==1.5.4
+sentencepiece==0.2.1
+safetensors==0.6.2
+rpds-py==0.28.0
+rignore==0.7.6
+regex==2025.11.3
+RapidFuzz==3.14.3
+pyzmq==27.1.0
+PyYAML==6.0.3
+pytokens==0.3.0
+python-multipart==0.0.20
+python-json-logger==4.0.0
+python-dotenv==1.2.1
+PySocks==1.7.1
+pyparsing==3.2.5
+PyJWT==2.10.1
+Pygments==2.19.2
+pygame==2.6.1
+pydantic_core==2.41.5
+pycparser==2.23
+pycountry==24.6.1
+pybind11==3.0.1
+pyarrow==22.0.0
+psutil==7.1.3
+protobuf==6.33.0
+propcache==0.4.1
+prometheus_client==0.23.1
+platformdirs==4.5.0
+pillow==11.3.0
+pexpect==4.9.0
+pathvalidate==3.3.1
+pathspec==0.12.1
+pathable==0.4.4
+partial-json-parser==0.2.1.1.post6
+parso==0.8.5
+packaging==25.0
+orjson==3.11.4
+numpy==1.26.4
+ninja==1.13.0
+nest-asyncio==1.6.0
+mypy_extensions==1.1.0
+murmurhash==1.0.13
+multidict==6.7.0
+msgspec==0.19.0
+msgpack==1.1.2
+more-itertools==10.8.0
+mdurl==0.1.2
+marisa-trie==1.3.1
+llvmlite==0.43.0
+llguidance==0.7.30
+lark==1.2.2
+kiwisolver==1.4.9
+joblib==1.5.2
+jiter==0.11.1
+jeepney==0.9.0
+jaraco.context==6.0.1
+itsdangerous==2.2.0
+interegular==0.3.3
+idna==3.11
+humanfriendly==10.0
+httpx-sse==0.4.3
+httptools==0.7.1
+html2text==2025.4.15
+hf-xet==1.2.0
+h11==0.16.0
+frozenlist==1.8.0
+fonttools==4.60.1
+executing==2.2.1
+exceptiongroup==1.3.0
+eval_type_backport==0.2.2
+docutils==0.22.3
+docstring_parser==0.17.0
+dnspython==2.8.0
+distro==1.9.0
+diskcache==5.6.3
+dill==0.4.0
+decorator==5.2.1
+debugpy==1.8.17
+Cython==3.2.0
+cycler==0.12.1
+codetiming==1.4.0
+cloudpickle==3.1.2
+cloudpathlib==0.23.0
+click==8.2.1
+charset-normalizer==3.4.4
+certifi==2025.10.5
+catalogue==2.0.10
+cachetools==6.2.1
+blinker==1.9.0
+blake3==1.0.8
+beartype==0.22.5
+attrs==25.4.0
+asttokens==3.0.0
+astor==0.8.1
+annotated-types==0.7.0
+annotated-doc==0.0.3
+airportsdata==20250909
+aiohappyeyeballs==2.6.1
+yarl==1.22.0
+uvicorn==0.38.0
+typer-slim==0.20.0
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.1
+smart_open==7.4.4
+sentry-sdk==2.43.0
+scipy==1.16.3
+requests==2.32.5
+referencing==0.36.2
+rank-bm25==0.2.2
+python-dateutil==2.9.0.post0
+pydantic==2.12.4
+py-key-value-shared==0.2.8
+prompt_toolkit==3.0.52
+preshed==3.0.10
+opencv-python-headless==4.11.0.86
+omegaconf==2.3.0
+numba==0.60.0
+nltk==3.9.2
+multiprocess==0.70.18
+matplotlib-inline==0.2.1
+markdown-it-py==4.0.0
+language_data==1.3.0
+jedi==0.19.2
+jaraco.functools==4.3.0
+jaraco.classes==3.4.0
+ipython_pygments_lexers==1.1.1
+importlib_metadata==8.7.0
+ImageIO==2.37.2
+httpcore==1.0.9
+gymnasium==1.2.2
+gym==0.26.2
+gitdb==4.0.12
+gguf==0.10.0
+Flask==3.1.2
+faiss-cpu==1.12.0
+email-validator==2.3.0
+depyf==0.18.0
+cupy-cuda12x==13.6.0
+contourpy==1.3.3
+coloredlogs==15.0.1
+cffi==2.0.0
+blis==1.3.0
+black==25.9.0
+beautifulsoup4==4.14.2
+anyio==4.11.0
+aiosignal==1.4.0
+watchfiles==1.1.1
+tiktoken==0.12.0
+starlette==0.49.3
+sse-starlette==3.0.3
+scikit-learn==1.7.2
+rich==14.2.0
+pydantic-settings==2.11.0
+pydantic-extra-types==2.10.6
+py-key-value-aio==0.2.8
+pandas==2.3.3
+openapi-pydantic==0.5.1
+onnxruntime==1.23.2
+matplotlib==3.10.7
+lm-format-enforcer==0.10.12
+langcodes==3.5.0
+jsonschema-specifications==2025.9.1
+jsonschema-path==0.3.4
+ipython==9.7.0
+hydra-core==1.3.2
+huggingface-hub==0.36.0
+httpx==0.28.1
+gym-sokoban==0.0.6
+GitPython==3.1.45
+cryptography==46.0.3
+confection==0.1.5
+cleantext==1.1.4
+aiohttp==3.13.2
+xformers==0.0.29.post2
+weasel==0.4.2
+wandb==0.22.3
+typer==0.19.2
+torchvision==0.21.0
+torchdata==0.11.0
+torchaudio==2.6.0
+tokenizers==0.22.1
+thinc==8.3.7
+tensordict==0.8.3
+SecretStorage==3.4.0
+rich-toolkit==0.15.1
+rich-rst==1.3.2
+prometheus-fastapi-instrumentator==7.1.0
+openai==2.7.1
+jsonschema==4.25.1
+gdown==5.2.0
+fastapi==0.121.0
+Authlib==1.6.5
+anthropic==0.72.0
+accelerate==1.11.0
+transformers==4.57.1
+together==1.5.30
+spacy==3.8.7
+ray==2.51.1
+outlines_core==0.1.26
+mistral_common==1.8.5
+mcp==1.20.0
+keyring==25.6.0
+fastapi-cloud-cli==0.3.1
+fastapi-cli==0.0.14
+datasets==4.4.1
+cyclopts==4.2.1
+xgrammar==0.1.16
+peft==0.17.1
+outlines==0.1.11
+compressed-tensors==0.9.2
+fastmcp==2.13.0.2
+vllm==0.8.2
+pyserini==1.3.0
+typeguard==4.4.4
+shtab==1.7.2
+tyro==0.9.35
+tensorboard-data-server==0.7.2
+Markdown==3.10
+grpcio==1.76.0
+absl-py==2.3.1
+tensorboard==2.20.0
+ragen==0.1
+verl==0.2.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.0.0
+inflect==7.3.1
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+more-itertools==10.3.0
+packaging==24.2
+platformdirs==4.2.2
+tomli==2.0.1
+typeguard==4.3.0
+typing_extensions==4.12.2
+wheel==0.45.1
+zipp==3.19.2

cleanrl/cleanrl/wandb/latest-run/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T04:56:47.687990Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-bandit"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/dqn_bandit.py",
+  "codePath":  "cleanrl/dqn_bandit.py",
+  "codePathLocal":  "dqn_bandit.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "31724965888"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "jbqdicudyaaspbdzq2z1959r4qyohhsf"
+}

cleanrl/cleanrl/wandb/latest-run/files/wandb-summary.json

@@ -0,0 +1 @@
+{"losses/q_values":1.63602,"_runtime":14,"global_step":4500,"_step":139,"losses/td_loss":1.7421228,"_wandb":{"runtime":14},"charts/epsilon":0.9145,"_timestamp":1.7624914231757627e+09,"charts/SPS":345}

cleanrl/cleanrl/wandb/latest-run/logs/debug-internal.log

@@ -0,0 +1,15 @@
+{"time":"2025-11-07T12:56:47.957309906+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T12:56:48.33142385+08:00","level":"INFO","msg":"stream: created new stream","id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.331674194+08:00","level":"INFO","msg":"handler: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335368381+08:00","level":"INFO","msg":"stream: started","id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335386015+08:00","level":"INFO","msg":"writer: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335389832+08:00","level":"INFO","msg":"sender: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.726770104+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T12:56:58.861202459+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T12:56:58.862839009+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__dqn_bandit__1__1762491400\")","namespace":""}
+{"time":"2025-11-07T12:56:58.864923146+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__dqn_bandit__1__1762491400/events.out.tfevents.1762491408.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.234009.0","runPath":"runs/Bandit__dqn_bandit__1__1762491400/events.out.tfevents.1762491408.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.234009.0"}
+{"time":"2025-11-07T12:56:58.868040818+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":122}
+{"time":"2025-11-07T12:56:58.871369044+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":311}
+{"time":"2025-11-07T12:57:03.576733669+08:00","level":"INFO","msg":"stream: closing","id":"g1edw7ov"}
+{"time":"2025-11-07T12:57:03.579454439+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":506}
+{"time":"2025-11-07T12:57:03.581505913+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":20}

cleanrl/cleanrl/wandb/latest-run/logs/debug.log

@@ -0,0 +1,388 @@
+2025-11-07 12:56:47,735 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Configure stats pid to 234009
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_125647-g1edw7ov/logs/debug.log
+2025-11-07 12:56:47,737 INFO    MainThread:234009 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_125647-g1edw7ov/logs/debug-internal.log
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():833] calling init triggers
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'dqn_bandit', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'save_model': False, 'env_id': 'Bandit', 'total_timesteps': 100000, 'learning_rate': 0.001, 'num_envs': 1, 'buffer_size': 10000, 'gamma': 0.99, 'tau': 1.0, 'target_network_frequency': 500, 'batch_size': 32, 'start_e': 1.0, 'end_e': 0.05, 'exploration_fraction': 0.5, 'learning_starts': 1000, 'train_frequency': 1, 'steps_per_episode': 10, '_wandb': {'code_path': 'code/cleanrl/dqn_bandit.py'}}
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():881] starting backend
+2025-11-07 12:56:47,944 INFO    MainThread:234009 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 12:56:47,954 INFO    MainThread:234009 [wandb_init.py:init():892] backend started and connected
+2025-11-07 12:56:47,956 INFO    MainThread:234009 [wandb_init.py:init():962] updated telemetry
+2025-11-07 12:56:47,990 INFO    MainThread:234009 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 12:56:48,714 INFO    MainThread:234009 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 12:56:48,856 INFO    MainThread:234009 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 12:56:48,859 INFO    MainThread:234009 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 12:56:48,860 INFO    MainThread:234009 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Bandit__dqn_bandit__1__1762491400, True
+2025-11-07 12:57:03,576 INFO    wandb-AsyncioManager-main:234009 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 12:57:03,577 INFO    wandb-AsyncioManager-main:234009 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.
+2025-11-07 12:57:03,925 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,933 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,933 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,934 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,934 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,936 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,936 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,939 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,939 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,948 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,948 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,950 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,951 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,952 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,953 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,954 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,955 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,955 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,957 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/code/cleanrl/ppo_bandit.py

@@ -0,0 +1,335 @@
+# PPO implementation for RAGEN Bandit environment
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Bandit"
+    """the id of the environment"""
+    total_timesteps: int = 1000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 32
+    """the number of parallel game environments"""
+    num_steps: int = 512
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed):
+    def thunk():
+        config = BanditEnvConfig()
+        env = BanditEnv(config)
+        env = BanditWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = np.array(envs.single_observation_space.shape).prod()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, 64)),
+            nn.Tanh(),
+            layer_init(nn.Linear(64, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed + i) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/config.yaml

@@ -0,0 +1,153 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/ppo_bandit.py
+        e:
+            xa4im9wkbwlcw1r2rhsulzxqq9xni8uv:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-bandit
+                codePath: cleanrl/ppo_bandit.py
+                codePathLocal: ppo_bandit.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "30509879296"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_bandit.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T02:06:19.722084Z"
+                writerId: xa4im9wkbwlcw1r2rhsulzxqq9xni8uv
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+anneal_lr:
+    value: true
+batch_size:
+    value: 16384
+capture_video:
+    value: false
+clip_coef:
+    value: 0.2
+clip_vloss:
+    value: true
+cuda:
+    value: true
+ent_coef:
+    value: 0.01
+env_id:
+    value: Bandit
+exp_name:
+    value: ppo_bandit
+gae_lambda:
+    value: 0.95
+gamma:
+    value: 0.99
+learning_rate:
+    value: 0.00025
+max_grad_norm:
+    value: 0.5
+minibatch_size:
+    value: 4096
+norm_adv:
+    value: true
+num_envs:
+    value: 32
+num_iterations:
+    value: 61
+num_minibatches:
+    value: 4
+num_steps:
+    value: 512
+seed:
+    value: 1
+target_kl:
+    value: null
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 1000000
+track:
+    value: true
+update_epochs:
+    value: 4
+vf_coef:
+    value: 0.5
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-bandit

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/output.log

@@ -0,0 +1,61 @@
+[  1.6%] Iter    1/61 | SPS: 17749 | Reward:  0.087 | Value: -0.018 | VLoss: 0.0488 | PLoss: -0.0002 | Ent: 0.6931
+[  3.3%] Iter    2/61 | SPS: 21695 | Reward:  0.084 | Value:  0.098 | VLoss: 0.0444 | PLoss: 0.0000 | Ent: 0.6929
+[  4.9%] Iter    3/61 | SPS: 23367 | Reward:  0.087 | Value:  0.131 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6929
+[  6.6%] Iter    4/61 | SPS: 24347 | Reward:  0.087 | Value:  0.155 | VLoss: 0.0452 | PLoss: -0.0001 | Ent: 0.6928
+[  8.2%] Iter    5/61 | SPS: 24887 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6923
+[  9.8%] Iter    6/61 | SPS: 25340 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0476 | PLoss: -0.0001 | Ent: 0.6916
+[ 11.5%] Iter    7/61 | SPS: 25670 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6905
+[ 13.1%] Iter    8/61 | SPS: 25929 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6899
+[ 14.8%] Iter    9/61 | SPS: 26121 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0480 | PLoss: 0.0001 | Ent: 0.6898
+[ 16.4%] Iter   10/61 | SPS: 26281 | Reward:  0.083 | Value:  0.177 | VLoss: 0.0438 | PLoss: -0.0000 | Ent: 0.6903
+[ 18.0%] Iter   11/61 | SPS: 26419 | Reward:  0.091 | Value:  0.165 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6903
+[ 19.7%] Iter   12/61 | SPS: 26528 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6907
+[ 21.3%] Iter   13/61 | SPS: 26604 | Reward:  0.085 | Value:  0.169 | VLoss: 0.0466 | PLoss: -0.0003 | Ent: 0.6913
+[ 23.0%] Iter   14/61 | SPS: 26663 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0449 | PLoss: -0.0002 | Ent: 0.6920
+[ 24.6%] Iter   15/61 | SPS: 26710 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0469 | PLoss: 0.0001 | Ent: 0.6924
+[ 26.2%] Iter   16/61 | SPS: 26749 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0486 | PLoss: -0.0002 | Ent: 0.6927
+[ 27.9%] Iter   17/61 | SPS: 26778 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6929
+[ 29.5%] Iter   18/61 | SPS: 26807 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0456 | PLoss: -0.0001 | Ent: 0.6930
+[ 31.1%] Iter   19/61 | SPS: 26829 | Reward:  0.089 | Value:  0.169 | VLoss: 0.0488 | PLoss: -0.0000 | Ent: 0.6931
+[ 32.8%] Iter   20/61 | SPS: 26867 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0461 | PLoss: -0.0001 | Ent: 0.6931
+[ 34.4%] Iter   21/61 | SPS: 26887 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0458 | PLoss: 0.0002 | Ent: 0.6931
+[ 36.1%] Iter   22/61 | SPS: 26906 | Reward:  0.091 | Value:  0.172 | VLoss: 0.0505 | PLoss: -0.0000 | Ent: 0.6931
+[ 37.7%] Iter   23/61 | SPS: 26936 | Reward:  0.083 | Value:  0.181 | VLoss: 0.0434 | PLoss: -0.0001 | Ent: 0.6930
+[ 39.3%] Iter   24/61 | SPS: 26966 | Reward:  0.084 | Value:  0.167 | VLoss: 0.0435 | PLoss: 0.0000 | Ent: 0.6929
+[ 41.0%] Iter   25/61 | SPS: 26984 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6929
+[ 42.6%] Iter   26/61 | SPS: 27009 | Reward:  0.087 | Value:  0.167 | VLoss: 0.0446 | PLoss: -0.0000 | Ent: 0.6928
+[ 44.3%] Iter   27/61 | SPS: 27032 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6928
+[ 45.9%] Iter   28/61 | SPS: 27053 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0488 | PLoss: -0.0001 | Ent: 0.6925
+[ 47.5%] Iter   29/61 | SPS: 27075 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0448 | PLoss: 0.0000 | Ent: 0.6923
+[ 49.2%] Iter   30/61 | SPS: 27094 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6924
+[ 50.8%] Iter   31/61 | SPS: 27113 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6925
+[ 52.5%] Iter   32/61 | SPS: 27131 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6925
+[ 54.1%] Iter   33/61 | SPS: 27147 | Reward:  0.084 | Value:  0.178 | VLoss: 0.0438 | PLoss: -0.0001 | Ent: 0.6923
+[ 55.7%] Iter   34/61 | SPS: 27159 | Reward:  0.087 | Value:  0.167 | VLoss: 0.0452 | PLoss: -0.0001 | Ent: 0.6920
+[ 57.4%] Iter   35/61 | SPS: 27159 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6919
+[ 59.0%] Iter   36/61 | SPS: 27172 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0448 | PLoss: 0.0000 | Ent: 0.6918
+[ 60.7%] Iter   37/61 | SPS: 27184 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6916
+[ 62.3%] Iter   38/61 | SPS: 27184 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6911
+[ 63.9%] Iter   39/61 | SPS: 27189 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0499 | PLoss: 0.0001 | Ent: 0.6906
+[ 65.6%] Iter   40/61 | SPS: 27200 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6909
+[ 67.2%] Iter   41/61 | SPS: 27200 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0453 | PLoss: 0.0000 | Ent: 0.6913
+[ 68.9%] Iter   42/61 | SPS: 27197 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6913
+[ 70.5%] Iter   43/61 | SPS: 27199 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6912
+[ 72.1%] Iter   44/61 | SPS: 27200 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0479 | PLoss: -0.0001 | Ent: 0.6912
+[ 73.8%] Iter   45/61 | SPS: 27202 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0456 | PLoss: -0.0001 | Ent: 0.6915
+[ 75.4%] Iter   46/61 | SPS: 27205 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0484 | PLoss: 0.0000 | Ent: 0.6916
+[ 77.0%] Iter   47/61 | SPS: 27202 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0437 | PLoss: -0.0001 | Ent: 0.6918
+[ 78.7%] Iter   48/61 | SPS: 27203 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0512 | PLoss: 0.0000 | Ent: 0.6920
+[ 80.3%] Iter   49/61 | SPS: 27205 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6919
+[ 82.0%] Iter   50/61 | SPS: 27208 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0438 | PLoss: -0.0000 | Ent: 0.6919
+[ 83.6%] Iter   51/61 | SPS: 27209 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6920
+[ 85.2%] Iter   52/61 | SPS: 27211 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0479 | PLoss: 0.0000 | Ent: 0.6920
+[ 86.9%] Iter   53/61 | SPS: 27213 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6919
+[ 88.5%] Iter   54/61 | SPS: 27215 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0472 | PLoss: -0.0001 | Ent: 0.6921
+[ 90.2%] Iter   55/61 | SPS: 27206 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6922
+[ 91.8%] Iter   56/61 | SPS: 27204 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6922
+[ 93.4%] Iter   57/61 | SPS: 27205 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6923
+[ 95.1%] Iter   58/61 | SPS: 27209 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6922
+[ 96.7%] Iter   59/61 | SPS: 27210 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6922
+[ 98.4%] Iter   60/61 | SPS: 27219 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6922
+[100.0%] Iter   61/61 | SPS: 27228 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6922

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/requirements.txt

@@ -0,0 +1,305 @@
+ragen==0.1
+setuptools==80.9.0
+wheel==0.45.1
+pip==25.2
+zipp==3.23.0
+verl==0.2.0.dev0
+ragen==0.1
+triton==3.2.0
+nvidia-cusparselt-cu12==0.6.2
+mpmath==1.3.0
+typing_extensions==4.15.0
+sympy==1.13.1
+nvidia-nvtx-cu12==12.4.127
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nccl-cu12==2.21.5
+nvidia-curand-cu12==10.3.5.147
+nvidia-cufft-cu12==11.2.1.3
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cublas-cu12==12.4.5.8
+networkx==3.5
+MarkupSafe==2.1.5
+fsspec==2025.9.0
+filelock==3.19.1
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cudnn-cu12==9.1.0.70
+Jinja2==3.1.6
+nvidia-cusolver-cu12==11.6.1.9
+torch==2.6.0+cu124
+einops==0.8.1
+flash_attn==2.7.4.post1
+pytz==2025.2
+pyperclip==1.11.0
+pylatexenc==2.10
+pyjnius==1.7.0
+py-cpuinfo==9.0.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+gym-notices==0.1.0
+flatbuffers==25.9.23
+fastrlock==0.8.3
+Farama-Notifications==0.0.4
+cymem==2.0.11
+antlr4-python3-runtime==4.9.3
+xxhash==3.6.0
+wrapt==2.0.0
+Werkzeug==3.1.3
+websockets==15.0.1
+wcwidth==0.2.14
+wasabi==1.1.3
+uvloop==0.22.1
+urllib3==2.5.0
+tzdata==2025.2
+typing-inspection==0.4.2
+traitlets==5.14.3
+tqdm==4.67.1
+threadpoolctl==3.6.0
+tabulate==0.9.0
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8
+sniffio==1.3.1
+smmap==5.0.2
+six==1.17.0
+shellingham==1.5.4
+sentencepiece==0.2.1
+safetensors==0.6.2
+rpds-py==0.28.0
+rignore==0.7.6
+regex==2025.11.3
+RapidFuzz==3.14.3
+pyzmq==27.1.0
+PyYAML==6.0.3
+pytokens==0.3.0
+python-multipart==0.0.20
+python-json-logger==4.0.0
+python-dotenv==1.2.1
+PySocks==1.7.1
+pyparsing==3.2.5
+PyJWT==2.10.1
+Pygments==2.19.2
+pygame==2.6.1
+pydantic_core==2.41.5
+pycparser==2.23
+pycountry==24.6.1
+pybind11==3.0.1
+pyarrow==22.0.0
+psutil==7.1.3
+protobuf==6.33.0
+propcache==0.4.1
+prometheus_client==0.23.1
+platformdirs==4.5.0
+pillow==11.3.0
+pexpect==4.9.0
+pathvalidate==3.3.1
+pathspec==0.12.1
+pathable==0.4.4
+partial-json-parser==0.2.1.1.post6
+parso==0.8.5
+packaging==25.0
+orjson==3.11.4
+numpy==1.26.4
+ninja==1.13.0
+nest-asyncio==1.6.0
+mypy_extensions==1.1.0
+murmurhash==1.0.13
+multidict==6.7.0
+msgspec==0.19.0
+msgpack==1.1.2
+more-itertools==10.8.0
+mdurl==0.1.2
+marisa-trie==1.3.1
+llvmlite==0.43.0
+llguidance==0.7.30
+lark==1.2.2
+kiwisolver==1.4.9
+joblib==1.5.2
+jiter==0.11.1
+jeepney==0.9.0
+jaraco.context==6.0.1
+itsdangerous==2.2.0
+interegular==0.3.3
+idna==3.11
+humanfriendly==10.0
+httpx-sse==0.4.3
+httptools==0.7.1
+html2text==2025.4.15
+hf-xet==1.2.0
+h11==0.16.0
+frozenlist==1.8.0
+fonttools==4.60.1
+executing==2.2.1
+exceptiongroup==1.3.0
+eval_type_backport==0.2.2
+docutils==0.22.3
+docstring_parser==0.17.0
+dnspython==2.8.0
+distro==1.9.0
+diskcache==5.6.3
+dill==0.4.0
+decorator==5.2.1
+debugpy==1.8.17
+Cython==3.2.0
+cycler==0.12.1
+codetiming==1.4.0
+cloudpickle==3.1.2
+cloudpathlib==0.23.0
+click==8.2.1
+charset-normalizer==3.4.4
+certifi==2025.10.5
+catalogue==2.0.10
+cachetools==6.2.1
+blinker==1.9.0
+blake3==1.0.8
+beartype==0.22.5
+attrs==25.4.0
+asttokens==3.0.0
+astor==0.8.1
+annotated-types==0.7.0
+annotated-doc==0.0.3
+airportsdata==20250909
+aiohappyeyeballs==2.6.1
+yarl==1.22.0
+uvicorn==0.38.0
+typer-slim==0.20.0
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.1
+smart_open==7.4.4
+sentry-sdk==2.43.0
+scipy==1.16.3
+requests==2.32.5
+referencing==0.36.2
+rank-bm25==0.2.2
+python-dateutil==2.9.0.post0
+pydantic==2.12.4
+py-key-value-shared==0.2.8
+prompt_toolkit==3.0.52
+preshed==3.0.10
+opencv-python-headless==4.11.0.86
+omegaconf==2.3.0
+numba==0.60.0
+nltk==3.9.2
+multiprocess==0.70.18
+matplotlib-inline==0.2.1
+markdown-it-py==4.0.0
+language_data==1.3.0
+jedi==0.19.2
+jaraco.functools==4.3.0
+jaraco.classes==3.4.0
+ipython_pygments_lexers==1.1.1
+importlib_metadata==8.7.0
+ImageIO==2.37.2
+httpcore==1.0.9
+gymnasium==1.2.2
+gym==0.26.2
+gitdb==4.0.12
+gguf==0.10.0
+Flask==3.1.2
+faiss-cpu==1.12.0
+email-validator==2.3.0
+depyf==0.18.0
+cupy-cuda12x==13.6.0
+contourpy==1.3.3
+coloredlogs==15.0.1
+cffi==2.0.0
+blis==1.3.0
+black==25.9.0
+beautifulsoup4==4.14.2
+anyio==4.11.0
+aiosignal==1.4.0
+watchfiles==1.1.1
+tiktoken==0.12.0
+starlette==0.49.3
+sse-starlette==3.0.3
+scikit-learn==1.7.2
+rich==14.2.0
+pydantic-settings==2.11.0
+pydantic-extra-types==2.10.6
+py-key-value-aio==0.2.8
+pandas==2.3.3
+openapi-pydantic==0.5.1
+onnxruntime==1.23.2
+matplotlib==3.10.7
+lm-format-enforcer==0.10.12
+langcodes==3.5.0
+jsonschema-specifications==2025.9.1
+jsonschema-path==0.3.4
+ipython==9.7.0
+hydra-core==1.3.2
+huggingface-hub==0.36.0
+httpx==0.28.1
+gym-sokoban==0.0.6
+GitPython==3.1.45
+cryptography==46.0.3
+confection==0.1.5
+cleantext==1.1.4
+aiohttp==3.13.2
+xformers==0.0.29.post2
+weasel==0.4.2
+wandb==0.22.3
+typer==0.19.2
+torchvision==0.21.0
+torchdata==0.11.0
+torchaudio==2.6.0
+tokenizers==0.22.1
+thinc==8.3.7
+tensordict==0.8.3
+SecretStorage==3.4.0
+rich-toolkit==0.15.1
+rich-rst==1.3.2
+prometheus-fastapi-instrumentator==7.1.0
+openai==2.7.1
+jsonschema==4.25.1
+gdown==5.2.0
+fastapi==0.121.0
+Authlib==1.6.5
+anthropic==0.72.0
+accelerate==1.11.0
+transformers==4.57.1
+together==1.5.30
+spacy==3.8.7
+ray==2.51.1
+outlines_core==0.1.26
+mistral_common==1.8.5
+mcp==1.20.0
+keyring==25.6.0
+fastapi-cloud-cli==0.3.1
+fastapi-cli==0.0.14
+datasets==4.4.1
+cyclopts==4.2.1
+xgrammar==0.1.16
+peft==0.17.1
+outlines==0.1.11
+compressed-tensors==0.9.2
+fastmcp==2.13.0.2
+vllm==0.8.2
+pyserini==1.3.0
+typeguard==4.4.4
+shtab==1.7.2
+tyro==0.9.35
+tensorboard-data-server==0.7.2
+Markdown==3.10
+grpcio==1.76.0
+absl-py==2.3.1
+tensorboard==2.20.0
+ragen==0.1
+verl==0.2.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.0.0
+inflect==7.3.1
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+more-itertools==10.3.0
+packaging==24.2
+platformdirs==4.2.2
+tomli==2.0.1
+typeguard==4.3.0
+typing_extensions==4.12.2
+wheel==0.45.1
+zipp==3.19.2

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T02:06:19.722084Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-bandit"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_bandit.py",
+  "codePath":  "cleanrl/ppo_bandit.py",
+  "codePathLocal":  "ppo_bandit.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "30509879296"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "xa4im9wkbwlcw1r2rhsulzxqq9xni8uv"
+}

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/files/wandb-summary.json

@@ -0,0 +1 @@
+{"losses/entropy":0.6921915,"_step":792,"_timestamp":1.7624812191309254e+09,"losses/old_approx_kl":4.6293717e-06,"losses/explained_variance":-7.891655e-05,"_runtime":38,"charts/avg_reward":0.087274164,"charts/SPS":27228,"global_step":999424,"losses/policy_loss":-2.1699816e-06,"losses/approx_kl":7.246854e-09,"charts/min_reward":0,"_wandb":{"runtime":38},"losses/value_loss":0.04838482,"charts/max_reward":1,"losses/clipfrac":0,"charts/learning_rate":4.0983605e-06,"charts/avg_value":0.17467922}

cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/logs/debug.log

@@ -0,0 +1,24 @@
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_setup.py:_flush():81] Configure stats pid to 131343
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 10:06:19,770 INFO    MainThread:131343 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/logs/debug.log
+2025-11-07 10:06:19,771 INFO    MainThread:131343 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_100619-gm3bobw8/logs/debug-internal.log
+2025-11-07 10:06:19,774 INFO    MainThread:131343 [wandb_init.py:init():833] calling init triggers
+2025-11-07 10:06:19,774 INFO    MainThread:131343 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'ppo_bandit', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'env_id': 'Bandit', 'total_timesteps': 1000000, 'learning_rate': 0.00025, 'num_envs': 32, 'num_steps': 512, 'anneal_lr': True, 'gamma': 0.99, 'gae_lambda': 0.95, 'num_minibatches': 4, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': True, 'ent_coef': 0.01, 'vf_coef': 0.5, 'max_grad_norm': 0.5, 'target_kl': None, 'batch_size': 16384, 'minibatch_size': 4096, 'num_iterations': 61, '_wandb': {'code_path': 'code/cleanrl/ppo_bandit.py'}}
+2025-11-07 10:06:19,774 INFO    MainThread:131343 [wandb_init.py:init():881] starting backend
+2025-11-07 10:06:19,980 INFO    MainThread:131343 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 10:06:19,991 INFO    MainThread:131343 [wandb_init.py:init():892] backend started and connected
+2025-11-07 10:06:19,993 INFO    MainThread:131343 [wandb_init.py:init():962] updated telemetry
+2025-11-07 10:06:20,030 INFO    MainThread:131343 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 10:06:20,800 INFO    MainThread:131343 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 10:06:20,946 INFO    MainThread:131343 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 10:06:20,946 INFO    MainThread:131343 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 10:06:20,946 INFO    MainThread:131343 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 10:06:20,947 INFO    MainThread:131343 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 10:06:20,949 INFO    MainThread:131343 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 10:06:20,949 INFO    MainThread:131343 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Bandit__ppo_bandit__1__1762481172, True
+2025-11-07 10:06:59,151 INFO    wandb-AsyncioManager-main:131343 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 10:06:59,152 INFO    wandb-AsyncioManager-main:131343 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/files/output.log

@@ -0,0 +1,610 @@
+[  0.2%] Iter    1/610 | SPS: 17195 | Reward:  0.087 | Value: -0.018 | VLoss: 0.0488 | PLoss: -0.0002 | Ent: 0.6931
+[  0.3%] Iter    2/610 | SPS: 21007 | Reward:  0.084 | Value:  0.098 | VLoss: 0.0444 | PLoss: 0.0000 | Ent: 0.6929
+[  0.5%] Iter    3/610 | SPS: 22807 | Reward:  0.087 | Value:  0.131 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6929
+[  0.7%] Iter    4/610 | SPS: 23807 | Reward:  0.087 | Value:  0.156 | VLoss: 0.0452 | PLoss: -0.0001 | Ent: 0.6927
+[  0.8%] Iter    5/610 | SPS: 24488 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6922
+[  1.0%] Iter    6/610 | SPS: 24959 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0476 | PLoss: -0.0001 | Ent: 0.6914
+[  1.1%] Iter    7/610 | SPS: 25311 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6902
+[  1.3%] Iter    8/610 | SPS: 25594 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6896
+[  1.5%] Iter    9/610 | SPS: 25819 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0479 | PLoss: 0.0001 | Ent: 0.6892
+[  1.6%] Iter   10/610 | SPS: 26001 | Reward:  0.083 | Value:  0.177 | VLoss: 0.0438 | PLoss: -0.0000 | Ent: 0.6896
+[  1.8%] Iter   11/610 | SPS: 26145 | Reward:  0.091 | Value:  0.165 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6898
+[  2.0%] Iter   12/610 | SPS: 26270 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6905
+[  2.1%] Iter   13/610 | SPS: 26378 | Reward:  0.085 | Value:  0.169 | VLoss: 0.0469 | PLoss: -0.0005 | Ent: 0.6915
+[  2.3%] Iter   14/610 | SPS: 26469 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0455 | PLoss: -0.0002 | Ent: 0.6925
+[  2.5%] Iter   15/610 | SPS: 26553 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0464 | PLoss: 0.0001 | Ent: 0.6928
+[  2.6%] Iter   16/610 | SPS: 26625 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6928
+[  2.8%] Iter   17/610 | SPS: 26556 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6929
+[  3.0%] Iter   18/610 | SPS: 26439 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0459 | PLoss: -0.0001 | Ent: 0.6930
+[  3.1%] Iter   19/610 | SPS: 26495 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6931
+[  3.3%] Iter   20/610 | SPS: 26543 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[  3.4%] Iter   21/610 | SPS: 26592 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0453 | PLoss: 0.0002 | Ent: 0.6931
+[  3.6%] Iter   22/610 | SPS: 26631 | Reward:  0.091 | Value:  0.169 | VLoss: 0.0501 | PLoss: -0.0000 | Ent: 0.6931
+[  3.8%] Iter   23/610 | SPS: 26671 | Reward:  0.084 | Value:  0.183 | VLoss: 0.0430 | PLoss: -0.0001 | Ent: 0.6931
+[  3.9%] Iter   24/610 | SPS: 26715 | Reward:  0.084 | Value:  0.168 | VLoss: 0.0437 | PLoss: 0.0001 | Ent: 0.6930
+[  4.1%] Iter   25/610 | SPS: 26755 | Reward:  0.085 | Value:  0.164 | VLoss: 0.0453 | PLoss: -0.0001 | Ent: 0.6928
+[  4.3%] Iter   26/610 | SPS: 26791 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0445 | PLoss: -0.0001 | Ent: 0.6927
+[  4.4%] Iter   27/610 | SPS: 26819 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6926
+[  4.6%] Iter   28/610 | SPS: 26847 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6922
+[  4.8%] Iter   29/610 | SPS: 26873 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0445 | PLoss: 0.0001 | Ent: 0.6920
+[  4.9%] Iter   30/610 | SPS: 26899 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0002 | Ent: 0.6924
+[  5.1%] Iter   31/610 | SPS: 26915 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0479 | PLoss: 0.0000 | Ent: 0.6927
+[  5.2%] Iter   32/610 | SPS: 26930 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6927
+[  5.4%] Iter   33/610 | SPS: 26947 | Reward:  0.084 | Value:  0.179 | VLoss: 0.0439 | PLoss: -0.0003 | Ent: 0.6924
+[  5.6%] Iter   34/610 | SPS: 26963 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6918
+[  5.7%] Iter   35/610 | SPS: 26886 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6915
+[  5.9%] Iter   36/610 | SPS: 26905 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0452 | PLoss: 0.0000 | Ent: 0.6913
+[  6.1%] Iter   37/610 | SPS: 26919 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6909
+[  6.2%] Iter   38/610 | SPS: 26934 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6902
+[  6.4%] Iter   39/610 | SPS: 26946 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0499 | PLoss: 0.0001 | Ent: 0.6891
+[  6.6%] Iter   40/610 | SPS: 26961 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0472 | PLoss: 0.0000 | Ent: 0.6897
+[  6.7%] Iter   41/610 | SPS: 26975 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0449 | PLoss: 0.0003 | Ent: 0.6906
+[  6.9%] Iter   42/610 | SPS: 26993 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6905
+[  7.0%] Iter   43/610 | SPS: 27005 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0461 | PLoss: -0.0001 | Ent: 0.6901
+[  7.2%] Iter   44/610 | SPS: 27020 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0480 | PLoss: -0.0002 | Ent: 0.6908
+[  7.4%] Iter   45/610 | SPS: 27033 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0446 | PLoss: -0.0000 | Ent: 0.6916
+[  7.5%] Iter   46/610 | SPS: 27046 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0492 | PLoss: -0.0000 | Ent: 0.6920
+[  7.7%] Iter   47/610 | SPS: 27056 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0451 | PLoss: -0.0002 | Ent: 0.6928
+[  7.9%] Iter   48/610 | SPS: 27067 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0509 | PLoss: 0.0001 | Ent: 0.6930
+[  8.0%] Iter   49/610 | SPS: 27076 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6931
+[  8.2%] Iter   50/610 | SPS: 27085 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6931
+[  8.4%] Iter   51/610 | SPS: 27083 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0477 | PLoss: 0.0000 | Ent: 0.6931
+[  8.5%] Iter   52/610 | SPS: 27078 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6931
+[  8.7%] Iter   53/610 | SPS: 27085 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6931
+[  8.9%] Iter   54/610 | SPS: 27092 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6931
+[  9.0%] Iter   55/610 | SPS: 27098 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6931
+[  9.2%] Iter   56/610 | SPS: 27104 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0492 | PLoss: -0.0000 | Ent: 0.6931
+[  9.3%] Iter   57/610 | SPS: 27112 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6931
+[  9.5%] Iter   58/610 | SPS: 27119 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6931
+[  9.7%] Iter   59/610 | SPS: 27123 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[  9.8%] Iter   60/610 | SPS: 27129 | Reward:  0.090 | Value:  0.177 | VLoss: 0.0493 | PLoss: -0.0001 | Ent: 0.6931
+[ 10.0%] Iter   61/610 | SPS: 27133 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6931
+[ 10.2%] Iter   62/610 | SPS: 27139 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6931
+[ 10.3%] Iter   63/610 | SPS: 27137 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0477 | PLoss: -0.0000 | Ent: 0.6931
+[ 10.5%] Iter   64/610 | SPS: 27141 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0492 | PLoss: -0.0000 | Ent: 0.6931
+[ 10.7%] Iter   65/610 | SPS: 27146 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6931
+[ 10.8%] Iter   66/610 | SPS: 27152 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6931
+[ 11.0%] Iter   67/610 | SPS: 27156 | Reward:  0.083 | Value:  0.176 | VLoss: 0.0431 | PLoss: -0.0000 | Ent: 0.6931
+[ 11.1%] Iter   68/610 | SPS: 27155 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6931
+[ 11.3%] Iter   69/610 | SPS: 27155 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0445 | PLoss: -0.0002 | Ent: 0.6931
+[ 11.5%] Iter   70/610 | SPS: 27161 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0476 | PLoss: -0.0002 | Ent: 0.6931
+[ 11.6%] Iter   71/610 | SPS: 27165 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0453 | PLoss: -0.0002 | Ent: 0.6929
+[ 11.8%] Iter   72/610 | SPS: 27170 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6929
+[ 12.0%] Iter   73/610 | SPS: 27173 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6930
+[ 12.1%] Iter   74/610 | SPS: 27178 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6931
+[ 12.3%] Iter   75/610 | SPS: 27183 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6931
+[ 12.5%] Iter   76/610 | SPS: 27191 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0448 | PLoss: -0.0001 | Ent: 0.6931
+[ 12.6%] Iter   77/610 | SPS: 27197 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6931
+[ 12.8%] Iter   78/610 | SPS: 27204 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6931
+[ 13.0%] Iter   79/610 | SPS: 27210 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0467 | PLoss: -0.0001 | Ent: 0.6930
+[ 13.1%] Iter   80/610 | SPS: 27217 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0463 | PLoss: -0.0002 | Ent: 0.6928
+[ 13.3%] Iter   81/610 | SPS: 27222 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0468 | PLoss: 0.0001 | Ent: 0.6926
+[ 13.4%] Iter   82/610 | SPS: 27228 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6924
+[ 13.6%] Iter   83/610 | SPS: 27236 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6920
+[ 13.8%] Iter   84/610 | SPS: 27242 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0431 | PLoss: -0.0000 | Ent: 0.6920
+[ 13.9%] Iter   85/610 | SPS: 27245 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6922
+[ 14.1%] Iter   86/610 | SPS: 27247 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0465 | PLoss: -0.0001 | Ent: 0.6926
+[ 14.3%] Iter   87/610 | SPS: 27252 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6927
+[ 14.4%] Iter   88/610 | SPS: 27258 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6928
+[ 14.6%] Iter   89/610 | SPS: 27261 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6927
+[ 14.8%] Iter   90/610 | SPS: 27266 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6927
+[ 14.9%] Iter   91/610 | SPS: 27270 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0486 | PLoss: -0.0001 | Ent: 0.6923
+[ 15.1%] Iter   92/610 | SPS: 27276 | Reward:  0.084 | Value:  0.179 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6918
+[ 15.2%] Iter   93/610 | SPS: 27281 | Reward:  0.086 | Value:  0.166 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6918
+[ 15.4%] Iter   94/610 | SPS: 27286 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0445 | PLoss: -0.0001 | Ent: 0.6920
+[ 15.6%] Iter   95/610 | SPS: 27292 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0495 | PLoss: 0.0000 | Ent: 0.6923
+[ 15.7%] Iter   96/610 | SPS: 27297 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0465 | PLoss: -0.0001 | Ent: 0.6925
+[ 15.9%] Iter   97/610 | SPS: 27303 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6926
+[ 16.1%] Iter   98/610 | SPS: 27306 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6926
+[ 16.2%] Iter   99/610 | SPS: 27309 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6926
+[ 16.4%] Iter  100/610 | SPS: 27314 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6927
+[ 16.6%] Iter  101/610 | SPS: 27317 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0450 | PLoss: -0.0002 | Ent: 0.6929
+[ 16.7%] Iter  102/610 | SPS: 27315 | Reward:  0.094 | Value:  0.175 | VLoss: 0.0516 | PLoss: 0.0000 | Ent: 0.6931
+[ 16.9%] Iter  103/610 | SPS: 27317 | Reward:  0.087 | Value:  0.186 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6931
+[ 17.0%] Iter  104/610 | SPS: 27320 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6931
+[ 17.2%] Iter  105/610 | SPS: 27324 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0449 | PLoss: 0.0000 | Ent: 0.6931
+[ 17.4%] Iter  106/610 | SPS: 27328 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0485 | PLoss: -0.0001 | Ent: 0.6931
+[ 17.5%] Iter  107/610 | SPS: 27331 | Reward:  0.091 | Value:  0.174 | VLoss: 0.0480 | PLoss: -0.0003 | Ent: 0.6931
+[ 17.7%] Iter  108/610 | SPS: 27336 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6930
+[ 17.9%] Iter  109/610 | SPS: 27340 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6930
+[ 18.0%] Iter  110/610 | SPS: 27343 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6929
+[ 18.2%] Iter  111/610 | SPS: 27346 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6929
+[ 18.4%] Iter  112/610 | SPS: 27349 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6930
+[ 18.5%] Iter  113/610 | SPS: 27353 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0440 | PLoss: -0.0000 | Ent: 0.6930
+[ 18.7%] Iter  114/610 | SPS: 27356 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6930
+[ 18.9%] Iter  115/610 | SPS: 27359 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0456 | PLoss: 0.0000 | Ent: 0.6931
+[ 19.0%] Iter  116/610 | SPS: 27362 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0442 | PLoss: -0.0001 | Ent: 0.6931
+[ 19.2%] Iter  117/610 | SPS: 27364 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6931
+[ 19.3%] Iter  118/610 | SPS: 27368 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6931
+[ 19.5%] Iter  119/610 | SPS: 27364 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6931
+[ 19.7%] Iter  120/610 | SPS: 27369 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0444 | PLoss: -0.0001 | Ent: 0.6930
+[ 19.8%] Iter  121/610 | SPS: 27371 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0488 | PLoss: 0.0000 | Ent: 0.6930
+[ 20.0%] Iter  122/610 | SPS: 27375 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6930
+[ 20.2%] Iter  123/610 | SPS: 27377 | Reward:  0.089 | Value:  0.169 | VLoss: 0.0477 | PLoss: 0.0000 | Ent: 0.6931
+[ 20.3%] Iter  124/610 | SPS: 27379 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0501 | PLoss: 0.0000 | Ent: 0.6931
+[ 20.5%] Iter  125/610 | SPS: 27382 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6931
+[ 20.7%] Iter  126/610 | SPS: 27386 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6931
+[ 20.8%] Iter  127/610 | SPS: 27389 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6931
+[ 21.0%] Iter  128/610 | SPS: 27391 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6930
+[ 21.1%] Iter  129/610 | SPS: 27393 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6930
+[ 21.3%] Iter  130/610 | SPS: 27396 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6929
+[ 21.5%] Iter  131/610 | SPS: 27398 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0441 | PLoss: -0.0001 | Ent: 0.6930
+[ 21.6%] Iter  132/610 | SPS: 27400 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6931
+[ 21.8%] Iter  133/610 | SPS: 27404 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0443 | PLoss: -0.0001 | Ent: 0.6930
+[ 22.0%] Iter  134/610 | SPS: 27405 | Reward:  0.090 | Value:  0.168 | VLoss: 0.0504 | PLoss: 0.0001 | Ent: 0.6929
+[ 22.1%] Iter  135/610 | SPS: 27406 | Reward:  0.088 | Value:  0.182 | VLoss: 0.0452 | PLoss: -0.0000 | Ent: 0.6929
+[ 22.3%] Iter  136/610 | SPS: 27404 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6929
+[ 22.5%] Iter  137/610 | SPS: 27406 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0452 | PLoss: 0.0001 | Ent: 0.6930
+[ 22.6%] Iter  138/610 | SPS: 27408 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6930
+[ 22.8%] Iter  139/610 | SPS: 27410 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.0%] Iter  140/610 | SPS: 27412 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.1%] Iter  141/610 | SPS: 27413 | Reward:  0.090 | Value:  0.171 | VLoss: 0.0488 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.3%] Iter  142/610 | SPS: 27414 | Reward:  0.092 | Value:  0.177 | VLoss: 0.0512 | PLoss: 0.0000 | Ent: 0.6931
+[ 23.4%] Iter  143/610 | SPS: 27416 | Reward:  0.086 | Value:  0.186 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.6%] Iter  144/610 | SPS: 27418 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.8%] Iter  145/610 | SPS: 27419 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6931
+[ 23.9%] Iter  146/610 | SPS: 27421 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6931
+[ 24.1%] Iter  147/610 | SPS: 27423 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0499 | PLoss: -0.0002 | Ent: 0.6931
+[ 24.3%] Iter  148/610 | SPS: 27424 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6929
+[ 24.4%] Iter  149/610 | SPS: 27423 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0478 | PLoss: 0.0001 | Ent: 0.6928
+[ 24.6%] Iter  150/610 | SPS: 27426 | Reward:  0.083 | Value:  0.170 | VLoss: 0.0430 | PLoss: -0.0001 | Ent: 0.6929
+[ 24.8%] Iter  151/610 | SPS: 27428 | Reward:  0.087 | Value:  0.165 | VLoss: 0.0460 | PLoss: 0.0001 | Ent: 0.6930
+[ 24.9%] Iter  152/610 | SPS: 27428 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6930
+[ 25.1%] Iter  153/610 | SPS: 27426 | Reward:  0.092 | Value:  0.177 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6929
+[ 25.2%] Iter  154/610 | SPS: 27427 | Reward:  0.089 | Value:  0.181 | VLoss: 0.0484 | PLoss: 0.0001 | Ent: 0.6929
+[ 25.4%] Iter  155/610 | SPS: 27429 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6929
+[ 25.6%] Iter  156/610 | SPS: 27431 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0452 | PLoss: -0.0000 | Ent: 0.6929
+[ 25.7%] Iter  157/610 | SPS: 27431 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6930
+[ 25.9%] Iter  158/610 | SPS: 27433 | Reward:  0.087 | Value:  0.181 | VLoss: 0.0469 | PLoss: 0.0001 | Ent: 0.6930
+[ 26.1%] Iter  159/610 | SPS: 27435 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6930
+[ 26.2%] Iter  160/610 | SPS: 27437 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6929
+[ 26.4%] Iter  161/610 | SPS: 27439 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6930
+[ 26.6%] Iter  162/610 | SPS: 27440 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6930
+[ 26.7%] Iter  163/610 | SPS: 27442 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6930
+[ 26.9%] Iter  164/610 | SPS: 27445 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0430 | PLoss: 0.0000 | Ent: 0.6930
+[ 27.0%] Iter  165/610 | SPS: 27446 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6930
+[ 27.2%] Iter  166/610 | SPS: 27448 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6930
+[ 27.4%] Iter  167/610 | SPS: 27450 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6931
+[ 27.5%] Iter  168/610 | SPS: 27451 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6931
+[ 27.7%] Iter  169/610 | SPS: 27450 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6930
+[ 27.9%] Iter  170/610 | SPS: 27448 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6931
+[ 28.0%] Iter  171/610 | SPS: 27450 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0464 | PLoss: 0.0000 | Ent: 0.6931
+[ 28.2%] Iter  172/610 | SPS: 27452 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6931
+[ 28.4%] Iter  173/610 | SPS: 27453 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0467 | PLoss: -0.0001 | Ent: 0.6931
+[ 28.5%] Iter  174/610 | SPS: 27453 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6930
+[ 28.7%] Iter  175/610 | SPS: 27454 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0474 | PLoss: 0.0001 | Ent: 0.6931
+[ 28.9%] Iter  176/610 | SPS: 27456 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[ 29.0%] Iter  177/610 | SPS: 27458 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0434 | PLoss: 0.0001 | Ent: 0.6931
+[ 29.2%] Iter  178/610 | SPS: 27459 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0453 | PLoss: 0.0001 | Ent: 0.6930
+[ 29.3%] Iter  179/610 | SPS: 27461 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6930
+[ 29.5%] Iter  180/610 | SPS: 27462 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6930
+[ 29.7%] Iter  181/610 | SPS: 27464 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6930
+[ 29.8%] Iter  182/610 | SPS: 27466 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0462 | PLoss: -0.0000 | Ent: 0.6930
+[ 30.0%] Iter  183/610 | SPS: 27336 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6930
+[ 30.2%] Iter  184/610 | SPS: 27338 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0475 | PLoss: -0.0001 | Ent: 0.6929
+[ 30.3%] Iter  185/610 | SPS: 27338 | Reward:  0.084 | Value:  0.172 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6929
+[ 30.5%] Iter  186/610 | SPS: 27234 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0464 | PLoss: 0.0000 | Ent: 0.6929
+[ 30.7%] Iter  187/610 | SPS: 27237 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6930
+[ 30.8%] Iter  188/610 | SPS: 27240 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6930
+[ 31.0%] Iter  189/610 | SPS: 27241 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0486 | PLoss: -0.0001 | Ent: 0.6931
+[ 31.1%] Iter  190/610 | SPS: 27244 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0460 | PLoss: 0.0000 | Ent: 0.6931
+[ 31.3%] Iter  191/610 | SPS: 27247 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6930
+[ 31.5%] Iter  192/610 | SPS: 27250 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6929
+[ 31.6%] Iter  193/610 | SPS: 27253 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6928
+[ 31.8%] Iter  194/610 | SPS: 27256 | Reward:  0.090 | Value:  0.179 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6929
+[ 32.0%] Iter  195/610 | SPS: 27259 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0425 | PLoss: -0.0001 | Ent: 0.6929
+[ 32.1%] Iter  196/610 | SPS: 27263 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6929
+[ 32.3%] Iter  197/610 | SPS: 27266 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6928
+[ 32.5%] Iter  198/610 | SPS: 27268 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6929
+[ 32.6%] Iter  199/610 | SPS: 27270 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6929
+[ 32.8%] Iter  200/610 | SPS: 27273 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6929
+[ 33.0%] Iter  201/610 | SPS: 27274 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6929
+[ 33.1%] Iter  202/610 | SPS: 27273 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6929
+[ 33.3%] Iter  203/610 | SPS: 27275 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0463 | PLoss: 0.0000 | Ent: 0.6929
+[ 33.4%] Iter  204/610 | SPS: 27277 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0451 | PLoss: 0.0001 | Ent: 0.6929
+[ 33.6%] Iter  205/610 | SPS: 27279 | Reward:  0.091 | Value:  0.170 | VLoss: 0.0488 | PLoss: -0.0000 | Ent: 0.6928
+[ 33.8%] Iter  206/610 | SPS: 27282 | Reward:  0.087 | Value:  0.182 | VLoss: 0.0452 | PLoss: -0.0000 | Ent: 0.6930
+[ 33.9%] Iter  207/610 | SPS: 27284 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 34.1%] Iter  208/610 | SPS: 27287 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6931
+[ 34.3%] Iter  209/610 | SPS: 27290 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6931
+[ 34.4%] Iter  210/610 | SPS: 27293 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0470 | PLoss: -0.0001 | Ent: 0.6931
+[ 34.6%] Iter  211/610 | SPS: 27294 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6930
+[ 34.8%] Iter  212/610 | SPS: 27296 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0479 | PLoss: 0.0001 | Ent: 0.6929
+[ 34.9%] Iter  213/610 | SPS: 27298 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0500 | PLoss: -0.0000 | Ent: 0.6928
+[ 35.1%] Iter  214/610 | SPS: 27300 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6928
+[ 35.2%] Iter  215/610 | SPS: 27301 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6927
+[ 35.4%] Iter  216/610 | SPS: 27303 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0450 | PLoss: 0.0000 | Ent: 0.6926
+[ 35.6%] Iter  217/610 | SPS: 27306 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6927
+[ 35.7%] Iter  218/610 | SPS: 27307 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0492 | PLoss: -0.0003 | Ent: 0.6930
+[ 35.9%] Iter  219/610 | SPS: 27306 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0489 | PLoss: 0.0000 | Ent: 0.6931
+[ 36.1%] Iter  220/610 | SPS: 27309 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0424 | PLoss: 0.0000 | Ent: 0.6931
+[ 36.2%] Iter  221/610 | SPS: 27310 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0476 | PLoss: -0.0001 | Ent: 0.6931
+[ 36.4%] Iter  222/610 | SPS: 27313 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6931
+[ 36.6%] Iter  223/610 | SPS: 27315 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6931
+[ 36.7%] Iter  224/610 | SPS: 27315 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6931
+[ 36.9%] Iter  225/610 | SPS: 27317 | Reward:  0.094 | Value:  0.176 | VLoss: 0.0512 | PLoss: 0.0000 | Ent: 0.6931
+[ 37.0%] Iter  226/610 | SPS: 27318 | Reward:  0.087 | Value:  0.186 | VLoss: 0.0456 | PLoss: -0.0001 | Ent: 0.6931
+[ 37.2%] Iter  227/610 | SPS: 27319 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0493 | PLoss: -0.0001 | Ent: 0.6931
+[ 37.4%] Iter  228/610 | SPS: 27316 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6931
+[ 37.5%] Iter  229/610 | SPS: 27317 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6931
+[ 37.7%] Iter  230/610 | SPS: 27318 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0482 | PLoss: 0.0001 | Ent: 0.6931
+[ 37.9%] Iter  231/610 | SPS: 27319 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6931
+[ 38.0%] Iter  232/610 | SPS: 27320 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6931
+[ 38.2%] Iter  233/610 | SPS: 27321 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6931
+[ 38.4%] Iter  234/610 | SPS: 27323 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0442 | PLoss: 0.0000 | Ent: 0.6930
+[ 38.5%] Iter  235/610 | SPS: 27322 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6930
+[ 38.7%] Iter  236/610 | SPS: 27321 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0476 | PLoss: -0.0001 | Ent: 0.6930
+[ 38.9%] Iter  237/610 | SPS: 27322 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6928
+[ 39.0%] Iter  238/610 | SPS: 27324 | Reward:  0.084 | Value:  0.178 | VLoss: 0.0452 | PLoss: -0.0002 | Ent: 0.6926
+[ 39.2%] Iter  239/610 | SPS: 27326 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0442 | PLoss: -0.0001 | Ent: 0.6921
+[ 39.3%] Iter  240/610 | SPS: 27327 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0497 | PLoss: -0.0001 | Ent: 0.6918
+[ 39.5%] Iter  241/610 | SPS: 27329 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0472 | PLoss: -0.0002 | Ent: 0.6911
+[ 39.7%] Iter  242/610 | SPS: 27330 | Reward:  0.091 | Value:  0.173 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6909
+[ 39.8%] Iter  243/610 | SPS: 27332 | Reward:  0.090 | Value:  0.179 | VLoss: 0.0489 | PLoss: -0.0001 | Ent: 0.6904
+[ 40.0%] Iter  244/610 | SPS: 27333 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0484 | PLoss: -0.0004 | Ent: 0.6888
+[ 40.2%] Iter  245/610 | SPS: 27335 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0493 | PLoss: -0.0009 | Ent: 0.6862
+[ 40.3%] Iter  246/610 | SPS: 27337 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6848
+[ 40.5%] Iter  247/610 | SPS: 27339 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6842
+[ 40.7%] Iter  248/610 | SPS: 27340 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0502 | PLoss: -0.0001 | Ent: 0.6841
+[ 40.8%] Iter  249/610 | SPS: 27341 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6848
+[ 41.0%] Iter  250/610 | SPS: 27342 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0466 | PLoss: -0.0002 | Ent: 0.6832
+[ 41.1%] Iter  251/610 | SPS: 27342 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0467 | PLoss: -0.0002 | Ent: 0.6818
+[ 41.3%] Iter  252/610 | SPS: 27340 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6823
+[ 41.5%] Iter  253/610 | SPS: 27338 | Reward:  0.091 | Value:  0.176 | VLoss: 0.0499 | PLoss: -0.0001 | Ent: 0.6833
+[ 41.6%] Iter  254/610 | SPS: 27339 | Reward:  0.087 | Value:  0.181 | VLoss: 0.0480 | PLoss: -0.0001 | Ent: 0.6834
+[ 41.8%] Iter  255/610 | SPS: 27305 | Reward:  0.091 | Value:  0.171 | VLoss: 0.0483 | PLoss: -0.0005 | Ent: 0.6821
+[ 42.0%] Iter  256/610 | SPS: 27306 | Reward:  0.086 | Value:  0.182 | VLoss: 0.0462 | PLoss: -0.0003 | Ent: 0.6818
+[ 42.1%] Iter  257/610 | SPS: 27306 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0478 | PLoss: 0.0003 | Ent: 0.6837
+[ 42.3%] Iter  258/610 | SPS: 27307 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0489 | PLoss: -0.0001 | Ent: 0.6854
+[ 42.5%] Iter  259/610 | SPS: 27307 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6850
+[ 42.6%] Iter  260/610 | SPS: 27308 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0463 | PLoss: 0.0000 | Ent: 0.6850
+[ 42.8%] Iter  261/610 | SPS: 27309 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0445 | PLoss: -0.0004 | Ent: 0.6841
+[ 43.0%] Iter  262/610 | SPS: 27310 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6839
+[ 43.1%] Iter  263/610 | SPS: 27310 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0499 | PLoss: -0.0003 | Ent: 0.6819
+[ 43.3%] Iter  264/610 | SPS: 27311 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6822
+[ 43.4%] Iter  265/610 | SPS: 27311 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0462 | PLoss: 0.0002 | Ent: 0.6851
+[ 43.6%] Iter  266/610 | SPS: 27311 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6860
+[ 43.8%] Iter  267/610 | SPS: 27311 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0453 | PLoss: 0.0000 | Ent: 0.6865
+[ 43.9%] Iter  268/610 | SPS: 27311 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0482 | PLoss: 0.0001 | Ent: 0.6874
+[ 44.1%] Iter  269/610 | SPS: 27309 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0457 | PLoss: -0.0002 | Ent: 0.6883
+[ 44.3%] Iter  270/610 | SPS: 27310 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6886
+[ 44.4%] Iter  271/610 | SPS: 27310 | Reward:  0.087 | Value:  0.181 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6880
+[ 44.6%] Iter  272/610 | SPS: 27311 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0440 | PLoss: -0.0001 | Ent: 0.6871
+[ 44.8%] Iter  273/610 | SPS: 27311 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6873
+[ 44.9%] Iter  274/610 | SPS: 27312 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6868
+[ 45.1%] Iter  275/610 | SPS: 27313 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6859
+[ 45.2%] Iter  276/610 | SPS: 27314 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0496 | PLoss: -0.0002 | Ent: 0.6870
+[ 45.4%] Iter  277/610 | SPS: 27315 | Reward:  0.086 | Value:  0.179 | VLoss: 0.0453 | PLoss: -0.0001 | Ent: 0.6873
+[ 45.6%] Iter  278/610 | SPS: 27316 | Reward:  0.082 | Value:  0.172 | VLoss: 0.0427 | PLoss: -0.0000 | Ent: 0.6880
+[ 45.7%] Iter  279/610 | SPS: 27316 | Reward:  0.087 | Value:  0.164 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6886
+[ 45.9%] Iter  280/610 | SPS: 27317 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0482 | PLoss: 0.0001 | Ent: 0.6887
+[ 46.1%] Iter  281/610 | SPS: 27317 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0454 | PLoss: -0.0002 | Ent: 0.6879
+[ 46.2%] Iter  282/610 | SPS: 27317 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6865
+[ 46.4%] Iter  283/610 | SPS: 27318 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6869
+[ 46.6%] Iter  284/610 | SPS: 27319 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0465 | PLoss: -0.0004 | Ent: 0.6882
+[ 46.7%] Iter  285/610 | SPS: 27317 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6894
+[ 46.9%] Iter  286/610 | SPS: 27316 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0438 | PLoss: -0.0001 | Ent: 0.6896
+[ 47.0%] Iter  287/610 | SPS: 27316 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0432 | PLoss: -0.0000 | Ent: 0.6897
+[ 47.2%] Iter  288/610 | SPS: 27316 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0485 | PLoss: -0.0001 | Ent: 0.6906
+[ 47.4%] Iter  289/610 | SPS: 27317 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0459 | PLoss: 0.0001 | Ent: 0.6911
+[ 47.5%] Iter  290/610 | SPS: 27318 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0460 | PLoss: 0.0000 | Ent: 0.6915
+[ 47.7%] Iter  291/610 | SPS: 27319 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0458 | PLoss: -0.0001 | Ent: 0.6918
+[ 47.9%] Iter  292/610 | SPS: 27320 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0476 | PLoss: 0.0001 | Ent: 0.6922
+[ 48.0%] Iter  293/610 | SPS: 27320 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6922
+[ 48.2%] Iter  294/610 | SPS: 27321 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6921
+[ 48.4%] Iter  295/610 | SPS: 27323 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6919
+[ 48.5%] Iter  296/610 | SPS: 27324 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0480 | PLoss: 0.0000 | Ent: 0.6922
+[ 48.7%] Iter  297/610 | SPS: 27324 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0503 | PLoss: -0.0000 | Ent: 0.6923
+[ 48.9%] Iter  298/610 | SPS: 27325 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0498 | PLoss: 0.0000 | Ent: 0.6923
+[ 49.0%] Iter  299/610 | SPS: 27325 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0508 | PLoss: -0.0001 | Ent: 0.6924
+[ 49.2%] Iter  300/610 | SPS: 27325 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6924
+[ 49.3%] Iter  301/610 | SPS: 27326 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0488 | PLoss: -0.0001 | Ent: 0.6923
+[ 49.5%] Iter  302/610 | SPS: 27325 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6921
+[ 49.7%] Iter  303/610 | SPS: 27325 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0466 | PLoss: -0.0001 | Ent: 0.6923
+[ 49.8%] Iter  304/610 | SPS: 27327 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6923
+[ 50.0%] Iter  305/610 | SPS: 27328 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0449 | PLoss: 0.0000 | Ent: 0.6922
+[ 50.2%] Iter  306/610 | SPS: 27329 | Reward:  0.087 | Value:  0.167 | VLoss: 0.0478 | PLoss: -0.0003 | Ent: 0.6920
+[ 50.3%] Iter  307/610 | SPS: 27331 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6917
+[ 50.5%] Iter  308/610 | SPS: 27332 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6919
+[ 50.7%] Iter  309/610 | SPS: 27334 | Reward:  0.086 | Value:  0.179 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6921
+[ 50.8%] Iter  310/610 | SPS: 27335 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6921
+[ 51.0%] Iter  311/610 | SPS: 27336 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6922
+[ 51.1%] Iter  312/610 | SPS: 27338 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6925
+[ 51.3%] Iter  313/610 | SPS: 27340 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0492 | PLoss: -0.0001 | Ent: 0.6925
+[ 51.5%] Iter  314/610 | SPS: 27342 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6924
+[ 51.6%] Iter  315/610 | SPS: 27342 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6924
+[ 51.8%] Iter  316/610 | SPS: 27343 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6927
+[ 52.0%] Iter  317/610 | SPS: 27344 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0423 | PLoss: -0.0000 | Ent: 0.6926
+[ 52.1%] Iter  318/610 | SPS: 27345 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6926
+[ 52.3%] Iter  319/610 | SPS: 27345 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0453 | PLoss: 0.0000 | Ent: 0.6927
+[ 52.5%] Iter  320/610 | SPS: 27345 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6927
+[ 52.6%] Iter  321/610 | SPS: 27346 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0495 | PLoss: 0.0000 | Ent: 0.6927
+[ 52.8%] Iter  322/610 | SPS: 27347 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6926
+[ 53.0%] Iter  323/610 | SPS: 27348 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0474 | PLoss: -0.0001 | Ent: 0.6924
+[ 53.1%] Iter  324/610 | SPS: 27349 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0495 | PLoss: -0.0000 | Ent: 0.6924
+[ 53.3%] Iter  325/610 | SPS: 27350 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6924
+[ 53.4%] Iter  326/610 | SPS: 27351 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6923
+[ 53.6%] Iter  327/610 | SPS: 27353 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0500 | PLoss: -0.0000 | Ent: 0.6920
+[ 53.8%] Iter  328/610 | SPS: 27353 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0453 | PLoss: -0.0002 | Ent: 0.6923
+[ 53.9%] Iter  329/610 | SPS: 27354 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6925
+[ 54.1%] Iter  330/610 | SPS: 27355 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6927
+[ 54.3%] Iter  331/610 | SPS: 27356 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0492 | PLoss: -0.0000 | Ent: 0.6928
+[ 54.4%] Iter  332/610 | SPS: 27357 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6928
+[ 54.6%] Iter  333/610 | SPS: 27357 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6928
+[ 54.8%] Iter  334/610 | SPS: 27359 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6930
+[ 54.9%] Iter  335/610 | SPS: 27359 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6930
+[ 55.1%] Iter  336/610 | SPS: 27358 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0460 | PLoss: 0.0001 | Ent: 0.6931
+[ 55.2%] Iter  337/610 | SPS: 27358 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0467 | PLoss: 0.0000 | Ent: 0.6931
+[ 55.4%] Iter  338/610 | SPS: 27359 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6931
+[ 55.6%] Iter  339/610 | SPS: 27360 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0444 | PLoss: 0.0000 | Ent: 0.6931
+[ 55.7%] Iter  340/610 | SPS: 27361 | Reward:  0.084 | Value:  0.168 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6931
+[ 55.9%] Iter  341/610 | SPS: 27362 | Reward:  0.086 | Value:  0.166 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[ 56.1%] Iter  342/610 | SPS: 27363 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0439 | PLoss: -0.0001 | Ent: 0.6931
+[ 56.2%] Iter  343/610 | SPS: 27365 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0450 | PLoss: 0.0000 | Ent: 0.6931
+[ 56.4%] Iter  344/610 | SPS: 27366 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6931
+[ 56.6%] Iter  345/610 | SPS: 27367 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6931
+[ 56.7%] Iter  346/610 | SPS: 27368 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6930
+[ 56.9%] Iter  347/610 | SPS: 27369 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6929
+[ 57.0%] Iter  348/610 | SPS: 27370 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0474 | PLoss: -0.0001 | Ent: 0.6928
+[ 57.2%] Iter  349/610 | SPS: 27371 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0437 | PLoss: -0.0000 | Ent: 0.6928
+[ 57.4%] Iter  350/610 | SPS: 27372 | Reward:  0.087 | Value:  0.166 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6928
+[ 57.5%] Iter  351/610 | SPS: 27373 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0456 | PLoss: 0.0000 | Ent: 0.6928
+[ 57.7%] Iter  352/610 | SPS: 27374 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6927
+[ 57.9%] Iter  353/610 | SPS: 27372 | Reward:  0.091 | Value:  0.174 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6927
+[ 58.0%] Iter  354/610 | SPS: 27373 | Reward:  0.088 | Value:  0.182 | VLoss: 0.0455 | PLoss: -0.0002 | Ent: 0.6928
+[ 58.2%] Iter  355/610 | SPS: 27373 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0467 | PLoss: 0.0001 | Ent: 0.6930
+[ 58.4%] Iter  356/610 | SPS: 27374 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6930
+[ 58.5%] Iter  357/610 | SPS: 27374 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0482 | PLoss: -0.0001 | Ent: 0.6929
+[ 58.7%] Iter  358/610 | SPS: 27375 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6929
+[ 58.9%] Iter  359/610 | SPS: 27375 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0457 | PLoss: 0.0001 | Ent: 0.6930
+[ 59.0%] Iter  360/610 | SPS: 27376 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.2%] Iter  361/610 | SPS: 27376 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.3%] Iter  362/610 | SPS: 27377 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0460 | PLoss: 0.0000 | Ent: 0.6931
+[ 59.5%] Iter  363/610 | SPS: 27377 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6931
+[ 59.7%] Iter  364/610 | SPS: 27378 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0442 | PLoss: 0.0000 | Ent: 0.6931
+[ 59.8%] Iter  365/610 | SPS: 27377 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6931
+[ 60.0%] Iter  366/610 | SPS: 27378 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0447 | PLoss: -0.0001 | Ent: 0.6931
+[ 60.2%] Iter  367/610 | SPS: 27378 | Reward:  0.083 | Value:  0.177 | VLoss: 0.0439 | PLoss: 0.0000 | Ent: 0.6931
+[ 60.3%] Iter  368/610 | SPS: 27378 | Reward:  0.087 | Value:  0.165 | VLoss: 0.0437 | PLoss: -0.0000 | Ent: 0.6931
+[ 60.5%] Iter  369/610 | SPS: 27378 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6931
+[ 60.7%] Iter  370/610 | SPS: 27377 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 60.8%] Iter  371/610 | SPS: 27377 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0433 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.0%] Iter  372/610 | SPS: 27377 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0433 | PLoss: 0.0000 | Ent: 0.6931
+[ 61.1%] Iter  373/610 | SPS: 27378 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.3%] Iter  374/610 | SPS: 27378 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.5%] Iter  375/610 | SPS: 27379 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.6%] Iter  376/610 | SPS: 27380 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6931
+[ 61.8%] Iter  377/610 | SPS: 27380 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.0%] Iter  378/610 | SPS: 27381 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6931
+[ 62.1%] Iter  379/610 | SPS: 27382 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.3%] Iter  380/610 | SPS: 27383 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0480 | PLoss: -0.0001 | Ent: 0.6931
+[ 62.5%] Iter  381/610 | SPS: 27383 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.6%] Iter  382/610 | SPS: 27384 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.8%] Iter  383/610 | SPS: 27385 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.0%] Iter  384/610 | SPS: 27386 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.1%] Iter  385/610 | SPS: 27387 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0447 | PLoss: 0.0000 | Ent: 0.6931
+[ 63.3%] Iter  386/610 | SPS: 27387 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0488 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.4%] Iter  387/610 | SPS: 27387 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0448 | PLoss: 0.0000 | Ent: 0.6931
+[ 63.6%] Iter  388/610 | SPS: 27388 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6931
+[ 63.8%] Iter  389/610 | SPS: 27389 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.9%] Iter  390/610 | SPS: 27390 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0479 | PLoss: 0.0000 | Ent: 0.6931
+[ 64.1%] Iter  391/610 | SPS: 27391 | Reward:  0.091 | Value:  0.176 | VLoss: 0.0502 | PLoss: -0.0000 | Ent: 0.6931
+[ 64.3%] Iter  392/610 | SPS: 27392 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6931
+[ 64.4%] Iter  393/610 | SPS: 27392 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0459 | PLoss: 0.0000 | Ent: 0.6931
+[ 64.6%] Iter  394/610 | SPS: 27392 | Reward:  0.085 | Value:  0.165 | VLoss: 0.0445 | PLoss: -0.0000 | Ent: 0.6931
+[ 64.8%] Iter  395/610 | SPS: 27393 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6931
+[ 64.9%] Iter  396/610 | SPS: 27393 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0483 | PLoss: -0.0001 | Ent: 0.6931
+[ 65.1%] Iter  397/610 | SPS: 27393 | Reward:  0.088 | Value:  0.181 | VLoss: 0.0467 | PLoss: -0.0001 | Ent: 0.6930
+[ 65.2%] Iter  398/610 | SPS: 27394 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6930
+[ 65.4%] Iter  399/610 | SPS: 27394 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6930
+[ 65.6%] Iter  400/610 | SPS: 27393 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0459 | PLoss: 0.0000 | Ent: 0.6931
+[ 65.7%] Iter  401/610 | SPS: 27393 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.9%] Iter  402/610 | SPS: 27393 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6931
+[ 66.1%] Iter  403/610 | SPS: 27393 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6931
+[ 66.2%] Iter  404/610 | SPS: 27393 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0509 | PLoss: -0.0001 | Ent: 0.6930
+[ 66.4%] Iter  405/610 | SPS: 27393 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6930
+[ 66.6%] Iter  406/610 | SPS: 27393 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6931
+[ 66.7%] Iter  407/610 | SPS: 27393 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0459 | PLoss: 0.0000 | Ent: 0.6931
+[ 66.9%] Iter  408/610 | SPS: 27393 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6931
+[ 67.0%] Iter  409/610 | SPS: 27393 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6931
+[ 67.2%] Iter  410/610 | SPS: 27393 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0474 | PLoss: -0.0001 | Ent: 0.6931
+[ 67.4%] Iter  411/610 | SPS: 27393 | Reward:  0.091 | Value:  0.181 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6931
+[ 67.5%] Iter  412/610 | SPS: 27394 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0467 | PLoss: 0.0000 | Ent: 0.6931
+[ 67.7%] Iter  413/610 | SPS: 27394 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6931
+[ 67.9%] Iter  414/610 | SPS: 27394 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 68.0%] Iter  415/610 | SPS: 27394 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6931
+[ 68.2%] Iter  416/610 | SPS: 27394 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6931
+[ 68.4%] Iter  417/610 | SPS: 27394 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6931
+[ 68.5%] Iter  418/610 | SPS: 27395 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6931
+[ 68.7%] Iter  419/610 | SPS: 27395 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6931
+[ 68.9%] Iter  420/610 | SPS: 27393 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0452 | PLoss: 0.0000 | Ent: 0.6931
+[ 69.0%] Iter  421/610 | SPS: 27393 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6931
+[ 69.2%] Iter  422/610 | SPS: 27393 | Reward:  0.084 | Value:  0.171 | VLoss: 0.0434 | PLoss: -0.0000 | Ent: 0.6931
+[ 69.3%] Iter  423/610 | SPS: 27393 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6931
+[ 69.5%] Iter  424/610 | SPS: 27393 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0472 | PLoss: 0.0000 | Ent: 0.6931
+[ 69.7%] Iter  425/610 | SPS: 27393 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0450 | PLoss: 0.0000 | Ent: 0.6931
+[ 69.8%] Iter  426/610 | SPS: 27393 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6931
+[ 70.0%] Iter  427/610 | SPS: 27393 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6931
+[ 70.2%] Iter  428/610 | SPS: 27393 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6931
+[ 70.3%] Iter  429/610 | SPS: 27393 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6931
+[ 70.5%] Iter  430/610 | SPS: 27393 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 70.7%] Iter  431/610 | SPS: 27394 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0445 | PLoss: -0.0000 | Ent: 0.6931
+[ 70.8%] Iter  432/610 | SPS: 27394 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6931
+[ 71.0%] Iter  433/610 | SPS: 27394 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0482 | PLoss: 0.0000 | Ent: 0.6931
+[ 71.1%] Iter  434/610 | SPS: 27394 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6931
+[ 71.3%] Iter  435/610 | SPS: 27395 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6931
+[ 71.5%] Iter  436/610 | SPS: 27394 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6931
+[ 71.6%] Iter  437/610 | SPS: 27393 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6931
+[ 71.8%] Iter  438/610 | SPS: 27393 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6931
+[ 72.0%] Iter  439/610 | SPS: 27394 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6931
+[ 72.1%] Iter  440/610 | SPS: 27394 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0453 | PLoss: 0.0000 | Ent: 0.6931
+[ 72.3%] Iter  441/610 | SPS: 27394 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6931
+[ 72.5%] Iter  442/610 | SPS: 27394 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6931
+[ 72.6%] Iter  443/610 | SPS: 27394 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6931
+[ 72.8%] Iter  444/610 | SPS: 27394 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6931
+[ 73.0%] Iter  445/610 | SPS: 27395 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6931
+[ 73.1%] Iter  446/610 | SPS: 27395 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6931
+[ 73.3%] Iter  447/610 | SPS: 27395 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6931
+[ 73.4%] Iter  448/610 | SPS: 27395 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6931
+[ 73.6%] Iter  449/610 | SPS: 27395 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6931
+[ 73.8%] Iter  450/610 | SPS: 27396 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6931
+[ 73.9%] Iter  451/610 | SPS: 27396 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6931
+[ 74.1%] Iter  452/610 | SPS: 27396 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0482 | PLoss: 0.0000 | Ent: 0.6931
+[ 74.3%] Iter  453/610 | SPS: 27396 | Reward:  0.091 | Value:  0.178 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6931
+[ 74.4%] Iter  454/610 | SPS: 27395 | Reward:  0.087 | Value:  0.181 | VLoss: 0.0456 | PLoss: -0.0001 | Ent: 0.6931
+[ 74.6%] Iter  455/610 | SPS: 27395 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0459 | PLoss: -0.0001 | Ent: 0.6931
+[ 74.8%] Iter  456/610 | SPS: 27395 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6930
+[ 74.9%] Iter  457/610 | SPS: 27395 | Reward:  0.084 | Value:  0.175 | VLoss: 0.0461 | PLoss: -0.0001 | Ent: 0.6930
+[ 75.1%] Iter  458/610 | SPS: 27396 | Reward:  0.090 | Value:  0.166 | VLoss: 0.0522 | PLoss: -0.0000 | Ent: 0.6930
+[ 75.2%] Iter  459/610 | SPS: 27396 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6930
+[ 75.4%] Iter  460/610 | SPS: 27396 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6931
+[ 75.6%] Iter  461/610 | SPS: 27396 | Reward:  0.083 | Value:  0.171 | VLoss: 0.0405 | PLoss: 0.0000 | Ent: 0.6931
+[ 75.7%] Iter  462/610 | SPS: 27396 | Reward:  0.090 | Value:  0.165 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6931
+[ 75.9%] Iter  463/610 | SPS: 27397 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6931
+[ 76.1%] Iter  464/610 | SPS: 27398 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6931
+[ 76.2%] Iter  465/610 | SPS: 27399 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6931
+[ 76.4%] Iter  466/610 | SPS: 27400 | Reward:  0.090 | Value:  0.177 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6931
+[ 76.6%] Iter  467/610 | SPS: 27401 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6930
+[ 76.7%] Iter  468/610 | SPS: 27402 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0459 | PLoss: 0.0000 | Ent: 0.6930
+[ 76.9%] Iter  469/610 | SPS: 27402 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6929
+[ 77.0%] Iter  470/610 | SPS: 27403 | Reward:  0.091 | Value:  0.173 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6929
+[ 77.2%] Iter  471/610 | SPS: 27403 | Reward:  0.087 | Value:  0.182 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6929
+[ 77.4%] Iter  472/610 | SPS: 27404 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0479 | PLoss: -0.0001 | Ent: 0.6930
+[ 77.5%] Iter  473/610 | SPS: 27405 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6930
+[ 77.7%] Iter  474/610 | SPS: 27407 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6929
+[ 77.9%] Iter  475/610 | SPS: 27407 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6929
+[ 78.0%] Iter  476/610 | SPS: 27407 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0436 | PLoss: -0.0000 | Ent: 0.6929
+[ 78.2%] Iter  477/610 | SPS: 27407 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0450 | PLoss: 0.0000 | Ent: 0.6929
+[ 78.4%] Iter  478/610 | SPS: 27407 | Reward:  0.088 | Value:  0.167 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6929
+[ 78.5%] Iter  479/610 | SPS: 27408 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0420 | PLoss: -0.0001 | Ent: 0.6928
+[ 78.7%] Iter  480/610 | SPS: 27408 | Reward:  0.085 | Value:  0.170 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6926
+[ 78.9%] Iter  481/610 | SPS: 27409 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6926
+[ 79.0%] Iter  482/610 | SPS: 27409 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6926
+[ 79.2%] Iter  483/610 | SPS: 27409 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6925
+[ 79.3%] Iter  484/610 | SPS: 27409 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0462 | PLoss: -0.0000 | Ent: 0.6925
+[ 79.5%] Iter  485/610 | SPS: 27409 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6926
+[ 79.7%] Iter  486/610 | SPS: 27409 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6926
+[ 79.8%] Iter  487/610 | SPS: 27409 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0477 | PLoss: -0.0000 | Ent: 0.6926
+[ 80.0%] Iter  488/610 | SPS: 27409 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6926
+[ 80.2%] Iter  489/610 | SPS: 27409 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6926
+[ 80.3%] Iter  490/610 | SPS: 27409 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0506 | PLoss: -0.0000 | Ent: 0.6925
+[ 80.5%] Iter  491/610 | SPS: 27410 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0467 | PLoss: 0.0000 | Ent: 0.6924
+[ 80.7%] Iter  492/610 | SPS: 27410 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0438 | PLoss: -0.0000 | Ent: 0.6924
+[ 80.8%] Iter  493/610 | SPS: 27410 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6925
+[ 81.0%] Iter  494/610 | SPS: 27411 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0483 | PLoss: 0.0000 | Ent: 0.6926
+[ 81.1%] Iter  495/610 | SPS: 27412 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0503 | PLoss: -0.0001 | Ent: 0.6927
+[ 81.3%] Iter  496/610 | SPS: 27413 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6928
+[ 81.5%] Iter  497/610 | SPS: 27414 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6929
+[ 81.6%] Iter  498/610 | SPS: 27415 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0436 | PLoss: 0.0000 | Ent: 0.6929
+[ 81.8%] Iter  499/610 | SPS: 27417 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6929
+[ 82.0%] Iter  500/610 | SPS: 27418 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6929
+[ 82.1%] Iter  501/610 | SPS: 27418 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6929
+[ 82.3%] Iter  502/610 | SPS: 27419 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6929
+[ 82.5%] Iter  503/610 | SPS: 27420 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6929
+[ 82.6%] Iter  504/610 | SPS: 27420 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0482 | PLoss: 0.0000 | Ent: 0.6929
+[ 82.8%] Iter  505/610 | SPS: 27420 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0481 | PLoss: -0.0001 | Ent: 0.6930
+[ 83.0%] Iter  506/610 | SPS: 27421 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.1%] Iter  507/610 | SPS: 27423 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.3%] Iter  508/610 | SPS: 27424 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.4%] Iter  509/610 | SPS: 27425 | Reward:  0.089 | Value:  0.169 | VLoss: 0.0509 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.6%] Iter  510/610 | SPS: 27426 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.8%] Iter  511/610 | SPS: 27427 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6930
+[ 83.9%] Iter  512/610 | SPS: 27428 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0484 | PLoss: 0.0000 | Ent: 0.6930
+[ 84.1%] Iter  513/610 | SPS: 27429 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6930
+[ 84.3%] Iter  514/610 | SPS: 27429 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0446 | PLoss: -0.0000 | Ent: 0.6930
+[ 84.4%] Iter  515/610 | SPS: 27430 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0424 | PLoss: 0.0000 | Ent: 0.6930
+[ 84.6%] Iter  516/610 | SPS: 27431 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6930
+[ 84.8%] Iter  517/610 | SPS: 27432 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6929
+[ 84.9%] Iter  518/610 | SPS: 27432 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6929
+[ 85.1%] Iter  519/610 | SPS: 27433 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0462 | PLoss: -0.0000 | Ent: 0.6928
+[ 85.2%] Iter  520/610 | SPS: 27434 | Reward:  0.084 | Value:  0.176 | VLoss: 0.0423 | PLoss: 0.0000 | Ent: 0.6928
+[ 85.4%] Iter  521/610 | SPS: 27434 | Reward:  0.085 | Value:  0.166 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6928
+[ 85.6%] Iter  522/610 | SPS: 27434 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0477 | PLoss: 0.0000 | Ent: 0.6928
+[ 85.7%] Iter  523/610 | SPS: 27434 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6929
+[ 85.9%] Iter  524/610 | SPS: 27434 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6929
+[ 86.1%] Iter  525/610 | SPS: 27434 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6929
+[ 86.2%] Iter  526/610 | SPS: 27434 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6929
+[ 86.4%] Iter  527/610 | SPS: 27434 | Reward:  0.084 | Value:  0.176 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6929
+[ 86.6%] Iter  528/610 | SPS: 27434 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0495 | PLoss: 0.0000 | Ent: 0.6930
+[ 86.7%] Iter  529/610 | SPS: 27434 | Reward:  0.084 | Value:  0.175 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6930
+[ 86.9%] Iter  530/610 | SPS: 27434 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0498 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.0%] Iter  531/610 | SPS: 27434 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.2%] Iter  532/610 | SPS: 27434 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.4%] Iter  533/610 | SPS: 27435 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.5%] Iter  534/610 | SPS: 27436 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.7%] Iter  535/610 | SPS: 27437 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6930
+[ 87.9%] Iter  536/610 | SPS: 27438 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6930
+[ 88.0%] Iter  537/610 | SPS: 27425 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6930
+[ 88.2%] Iter  538/610 | SPS: 27411 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6930
+[ 88.4%] Iter  539/610 | SPS: 27412 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6930
+[ 88.5%] Iter  540/610 | SPS: 27413 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6930
+[ 88.7%] Iter  541/610 | SPS: 27414 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6930
+[ 88.9%] Iter  542/610 | SPS: 27415 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6930
+[ 89.0%] Iter  543/610 | SPS: 27416 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6930
+[ 89.2%] Iter  544/610 | SPS: 27417 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0437 | PLoss: 0.0000 | Ent: 0.6930
+[ 89.3%] Iter  545/610 | SPS: 27418 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6930
+[ 89.5%] Iter  546/610 | SPS: 27419 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6930
+[ 89.7%] Iter  547/610 | SPS: 27420 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[ 89.8%] Iter  548/610 | SPS: 27421 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[ 90.0%] Iter  549/610 | SPS: 27422 | Reward:  0.091 | Value:  0.173 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6930
+[ 90.2%] Iter  550/610 | SPS: 27423 | Reward:  0.090 | Value:  0.179 | VLoss: 0.0502 | PLoss: -0.0000 | Ent: 0.6930
+[ 90.3%] Iter  551/610 | SPS: 27423 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6930
+[ 90.5%] Iter  552/610 | SPS: 27424 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6930
+[ 90.7%] Iter  553/610 | SPS: 27425 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6930
+[ 90.8%] Iter  554/610 | SPS: 27425 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6930
+[ 91.0%] Iter  555/610 | SPS: 27425 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6930
+[ 91.1%] Iter  556/610 | SPS: 27426 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6930
+[ 91.3%] Iter  557/610 | SPS: 27427 | Reward:  0.091 | Value:  0.176 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6930
+[ 91.5%] Iter  558/610 | SPS: 27427 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[ 91.6%] Iter  559/610 | SPS: 27428 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0514 | PLoss: -0.0000 | Ent: 0.6930
+[ 91.8%] Iter  560/610 | SPS: 27429 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6930
+[ 92.0%] Iter  561/610 | SPS: 27430 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6930
+[ 92.1%] Iter  562/610 | SPS: 27431 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6930
+[ 92.3%] Iter  563/610 | SPS: 27432 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6930
+[ 92.5%] Iter  564/610 | SPS: 27432 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6929
+[ 92.6%] Iter  565/610 | SPS: 27433 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6930
+[ 92.8%] Iter  566/610 | SPS: 27434 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6929
+[ 93.0%] Iter  567/610 | SPS: 27435 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6929
+[ 93.1%] Iter  568/610 | SPS: 27436 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6929
+[ 93.3%] Iter  569/610 | SPS: 27437 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0463 | PLoss: 0.0000 | Ent: 0.6929
+[ 93.4%] Iter  570/610 | SPS: 27438 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6930
+[ 93.6%] Iter  571/610 | SPS: 27438 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6930
+[ 93.8%] Iter  572/610 | SPS: 27438 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6929
+[ 93.9%] Iter  573/610 | SPS: 27439 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6929
+[ 94.1%] Iter  574/610 | SPS: 27440 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6929
+[ 94.3%] Iter  575/610 | SPS: 27441 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0501 | PLoss: 0.0000 | Ent: 0.6929
+[ 94.4%] Iter  576/610 | SPS: 27441 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6929
+[ 94.6%] Iter  577/610 | SPS: 27442 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6929
+[ 94.8%] Iter  578/610 | SPS: 27443 | Reward:  0.089 | Value:  0.178 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6929
+[ 94.9%] Iter  579/610 | SPS: 27444 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0445 | PLoss: -0.0000 | Ent: 0.6929
+[ 95.1%] Iter  580/610 | SPS: 27444 | Reward:  0.091 | Value:  0.176 | VLoss: 0.0498 | PLoss: 0.0000 | Ent: 0.6929
+[ 95.2%] Iter  581/610 | SPS: 27445 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0444 | PLoss: -0.0000 | Ent: 0.6929
+[ 95.4%] Iter  582/610 | SPS: 27446 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6929
+[ 95.6%] Iter  583/610 | SPS: 27447 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0467 | PLoss: 0.0000 | Ent: 0.6929
+[ 95.7%] Iter  584/610 | SPS: 27448 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6929
+[ 95.9%] Iter  585/610 | SPS: 27449 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6930
+[ 96.1%] Iter  586/610 | SPS: 27450 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6930
+[ 96.2%] Iter  587/610 | SPS: 27450 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6930
+[ 96.4%] Iter  588/610 | SPS: 27450 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6930
+[ 96.6%] Iter  589/610 | SPS: 27450 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6930
+[ 96.7%] Iter  590/610 | SPS: 27451 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0495 | PLoss: -0.0000 | Ent: 0.6930
+[ 96.9%] Iter  591/610 | SPS: 27452 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0497 | PLoss: -0.0000 | Ent: 0.6930
+[ 97.0%] Iter  592/610 | SPS: 27452 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[ 97.2%] Iter  593/610 | SPS: 27453 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6930
+[ 97.4%] Iter  594/610 | SPS: 27454 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6930
+[ 97.5%] Iter  595/610 | SPS: 27454 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6930
+[ 97.7%] Iter  596/610 | SPS: 27455 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6930
+[ 97.9%] Iter  597/610 | SPS: 27456 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6930
+[ 98.0%] Iter  598/610 | SPS: 27457 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6930
+[ 98.2%] Iter  599/610 | SPS: 27458 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6930
+[ 98.4%] Iter  600/610 | SPS: 27458 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6930
+[ 98.5%] Iter  601/610 | SPS: 27459 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6930
+[ 98.7%] Iter  602/610 | SPS: 27460 | Reward:  0.084 | Value:  0.172 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6930
+[ 98.9%] Iter  603/610 | SPS: 27460 | Reward:  0.093 | Value:  0.171 | VLoss: 0.0519 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.0%] Iter  604/610 | SPS: 27461 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.2%] Iter  605/610 | SPS: 27461 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.3%] Iter  606/610 | SPS: 27461 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.5%] Iter  607/610 | SPS: 27462 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.7%] Iter  608/610 | SPS: 27463 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6930
+[ 99.8%] Iter  609/610 | SPS: 27463 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[100.0%] Iter  610/610 | SPS: 27464 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0440 | PLoss: 0.0000 | Ent: 0.6930

cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/files/requirements.txt

@@ -0,0 +1,305 @@
+ragen==0.1
+setuptools==80.9.0
+wheel==0.45.1
+pip==25.2
+zipp==3.23.0
+verl==0.2.0.dev0
+ragen==0.1
+triton==3.2.0
+nvidia-cusparselt-cu12==0.6.2
+mpmath==1.3.0
+typing_extensions==4.15.0
+sympy==1.13.1
+nvidia-nvtx-cu12==12.4.127
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nccl-cu12==2.21.5
+nvidia-curand-cu12==10.3.5.147
+nvidia-cufft-cu12==11.2.1.3
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cublas-cu12==12.4.5.8
+networkx==3.5
+MarkupSafe==2.1.5
+fsspec==2025.9.0
+filelock==3.19.1
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cudnn-cu12==9.1.0.70
+Jinja2==3.1.6
+nvidia-cusolver-cu12==11.6.1.9
+torch==2.6.0+cu124
+einops==0.8.1
+flash_attn==2.7.4.post1
+pytz==2025.2
+pyperclip==1.11.0
+pylatexenc==2.10
+pyjnius==1.7.0
+py-cpuinfo==9.0.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+gym-notices==0.1.0
+flatbuffers==25.9.23
+fastrlock==0.8.3
+Farama-Notifications==0.0.4
+cymem==2.0.11
+antlr4-python3-runtime==4.9.3
+xxhash==3.6.0
+wrapt==2.0.0
+Werkzeug==3.1.3
+websockets==15.0.1
+wcwidth==0.2.14
+wasabi==1.1.3
+uvloop==0.22.1
+urllib3==2.5.0
+tzdata==2025.2
+typing-inspection==0.4.2
+traitlets==5.14.3
+tqdm==4.67.1
+threadpoolctl==3.6.0
+tabulate==0.9.0
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8
+sniffio==1.3.1
+smmap==5.0.2
+six==1.17.0
+shellingham==1.5.4
+sentencepiece==0.2.1
+safetensors==0.6.2
+rpds-py==0.28.0
+rignore==0.7.6
+regex==2025.11.3
+RapidFuzz==3.14.3
+pyzmq==27.1.0
+PyYAML==6.0.3
+pytokens==0.3.0
+python-multipart==0.0.20
+python-json-logger==4.0.0
+python-dotenv==1.2.1
+PySocks==1.7.1
+pyparsing==3.2.5
+PyJWT==2.10.1
+Pygments==2.19.2
+pygame==2.6.1
+pydantic_core==2.41.5
+pycparser==2.23
+pycountry==24.6.1
+pybind11==3.0.1
+pyarrow==22.0.0
+psutil==7.1.3
+protobuf==6.33.0
+propcache==0.4.1
+prometheus_client==0.23.1
+platformdirs==4.5.0
+pillow==11.3.0
+pexpect==4.9.0
+pathvalidate==3.3.1
+pathspec==0.12.1
+pathable==0.4.4
+partial-json-parser==0.2.1.1.post6
+parso==0.8.5
+packaging==25.0
+orjson==3.11.4
+numpy==1.26.4
+ninja==1.13.0
+nest-asyncio==1.6.0
+mypy_extensions==1.1.0
+murmurhash==1.0.13
+multidict==6.7.0
+msgspec==0.19.0
+msgpack==1.1.2
+more-itertools==10.8.0
+mdurl==0.1.2
+marisa-trie==1.3.1
+llvmlite==0.43.0
+llguidance==0.7.30
+lark==1.2.2
+kiwisolver==1.4.9
+joblib==1.5.2
+jiter==0.11.1
+jeepney==0.9.0
+jaraco.context==6.0.1
+itsdangerous==2.2.0
+interegular==0.3.3
+idna==3.11
+humanfriendly==10.0
+httpx-sse==0.4.3
+httptools==0.7.1
+html2text==2025.4.15
+hf-xet==1.2.0
+h11==0.16.0
+frozenlist==1.8.0
+fonttools==4.60.1
+executing==2.2.1
+exceptiongroup==1.3.0
+eval_type_backport==0.2.2
+docutils==0.22.3
+docstring_parser==0.17.0
+dnspython==2.8.0
+distro==1.9.0
+diskcache==5.6.3
+dill==0.4.0
+decorator==5.2.1
+debugpy==1.8.17
+Cython==3.2.0
+cycler==0.12.1
+codetiming==1.4.0
+cloudpickle==3.1.2
+cloudpathlib==0.23.0
+click==8.2.1
+charset-normalizer==3.4.4
+certifi==2025.10.5
+catalogue==2.0.10
+cachetools==6.2.1
+blinker==1.9.0
+blake3==1.0.8
+beartype==0.22.5
+attrs==25.4.0
+asttokens==3.0.0
+astor==0.8.1
+annotated-types==0.7.0
+annotated-doc==0.0.3
+airportsdata==20250909
+aiohappyeyeballs==2.6.1
+yarl==1.22.0
+uvicorn==0.38.0
+typer-slim==0.20.0
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.1
+smart_open==7.4.4
+sentry-sdk==2.43.0
+scipy==1.16.3
+requests==2.32.5
+referencing==0.36.2
+rank-bm25==0.2.2
+python-dateutil==2.9.0.post0
+pydantic==2.12.4
+py-key-value-shared==0.2.8
+prompt_toolkit==3.0.52
+preshed==3.0.10
+opencv-python-headless==4.11.0.86
+omegaconf==2.3.0
+numba==0.60.0
+nltk==3.9.2
+multiprocess==0.70.18
+matplotlib-inline==0.2.1
+markdown-it-py==4.0.0
+language_data==1.3.0
+jedi==0.19.2
+jaraco.functools==4.3.0
+jaraco.classes==3.4.0
+ipython_pygments_lexers==1.1.1
+importlib_metadata==8.7.0
+ImageIO==2.37.2
+httpcore==1.0.9
+gymnasium==1.2.2
+gym==0.26.2
+gitdb==4.0.12
+gguf==0.10.0
+Flask==3.1.2
+faiss-cpu==1.12.0
+email-validator==2.3.0
+depyf==0.18.0
+cupy-cuda12x==13.6.0
+contourpy==1.3.3
+coloredlogs==15.0.1
+cffi==2.0.0
+blis==1.3.0
+black==25.9.0
+beautifulsoup4==4.14.2
+anyio==4.11.0
+aiosignal==1.4.0
+watchfiles==1.1.1
+tiktoken==0.12.0
+starlette==0.49.3
+sse-starlette==3.0.3
+scikit-learn==1.7.2
+rich==14.2.0
+pydantic-settings==2.11.0
+pydantic-extra-types==2.10.6
+py-key-value-aio==0.2.8
+pandas==2.3.3
+openapi-pydantic==0.5.1
+onnxruntime==1.23.2
+matplotlib==3.10.7
+lm-format-enforcer==0.10.12
+langcodes==3.5.0
+jsonschema-specifications==2025.9.1
+jsonschema-path==0.3.4
+ipython==9.7.0
+hydra-core==1.3.2
+huggingface-hub==0.36.0
+httpx==0.28.1
+gym-sokoban==0.0.6
+GitPython==3.1.45
+cryptography==46.0.3
+confection==0.1.5
+cleantext==1.1.4
+aiohttp==3.13.2
+xformers==0.0.29.post2
+weasel==0.4.2
+wandb==0.22.3
+typer==0.19.2
+torchvision==0.21.0
+torchdata==0.11.0
+torchaudio==2.6.0
+tokenizers==0.22.1
+thinc==8.3.7
+tensordict==0.8.3
+SecretStorage==3.4.0
+rich-toolkit==0.15.1
+rich-rst==1.3.2
+prometheus-fastapi-instrumentator==7.1.0
+openai==2.7.1
+jsonschema==4.25.1
+gdown==5.2.0
+fastapi==0.121.0
+Authlib==1.6.5
+anthropic==0.72.0
+accelerate==1.11.0
+transformers==4.57.1
+together==1.5.30
+spacy==3.8.7
+ray==2.51.1
+outlines_core==0.1.26
+mistral_common==1.8.5
+mcp==1.20.0
+keyring==25.6.0
+fastapi-cloud-cli==0.3.1
+fastapi-cli==0.0.14
+datasets==4.4.1
+cyclopts==4.2.1
+xgrammar==0.1.16
+peft==0.17.1
+outlines==0.1.11
+compressed-tensors==0.9.2
+fastmcp==2.13.0.2
+vllm==0.8.2
+pyserini==1.3.0
+typeguard==4.4.4
+shtab==1.7.2
+tyro==0.9.35
+tensorboard-data-server==0.7.2
+Markdown==3.10
+grpcio==1.76.0
+absl-py==2.3.1
+tensorboard==2.20.0
+ragen==0.1
+verl==0.2.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.0.0
+inflect==7.3.1
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+more-itertools==10.3.0
+packaging==24.2
+platformdirs==4.2.2
+tomli==2.0.1
+typeguard==4.3.0
+typing_extensions==4.12.2
+wheel==0.45.1
+zipp==3.19.2

cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/logs/debug-internal.log

@@ -0,0 +1,237 @@
+{"time":"2025-11-07T10:09:11.966826198+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T10:09:12.342225544+08:00","level":"INFO","msg":"stream: created new stream","id":"8xuf7idy"}
+{"time":"2025-11-07T10:09:12.342405699+08:00","level":"INFO","msg":"handler: started","stream_id":"8xuf7idy"}
+{"time":"2025-11-07T10:09:12.345368242+08:00","level":"INFO","msg":"stream: started","id":"8xuf7idy"}
+{"time":"2025-11-07T10:09:12.345387564+08:00","level":"INFO","msg":"writer: started","stream_id":"8xuf7idy"}
+{"time":"2025-11-07T10:09:12.345394576+08:00","level":"INFO","msg":"sender: started","stream_id":"8xuf7idy"}
+{"time":"2025-11-07T10:09:12.675299434+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T10:09:22.810401519+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T10:09:22.811137223+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__ppo_bandit__1__1762481344\")","namespace":""}
+{"time":"2025-11-07T10:09:22.812700965+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__ppo_bandit__1__1762481344/events.out.tfevents.1762481352.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.131665.0","runPath":"runs/Bandit__ppo_bandit__1__1762481344/events.out.tfevents.1762481352.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.131665.0"}
+{"time":"2025-11-07T10:09:22.81544715+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":82}
+{"time":"2025-11-07T10:09:22.81554868+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:09:22.815598042+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":114}
+{"time":"2025-11-07T10:09:22.818968124+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":428}
+{"time":"2025-11-07T10:09:27.822509065+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":594}
+{"time":"2025-11-07T10:09:28.148323264+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":281}
+{"time":"2025-11-07T10:09:32.828622741+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":925}
+{"time":"2025-11-07T10:09:32.828726578+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:09:32.829137611+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":957}
+{"time":"2025-11-07T10:09:32.831661291+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:09:42.842979832+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1623}
+{"time":"2025-11-07T10:09:43.158591355+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:09:47.848778763+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2085}
+{"time":"2025-11-07T10:09:47.848872784+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:09:47.849368143+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2117}
+{"time":"2025-11-07T10:09:47.853329609+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":152}
+{"time":"2025-11-07T10:09:52.855987214+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2320}
+{"time":"2025-11-07T10:09:52.856056786+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:09:52.856467985+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2352}
+{"time":"2025-11-07T10:09:52.858961503+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":245}
+{"time":"2025-11-07T10:09:57.862444736+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2650}
+{"time":"2025-11-07T10:09:58.175098246+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:10:02.869141467+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3018}
+{"time":"2025-11-07T10:10:02.869227383+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:02.86975056+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3050}
+{"time":"2025-11-07T10:10:02.872366834+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:10:07.876457838+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3347}
+{"time":"2025-11-07T10:10:07.876575967+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:07.876891994+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3379}
+{"time":"2025-11-07T10:10:07.87944904+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:10:12.882750276+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3716}
+{"time":"2025-11-07T10:10:13.072297571+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":279}
+{"time":"2025-11-07T10:10:22.896229902+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4414}
+{"time":"2025-11-07T10:10:22.896340216+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:22.896744337+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4446}
+{"time":"2025-11-07T10:10:22.900121026+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:10:27.904510442+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4743}
+{"time":"2025-11-07T10:10:28.157449561+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:10:32.931281796+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5123}
+{"time":"2025-11-07T10:10:32.931391826+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:32.931855488+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5155}
+{"time":"2025-11-07T10:10:32.935989943+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":236}
+{"time":"2025-11-07T10:10:37.938755169+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5440}
+{"time":"2025-11-07T10:10:37.93888417+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:37.939237843+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5472}
+{"time":"2025-11-07T10:10:37.94204248+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":247}
+{"time":"2025-11-07T10:10:42.945142652+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5772}
+{"time":"2025-11-07T10:10:43.099123604+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:10:47.954626916+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6265}
+{"time":"2025-11-07T10:10:47.954706268+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:47.955184557+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6297}
+{"time":"2025-11-07T10:10:47.956394614+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":121}
+{"time":"2025-11-07T10:10:52.960924481+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6614}
+{"time":"2025-11-07T10:10:52.960980558+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:10:52.961444009+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6646}
+{"time":"2025-11-07T10:10:52.963630532+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":141}
+{"time":"2025-11-07T10:10:57.967852858+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6838}
+{"time":"2025-11-07T10:10:58.06695384+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":279}
+{"time":"2025-11-07T10:11:02.974120659+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7168}
+{"time":"2025-11-07T10:11:02.974241971+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:02.975227134+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7201}
+{"time":"2025-11-07T10:11:02.977256695+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:11:07.980152756+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7568}
+{"time":"2025-11-07T10:11:07.980229786+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:07.980707581+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7600}
+{"time":"2025-11-07T10:11:07.982877998+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":155}
+{"time":"2025-11-07T10:11:12.994240702+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7824}
+{"time":"2025-11-07T10:11:13.160351751+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":279}
+{"time":"2025-11-07T10:11:18.002699541+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8154}
+{"time":"2025-11-07T10:11:18.002788149+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:18.003229269+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8186}
+{"time":"2025-11-07T10:11:18.005808172+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":245}
+{"time":"2025-11-07T10:11:23.010421518+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8483}
+{"time":"2025-11-07T10:11:23.014679182+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":317}
+{"time":"2025-11-07T10:11:28.019757498+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8851}
+{"time":"2025-11-07T10:11:28.075431015+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":281}
+{"time":"2025-11-07T10:11:33.026553411+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9192}
+{"time":"2025-11-07T10:11:33.026624538+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:33.027141253+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9224}
+{"time":"2025-11-07T10:11:33.031451151+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":275}
+{"time":"2025-11-07T10:11:38.038561028+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9601}
+{"time":"2025-11-07T10:11:38.038678348+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:38.039027821+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9633}
+{"time":"2025-11-07T10:11:38.040504549+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":194}
+{"time":"2025-11-07T10:11:43.046677526+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9877}
+{"time":"2025-11-07T10:11:43.06573047+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":321}
+{"time":"2025-11-07T10:11:48.053736852+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10304}
+{"time":"2025-11-07T10:11:48.053803012+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:48.054938099+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10337}
+{"time":"2025-11-07T10:11:48.05666238+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":189}
+{"time":"2025-11-07T10:11:53.060888105+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10665}
+{"time":"2025-11-07T10:11:53.060944679+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:11:53.061391772+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10697}
+{"time":"2025-11-07T10:11:53.063097501+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":157}
+{"time":"2025-11-07T10:12:03.092667398+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11335}
+{"time":"2025-11-07T10:12:03.092721576+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:03.093163508+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11367}
+{"time":"2025-11-07T10:12:03.094999483+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":186}
+{"time":"2025-11-07T10:12:08.100540689+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11603}
+{"time":"2025-11-07T10:12:08.100683211+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:08.101093087+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11635}
+{"time":"2025-11-07T10:12:08.104101991+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:12:13.108627845+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11932}
+{"time":"2025-11-07T10:12:13.112796809+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:12:23.120208627+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12631}
+{"time":"2025-11-07T10:12:23.120349654+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:23.120842427+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12663}
+{"time":"2025-11-07T10:12:23.123194297+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:12:28.127063984+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13071}
+{"time":"2025-11-07T10:12:28.127126888+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:28.12753951+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13103}
+{"time":"2025-11-07T10:12:28.129156841+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":176}
+{"time":"2025-11-07T10:12:33.134846093+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13351}
+{"time":"2025-11-07T10:12:33.134932231+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:33.135304256+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13383}
+{"time":"2025-11-07T10:12:33.137691215+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":232}
+{"time":"2025-11-07T10:12:38.158698045+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13813}
+{"time":"2025-11-07T10:12:38.158793146+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:38.159214256+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13845}
+{"time":"2025-11-07T10:12:38.160537232+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":131}
+{"time":"2025-11-07T10:12:43.165062325+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14028}
+{"time":"2025-11-07T10:12:43.165152442+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:43.165644175+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14060}
+{"time":"2025-11-07T10:12:43.167545893+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:12:48.171489906+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14357}
+{"time":"2025-11-07T10:12:48.171688673+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:48.171984157+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14389}
+{"time":"2025-11-07T10:12:48.175462994+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:12:53.180918259+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14725}
+{"time":"2025-11-07T10:12:53.181009051+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:53.181407852+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14757}
+{"time":"2025-11-07T10:12:53.184249723+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:12:58.188596289+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15084}
+{"time":"2025-11-07T10:12:58.188658496+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:12:58.189076631+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15116}
+{"time":"2025-11-07T10:12:58.192681825+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":258}
+{"time":"2025-11-07T10:13:03.196504848+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15424}
+{"time":"2025-11-07T10:13:03.196630701+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:03.197098842+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15456}
+{"time":"2025-11-07T10:13:03.199929985+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:13:18.221423379+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16509}
+{"time":"2025-11-07T10:13:18.221494321+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:18.221921307+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16541}
+{"time":"2025-11-07T10:13:18.223883783+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":188}
+{"time":"2025-11-07T10:13:23.228308162+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16783}
+{"time":"2025-11-07T10:13:23.228453474+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:23.228727631+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16815}
+{"time":"2025-11-07T10:13:23.231666988+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":283}
+{"time":"2025-11-07T10:13:28.236219887+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17300}
+{"time":"2025-11-07T10:13:28.236298051+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:28.23665126+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17332}
+{"time":"2025-11-07T10:13:28.237811871+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":96}
+{"time":"2025-11-07T10:13:43.258714416+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18213}
+{"time":"2025-11-07T10:13:43.25885979+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:43.259500985+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18245}
+{"time":"2025-11-07T10:13:43.261236795+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":210}
+{"time":"2025-11-07T10:13:48.265158923+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18543}
+{"time":"2025-11-07T10:13:48.265336635+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:48.265752339+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18575}
+{"time":"2025-11-07T10:13:48.268370012+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":249}
+{"time":"2025-11-07T10:13:53.272195814+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18874}
+{"time":"2025-11-07T10:13:53.272328834+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:53.272671318+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18906}
+{"time":"2025-11-07T10:13:53.276471403+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:13:58.280327443+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19305}
+{"time":"2025-11-07T10:13:58.280391127+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:13:58.280757709+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19337}
+{"time":"2025-11-07T10:13:58.282286802+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":186}
+{"time":"2025-11-07T10:14:08.294534894+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19952}
+{"time":"2025-11-07T10:14:08.294635147+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:08.295007424+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19984}
+{"time":"2025-11-07T10:14:08.297041354+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":195}
+{"time":"2025-11-07T10:14:13.301996538+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20232}
+{"time":"2025-11-07T10:14:13.302158576+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:13.302951633+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20265}
+{"time":"2025-11-07T10:14:13.305004383+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:14:18.310228549+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20599}
+{"time":"2025-11-07T10:14:18.310322321+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:18.310676475+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20631}
+{"time":"2025-11-07T10:14:18.313232224+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":247}
+{"time":"2025-11-07T10:14:23.317720376+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20929}
+{"time":"2025-11-07T10:14:23.317866228+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:23.318198118+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20961}
+{"time":"2025-11-07T10:14:23.320943116+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:14:28.327603484+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21496}
+{"time":"2025-11-07T10:14:28.327687895+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:28.328049086+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21528}
+{"time":"2025-11-07T10:14:28.328828301+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":49}
+{"time":"2025-11-07T10:14:33.333285025+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21630}
+{"time":"2025-11-07T10:14:33.33337794+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:33.333778835+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21662}
+{"time":"2025-11-07T10:14:33.337830594+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":284}
+{"time":"2025-11-07T10:14:38.341518497+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22142}
+{"time":"2025-11-07T10:14:38.341578698+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:38.342096344+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22174}
+{"time":"2025-11-07T10:14:38.34310572+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":100}
+{"time":"2025-11-07T10:14:43.348258984+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22497}
+{"time":"2025-11-07T10:14:43.348347545+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:43.348700883+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22529}
+{"time":"2025-11-07T10:14:43.349769283+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":75}
+{"time":"2025-11-07T10:14:48.353974971+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22680}
+{"time":"2025-11-07T10:14:48.354050306+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:48.354514355+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22712}
+{"time":"2025-11-07T10:14:48.357181845+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":261}
+{"time":"2025-11-07T10:14:53.361374066+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23023}
+{"time":"2025-11-07T10:14:53.361443277+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:53.361839829+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23055}
+{"time":"2025-11-07T10:14:53.364316471+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:14:58.369454725+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23440}
+{"time":"2025-11-07T10:14:58.369520979+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:14:58.369885747+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23472}
+{"time":"2025-11-07T10:14:58.371284742+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":200}
+{"time":"2025-11-07T10:15:08.386820073+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24052}
+{"time":"2025-11-07T10:15:08.386918709+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:15:08.387408289+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24084}
+{"time":"2025-11-07T10:15:08.391285708+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:15:13.396266192+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24544}
+{"time":"2025-11-07T10:15:13.396359183+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:15:13.396700881+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24576}
+{"time":"2025-11-07T10:15:13.398183342+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":123}
+{"time":"2025-11-07T10:15:18.219934261+08:00","level":"INFO","msg":"stream: closing","id":"8xuf7idy"}
+{"time":"2025-11-07T10:15:18.222879922+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24750}
+{"time":"2025-11-07T10:15:18.227486835+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:15:20.022975156+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T10:15:20.387206479+08:00","level":"INFO","msg":"handler: closed","stream_id":"8xuf7idy"}
+{"time":"2025-11-07T10:15:20.389093232+08:00","level":"INFO","msg":"sender: closed","stream_id":"8xuf7idy"}
+{"time":"2025-11-07T10:15:20.389196771+08:00","level":"INFO","msg":"stream: closed","id":"8xuf7idy"}

cleanrl/convert_test_results.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+Convert test results from one-hot vector format to human-readable 10x10 grid format.
+This makes the environment observations easier for LLM analysis.
+"""
+
+import json
+import numpy as np
+import os
+import argparse
+from pathlib import Path
+
+
+def decode_letter(one_hot_vector):
+    """Decode one-hot vector back to letter"""
+    letter_map = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'X'}
+    idx = np.argmax(one_hot_vector)
+    return letter_map.get(idx, '?')
+
+
+def parse_observation(obs_vector):
+    """
+    Parse observation vector into human-readable format.
+    
+    Observation structure (605 dimensions):
+    - Position (x, y): indices 0-1 (normalized to [0, 1])
+    - Energy: index 2 (normalized)
+    - Score: index 3
+    - Steps: index 4 (normalized)
+    - Grid state: indices 5-604 (10x10 grid, each cell has 6 one-hot values)
+    
+    Returns:
+        dict with parsed information
+    """
+    obs = np.array(obs_vector)
+    
+    # Extract position (denormalize from [0, 1] to [0, 9])
+    x = int(round(obs[0] * 9.0))
+    y = int(round(obs[1] * 9.0))
+    
+    # Extract other state info
+    energy = obs[2] * 20.0  # Denormalize energy
+    score = obs[3]
+    steps = obs[4] * 30.0  # Denormalize steps
+    
+    # Extract grid (10x10 grid with 6-dimensional one-hot encoding per cell)
+    grid_encoding = obs[5:]  # 600 values = 10x10x6
+    
+    # Reconstruct 10x10 grid
+    grid = []
+    for y_coord in range(10):
+        row = []
+        for x_coord in range(10):
+            # Each cell has 6 one-hot values
+            cell_idx = (y_coord * 10 + x_coord) * 6
+            one_hot = grid_encoding[cell_idx:cell_idx + 6]
+            letter = decode_letter(one_hot)
+            row.append(letter)
+        grid.append(row)
+    
+    return {
+        'position': {'x': x, 'y': y},
+        'energy': round(energy, 2),
+        'score': round(score, 2),
+        'steps': round(steps, 2),
+        'grid': grid
+    }
+
+
+def grid_to_string(grid, current_pos=None):
+    """
+    Convert grid to a formatted string representation.
+    If current_pos is provided, mark the agent's position with '@'.
+    
+    Coordinate system explanation:
+    - In env: grid[0] = y=9 (top), grid[9] = y=0 (bottom)
+    - In wrapper encoding: y_coord=0 -> env.grid[9], y_coord=9 -> env.grid[0]
+    - Our reconstructed grid[0] = env.grid[9] = env y=0 (bottom)
+    - Our reconstructed grid[9] = env.grid[0] = env y=9 (top)
+    - Display: Show y=0 at top, y=9 at bottom (array index order, matching typical grid display)
+    """
+    lines = []
+    lines.append("  " + " ".join(str(i) for i in range(10)))
+    lines.append("  " + "-" * 19)
+    
+    for display_row in range(10):
+        # Display from top to bottom: y=0, y=1, ..., y=9
+        env_y = display_row
+        row_str = f"{env_y}|"
+        for x in range(10):
+            # grid[env_y] has the data for env_y
+            if current_pos and current_pos['x'] == x and current_pos['y'] == env_y:
+                # Mark agent position
+                row_str += "@" + " "
+            else:
+                row_str += grid[env_y][x] + " "
+        lines.append(row_str)
+    
+    return "\n".join(lines)
+
+
+def convert_trajectory(trajectory):
+    """Convert a single trajectory to human-readable format"""
+    action_names = {0: 'up', 1: 'down', 2: 'left', 3: 'right'}
+    
+    # Extract energy values from all observations
+    energies = []
+    observations = []
+    
+    for i, obs_vector in enumerate(trajectory['observations']):
+        parsed_obs = parse_observation(obs_vector)
+        energies.append(parsed_obs['energy'])
+        
+        # Create a readable representation
+        readable_obs = {
+            'step': i,
+            'position': parsed_obs['position'],
+            'score': parsed_obs['score'],
+            'steps': parsed_obs['steps'],
+            'grid': parsed_obs['grid'],
+            'grid_string': grid_to_string(parsed_obs['grid'], parsed_obs['position'])
+        }
+        
+        # Add action taken at this step if available
+        if i < len(trajectory['actions']):
+            readable_obs['action'] = action_names.get(trajectory['actions'][i], 'unknown')
+            readable_obs['reward'] = trajectory['rewards'][i]
+        
+        observations.append(readable_obs)
+    
+    converted = {
+        'actions': trajectory['actions'],
+        'rewards': trajectory['rewards'],
+        'dones': trajectory['dones'],
+        'energies': energies,
+        'observations': observations
+    }
+    
+    return converted
+
+
+def convert_test_results(input_file, output_file=None):
+    """
+    Convert test results file from one-hot format to readable format.
+    
+    Args:
+        input_file: Path to input JSON file with test results
+        output_file: Path to output JSON file (if None, will add '_readable' suffix)
+    """
+    # Read input file
+    with open(input_file, 'r') as f:
+        data = json.load(f)
+    
+    # Convert trajectories
+    test_results = data['test_results']
+    converted_trajectories = []
+    
+    print(f"Converting {len(test_results['trajectories'])} trajectories...")
+    
+    for i, trajectory in enumerate(test_results['trajectories']):
+        print(f"  Processing trajectory {i+1}/{len(test_results['trajectories'])}...")
+        converted_traj = convert_trajectory(trajectory)
+        converted_trajectories.append(converted_traj)
+    
+    # Create output data structure
+    output_data = {
+        'iteration': data['iteration'],
+        'global_step': data['global_step'],
+        'training_progress': data['training_progress'],
+        'test_results': {
+            'episode_returns': test_results['episode_returns'],
+            'episode_lengths': test_results['episode_lengths'],
+            'final_scores': test_results['final_scores'],
+            'mean_return': test_results['mean_return'],
+            'std_return': test_results['std_return'],
+            'mean_length': test_results['mean_length'],
+            'mean_final_score': test_results['mean_final_score'],
+            'std_final_score': test_results['std_final_score'],
+            'trajectories': converted_trajectories
+        }
+    }
+    
+    # Determine output file path
+    if output_file is None:
+        input_path = Path(input_file)
+        output_file = input_path.parent / f"{input_path.stem}_readable{input_path.suffix}"
+    
+    # Write output file
+    with open(output_file, 'w') as f:
+        json.dump(output_data, f, indent=2)
+    
+    print(f"\nConversion complete!")
+    print(f"Output saved to: {output_file}")
+    print(f"File size: {os.path.getsize(output_file) / 1024:.2f} KB")
+    
+    return output_file
+
+
+def convert_all_test_results(runs_dir, pattern="test_iter_*.json"):
+    """
+    Convert all test result files in a runs directory.
+    
+    Args:
+        runs_dir: Path to runs directory
+        pattern: Glob pattern for test result files
+    """
+    runs_path = Path(runs_dir)
+    
+    # Find all test result files
+    test_files = list(runs_path.rglob(pattern))
+    
+    if not test_files:
+        print(f"No test result files found matching pattern '{pattern}' in {runs_dir}")
+        return
+    
+    print(f"Found {len(test_files)} test result files to convert\n")
+    
+    for i, test_file in enumerate(test_files, 1):
+        print(f"\n{'='*60}")
+        print(f"[{i}/{len(test_files)}] Converting: {test_file.name}")
+        print(f"{'='*60}")
+        
+        try:
+            convert_test_results(test_file)
+        except Exception as e:
+            print(f"Error converting {test_file}: {e}")
+            continue
+    
+    print(f"\n{'='*60}")
+    print(f"Batch conversion complete! Converted {len(test_files)} files.")
+    print(f"{'='*60}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert test results from one-hot format to readable 10x10 grid format"
+    )
+    parser.add_argument(
+        'input',
+        help='Input file or directory containing test results'
+    )
+    parser.add_argument(
+        '-o', '--output',
+        help='Output file path (only for single file conversion)',
+        default=None
+    )
+    parser.add_argument(
+        '-a', '--all',
+        action='store_true',
+        help='Convert all test result files in the directory'
+    )
+    parser.add_argument(
+        '-p', '--pattern',
+        default='test_iter_*.json',
+        help='Glob pattern for batch conversion (default: test_iter_*.json)'
+    )
+    
+    args = parser.parse_args()
+    
+    input_path = Path(args.input)
+    
+    if args.all or input_path.is_dir():
+        # Batch conversion
+        convert_all_test_results(input_path, args.pattern)
+    else:
+        # Single file conversion
+        if not input_path.exists():
+            print(f"Error: File not found: {input_path}")
+            return
+        
+        convert_test_results(input_path, args.output)
+
+
+if __name__ == "__main__":
+    main()

cleanrl/entrypoint.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+Xvfb :1 -screen 0 1024x768x24 -ac +extension GLX +render -noreset &> xvfb.log &
+export DISPLAY=:1
+set -e
+# bash -c "echo vm.overcommit_memory=1 >> /etc/sysctl.conf" && sysctl -p
+exec "$@"

cleanrl/mkdocs.yml

@@ -0,0 +1,120 @@
+site_name: CleanRL
+theme:
+  name: material
+  features:
+    # - navigation.instant
+    - navigation.tracking
+    # - navigation.tabs
+    # - navigation.tabs.sticky
+    - navigation.sections
+    - navigation.expand
+    - navigation.top
+    - search.suggest
+    - search.highlight
+  palette:
+    - media: "(prefers-color-scheme: dark)" 
+      scheme: slate
+      primary: teal
+      accent: light green
+      toggle:
+        icon: material/lightbulb
+        name: Switch to light mode
+    - media: "(prefers-color-scheme: light)" 
+      scheme: default
+      primary: green
+      accent: deep orange
+      toggle:
+        icon: material/lightbulb-outline
+        name: Switch to dark mode
+plugins:
+  - search
+nav:
+  - Overview: index.md
+  - Get Started:
+    - get-started/installation.md
+    - get-started/basic-usage.md
+    - get-started/experiment-tracking.md
+    - get-started/examples.md
+    - get-started/benchmark-utility.md
+    - get-started/zoo.md
+  - RL Algorithms:
+    - rl-algorithms/overview.md
+    - rl-algorithms/ppo.md
+    - rl-algorithms/dqn.md
+    - rl-algorithms/c51.md
+    - rl-algorithms/ddpg.md
+    - rl-algorithms/sac.md
+    - rl-algorithms/td3.md
+    - rl-algorithms/ppg.md
+    - rl-algorithms/ppo-rnd.md
+    - rl-algorithms/rpo.md
+    - rl-algorithms/qdagger.md
+    - rl-algorithms/ppo-trxl.md
+    - rl-algorithms/pqn.md
+    - rl-algorithms/rainbow.md
+  - Advanced:
+    - advanced/hyperparameter-tuning.md
+    - advanced/resume-training.md
+  - Community:
+    - contribution.md
+    - cleanrl-supported-papers-projects.md
+  - Cloud Integration: 
+    - cloud/installation.md
+    - cloud/submit-experiments.md
+#adding git repo
+repo_url: https://github.com/vwxyzjn/cleanrl
+repo_name: vwxyzjn/cleanrl
+#markdown_extensions 
+markdown_extensions:
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true 
+  - abbr
+  - pymdownx.highlight
+  - pymdownx.inlinehilite
+  - pymdownx.superfences
+  - pymdownx.snippets
+  - admonition
+  - pymdownx.details
+  - attr_list
+  - md_in_html
+  - footnotes
+  - markdown_include.include:
+      base_path: docs
+  - pymdownx.emoji:
+      emoji_index: !!python/name:materialx.emoji.twemoji
+      emoji_generator: !!python/name:materialx.emoji.to_svg
+  - pymdownx.arithmatex:
+      generic: true
+  # - toc:
+  #     permalink: true
+  # - markdown.extensions.codehilite:
+  #     guess_lang: false
+  # - admonition
+  # - codehilite
+  # - extra
+  # - pymdownx.superfences:
+  #     custom_fences:
+  #     - name: mermaid
+  #       class: mermaid
+  #       format: !!python/name:pymdownx.superfences.fence_code_format ''
+  # - pymdownx.tabbed
+extra_css:
+  - stylesheets/extra.css
+# extra_javascript:
+#   - js/termynal.js
+#   - js/custom.js
+#footer
+extra:
+  social:
+    - icon: fontawesome/solid/envelope
+      link: mailto:costa.huang@outlook.com
+    - icon: fontawesome/brands/twitter
+      link: https://twitter.com/vwxyzjn
+    - icon: fontawesome/brands/github
+      link: https://github.com/vwxyzjn/cleanrl
+copyright: Copyright © 2021, CleanRL. All rights reserved.
+extra_javascript:
+#   - javascripts/mathjax.js
+#   - https://polyfill.io/v3/polyfill.min.js?features=es6
+  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js

cleanrl/ultrahorizon_gym_wrapper.py

@@ -0,0 +1,200 @@
+"""
+Gymnasium wrapper for Ultrahorizon_grid_env to make it compatible with CleanRL PPO
+"""
+import gymnasium as gym
+import numpy as np
+import asyncio
+from typing import Dict, Any, Tuple
+from Ultrahorizon_grid_env import MysteryGridEnvironment, Difficulty
+
+
+class UltrahorizonGymWrapper(gym.Env):
+    """
+    Gymnasium wrapper for the Ultrahorizon grid environment.
+    Converts the async text-based environment into a sync gym-compatible interface.
+    
+    Goal: Train RL agent to maximize score (not to understand world rules).
+    Observation: Full global observation of 10x10 grid.
+    Episode length: 20-30 steps (limited by energy=20 and max_steps=30).
+    """
+    
+    metadata = {"render_modes": ["human"]}
+    
+    def __init__(self, difficulty: Difficulty = Difficulty.HARD, required_steps: int = 50, free: bool = True):
+        super().__init__()
+        
+        # Initialize the underlying environment
+        self.env = MysteryGridEnvironment(difficulty=difficulty, required_steps=required_steps, free=free)
+        
+        # Define action space: 0=up, 1=down, 2=left, 3=right
+        self.action_space = gym.spaces.Discrete(4)
+        self.action_map = {0: "up", 1: "down", 2: "left", 3: "right"}
+        
+        # Define observation space
+        # We'll create a feature vector with:
+        # - Position (x, y): 2 values normalized to [0, 1]
+        # - Energy: 1 value normalized
+        # - Score: 1 value (can be negative)
+        # - Steps: 1 value normalized
+        # - Grid state: 10x10 one-hot encoded letters (A-E, X) = 10x10x6 = 600 values
+        # Total: 2 + 1 + 1 + 1 + 600 = 605 dimensional vector
+        
+        # For simplicity, we'll use a flattened representation
+        # Position (2) + energy (1) + score (1) + steps (1) + grid (600) = 605
+        obs_dim = 605
+        self.observation_space = gym.spaces.Box(
+            low=-np.inf, high=np.inf, shape=(obs_dim,), dtype=np.float32
+        )
+        
+        self.current_state = None
+        self.episode_return = 0
+        self.episode_length = 0
+        
+    def _encode_letter(self, letter: str) -> np.ndarray:
+        """One-hot encode a letter (A, B, C, D, E, X)"""
+        letter_map = {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'X': 5}
+        encoding = np.zeros(6, dtype=np.float32)
+        if letter in letter_map:
+            encoding[letter_map[letter]] = 1.0
+        return encoding
+    
+    def _get_observation(self) -> np.ndarray:
+        """Convert environment state to observation vector"""
+        # Get current state synchronously
+        state_dict = asyncio.run(self.env.get_current_state())
+        
+        # Extract position from string format "(x,y,letter)"
+        pos_str = state_dict["current_position"]
+        x, y, current_letter = pos_str.strip("()").split(",")
+        x, y = int(x), int(y)
+        
+        # Normalize position to [0, 1]
+        pos_normalized = np.array([x / 9.0, y / 9.0], dtype=np.float32)
+        
+        # Normalize energy (max is typically 20, but can increase)
+        energy_normalized = np.array([state_dict["energy"] / 20.0], dtype=np.float32)
+        
+        # Score (not normalized, can be negative)
+        score = np.array([state_dict["score"]], dtype=np.float32)
+        
+        # Normalize steps
+        steps_normalized = np.array([state_dict["steps"] / 30.0], dtype=np.float32)
+        
+        # Encode grid state (10x10 grid with letters)
+        grid_encoding = []
+        for y_coord in range(10):
+            for x_coord in range(10):
+                letter = self.env.grid[9 - y_coord][x_coord]
+                grid_encoding.append(self._encode_letter(letter))
+        grid_flat = np.concatenate(grid_encoding)
+        
+        # Concatenate all features
+        observation = np.concatenate([
+            pos_normalized,
+            energy_normalized,
+            score,
+            steps_normalized,
+            grid_flat
+        ])
+        
+        return observation
+    
+    def reset(self, seed=None, options=None) -> Tuple[np.ndarray, Dict[str, Any]]:
+        """Reset the environment"""
+        super().reset(seed=seed)
+        
+        if seed is not None:
+            np.random.seed(seed)
+        
+        # Reset the underlying environment
+        result = asyncio.run(self.env.reset())
+        
+        # Reset episode tracking
+        self.episode_return = 0
+        self.episode_length = 0
+        
+        # Get initial observation
+        observation = self._get_observation()
+        info = {}
+        
+        return observation, info
+    
+    def step(self, action: int) -> Tuple[np.ndarray, float, bool, bool, Dict[str, Any]]:
+        """Execute one step in the environment"""
+        # Store previous cumulative score
+        # Note: score in the environment is cumulative (total score so far)
+        prev_score = self.env.state.score
+        
+        # Convert action to direction
+        direction = self.action_map[action]
+        
+        # Execute move
+        result = asyncio.run(self.env.move(direction))
+        
+        # Get new observation
+        observation = self._get_observation()
+        
+        # Calculate single-step reward from cumulative score change
+        # score = cumulative total score (not single-step reward)
+        # reward = score_change = this step's contribution to total score
+        if result["success"]:
+            current_score = result.get("score", self.env.state.score)
+            # Single-step reward = change in cumulative score
+            reward = float(current_score - prev_score)
+        else:
+            # Invalid move: penalize heavily to avoid wasting steps
+            reward = -10
+        
+        # Episode termination conditions:
+        # 1. Energy reaches 0 (game_over=True)
+        # 2. Steps reach 30 (game_over=True)
+        # 3. Invalid move (out of bounds or already terminated)
+        # Note: Episode length will be 20-30 steps due to energy constraint
+        terminated = self.env.state.game_over or not result["success"]
+        truncated = False
+        # Update episode tracking
+        self.episode_return += reward
+        self.episode_length += 1
+        
+        # Info dict - don't add episode stats here, let RecordEpisodeStatistics handle it
+        info = {}
+        if terminated or truncated:
+            # Add the final cumulative score from the environment
+            info["final_score"] = float(self.env.state.score)
+        
+        return observation, reward, terminated, truncated, info
+    
+    def render(self):
+        """Render the environment (optional)"""
+        pass
+    
+    def close(self):
+        """Clean up resources"""
+        pass
+
+
+def make_ultrahorizon_env(difficulty: Difficulty = Difficulty.HARD, required_steps: int = 50, free: bool = True):
+    """Factory function to create Ultrahorizon environment"""
+    def thunk():
+        env = UltrahorizonGymWrapper(difficulty=difficulty, required_steps=required_steps, free=free)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        return env
+    return thunk
+
+
+if __name__ == "__main__":
+    # Test the wrapper
+    env = UltrahorizonGymWrapper(difficulty=Difficulty.EASY, free=True)
+    obs, info = env.reset()
+    print(f"Observation shape: {obs.shape}")
+    print(f"Action space: {env.action_space}")
+    # import pdb;pdb.set_trace()
+    for i in range(5):
+        action = env.action_space.sample()
+        import pdb;pdb.set_trace()
+        obs, reward, terminated, truncated, info = env.step(action)
+        print(f"Step {i+1}: action={action}, reward={reward}, terminated={terminated}")
+        if terminated:
+            break
+    
+    env.close()

train_starpo-s_qwen7B_frommlp_326.sh

@@ -0,0 +1,172 @@
+set -e
+export MASTER_PORT=29501  #
+# Section 1: Base Experiments
+USE_GRPO="algorithm.adv_estimator=grpo"
+# USE_GRPO="algorithm.adv_estimator=grpo agent_proxy.reward_normalization.method=mean_std actor_rollout_ref.actor.use_kl_loss=True"
+USE_PPO="algorithm.adv_estimator=gae" # by default.
+USE_BASE="algorithm.kl_ctrl.kl_coef=0.0 actor_rollout_ref.actor.kl_loss_coef=0.0 actor_rollout_ref.actor.clip_ratio_high=0.28 actor_rollout_ref.rollout.rollout_filter_ratio=0.25"
+export WANDB_API_KEY="wandb_v1_Ahkqz2osih1TkZ4XAAg0iz2t3Lv"
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask/global_step_200/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask/global_step_200/qwen2.5_7B_actor_hf
+
+# **************************************bandit*********************************
+########## 0.5B #############
+# python train.py --config-name _1_bandit system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_7B_it_multitask \
+#     trainer.total_training_steps=100 \
+#     trainer.save_freq=100 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask \
+#     trainer.experiment_name=bandit--starpos-fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask/global_step_100/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask/global_step_100/qwen2.5_7B_actor_hf
+
+# # #**************************************Frozenlake*********************************
+# python train.py --config-name _3_frozen_lake \
+#     system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_bandit_multitask/global_step_100/qwen2.5_7B_actor_hf \
+#     trainer.save_freq=200 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_frozenlake_sequence_multitask \
+#     trainer.experiment_name=frozen_lake--starpos-slippery_fromit_sequence_multitask_326 $USE_PPO $USE_BASE 
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_frozenlake_sequence_multitask/global_step_200/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_frozenlake_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf
+
+
+# # #**************************************sokoban-box1*********************************
+# python train.py --config-name _2_sokoban system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_frozenlake_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf  \
+#     custom_envs.CoordSokoban.env_config.num_boxes=1 \
+#     trainer.save_freq=200 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox1_sequence_multitask \
+#     trainer.experiment_name=sokoban-box1--starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox1_sequence_multitask/global_step_200/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox1_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf
+# # #**************************************sokoban-box2*********************************
+# python train.py --config-name _2_sokoban system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox1_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf  \
+#     custom_envs.CoordSokoban.env_config.num_boxes=2 \
+#     trainer.total_training_steps=100 \
+#     trainer.save_freq=100 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox2_sequence_multitask \
+#     trainer.experiment_name=sokoban-box2--starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox2_sequence_multitask/global_step_100/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox2_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf
+
+# # #**************************************rubikscube-rotato1*********************************
+# # ########### 0.5B #############
+# python train.py --config-name _10_rubikscube system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sokobanbox2_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf  \
+#     custom_envs.rubikscube.env_config.scramble_depth=1 \
+#     trainer.total_training_steps=100 \
+#     trainer.save_freq=100 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube1_sequence_multitask \
+#     trainer.experiment_name=rubikscube-1-starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube1_sequence_multitask/global_step_100/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube1_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf
+
+# # #**************************************rubikscube-rotato2*********************************
+# # ########### 0.5B #############
+# python train.py --config-name _10_rubikscube system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube1_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf  \
+#     custom_envs.rubikscube.env_config.scramble_depth=2 \
+#     trainer.total_training_steps=100 \
+#     trainer.save_freq=100 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube2_sequence_multitask \
+#     trainer.experiment_name=rubikscube-2-starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube2_sequence_multitask/global_step_100/actor \
+  --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube2_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf
+
+# #**************************************rubikscube-rotato3*********************************
+# ########### 0.5B #############
+python train.py --config-name _10_rubikscube system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+    trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+    trainer.n_gpus_per_node=8 \
+    model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube2_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf  \
+    custom_envs.rubikscube.env_config.scramble_depth=3 \
+    trainer.total_training_steps=100 \
+    trainer.save_freq=100 \
+    agent_proxy.enable_think=True\
+    trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube3_sequence_multitask \
+    trainer.experiment_name=rubikscube-3-starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube3_sequence_multitask/global_step_100/actor \
+  --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube3_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf
+
+#**********************************sudoku****************************************
+
+python train.py --config-name _11_sudoku \
+    system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+    trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp\
+    trainer.n_gpus_per_node=8 \
+    model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_cube3_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf \
+    trainer.save_freq=200 \
+    actor_rollout_ref.rollout.gpu_memory_utilization=0.5\
+    agent_proxy.enable_think=True\
+    trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sudoku_sequence_multitask \
+    trainer.experiment_name=sudoku-4x4-nohint-starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE 
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sudoku_sequence_multitask/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sudoku_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf
+
+# # **************************************2048*********************************
+# python train.py --config-name _8_2048 system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+#     trainer.project_name=ragen_latest_qwen2.5_7B_it_sequence_multitask_frommlp \
+#     trainer.n_gpus_per_node=8 \
+#     model_path=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_sudoku_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf  \
+#     trainer.save_freq=200 \
+#     agent_proxy.enable_think=True\
+#     trainer.default_local_dir=/mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_2048_sequence_multitask \
+#     actor_rollout_ref.rollout.gpu_memory_utilization=0.5\
+#     actor_rollout_ref.rollout.max_model_len=14400\
+#     agent_proxy.max_turn=700\
+#     trainer.experiment_name=_2048_-starpos_fromit_sequence_multitask_326 $USE_PPO $USE_BASE  
+
+# python -m verl.model_merger merge \
+#   --backend fsdp \
+#   --local_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_2048_sequence_multitask/global_step_200/actor \
+#   --target_dir /mnt/general/wanghy/RAGEN/saves/qwen7B_it_fromit_326_think_2048_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf